:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
feat(signals): enforce standing reviewer exclusions in auto-assignment (#122443)
posthog[bot]1a00c105992b
diff --git a/.semgrep/rules/security/idor-team-scoped-models.yaml b/.semgrep/rules/security/idor-team-scoped-models.yamlindex b552e2367288..2ada6507f784 100644--- a/.semgrep/rules/security/idor-team-scoped-models.yaml+++ b/.semgrep/rules/security/idor-team-scoped-models.yaml@@ -399,6 +399,8 @@ rules:|SignalReportSuggestedReviewer|SignalReportTask|SignalReportTrackerIssue+ |SignalReviewerExclusion+ |SignalReviewerExclusionRevision|SignalRepositoryAreaActivity|SignalTeamConfig|SignalSourceConfig@@ -874,6 +876,8 @@ rules:|SignalReportSuggestedReviewer|SignalReportTask|SignalReportTrackerIssue+ |SignalReviewerExclusion+ |SignalReviewerExclusionRevision|SignalRepositoryAreaActivity|SignalTeamConfig|SignalSourceConfigdiff --git a/products/signals/backend/migrations/0203_reviewer_exclusion.py b/products/signals/backend/migrations/0203_reviewer_exclusion.pynew file mode 100644index 000000000000..a9d1993db837--- /dev/null+++ b/products/signals/backend/migrations/0203_reviewer_exclusion.py@@ -0,0 +1,193 @@+# Generated by Django 5.2.18 on 2026-10-26 08:44++import django.db.models.manager+import django.db.models.deletion+from django.conf import settings+from django.db import migrations, models++import posthog.uuidt+++class Migration(migrations.Migration):+ dependencies = [+ ("posthog", "1412_drop_retired_desktop_file_system_tables"),+ ("signals", "0202_useractivitysummaryqueuestate_pending_score"),+ migrations.swappable_dependency(settings.AUTH_USER_MODEL),+ ]++ operations = [+ migrations.CreateModel(+ name="SignalReviewerExclusion",+ fields=[+ (+ "id",+ models.UUIDField(+ default=posthog.uuidt.uuid7,+ editable=False,+ primary_key=True,+ serialize=False,+ ),+ ),+ ("subject_user_uuid", models.UUIDField()),+ (+ "subject_github_login",+ models.CharField(blank=True, max_length=100, null=True),+ ),+ (+ "repository",+ models.CharField(blank=True, default="", max_length=200),+ ),+ (+ "path_prefix",+ models.CharField(blank=True, default="", max_length=500),+ ),+ ("instruction", models.TextField()),+ (+ "status",+ models.CharField(+ choices=[("active", "Active"), ("revoked", "Revoked")],+ default="active",+ max_length=10,+ ),+ ),+ ("revision", models.PositiveIntegerField(default=1)),+ ("created_at", models.DateTimeField(auto_now_add=True)),+ ("updated_at", models.DateTimeField(auto_now=True)),+ (+ "created_by",+ models.ForeignKey(+ blank=True,+ db_constraint=False,+ null=True,+ on_delete=django.db.models.deletion.SET_NULL,+ related_name="+",+ to=settings.AUTH_USER_MODEL,+ ),+ ),+ (+ "team",+ models.ForeignKey(+ db_constraint=False,+ on_delete=django.db.models.deletion.CASCADE,+ related_name="+",+ to="posthog.team",+ ),+ ),+ ],+ options={+ "default_manager_name": "all_teams",+ },+ managers=[+ ("all_teams", django.db.models.manager.Manager()),+ ],+ ),+ migrations.CreateModel(+ name="SignalReviewerExclusionRevision",+ fields=[+ (+ "id",+ models.UUIDField(+ default=posthog.uuidt.uuid7,+ editable=False,+ primary_key=True,+ serialize=False,+ ),+ ),+ ("revision", models.PositiveIntegerField()),+ (+ "action",+ models.CharField(+ choices=[+ ("created", "Created"),+ ("revised", "Revised"),+ ("revoked", "Revoked"),+ ],+ max_length=10,+ ),+ ),+ ("subject_user_uuid", models.UUIDField()),+ (+ "subject_github_login",+ models.CharField(blank=True, max_length=100, null=True),+ ),+ (+ "repository",+ models.CharField(blank=True, default="", max_length=200),+ ),+ (+ "path_prefix",+ models.CharField(blank=True, default="", max_length=500),+ ),+ ("instruction", models.TextField()),+ (+ "status",+ models.CharField(+ choices=[("active", "Active"), ("revoked", "Revoked")],+ max_length=10,+ ),+ ),+ ("created_at", models.DateTimeField(auto_now_add=True)),+ (+ "actor",+ models.ForeignKey(+ blank=True,+ db_constraint=False,+ null=True,+ on_delete=django.db.models.deletion.SET_NULL,+ related_name="+",+ to=settings.AUTH_USER_MODEL,+ ),+ ),+ (+ "exclusion",+ models.ForeignKey(+ on_delete=django.db.models.deletion.CASCADE,+ related_name="revisions",+ to="signals.signalreviewerexclusion",+ ),+ ),+ (+ "team",+ models.ForeignKey(+ db_constraint=False,+ on_delete=django.db.models.deletion.CASCADE,+ related_name="+",+ to="posthog.team",+ ),+ ),+ ],+ options={+ "default_manager_name": "all_teams",+ },+ managers=[+ ("all_teams", django.db.models.manager.Manager()),+ ],+ ),+ migrations.AddIndex(+ model_name="signalreviewerexclusion",+ index=models.Index(fields=["team", "status"], name="signals_rev_excl_status_idx"),+ ),+ migrations.AddConstraint(+ model_name="signalreviewerexclusion",+ constraint=models.CheckConstraint(+ condition=models.Q(+ ("path_prefix", ""),+ models.Q(("repository", ""), _negated=True),+ _connector="OR",+ ),+ name="signals_rev_excl_path_needs_repo",+ ),+ ),+ migrations.AddConstraint(+ model_name="signalreviewerexclusion",+ constraint=models.UniqueConstraint(+ condition=models.Q(("status", "active")),+ fields=("team", "subject_user_uuid", "repository", "path_prefix"),+ name="signals_rev_excl_active_user_uniq",+ ),+ ),+ migrations.AddConstraint(+ model_name="signalreviewerexclusionrevision",+ constraint=models.UniqueConstraint(fields=("exclusion", "revision"), name="signals_rev_excl_revision_uniq"),+ ),+ ]diff --git a/products/signals/backend/migrations/max_migration.txt b/products/signals/backend/migrations/max_migration.txtindex cec63b7df899..9f784deae797 100644--- a/products/signals/backend/migrations/max_migration.txt+++ b/products/signals/backend/migrations/max_migration.txt@@ -1 +1 @@-0202_useractivitysummaryqueuestate_pending_score+0203_reviewer_exclusiondiff --git a/products/signals/backend/models.py b/products/signals/backend/models.pyindex de9ac2e7b2df..1ff816d539c6 100644--- a/products/signals/backend/models.py+++ b/products/signals/backend/models.py@@ -2617,6 +2617,84 @@ class SignalReportMonitoringAttempt(UUIDModel):]+class SignalReviewerExclusion(TeamScopedRootMixin, UUIDModel):+ """A standing instruction that keeps one person off automatic reviewer selection in one area.++ The instruction applies to every automatic writer and does not expire. A person revokes it, and+ every change appends a `SignalReviewerExclusionRevision`, so the row holds the current state and+ the revisions hold its history.+ """++ class Status(models.TextChoices):+ ACTIVE = "active", "Active"+ REVOKED = "revoked", "Revoked"++ all_teams = models.Manager() # noqa: DJ012++ team = models.ForeignKey("posthog.Team", on_delete=models.CASCADE, db_constraint=False, related_name="+")+ # The subject is always a PostHog user. The login is a snapshot for display and telemetry, never an identity.+ subject_user_uuid = models.UUIDField()+ subject_github_login = models.CharField(max_length=100, null=True, blank=True)+ # An empty repository covers every repository. A path prefix narrows a repository to one subtree.+ repository = models.CharField(max_length=200, blank=True, default="")+ path_prefix = models.CharField(max_length=500, blank=True, default="")+ instruction = models.TextField()+ status = models.CharField(max_length=10, choices=Status, default=Status.ACTIVE)+ revision = models.PositiveIntegerField(default=1)+ created_by = models.ForeignKey(+ "posthog.User", on_delete=models.SET_NULL, null=True, blank=True, db_constraint=False, related_name="+"+ )+ created_at = models.DateTimeField(auto_now_add=True)+ updated_at = models.DateTimeField(auto_now=True)++ class Meta:+ default_manager_name = "all_teams"+ indexes = [models.Index(fields=["team", "status"], name="signals_rev_excl_status_idx")]+ constraints = [+ models.CheckConstraint(+ condition=models.Q(path_prefix="") | ~models.Q(repository=""),+ name="signals_rev_excl_path_needs_repo",+ ),+ # One active instruction per person and area, so a retried create cannot leave a twin+ # that stays active after the other is revoked.+ models.UniqueConstraint(+ fields=["team", "subject_user_uuid", "repository", "path_prefix"],+ condition=models.Q(status="active"),+ name="signals_rev_excl_active_user_uniq",+ ),+ ]+++class SignalReviewerExclusionRevision(TeamScopedRootMixin, UUIDModel):+ """One append-only revision of a `SignalReviewerExclusion`, with the person who made it."""++ class Action(models.TextChoices):+ CREATED = "created", "Created"+ REVISED = "revised", "Revised"+ REVOKED = "revoked", "Revoked"++ all_teams = models.Manager() # noqa: DJ012++ team = models.ForeignKey("posthog.Team", on_delete=models.CASCADE, db_constraint=False, related_name="+")+ exclusion = models.ForeignKey(SignalReviewerExclusion, on_delete=models.CASCADE, related_name="revisions")+ revision = models.PositiveIntegerField()+ action = models.CharField(max_length=10, choices=Action)+ subject_user_uuid = models.UUIDField()+ subject_github_login = models.CharField(max_length=100, null=True, blank=True)+ repository = models.CharField(max_length=200, blank=True, default="")+ path_prefix = models.CharField(max_length=500, blank=True, default="")+ instruction = models.TextField()+ status = models.CharField(max_length=10, choices=SignalReviewerExclusion.Status)+ actor = models.ForeignKey(+ "posthog.User", on_delete=models.SET_NULL, null=True, blank=True, db_constraint=False, related_name="+"+ )+ created_at = models.DateTimeField(auto_now_add=True)++ class Meta:+ default_manager_name = "all_teams"+ constraints = [models.UniqueConstraint(fields=["exclusion", "revision"], name="signals_rev_excl_revision_uniq")]++# ── Signals scout (headless cross-source explorer) ──────────────────────────────## Core tables backing the Signals scout:diff --git a/products/signals/backend/report_generation/reviewer_telemetry.py b/products/signals/backend/report_generation/reviewer_telemetry.pyindex 77c44c0ae8ef..8c928a19cd6c 100644--- a/products/signals/backend/report_generation/reviewer_telemetry.py+++ b/products/signals/backend/report_generation/reviewer_telemetry.py@@ -7,6 +7,7 @@ import posthoganalyticsfrom posthog.dataclasses import frozenfrom posthog.event_usage import groupsfrom posthog.models import Team+from posthog.ph_client import ph_background_capturefrom products.signals.backend.report_generation.resolve_reviewers import (ReviewerResolutionDiagnostics,@@ -188,3 +189,42 @@ def capture_suggested_reviewers_unresolved()except Exception:logger.exception("Failed to capture signals_suggested_reviewers_unresolved for report %s", report_id)+++ReviewerExclusionOutcome = Literal["suppressed", "pin_conflict", "unresolved"]+++def capture_reviewer_exclusion_applied(+ *,+ team_id: int,+ report_id: str,+ source: str,+ events: list[tuple[ReviewerExclusionOutcome, list[str]]],+) -> None:+ """Emit one `signals_reviewer_exclusion_applied` per outcome when standing exclusions change a selection.++ `suppressed` fires once per candidate an instruction removed. `pin_conflict` fires when a+ report-specific pin keeps a person an instruction excludes, so a person must resolve it.+ `unresolved` fires when the report or the instruction cannot tell whether it applies, so the+ selection kept its current reviewers.++ Best-effort: never raises, so analytics can't break a reviewer write.+ """+ try:+ team = Team.objects.select_related("organization").get(id=team_id)+ capture = ph_background_capture()+ for outcome, exclusion_ids in events:+ capture(+ event="signals_reviewer_exclusion_applied",+ distinct_id=str(team.uuid),+ properties={+ "team_id": team_id,+ "report_id": report_id,+ "outcome": outcome,+ "source": source,+ "exclusion_ids": exclusion_ids[:_MAX_LOGINS_PER_EVENT],+ },+ groups=groups(team.organization, team),+ )+ except Exception:+ logger.exception("Failed to capture signals_reviewer_exclusion_applied for report %s", report_id)diff --git a/products/signals/backend/reviewer_exclusions.py b/products/signals/backend/reviewer_exclusions.pynew file mode 100644index 000000000000..b3ecc9fa0422--- /dev/null+++ b/products/signals/backend/reviewer_exclusions.py@@ -0,0 +1,408 @@+"""Standing instructions that keep a person off automatic reviewer selection in one area.++A person who left an area records one instruction, and every automatic writer (research, scouts,+custom agents) honors it through `ReviewerRules.prepare`. An instruction applies to a report when the+report's selected repository matches and, for a path instruction, when one of its finding paths is+under the prefix. When the report or the instruction cannot answer that question, the selection+stays unresolved instead of guessing. Pull request assignment reads the same instructions, so an+excluded person is neither assigned nor asked to review.++The subject of an instruction is always a PostHog user. A candidate known only by a GitHub login+resolves to the member who links that login now. A login that resolves to nobody cannot be excluded.+"""++from __future__ import annotations++import json+from uuid import UUID++from django.db import IntegrityError, transaction+from django.db.models import QuerySet++import structlog++from posthog.dataclasses import frozen++from products.signals.backend.artefact_schemas import SuggestedReviewerEntry+from products.signals.backend.models import (+ SignalReportArtefact,+ SignalReviewerExclusion,+ SignalReviewerExclusionRevision,+)+from products.signals.backend.report_generation.resolve_reviewers import resolve_org_github_login_to_users++logger = structlog.get_logger(__name__)+++class DuplicateExclusion(ValueError):+ pass+++@frozen+class StandingExclusion:+ id: str+ user_uuid: str+ repository: str+ path_prefix: str+++@frozen+class Suppression:+ exclusion_id: str+ reviewer: SuggestedReviewerEntry+++@frozen+class ExclusionReview:+ kept: tuple[SuggestedReviewerEntry, ...]+ suppressed: tuple[Suppression, ...]+ unresolved: bool+++def _normalized_path(path: str) -> str:+ return path.strip().removeprefix("./").strip("/")+++def _normalized_login(login: str | None) -> str | None:+ return (login.strip().lower() or None) if login else None+++class StandingExclusions:+ """The team's active instructions, read against one report's area evidence."""++ def __init__(+ self,+ *,+ team_id: int,+ report_id: str,+ repository_override: str | None,+ versions: tuple[tuple[UUID, int], ...],+ exclusions: tuple[StandingExclusion, ...],+ repository: str | None,+ paths: tuple[str, ...],+ ) -> None:+ self.team_id = team_id+ self.report_id = report_id+ self.repository_override = repository_override+ self.versions = versions+ self.exclusions = exclusions+ self.repository = repository+ self.paths = paths+ # Each login resolves once per instance, however many candidate lists the caller checks.+ self.user_uuid_by_login: dict[str, str | None] = {}++ @classmethod+ def load(cls, *, team_id: int, report_id: str, repository: str | None = None) -> StandingExclusions:+ """Read the team's instructions against the report's area.++ `repository` overrides the report's repository selection, for a caller that already knows+ the repository the work landed in.+ """+ rows = list(+ SignalReviewerExclusion.objects.for_team(team_id)+ .filter(status=SignalReviewerExclusion.Status.ACTIVE)+ .order_by("created_at", "id")+ )+ versions = tuple((row.id, row.revision) for row in rows)+ exclusions = tuple(+ StandingExclusion(+ id=str(row.id),+ user_uuid=str(row.subject_user_uuid),+ repository=row.repository.strip().lower(),+ path_prefix=_normalized_path(row.path_prefix),+ )+ for row in rows+ )+ if not exclusions:+ return cls(+ team_id=team_id,+ report_id=report_id,+ repository_override=repository,+ versions=versions,+ exclusions=(),+ repository=None,+ paths=(),+ )+ repository_override = repository+ artefacts = SignalReportArtefact.objects.filter(team_id=team_id, report_id=report_id)+ if repository is None:+ selection = (+ artefacts.filter(type=SignalReportArtefact.ArtefactType.REPO_SELECTION)+ .order_by("-created_at", "-id")+ .values_list("content", flat=True)+ .first()+ )+ repository = cls._read_repository(selection)+ else:+ repository = repository.strip().lower() or None+ paths: tuple[str, ...] = ()+ # Finding paths decide only a path instruction for this report's repository, and the read runs+ # under the report lock, so skip it for every other report.+ if repository is not None and any(e.path_prefix and e.repository == repository for e in exclusions):+ paths = cls._read_paths(artefacts.filter(type=SignalReportArtefact.ArtefactType.SIGNAL_FINDING))+ return cls(+ team_id=team_id,+ report_id=report_id,+ repository_override=repository_override,+ versions=versions,+ exclusions=exclusions,+ repository=repository,+ paths=paths,+ )++ def refreshed(self) -> StandingExclusions:+ """These instructions when none changed since the load, otherwise a fresh load. One query when none changed."""+ current = tuple(+ SignalReviewerExclusion.objects.for_team(self.team_id)+ .filter(status=SignalReviewerExclusion.Status.ACTIVE)+ .order_by("created_at", "id")+ .values_list("id", "revision")+ )+ if current == self.versions:+ return self+ fresh = StandingExclusions.load(+ team_id=self.team_id, report_id=self.report_id, repository=self.repository_override+ )+ fresh.user_uuid_by_login = self.user_uuid_by_login+ return fresh++ def _member_uuids(self, logins: list[str]) -> list[str | None]:+ """The member each login resolves to now, looked up once per login."""+ normalized = [_normalized_login(login) for login in logins]+ missing = {login for login in normalized if login is not None and login not in self.user_uuid_by_login}+ if missing:+ users = resolve_org_github_login_to_users(self.team_id, missing)+ self.user_uuid_by_login.update(+ {login: str(users[login].uuid) if login in users else None for login in missing}+ )+ return [self.user_uuid_by_login[login] if login is not None else None for login in normalized]++ @staticmethod+ def _read_repository(content: str | None) -> str | None:+ try:+ data = json.loads(content or "")+ except ValueError:+ return None+ repository = data.get("repository") if isinstance(data, dict) else None+ return repository.strip().lower() if isinstance(repository, str) and repository.strip() else None++ @staticmethod+ def _read_paths(findings: QuerySet[SignalReportArtefact]) -> tuple[str, ...]:+ """The paths of each signal's current finding. Re-research supersedes a signal's older findings.++ Content parses in Python because a JSONB cast fails the whole read on one malformed row.+ """+ current: dict[str | None, object] = {}+ for content in (+ findings.filter(content__startswith="{").order_by("-created_at", "-id").values_list("content", flat=True)+ ):+ try:+ data = json.loads(content)+ except ValueError:+ logger.warning("signals.reviewer_exclusions.unreadable_finding")+ continue+ if not isinstance(data, dict):+ continue+ signal_id = data.get("signal_id")+ current.setdefault(None if signal_id is None else str(signal_id), data.get("relevant_code_paths"))+ paths: dict[str, None] = {}+ for found in current.values():+ for path in found if isinstance(found, list) else ():+ if isinstance(path, str) and _normalized_path(path):+ paths[_normalized_path(path)] = None+ return tuple(paths)++ def _applies(self, exclusion: StandingExclusion) -> bool | None:+ """Whether the instruction covers this report, or None when the report cannot tell."""+ if not exclusion.repository:+ return True+ if self.repository is None:+ return None+ if self.repository != exclusion.repository:+ return False+ if not exclusion.path_prefix:+ return True+ if not self.paths:+ return None+ return any(path == exclusion.path_prefix or path.startswith(f"{exclusion.path_prefix}/") for path in self.paths)++ def _verdict(self, user_uuid: str | None) -> tuple[StandingExclusion | None, bool]:+ """The first instruction that removes the member, and whether another one cannot tell."""+ suppressing: StandingExclusion | None = None+ unresolved = False+ for exclusion in self.exclusions:+ if user_uuid is None or exclusion.user_uuid != user_uuid:+ continue+ applies = self._applies(exclusion)+ if applies is False:+ continue+ if applies is None:+ unresolved = True+ elif suppressing is None:+ suppressing = exclusion+ return suppressing, unresolved++ def review(self, candidates: tuple[SuggestedReviewerEntry, ...]) -> ExclusionReview:+ if not self.exclusions:+ return ExclusionReview(kept=candidates, suppressed=(), unresolved=False)+ member_uuids = [+ candidate.user_uuid or member_uuid+ for candidate, member_uuid in zip(+ candidates,+ self._member_uuids(+ ["" if candidate.user_uuid else candidate.github_login or "" for candidate in candidates]+ ),+ )+ ]+ kept: list[SuggestedReviewerEntry] = []+ suppressed: list[Suppression] = []+ unresolved = False+ for candidate, member_uuid in zip(candidates, member_uuids):+ suppressing, uncertain = self._verdict(member_uuid)+ unresolved = unresolved or uncertain+ if suppressing is None:+ kept.append(candidate)+ else:+ suppressed.append(Suppression(exclusion_id=suppressing.id, reviewer=candidate))+ return ExclusionReview(kept=tuple(kept), suppressed=tuple(suppressed), unresolved=unresolved)++ def allowed_logins(self, logins: list[str]) -> list[str]:+ """The GitHub logins no instruction keeps off this area. A login nobody can decide on is left out."""+ if not self.exclusions:+ return list(logins)+ allowed: list[str] = []+ for login, member_uuid in zip(logins, self._member_uuids(logins)):+ suppressing, unresolved = self._verdict(member_uuid)+ if suppressing is None and not unresolved:+ allowed.append(login)+ return allowed+++def _record_revision(+ exclusion: SignalReviewerExclusion, action: SignalReviewerExclusionRevision.Action, actor_id: int | None+) -> None:+ SignalReviewerExclusionRevision.objects.for_team(exclusion.team_id).create(+ team_id=exclusion.team_id,+ exclusion=exclusion,+ revision=exclusion.revision,+ action=action,+ subject_user_uuid=exclusion.subject_user_uuid,+ subject_github_login=exclusion.subject_github_login,+ repository=exclusion.repository,+ path_prefix=exclusion.path_prefix,+ instruction=exclusion.instruction,+ status=exclusion.status,+ actor_id=actor_id,+ )+++def _active_twins(+ team_id: int, *, subject_user_uuid: UUID, repository: str, path_prefix: str+) -> QuerySet[SignalReviewerExclusion]:+ """Active instructions with the key of the partial unique index on the model."""+ return SignalReviewerExclusion.objects.for_team(team_id).filter(+ status=SignalReviewerExclusion.Status.ACTIVE,+ subject_user_uuid=subject_user_uuid,+ repository=repository,+ path_prefix=path_prefix,+ )+++def create_exclusion(+ *,+ team_id: int,+ actor_id: int,+ instruction: str,+ subject_user_uuid: UUID,+ subject_github_login: str | None = None,+ repository: str = "",+ path_prefix: str = "",+) -> tuple[SignalReviewerExclusion, bool]:+ """Create an instruction, or return the active one for the same member and area.++ Returns the instruction and whether it was created, so a retried request does not leave a twin.+ `subject_github_login` is a snapshot for display and plays no part in matching.+ """+ repository = repository.strip().lower()+ path_prefix = _normalized_path(path_prefix)+ active = _active_twins(team_id, subject_user_uuid=subject_user_uuid, repository=repository, path_prefix=path_prefix)+ if existing := active.first():+ return existing, False+ try:+ with transaction.atomic():+ exclusion = SignalReviewerExclusion.objects.for_team(team_id).create(+ team_id=team_id,+ instruction=instruction,+ created_by_id=actor_id,+ subject_user_uuid=subject_user_uuid,+ subject_github_login=_normalized_login(subject_github_login),+ repository=repository,+ path_prefix=path_prefix,+ )+ _record_revision(exclusion, SignalReviewerExclusionRevision.Action.CREATED, actor_id)+ except IntegrityError:+ # A concurrent create of the same instruction won the unique constraint.+ if existing := active.first():+ return existing, False+ raise+ return exclusion, True+++def revise_exclusion(+ *,+ team_id: int,+ exclusion_id: UUID | str,+ actor_id: int,+ instruction: str | None = None,+ repository: str | None = None,+ path_prefix: str | None = None,+) -> SignalReviewerExclusion:+ """Apply the given changes as one new revision. A call that changes nothing records no revision."""+ with transaction.atomic():+ exclusion = (+ SignalReviewerExclusion.objects.for_team(team_id)+ .select_for_update()+ .get(id=exclusion_id, status=SignalReviewerExclusion.Status.ACTIVE)+ )+ changes = {+ field: value+ for field, value in (+ ("instruction", instruction),+ ("repository", repository.strip().lower() if repository is not None else None),+ ("path_prefix", _normalized_path(path_prefix) if path_prefix is not None else None),+ )+ if value is not None and value != getattr(exclusion, field)+ }+ if not changes:+ return exclusion+ for field, value in changes.items():+ setattr(exclusion, field, value)+ twin = _active_twins(+ team_id,+ subject_user_uuid=exclusion.subject_user_uuid,+ repository=exclusion.repository,+ path_prefix=exclusion.path_prefix,+ ).exclude(id=exclusion.id)+ if twin.exists():+ raise DuplicateExclusion("An active exclusion already covers this person and area.")+ exclusion.revision += 1+ try:+ with transaction.atomic():+ exclusion.save()+ except IntegrityError as e:+ # A concurrent amend moved another row onto this area after the twin check.+ raise DuplicateExclusion("An active exclusion already covers this person and area.") from e+ _record_revision(exclusion, SignalReviewerExclusionRevision.Action.REVISED, actor_id)+ return exclusion+++def revoke_exclusion(*, team_id: int, exclusion_id: UUID | str, actor_id: int) -> SignalReviewerExclusion:+ with transaction.atomic():+ exclusion = SignalReviewerExclusion.objects.for_team(team_id).select_for_update().get(id=exclusion_id)+ if exclusion.status == SignalReviewerExclusion.Status.REVOKED:+ return exclusion+ exclusion.status = SignalReviewerExclusion.Status.REVOKED+ exclusion.revision += 1+ exclusion.save()+ _record_revision(exclusion, SignalReviewerExclusionRevision.Action.REVOKED, actor_id)+ return exclusiondiff --git a/products/signals/backend/reviewer_pr_assignment.py b/products/signals/backend/reviewer_pr_assignment.pyindex 1cefded84be8..b45a6905bb35 100644--- a/products/signals/backend/reviewer_pr_assignment.py+++ b/products/signals/backend/reviewer_pr_assignment.py@@ -7,6 +7,10 @@ Manual GitHub assignments and removals remain authoritative.Other projects retain the legacy DRI and opt-in policies. Task execution permission isseparate from report and PR assignment. GitHub failures must not break report writes.++Standing reviewer exclusions for the pull request's repository apply to every automatic candidate,+including reviewer lists saved before the exclusion existed. The person who chose the work is+still assigned, because a claim is a person's own decision."""from __future__ import annotations@@ -60,6 +64,7 @@ from products.signals.backend.report_generation.resolve_reviewers import (normalized_github_logins_from_reviewer_payloads,resolve_org_github_login_to_users,)+from products.signals.backend.reviewer_exclusions import StandingExclusionsfrom products.signals.backend.reviewer_rules import ReviewerRules, contains_reviewerif TYPE_CHECKING:@@ -357,6 +362,7 @@ def _request_reviews(parsed: PullRequestRef,pr: dict[str, Any],reviewers: list[str],+ standing: StandingExclusions,) -> list[str]:assignees = list(dict.fromkeys(str(login).lower() for login in (pr.get("assignees") or []) if login))owner = assignees[0] if len(assignees) == 1 else None@@ -366,6 +372,14 @@ def _request_reviews(existing = {str(login).lower() for login in [pr.get("author"), *(pr.get("requested_reviewers") or [])] if login}candidates = [owner] if owner else reviewerswanted = [login for login in candidates if login.lower() not in existing]+ if not wanted:+ return []+ # The sole assignee can be an earlier automatic owner who has since excluded themselves. The+ # person who chose the work is still asked.+ allowed = standing.allowed_logins(wanted)+ if owner and not allowed and owner == (human_claimant_login(team_id=team_id, report_id=report_id) or "").lower():+ allowed = wanted+ wanted = allowedif not wanted:return []@@ -739,7 +753,13 @@ def _report_assignee_logins(team: Team, snapshot: ReviewerSnapshot, *, require_odef _assign_report_reviewers(- github: GitHubIntegration, *, team_id: int, report_id: str, parsed: PullRequestRef, pr: dict[str, Any]+ github: GitHubIntegration,+ *,+ team_id: int,+ report_id: str,+ parsed: PullRequestRef,+ pr: dict[str, Any],+ standing: StandingExclusions,) -> list[str]:assignments = PROwnerAssignmentService(team_id=team_id,@@ -772,7 +792,7 @@ def _assign_report_reviewers(snapshot = ReviewerRules.read_for_report(team_id=team_id, report_id=report_id)if snapshot.corrections.needs_review:return []- candidates = _report_assignee_logins(team, snapshot)+ candidates = standing.allowed_logins(_report_assignee_logins(team, snapshot))if len(candidates) < len(snapshot.reviewers):log.info("signals.reviewer_pr_assignment.unavailable_accounts",@@ -806,7 +826,11 @@ def _assign_report_reviewers(if not current_application.allowed or current_application.previous != application.previous:return []current = ReviewerRules.read_for_report(team_id=team_id, report_id=report_id)- if current.state != snapshot.state or _report_assignee_logins(team, current) != candidates:+ # An instruction saved during the GitHub calls must still stop the assignment.+ if (+ current.state != snapshot.state+ or standing.refreshed().allowed_logins(_report_assignee_logins(team, current)) != candidates+ ):return []if not (assignment_writer_enabled(team_id)@@ -862,8 +886,13 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: stif pr is None:return []+ standing = StandingExclusions.load(team_id=team_id, report_id=report_id, repository=parsed.repository)+ logins = standing.allowed_logins(logins)+ reviewers = standing.allowed_logins(reviewers)if shared_assignment:- assigned = _assign_report_reviewers(github, team_id=team_id, report_id=report_id, parsed=parsed, pr=pr)+ assigned = _assign_report_reviewers(+ github, team_id=team_id, report_id=report_id, parsed=parsed, pr=pr, standing=standing+ )elif dri_enabled:assigned = _assign_one_dri(github,@@ -873,6 +902,7 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: stpr=pr,opted_in=set(logins),reviewers=reviewers,+ standing=standing,)else:assigned = (@@ -902,6 +932,7 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: stif current_pr is None:return assignedpr = current_pr+ # An instruction saved during the assignment calls must still stop the review request._request_reviews(github,team_id=team_id,@@ -909,6 +940,7 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: stparsed=parsed,pr={**pr, "assignees": [*(pr.get("assignees") or []), *assigned]},reviewers=reviewers,+ standing=standing.refreshed(),)return assigned@@ -922,6 +954,7 @@ def _assign_one_dri(pr: dict[str, Any],opted_in: set[str],reviewers: list[str],+ standing: StandingExclusions,) -> list[str]:"""Assign one DRI, replacing only a prior owner this worker recorded."""assignments = PROwnerAssignmentService(@@ -960,10 +993,12 @@ def _assign_one_dri(reviewers=reviewers,)members = resolve_org_github_login_to_users(team_id, candidates)+ allowed = set(standing.allowed_logins(candidates))candidates = [loginfor login in candidates- if not contains_reviewer(+ if (login == claimant or login in allowed)+ and not contains_reviewer(snapshot.corrections.excluded,SuggestedReviewerEntry(github_login=login, user_uuid=str(members[login].uuid) if login in members else None@@ -997,10 +1032,13 @@ def _assign_one_dri(if not current_application.allowed or current_application.previous != application.previous:return []current = ReviewerRules.read_for_report(team_id=team_id, report_id=report_id)+ # An instruction saved during the GitHub calls must still stop the assignment.+ fresh = standing.refreshed()if (current.state != snapshot.stateor human_claimant_login(team_id=team_id, report_id=report_id) != claimant- or ranked_reviewer_logins(team_id=team_id, report_id=report_id) != reviewers+ or fresh.allowed_logins(ranked_reviewer_logins(team_id=team_id, report_id=report_id)) != reviewers+ or not (owner.login == claimant or fresh.allowed_logins([owner.login]))):return []return _apply_automatic_owners(diff --git a/products/signals/backend/reviewer_rules.py b/products/signals/backend/reviewer_rules.pyindex d2ff49b7892a..8ab430b6bc5c 100644--- a/products/signals/backend/reviewer_rules.py+++ b/products/signals/backend/reviewer_rules.py@@ -3,6 +3,7 @@ from __future__ import annotationsimport jsonfrom uuid import UUID+from django.db import transactionfrom django.db.models import Qfrom posthog.dataclasses import frozen@@ -25,6 +26,11 @@ from products.signals.backend.report_generation.resolve_reviewers import (get_org_member_github_logins_by_user_uuid,resolve_org_github_login_to_users,)+from products.signals.backend.report_generation.reviewer_telemetry import (+ ReviewerExclusionOutcome,+ capture_reviewer_exclusion_applied,+)+from products.signals.backend.reviewer_exclusions import StandingExclusionsclass ReviewerWriteError(ValueError):@@ -254,6 +260,15 @@ class ReviewerRules:unresolved_candidates=tuple(unresolved),)+ def _capture_exclusion_events(+ self, events: list[tuple[ReviewerExclusionOutcome, list[str]]], *, source: str+ ) -> None:+ transaction.on_commit(+ lambda: capture_reviewer_exclusion_applied(+ team_id=self.team.id, report_id=self.report_id, source=source, events=events+ )+ )+def prepare(self,content: SuggestedReviewers,@@ -264,6 +279,10 @@ class ReviewerRules:) -> ReviewerUpdate:"""Called by append_status while it holds the report lock."""snapshot = self.read()+ # Standing exclusions bind automatic writers only. A person's own edit or pin always wins.+ # They load only on a path that can change the list, because the read runs under the report lock.+ exclusions_bind = edit is None and attribution.kind != "user"+ exclusion_events: list[tuple[ReviewerExclusionOutcome, list[str]]] = []if edit is not None and attribution.kind != "user":raise ReviewerWriteError("Only a person can change reviewer corrections.")repairing = snapshot.invalid_reviewers@@ -336,12 +355,31 @@ class ReviewerRules:if corrections.confirmed or corrections.needs_review or failed:proposed = snapshot.reviewerselse:+ standing = (+ StandingExclusions.load(team_id=self.team.id, report_id=self.report_id) if exclusions_bind else None+ )validated = self._validate_members(proposed)- if proposed and not validated.reviewers:+ review = (+ standing.review(+ tuple(+ entry for entry in validated.reviewers if not contains_reviewer(corrections.pinned, entry)+ )+ )+ if standing+ else None+ )+ if review and review.unresolved:+ exclusion_events.append(("unresolved", []))+ if (proposed and not validated.reviewers) or (review and review.unresolved):proposed = snapshot.reviewerselse:+ suppressed = tuple(item.reviewer for item in review.suppressed) if review else ()+ if review:+ exclusion_events.extend(("suppressed", [item.exclusion_id]) for item in review.suppressed)proposed = tuple(- entry for entry in validated.reviewers if not contains_reviewer(corrections.excluded, entry)+ entry+ for entry in validated.reviewers+ if not contains_reviewer(corrections.excluded + suppressed, entry))extra_pins = tuple(entry@@ -352,12 +390,45 @@ class ReviewerRules:)proposed += self._validate_members(extra_pins).reviewers if extra_pins else ()members_validated = True+ pin_review = (+ standing.review(+ tuple(entry for entry in proposed if contains_reviewer(corrections.pinned, entry))+ )+ if standing+ else None+ )+ if pin_review and pin_review.unresolved:+ exclusion_events = [("unresolved", [])]+ proposed = snapshot.reviewers+ members_validated = False+ elif pin_review and pin_review.suppressed:+ corrections = corrections.model_copy(update={"needs_review": True})+ exclusion_events.append(("pin_conflict", [item.exclusion_id for item in pin_review.suppressed]))elif (proposaland proposal.source == "research"and (corrections.pinned or corrections.excluded or corrections.needs_review)):proposed = snapshot.reviewers+ elif (+ exclusions_bind+ and not protected+ and (standing := StandingExclusions.load(team_id=self.team.id, report_id=self.report_id)).exclusions+ ):+ # Writers without the protected flow store login-only entries, so match on resolved+ # identities and keep each entry as it was written.+ resolved = self._resolve_identities(self.team.id, proposed)+ review = standing.review(resolved)+ if review.unresolved:+ exclusion_events.append(("unresolved", []))+ proposed = snapshot.reviewers+ else:+ exclusion_events.extend(("suppressed", [item.exclusion_id]) for item in review.suppressed)+ proposed = tuple(+ entry for entry, match in zip(proposed, resolved) if contains_reviewer(review.kept, match)+ )+ if exclusion_events:+ self._capture_exclusion_events(exclusion_events, source=proposal.source if proposal else attribution.kind)if protected and not members_validated:proposed = self._validate_members(proposed).reviewersreviewers = SuggestedReviewers(root=list(proposed))diff --git a/products/signals/backend/test/test_report_pr_assignment.py b/products/signals/backend/test/test_report_pr_assignment.pyindex a18f6247fb46..c98827a8c7e5 100644--- a/products/signals/backend/test/test_report_pr_assignment.py+++ b/products/signals/backend/test/test_report_pr_assignment.py@@ -17,6 +17,7 @@ from products.signals.backend.artefact_schemas import ()from products.signals.backend.models import SignalReport, SignalReportArtefact, SignalUserAutonomyConfigfrom products.signals.backend.report_assignments import claim_report+from products.signals.backend.reviewer_exclusions import create_exclusionfrom products.signals.backend.reviewer_pr_assignment import assign_reviewers_to_pull_requestfrom products.signals.backend.test.test_reviewer_pr_assignment import (_NOT_UNASSIGNED,@@ -202,7 +203,8 @@ class TestReportPRAssignment:assert github.is_assignable.call_count == (1 if assignable else 10)@pytest.mark.parametrize(- "change", ["reviewers", "identity", "access", "preference", "github", "delivery", "writer", "selection"]+ "change",+ ["reviewers", "identity", "access", "preference", "github", "exclusion", "delivery", "writer", "selection"],)def test_a_change_during_permission_checks_stops_assignment(self, org_and_team, change):org, team = org_and_team@@ -221,6 +223,10 @@ class TestReportPRAssignment:SignalUserAutonomyConfig.objects.filter(user=selected).update(github_assign_on_pull_request=False)elif change == "github":github.assignee_state[:] = ["manual-owner"]+ elif change == "exclusion":+ create_exclusion(+ team_id=team.id, actor_id=selected.id, instruction="Off.", subject_user_uuid=selected.uuid+ )return {"success": True, "assignable": True}github.is_assignable.side_effect = check@@ -235,6 +241,8 @@ class TestReportPRAssignment:else:assert self.assign(report, github) == []github.add_pull_request_assignees.assert_not_called()+ if change == "exclusion":+ github.request_pull_request_reviews.assert_not_called()@pytest.mark.parametrize("opted_in", [False, True])def test_retry_uses_current_github_assignment_preference(diff --git a/products/signals/backend/test/test_reviewer_pr_assignment.py b/products/signals/backend/test/test_reviewer_pr_assignment.pyindex 1417d5f2f807..3feb1c8ba53a 100644--- a/products/signals/backend/test/test_reviewer_pr_assignment.py+++ b/products/signals/backend/test/test_reviewer_pr_assignment.py@@ -25,6 +25,7 @@ from products.signals.backend.report_assignments import (sync_task_pull_request_to_assignments,update_assignments_for_pull_request,)+from products.signals.backend.reviewer_exclusions import create_exclusionfrom products.signals.backend.reviewer_pr_assignment import (assign_reviewers_to_pull_request,opted_in_assignee_logins,@@ -879,6 +880,55 @@ class TestDirectlyResponsibleIndividual:assert self._assign(team, report, github) == []+ @pytest.mark.django_db+ @pytest.mark.parametrize(+ ("login_snapshot", "repository", "expected_owner"),+ [+ (None, "PostHog/posthog", "bob"),+ ("alice-before-rename", "posthog/posthog", "bob"),+ ("bob", "posthog/posthog", "bob"),+ (None, "PostHog/other", "alice"),+ ],+ ids=[+ "user_in_this_repository",+ "user_after_login_change",+ "login_moved_to_another_member",+ "another_repository",+ ],+ )+ def test_standing_exclusions_keep_a_person_off_owner_and_review_candidates(+ self, org_and_team: tuple[Organization, Team], login_snapshot: str | None, repository: str, expected_owner: str+ ) -> None:+ org, team = org_and_team+ report, users = self._setup(org, team, ["alice", "bob"])+ create_exclusion(+ team_id=team.id,+ actor_id=users["alice"].id,+ instruction="I moved off this repository.",+ subject_user_uuid=users["alice"].uuid,+ subject_github_login=login_snapshot,+ repository=repository,+ )+ github = self._github(existing_assignees=[], assignable=None)++ assert self._assign(team, report, github) == [[expected_owner]]+ assert [call.args[2] for call in github.request_pull_request_reviews.call_args_list] == [[expected_owner]]++ @pytest.mark.django_db+ def test_an_excluded_earlier_owner_is_not_asked_to_review(self, org_and_team: tuple[Organization, Team]) -> None:+ org, team = org_and_team+ report, users = self._setup(org, team, ["alice"])+ github = self._github(existing_assignees=[], assignable=None)+ assert self._assign(team, report, github) == [["alice"]]+ github.request_pull_request_reviews.reset_mock()+ create_exclusion(+ team_id=team.id, actor_id=users["alice"].id, instruction="Off.", subject_user_uuid=users["alice"].uuid+ )++ self._assign(team, report, github)++ github.request_pull_request_reviews.assert_not_called()+@pytest.mark.django_db@pytest.mark.parametrize("source", ["claimant", "reviewer-uuid", "reviewer-login"])@pytest.mark.parametrize("unavailable", ["inactive", "project"])@@ -903,14 +953,29 @@ class TestDirectlyResponsibleIndividual:@pytest.mark.django_db@pytest.mark.parametrize(- "change", ["assigned", "unassigned", "closed", "history-unavailable", "report", "claimant"]+ "change",+ [+ "assigned",+ "unassigned",+ "closed",+ "history-unavailable",+ "report",+ "claimant",+ "exclusion",+ "owner-exclusion",+ ],)def test_changes_during_github_checks_stop_dri_assignment(- self, org_and_team: tuple[Organization, Team], change: str+ self, org_and_team: tuple[Organization, Team], ownership: MagicMock, change: str) -> None:org, team = org_and_teamreport, users = self._setup(org, team, ["alice"])github = self._github(existing_assignees=[], assignable=None)+ if change == "owner-exclusion":+ ownership.return_value = PathOwnership(+ team_by_path={"posthog/api/a.py": "team-x"}, registry={}, resolved=True+ )+ github.list_team_members.return_value = {"success": True, "logins": ["carol"]}def check(_repo: str, _login: str) -> dict[str, bool]:if change == "assigned":@@ -926,6 +991,11 @@ class TestDirectlyResponsibleIndividual:SignalReportArtefact.objects.create(team=team, report=report, type="suggested_reviewers", content="[]")elif change == "claimant":self._claim(team, report, users, kind="user", login="bob")+ elif change in ("exclusion", "owner-exclusion"):+ subject = users["alice" if change == "exclusion" else "carol"]+ create_exclusion(+ team_id=team.id, actor_id=subject.id, instruction="Off.", subject_user_uuid=subject.uuid+ )return {"success": True, "assignable": True}github.is_assignable.side_effect = checkdiff --git a/products/signals/backend/test/test_reviewer_rules.py b/products/signals/backend/test/test_reviewer_rules.pyindex c17d75c0a8ee..4a72519018dc 100644--- a/products/signals/backend/test/test_reviewer_rules.py+++ b/products/signals/backend/test/test_reviewer_rules.py@@ -4,13 +4,15 @@ from uuid import UUIDfrom posthog.test.base import BaseTestfrom unittest.mock import patch+from django.db import connectionfrom django.test import SimpleTestCase+from django.test.utils import CaptureQueriesContextfrom django.utils import timezonefrom parameterized import parameterizedfrom social_django.models import UserSocialAuth-from posthog.models import OrganizationMembership, User+from posthog.models import OrganizationMembership, Team, Userfrom posthog.models.activity_logging.activity_log import ActivityLogfrom products.signals.backend.artefact_attribution import ArtefactAttribution@@ -25,11 +27,23 @@ from products.signals.backend.artefact_schemas import (WorkClaim,)from products.signals.backend.assignment_flags import assignment_side_effects_allowed, assignment_writer_enabled-from products.signals.backend.models import SignalReport, SignalReportArtefact+from products.signals.backend.models import (+ SignalReport,+ SignalReportArtefact,+ SignalReviewerExclusion,+ SignalReviewerExclusionRevision,+)from products.signals.backend.report_generation.resolve_reviewers import (get_org_member_github_logins_by_user_uuid,resolve_org_github_login_to_users,)+from products.signals.backend.reviewer_exclusions import (+ DuplicateExclusion,+ StandingExclusions,+ create_exclusion,+ revise_exclusion,+ revoke_exclusion,+)from products.signals.backend.reviewer_rules import ReviewerRules, ReviewerWriteError, StaleReviewerProposalfrom products.signals.backend.suggested_reviewer_index import report_ids_naming_reviewers, sync_suggested_reviewer_index@@ -447,6 +461,297 @@ class TestReviewerRules(BaseTest):) == [{"report_id": self.report.id}]+class TestStandingExclusions(BaseTest):+ def setUp(self) -> None:+ super().setUp()+ self.enabled = True+ self.flag = patch(+ "products.signals.backend.reviewer_rules.assignment_writer_enabled", side_effect=lambda _: self.enabled+ )+ self.flag.start()+ self.addCleanup(self.flag.stop)+ effects = patch("products.signals.backend.reviewer_rules.assignment_side_effects_enabled", return_value=False)+ effects.start()+ self.addCleanup(effects.stop)+ capture = patch("products.signals.backend.reviewer_rules.capture_reviewer_exclusion_applied")+ self.capture = capture.start()+ self.addCleanup(capture.stop)+ self.report = SignalReport.objects.create(team=self.team, status="ready", title="A report")+ self.rules = ReviewerRules(team=self.team, report_id=str(self.report.id))+ self.member = User.objects.create(email="[email protected]")+ OrganizationMembership.objects.create(user=self.member, organization=self.organization)+ self.me = SuggestedReviewerEntry(user_uuid=str(self.user.uuid))+ self.other = SuggestedReviewerEntry(user_uuid=str(self.member.uuid))+ SignalReportArtefact.objects.create(+ team=self.team, report=self.report, type="repo_selection", content=json.dumps({"repository": "Org/App"})+ )+ SignalReportArtefact.objects.create(+ team=self.team,+ report=self.report,+ type="signal_finding",+ content=json.dumps({"signal_id": "s1", "relevant_code_paths": ["/src/billing/charge.py"]}),+ )++ def exclude(self, **area: str) -> str:+ exclusion, _ = create_exclusion(+ team_id=self.team.id,+ actor_id=self.member.id,+ instruction="I moved off this area.",+ subject_user_uuid=self.member.uuid,+ **area,+ )+ return str(exclusion.id)++ def write(self, *reviewers: SuggestedReviewerEntry, source: str = "research") -> None:+ with self.captureOnCommitCallbacks(execute=True):+ SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=str(self.report.id),+ content=SuggestedReviewers(root=list(reviewers)),+ attribution=ArtefactAttribution.system(),+ reviewer_proposal=ReviewerProposal(expected_state=self.rules.read().state, source=source),+ )++ @parameterized.expand(+ [+ ("research_any_repo", "research", {}, True, True, None, False),+ ("scout_same_repo", "scout", {"repository": "org/app"}, True, True, None, False),+ (+ "custom_agent_path",+ "custom_agent",+ {"repository": "org/app", "path_prefix": "src/billing"},+ True,+ True,+ None,+ False,+ ),+ ("other_repo", "research", {"repository": "org/other"}, True, False, None, False),+ ("other_path", "scout", {"repository": "org/app", "path_prefix": "src/bill"}, True, False, None, False),+ (+ "superseded_finding_path",+ "research",+ {"repository": "org/app", "path_prefix": "src/billing"},+ True,+ False,+ ["src/search/query.py"],+ False,+ ),+ ("writer_disabled", "research", {"repository": "org/app"}, False, True, None, False),+ ("writer_disabled_login_only", "custom_agent", {}, False, True, None, True),+ ]+ )+ def test_matching_instruction_suppresses_the_subject_for_every_writer(+ self,+ _name: str,+ source: str,+ area: dict[str, str],+ enabled: bool,+ suppressed: bool,+ rewritten_paths: list[str] | None,+ by_login: bool,+ ) -> None:+ self.enabled = enabled+ if rewritten_paths is not None:+ SignalReportArtefact.objects.create(+ team=self.team,+ report=self.report,+ type="signal_finding",+ content=json.dumps({"signal_id": "s1", "relevant_code_paths": rewritten_paths}),+ )+ other = self.other+ if by_login:+ UserSocialAuth.objects.create(user=self.member, provider="github", uid="1", extra_data={"login": "member"})+ other = SuggestedReviewerEntry(github_login="member")+ exclusion_id = self.exclude(**area)+ self.write(self.me, other, source=source)+ assert [entry.user_uuid or entry.github_login for entry in self.rules.read().reviewers] == (+ [self.me.user_uuid] if suppressed else [self.me.user_uuid, other.user_uuid or other.github_login]+ )+ assert [call.kwargs for call in self.capture.call_args_list] == (+ [+ {+ "team_id": self.team.id,+ "report_id": str(self.report.id),+ "source": source,+ "events": [("suppressed", [exclusion_id])],+ }+ ]+ if suppressed+ else []+ )++ def test_unreadable_findings_do_not_block_a_path_instruction(self) -> None:+ for content in ["{not json", '{"signal_id": "s2", "relevant_code_paths": ["src/search/\\u0000.py"]}']:+ SignalReportArtefact.objects.create(+ team=self.team, report=self.report, type="signal_finding", content=content+ )+ self.exclude(repository="org/app", path_prefix="src/billing")+ self.write(self.me, self.other)+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.me.user_uuid]++ def test_login_only_writer_skips_identity_resolution_without_instructions(self) -> None:+ self.enabled = False+ UserSocialAuth.objects.create(user=self.member, provider="github", uid="1", extra_data={"login": "member"})+ with self.assertNumQueries(25):+ self.write(self.me, SuggestedReviewerEntry(github_login="member"), source="custom_agent")++ def test_revoked_instruction_stops_suppressing_and_keeps_history(self) -> None:+ exclusion_id = self.exclude()+ revise_exclusion(team_id=self.team.id, exclusion_id=exclusion_id, actor_id=self.user.id, repository="org/app")+ revise_exclusion(team_id=self.team.id, exclusion_id=exclusion_id, actor_id=self.user.id, repository=" Org/App ")+ revoke_exclusion(team_id=self.team.id, exclusion_id=exclusion_id, actor_id=self.user.id)+ self.write(self.other)+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.other.user_uuid]+ assert list(+ SignalReviewerExclusionRevision.objects.for_team(self.team.id)+ .filter(exclusion_id=exclusion_id)+ .order_by("revision")+ .values_list("revision", "action", "repository", "status", "actor_id")+ ) == [+ (1, "created", "", "active", self.member.id),+ (2, "revised", "org/app", "active", self.user.id),+ (3, "revoked", "org/app", "revoked", self.user.id),+ ]++ @parameterized.expand(+ [+ ("no_repository", {"repository": "org/app"}, "repo_selection", True),+ ("no_repository_writer_disabled", {"repository": "org/app"}, "repo_selection", False),+ ("no_paths", {"repository": "org/app", "path_prefix": "src"}, "signal_finding", True),+ ("no_paths_writer_disabled", {"repository": "org/app", "path_prefix": "src"}, "signal_finding", False),+ ]+ )+ def test_missing_area_state_keeps_the_current_selection(+ self, _name: str, area: dict[str, str], missing: str, enabled: bool+ ) -> None:+ self.enabled = enabled+ self.write(self.me)+ SignalReportArtefact.objects.filter(report=self.report, type=missing).delete()+ self.exclude(**area)+ self.write(self.other)+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.me.user_uuid]+ assert [event for call in self.capture.call_args_list for event in call.kwargs["events"]] == [+ ("unresolved", [])+ ]++ @parameterized.expand([("covered", True), ("repository_unknown", False)])+ def test_report_pin_wins_and_needs_a_person(self, _name: str, area_known: bool) -> None:+ SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=str(self.report.id),+ content=SuggestedReviewers(root=[self.other]),+ attribution=ArtefactAttribution.from_user(self.user.id),+ reviewer_edit=ReviewerEdit(action="add"),+ )+ if not area_known:+ SignalReportArtefact.objects.filter(report=self.report, type="repo_selection").delete()+ exclusion_id = self.exclude(repository="org/app")+ self.write(self.me, self.other)+ snapshot = self.rules.read()+ assert [entry.user_uuid for entry in snapshot.reviewers] == (+ [self.me.user_uuid, self.other.user_uuid] if area_known else [self.other.user_uuid]+ )+ assert snapshot.corrections.needs_review is area_known+ assert [event for call in self.capture.call_args_list for event in call.kwargs["events"]] == [+ ("pin_conflict", [exclusion_id]) if area_known else ("unresolved", [])+ ]++ def test_confirmed_list_is_kept_without_reading_instructions(self) -> None:+ self.write(self.me)+ SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=str(self.report.id),+ content=SuggestedReviewers(root=[]),+ attribution=ArtefactAttribution.from_user(self.user.id),+ reviewer_edit=ReviewerEdit(action="confirm", expected_state=self.rules.read().state),+ )+ self.exclude()+ with CaptureQueriesContext(connection) as queries:+ self.write(self.other)+ assert [entry.user_uuid for entry in self.rules.read().reviewers] == [self.me.user_uuid]+ assert not [query for query in queries.captured_queries if "signalreviewerexclusion" in query["sql"]]++ def test_finding_paths_are_read_only_for_a_path_instruction_in_the_report_repository(self) -> None:+ self.exclude(repository="org/other", path_prefix="src/billing")+ self.exclude(repository="org/app")+ with CaptureQueriesContext(connection) as queries:+ StandingExclusions.load(team_id=self.team.id, report_id=str(self.report.id))+ assert not [query for query in queries.captured_queries if "signal_finding" in query["sql"]]++ def test_create_returns_the_active_twin_and_revise_rejects_one(self) -> None:+ first = self.exclude(repository="org/app")+ assert self.exclude(repository=" Org/App ") == first+ after_github_connect, created = create_exclusion(+ team_id=self.team.id,+ actor_id=self.member.id,+ instruction="I moved off this area.",+ subject_user_uuid=self.member.uuid,+ subject_github_login="Reviewer",+ repository="org/app",+ )+ assert (str(after_github_connect.id), created) == (first, False)+ second = self.exclude(repository="org/other")+ with self.assertRaises(DuplicateExclusion):+ revise_exclusion(team_id=self.team.id, exclusion_id=second, actor_id=self.user.id, repository="org/app")+ # A concurrent amend can pass the twin check and still lose the unique index.+ with (+ patch(+ "products.signals.backend.reviewer_exclusions._active_twins",+ return_value=SignalReviewerExclusion.objects.none(),+ ),+ self.assertRaises(DuplicateExclusion),+ ):+ revise_exclusion(team_id=self.team.id, exclusion_id=second, actor_id=self.user.id, repository="org/app")+ assert SignalReviewerExclusion.objects.for_team(self.team.id).get(id=second).repository == "org/other"++ def test_a_moved_login_does_not_make_another_member_a_twin(self) -> None:+ theirs, _ = create_exclusion(+ team_id=self.team.id,+ actor_id=self.member.id,+ instruction="Off.",+ subject_user_uuid=self.member.uuid,+ subject_github_login="shared-login",+ )+ mine, created = create_exclusion(+ team_id=self.team.id,+ actor_id=self.user.id,+ instruction="Off.",+ subject_user_uuid=self.user.uuid,+ subject_github_login="shared-login",+ )+ assert created+ assert {theirs.subject_user_uuid, mine.subject_user_uuid} == {self.member.uuid, self.user.uuid}++ def test_each_login_resolves_once_per_load(self) -> None:+ UserSocialAuth.objects.create(user=self.member, provider="github", uid="1", extra_data={"login": "member"})+ self.exclude()+ standing = StandingExclusions.load(team_id=self.team.id, report_id=str(self.report.id))+ with patch(+ "products.signals.backend.reviewer_exclusions.resolve_org_github_login_to_users",+ wraps=resolve_org_github_login_to_users,+ ) as resolve:+ assert standing.allowed_logins(["member", "someone"]) == ["someone"]+ assert standing.allowed_logins(["Member"]) == []+ assert resolve.call_count == 1++ def test_active_twin_is_scoped_to_one_team(self) -> None:+ self.exclude(repository="org/app")+ self.exclude(repository="org/other")+ other_team = Team.objects.create(organization=self.organization)+ same_area, created = create_exclusion(+ team_id=other_team.id,+ actor_id=self.member.id,+ instruction="I moved off this area.",+ subject_user_uuid=self.member.uuid,+ repository="org/app",+ )+ assert created+ revised = revise_exclusion(+ team_id=other_team.id, exclusion_id=same_area.id, actor_id=self.member.id, repository="org/other"+ )+ assert (revised.team_id, revised.repository) == (other_team.id, "org/other")++class TestAssignmentReleaseControls(SimpleTestCase):@parameterized.expand([(None, False), (False, False), ("enabled", False), (True, True)])def test_writer_requires_explicit_enablement(self, value: object, enabled: bool) -> None: