: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
fix(signals): preserve reviewer edits in the existing artefact path (#119902)
Dylan Martinc91dc0dd1de6
diff --git a/docs/internal/signals-pr-lifecycle.md b/docs/internal/signals-pr-lifecycle.mdindex 1c15659d7ad1..eff08de2d0bc 100644--- a/docs/internal/signals-pr-lifecycle.md+++ b/docs/internal/signals-pr-lifecycle.md@@ -154,6 +154,106 @@ The notification activity retries transient ClickHouse reads before it claims thWhen an implementation pull request reaches the report, the worker requests reviews from suggested reviewers with connected GitHub accounts. It sends up to 15 reviewers per request. It skips the pull request author, existing assignees, the DRI it assigns, people with pending requests, and people who submitted a review. If GitHub rejects one reviewer, the worker continues with the other reviewers. Under the DRI rule, one assignee remains responsible for the pull request.+## Assignment decisions++All reviewer producers use `SignalReportArtefact.append_status()` (directly or through `append()`).+It applies `ReviewerRules` in the same transaction as the existing reviewer write, under the report lock.+The latest `suggested_reviewers` artefact remains the recipient list; `SignalReportSuggestedReviewer` remains its derived index.+Both use `(created_at, id)` to select the latest row.+There is no separate assignment table, operation ledger, or writer service.++### Assignment feedback loop++The product goal is for human feedback to improve the next relevant assignment, including when another research or scout producer makes it.+The shared write rules protect corrections on the current report. Existing notes, activity, and reviewer memory provide evidence for later selections.+Research already reads recent corrections, and eligible reviewer edits can send notes to relevant scouts.+Forwarding is best effort; permissions, identity coverage, retrieval, and agent judgment can each limit its effect.+Saving feedback alone does not establish that the next selection uses it.++The first milestone is to correct an assignment, explain the intended ownership, and run selection on a new, related report through another producer.+Confirm that the agent uses the feedback and explains its effect, while an unrelated case stays unaffected.+The original report must retain the correction. Repeat in both research-to-scout and scout-to-research directions, including members without GitHub accounts.+Each correction should work through existing controls and steering tools, without a code change or separate edits to every scout.+Selection guidance and scoped memory should remain inspectable and tunable; access and correction protection remain enforced in code.++A current-report correction is binding. On another report, it is scoped evidence with its source, date, and reason where available.+Self-removal alone does not establish an ownership change or a global exclusion.+Agents must not turn their own repeated selections into ownership evidence.++The complete-loop trial remains pending. Measure feedback availability before selection, retrieval, use, the applied result, and repeated assignment errors.+Distinguish unavailable feedback from feedback the agent considered but did not apply. Recipient review supplies the suitability judgment.+Existing notes do not guarantee an immediate rerun. Triggered reassessment remains separate work.+The [feedback-loop milestone](https://github.com/PostHog/posthog/issues/121777) tracks the trial and any missing links before broader identity, team, preference, or reassessment work.++### Human corrections++An add pins that person. A removal excludes that person.+Agents can still change people the user did not edit.+Adding an excluded person reverses that exclusion; removing a pinned person reverses that pin.+Only an explicit API `confirm` action protects the complete list, including an empty list.+The existing Inbox controls only add or remove people; they have no confirmation control.+Removing the last person does not confirm an empty list.+A person can still edit a confirmed list; agents cannot.+Current project access always applies, including to pins and confirmed lists.+A reviewer edit is not a work claim or permission to execute a task.++The same artefact table stores `reviewer_corrections`, with pins, exclusions, confirmation, and a history-review marker.+Corrections and membership are saved atomically with the existing actor and process attribution.+The first protected reviewer write recovers old corrections from reviewer deltas matched to activity records, under the report lock.+It saves the result once. Reads use saved corrections; before recovery, they mark reports with old human edits as needing review.+During rollout, automatic task start and PR owner selection wait for that recovery.+A human-authored snapshot alone does not prove approval of the complete list.+Incomplete history stops automatic changes until a person confirms the current list through the API.++### Write contract++Automatic callers read `reviewer_assignment.state` from the report detail response before selection.+This is the only API response that includes correction state.+The web app does not need it for targeted add/remove requests.+Send both `reviewers_id` and `corrections_id` as `expected_reviewers`.+The write rejects an old state under the report lock.+These IDs cover assignment state, not changes to research evidence.++Human add/remove requests name only the people changed.+They apply to current membership so unrelated concurrent edits survive.+Replacement and confirmation require the state the person saw.+Read the reviewer artefact named by that state when preparing either operation.+Clients can send explicit `targets` with an add/remove action while retaining a full `content` list for older servers.+Protected reports reject full replacements without state; older Desktop/mobile clients must update before rollout.++Automatic results distinguish `selected`, `no_suitable_owner`, and `lookup_failed`.+A deliberate empty result clears automatic recipients but retains pins and confirmed lists.+Failed lookup or wholly invalid selection retains valid current recipients.+Accepted recipients must be active members with project access.+An unchanged retry creates no reviewer row or delivery work. A retry with old state can return a conflict.+Research changes to explanations or display names alone also create no reviewer row or delivery work.+Generic artefact PATCH and DELETE cannot change reviewer history, and clients cannot write correction records directly.+If stored reviewer data is invalid, a person can replace the list with matching state, even with the writer flag off.+The repair keeps the old rows and existing corrections. It does not confirm the list or clear the history-review marker.++### Rollout and rollback++| Control | Allows |+| --------------------------------- | -------------------------------------------------------------------------------------------------------------------------------- |+| `signals-assignment-writer` | Reviewer corrections and state checks on existing writes. |+| `signals-assignment-side-effects` | Existing Slack delivery, automatic task start, GitHub assignment, review requests, and ready-state changes for enrolled reports. |++Both flags support organization targeting and require explicit enablement.+They use local evaluation, so a report lock never waits for the flag service.+Missing flag definitions keep the new behavior disabled.+Enable the writer with side effects disabled to test real assignment changes without external delivery or task start.+This changes the real Inbox list and index; it is not a shadow write.+Local activity records, scoped correction notes, and existing measurements remain active.+A corrections artefact marks enrollment, so delivery remains gated after writer rollback and for queued work.+Disable side effects and the writer to stop a trial. Automatic replacement stops on enrolled reports; human corrections still work.+Reports that never enrolled keep their existing behavior.+A flag change cannot retract a sent message or stop an external call that already passed its check.+After-commit scheduling is best effort. Suppressed actions are not queued for later delivery.++Before rollout, test self-removal, self-addition, concurrent edits, explicit empty confirmation, stale results, retries, access loss, and failed selection.+Also test the assignment feedback loop above. Preserving a correction does not establish that later selections improve.+The [system design](https://github.com/PostHog/posthog/issues/120572) describes selection, later roles, and delivery work.+## Report linksOnly scouts and the signals pipeline create and manage typed, directed report links.diff --git a/posthog/models/team/team.py b/posthog/models/team/team.pyindex e84aa78e694e..188128054c6d 100644--- a/posthog/models/team/team.py+++ b/posthog/models/team/team.py@@ -1,4 +1,5 @@from collections import defaultdict+from collections.abc import Collectionfrom datetime import timedeltafrom decimal import Decimalfrom typing import TYPE_CHECKING, Optional, cast@@ -1185,7 +1186,7 @@ class Team(UUIDTClassicModel):cache.set(cache_key, "True") # Create an item in the cache that we can use to see if the demo data is readycreate_data_for_demo_team.delay(self.id, initiating_user.id, cache_key)- def all_users_with_access(self) -> QuerySet["User"]:+ def all_users_with_access(self, *, user_uuids: Optional[Collection[str]] = None) -> QuerySet["User"]:from posthog.constants import AvailableFeature # noqa: PLC0415from posthog.models.user import User # noqa: PLC0415@@ -1196,13 +1197,14 @@ class Team(UUIDTClassicModel):from products.access_control.backend.models.role import RoleMembership # noqa: PLC0415organization = self.organization+ member_queryset = OrganizationMembership.objects.filter(organization_id=self.organization_id)+ if user_uuids is not None:+ member_queryset = member_queryset.filter(user__uuid__in=user_uuids)# An organization without ACCESS_CONTROL has no private projects, so every active member# has access. Return a SQL subquery so `.exists()`, `.count()`, and `.filter()` callers# answer in Postgres instead of materializing every membership here first.if not organization.is_feature_available(AvailableFeature.ACCESS_CONTROL):- member_user_ids = OrganizationMembership.objects.filter(organization_id=self.organization_id).values_list(- "user_id", flat=True- )+ member_user_ids = member_queryset.values_list("user_id", flat=True)return User.objects.filter(is_active=True, id__in=member_user_ids)team_rows = list(AccessControl.objects.filter(team_id=self.id, resource="project", resource_id=str(self.id)))@@ -1224,23 +1226,20 @@ class Team(UUIDTClassicModel):if default_level in (None, "member", "admin"):# No default rule falls through to the facade's admin default; "member"/"admin"# default rules grant access to every active org member.- member_user_ids = OrganizationMembership.objects.filter(- organization_id=self.organization_id- ).values_list("user_id", flat=True)+ member_user_ids = member_queryset.values_list("user_id", flat=True)else:# Default "none" denies every member; only org admins and owners pass the# subject's admin bypass.- member_user_ids = OrganizationMembership.objects.filter(- organization_id=self.organization_id,- level__gte=OrganizationMembership.Level.ADMIN,- ).values_list("user_id", flat=True)+ member_user_ids = member_queryset.filter(level__gte=OrganizationMembership.Level.ADMIN).values_list(+ "user_id", flat=True+ )return User.objects.filter(is_active=True, id__in=member_user_ids)# General case: resolve each active member through `SubjectAccessControl`, seeding its# pool from the single team-rules fetch so N subjects share one query rather than running# N of them. Only load the user columns subject resolution actually reads (its id).memberships = list(- OrganizationMembership.objects.filter(organization_id=self.organization_id, user__is_active=True)+ member_queryset.filter(user__is_active=True).select_related("user").only("id", "user_id", "level", "user__id"))diff --git a/posthog/models/test/test_team_model.py b/posthog/models/test/test_team_model.pyindex 5282212f178d..c3c0091f4e83 100644--- a/posthog/models/test/test_team_model.py+++ b/posthog/models/test/test_team_model.py@@ -136,6 +136,8 @@ class TestTeam(BaseTest):all_user_with_access_ids = list(self.team.all_users_with_access().values_list("id", flat=True))assert sorted(all_user_with_access_ids) == sorted([self.user.id, another_user.id])+ assert list(self.team.all_users_with_access(user_uuids={str(another_user.uuid)})) == [another_user]+ assert not self.team.all_users_with_access(user_uuids=set()).exists()def test_all_users_with_access_simple_org_membership_and_redundant_team_one(self):self.organization_membership.level = OrganizationMembership.Level.MEMBER@@ -151,6 +153,7 @@ class TestTeam(BaseTest):def test_all_users_with_access_new_access_control_non_private_team(self):"""Test that all organization members have access to a non-private team with the new access control system"""+ self._enable_access_control()# Create another user as a membermember_user = User.objects.create_and_join(@@ -166,6 +169,7 @@ class TestTeam(BaseTest):# Both users should have access since the team is not privateassert sorted(all_user_with_access_ids) == sorted([self.user.id, member_user.id])+ assert list(self.team.all_users_with_access(user_uuids={str(member_user.uuid)})) == [member_user]def test_all_users_with_access_new_access_control_private_team(self):"""Test that only users with specific access have access to a private team with the new access control system"""@@ -199,6 +203,7 @@ class TestTeam(BaseTest):# Only the admin user should have accessassert all_user_with_access_ids == [self.user.id]+ assert not self.team.all_users_with_access(user_uuids=set()).exists()def test_all_users_with_access_new_access_control_private_team_with_member_access(self):"""Test that users with specific member access have access to a private team with the new access control system"""@@ -242,6 +247,7 @@ class TestTeam(BaseTest):# Both users should have accessassert sorted(all_user_with_access_ids) == sorted([self.user.id, member_user.id])+ assert list(self.team.all_users_with_access(user_uuids={str(member_user.uuid)})) == [member_user]def test_all_users_with_access_new_access_control_private_team_with_role_access(self):"""Test that users with role-based access have access to a private team with the new access control system"""@@ -287,6 +293,8 @@ class TestTeam(BaseTest):# Both users should have accessassert sorted(all_user_with_access_ids) == sorted([self.user.id, member_user.id])+ assert list(self.team.all_users_with_access(user_uuids={str(member_user.uuid)})) == [member_user]+ assert not self.team.all_users_with_access(user_uuids=set()).exists()def test_all_users_with_access_ignores_role_membership_from_another_organization(self):self._enable_access_control(role_based=True)@@ -333,6 +341,7 @@ class TestTeam(BaseTest):all_user_with_access_ids = list(self.team.all_users_with_access().values_list("id", flat=True))assert all_user_with_access_ids == [self.user.id]+ assert not self.team.all_users_with_access(user_uuids={str(member_user.uuid)}).exists()def test_all_users_with_access_returns_all_org_members_without_access_control_feature(self):"""Without ACCESS_CONTROL there are no private teams — every org member has access,diff --git a/products/signals/backend/artefact_schemas.py b/products/signals/backend/artefact_schemas.pyindex c06196f73a58..9fdbd03c8b9f 100644--- a/products/signals/backend/artefact_schemas.py+++ b/products/signals/backend/artefact_schemas.py@@ -299,6 +299,44 @@ class SuggestedReviewers(RootModel[list[SuggestedReviewerEntry]]):"""Content schema for a `suggested_reviewers` artefact — the content root is a JSON list."""+class ReviewerState(BaseModel):+ model_config = ConfigDict(extra="forbid", frozen=True)++ reviewers_id: UUID | None = None+ corrections_id: UUID | None = None+++class ReviewerCorrections(BaseModel):+ model_config = ConfigDict(extra="forbid", frozen=True)++ pinned: tuple[SuggestedReviewerEntry, ...] = ()+ excluded: tuple[SuggestedReviewerEntry, ...] = ()+ confirmed: bool = False+ needs_review: bool = False+++class ReviewerProposal(BaseModel):+ model_config = ConfigDict(extra="forbid", frozen=True)++ expected_state: ReviewerState+ source: str = "automatic"+ outcome: Literal["selected", "no_suitable_owner", "lookup_failed"] = "selected"+ retry_reason: str | None = Field(default=None, max_length=500)++ @model_validator(mode="after")+ def validate_outcome(self) -> ReviewerProposal:+ if self.outcome == "lookup_failed" and not self.retry_reason:+ raise ValueError("A failed lookup needs a retry reason.")+ return self+++class ReviewerEdit(BaseModel):+ model_config = ConfigDict(extra="forbid", frozen=True)++ action: Literal["add", "remove", "replace", "confirm"]+ expected_state: ReviewerState | None = None++class ChannelAssignment(BaseModel):"""The space that currently owns a report. The latest assignment wins."""@@ -1186,6 +1224,7 @@ StatusArtefactContent = (| PriorityAssessment| RepoSelectionResult| SuggestedReviewers+ | ReviewerCorrections| ChannelAssignment| ImplementationDecision| ImplementationDispatch@@ -1227,6 +1266,7 @@ ARTEFACT_CONTENT_SCHEMAS: Mapping[str, type[BaseModel]] = {"signal_finding": SignalFinding,"repo_selection": RepoSelectionResult,"suggested_reviewers": SuggestedReviewers,+ "reviewer_corrections": ReviewerCorrections,"channel_assignment": ChannelAssignment,"ranking_score": RankingScore,"dismissal": Dismissal,@@ -1281,6 +1321,7 @@ _ARTEFACT_TYPE_BY_MODEL: Mapping[type[BaseModel], str] = {model: t for t, model# the API would let a caller fabricate a probability the model never produced.NON_WRITABLE_ARTEFACT_TYPES: frozenset[str] = frozenset({+ "reviewer_corrections","task_run","video_segment","title_change",diff --git a/products/signals/backend/assignment_flags.py b/products/signals/backend/assignment_flags.pynew file mode 100644index 000000000000..2af6f009a328--- /dev/null+++ b/products/signals/backend/assignment_flags.py@@ -0,0 +1,47 @@+import structlog++from posthog.models.team.team import Team+from posthog.ph_client import feature_enabled_or_false++from products.signals.backend.models import SignalReportArtefact++logger = structlog.get_logger(__name__)+++def _enabled(key: str, team_id: int) -> bool:+ try:+ organization_id = str(Team.objects.values_list("organization_id", flat=True).get(id=team_id))+ return (+ feature_enabled_or_false(+ key,+ organization_id,+ groups={"organization": organization_id},+ group_properties={"organization": {"id": organization_id}},+ send_feature_flag_events=False,+ only_evaluate_locally=True,+ )+ is True+ )+ except Exception:+ logger.exception("signals.assignment.flag_check_failed", team_id=team_id, flag=key)+ return False+++def assignment_writer_enabled(team_id: int) -> bool:+ return _enabled("signals-assignment-writer", team_id)+++def assignment_side_effects_enabled(team_id: int) -> bool:+ return _enabled("signals-assignment-side-effects", team_id)+++def assignment_side_effects_allowed(*, team_id: int, report_id: str) -> bool:+ # Keep the trial boundary after a writer flag is disabled, including for queued work.+ if not SignalReportArtefact.objects.filter(+ team_id=team_id, report_id=report_id, type="reviewer_corrections"+ ).exists():+ return True+ allowed = assignment_side_effects_enabled(team_id)+ if not allowed:+ logger.info("signals.assignment.side_effects_disabled", team_id=team_id, report_id=report_id)+ return alloweddiff --git a/products/signals/backend/auto_start.py b/products/signals/backend/auto_start.pyindex 3d4e846d9dae..e8028245720c 100644--- a/products/signals/backend/auto_start.py+++ b/products/signals/backend/auto_start.py@@ -24,7 +24,14 @@ from posthog.user_permissions import UserPermissionsfrom products.signals.backend.agent_runtime import STEP_IMPLEMENTATION, resolve_agent_runtimefrom products.signals.backend.artefact_attribution import ArtefactAttribution-from products.signals.backend.artefact_schemas import AutostartSkip, ImplementationDispatch, ImplementationReplacement+from products.signals.backend.artefact_schemas import (+ AutostartSkip,+ ImplementationDispatch,+ ImplementationReplacement,+ ReviewerState,+ SuggestedReviewerEntry,+)+from products.signals.backend.assignment_flags import assignment_side_effects_allowed, assignment_writer_enabledfrom products.signals.backend.billing import (BillingExemptionError,mark_report_billing_exempt,@@ -61,6 +68,7 @@ from products.signals.backend.report_generation.resolve_reviewers import (from products.signals.backend.report_generation.select_repo import RepoSelectionResultfrom products.signals.backend.report_steering import NO_STEERING, ReportSteering, load_report_steeringfrom products.signals.backend.report_urls import ReportLinkSource, build_report_url+from products.signals.backend.reviewer_rules import ReviewerRules, contains_reviewerfrom products.signals.backend.scout_authorship import report_is_from_background_scout, resolve_touching_scout_skillsfrom products.signals.backend.scout_harness.skill_loader import resolve_skill_owner_user_uuidsfrom products.signals.backend.signal_metadata import (@@ -755,6 +763,7 @@ def _create_implementation_task_if_absent(dispatch: ImplementationDispatch | None = None,requested_after_run_count: int | None = None,runner_source: str = "requested",+ expected_reviewers: ReviewerState | None = None,ch_user: ClickHouseUser = ClickHouseUser.DEFAULT,) -> bool | AutostartSkip:"""Create the implementation task and record it (gate row + work-log artefact), serialized per report.@@ -790,6 +799,13 @@ def _create_implementation_task_if_absent(report = SignalReport.objects.select_for_update().filter(id=report_id, team_id=team_id).first()if report is None:return False+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return False+ if (+ expected_reviewers is not None+ and ReviewerRules.read_for_report(team_id=team_id, report_id=report_id).state != expected_reviewers+ ):+ raise ReportChangedDuringAutostart("Reviewers changed before task creation")if ImplementationReportContent.from_report(report) != expected_content:raise ReportChangedDuringAutostart("Report changed before its implementation task could start")if requested_after_run_count is not None and (@@ -1396,6 +1412,9 @@ async def maybe_autostart_implementation_task(their report and artefacts. Callers should wrap this in try/except so anautostart failure does not fail the report itself."""+ if not await database_sync_to_async(assignment_side_effects_allowed)(team_id=team_id, report_id=report_id):+ return AutostartOutcome(status="cancelled", reason="Assignment side effects are disabled")+# Cheap pre-check to skip the expensive assignee resolution when a task already exists;# the authoritative, race-free check happens under the lock below.task_exists = bool(@@ -1407,6 +1426,33 @@ async def maybe_autostart_implementation_task(if report is None:logger.info("self-driving auto-start skipped", report_id=report_id, team_id=team_id, reason="report gone")return AutostartOutcome(status="cancelled", reason="Report no longer exists")+ assignment = await database_sync_to_async(ReviewerRules.read_for_report)(team_id=team_id, report_id=report_id)+ if (+ assignment.state.corrections_id is None+ and assignment.corrections.needs_review+ and await database_sync_to_async(assignment_writer_enabled)(team_id)+ ):+ return AutostartOutcome(+ status="blocked", reason="Older reviewer edits need recovery before automatic execution"+ )+ if assignment.state.corrections_id is not None:+ reviewers_content, triggering_user_id = await _latest_reviewers_content(report_id)+ if triggering_user_id is None and (+ assignment.corrections.pinned or assignment.corrections.excluded or assignment.corrections.needs_review+ ):+ # A pin records routing intent, not permission to run with that member's credentials.+ reviewers_content = [+ entry+ for entry in reviewers_content+ if not contains_reviewer(+ assignment.corrections.pinned,+ SuggestedReviewerEntry(user_uuid=entry.get("user_uuid"), github_login=entry.get("github_login")),+ )+ ]+ if assignment.corrections.needs_review or not reviewers_content:+ return AutostartOutcome(+ status="blocked", reason="No automatic reviewer remains after human corrections"+ )expected_content = ImplementationReportContent.from_report(report)if title != expected_content.title or summary != expected_content.summary:if remaining_retries:@@ -1597,6 +1643,7 @@ async def maybe_autostart_implementation_task(report_id=report_id,title=title,expected_content=expected_content,+ expected_reviewers=assignment.state,description=_build_autostart_task_description(report_id=report_id,team_id=team_id,@@ -1654,7 +1701,7 @@ async def _latest_reviewers_content(report_id: str) -> tuple[list[ReviewerContenawait SignalReportArtefact.objects.filter(report_id=report_id, type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS)- .order_by("-created_at")+ .order_by("-created_at", "-id").afirst())if artefact is None:diff --git a/products/signals/backend/custom_agent/persistence.py b/products/signals/backend/custom_agent/persistence.pyindex fd50c52edeac..27ec0a32f5db 100644--- a/products/signals/backend/custom_agent/persistence.py+++ b/products/signals/backend/custom_agent/persistence.py@@ -2,15 +2,24 @@ from __future__ import annotationsfrom collections.abc import Sequencefrom dataclasses import dataclass+from uuid import uuid4from django.db import transactionfrom django.utils import timezone-from products.signals.backend.artefact_schemas import ArtefactContent, SuggestedReviewers+from posthog.models.team.team import Team++from products.signals.backend.artefact_schemas import (+ ArtefactContent,+ ReviewerProposal,+ ReviewerState,+ SuggestedReviewers,+)from products.signals.backend.custom_agent.schemas import CustomAgentFinalReportfrom products.signals.backend.models import ArtefactAttribution, SignalReport, SignalReportArtefactfrom products.signals.backend.report_generation.reviewer_telemetry import capture_suggested_reviewers_resolvedfrom products.signals.backend.report_generation.select_repo import RepoSelectionResult+from products.signals.backend.reviewer_rules import ReviewerRulesfrom products.signals.backend.task_run_artefacts import append_task_run_artefact@@ -36,8 +45,11 @@ def create_custom_agent_ready_report(artefact type, queued during the run via the agent's `register_artefact`, written in queueorder (status types route through their latest-wins append semantics)."""+ report_id = str(uuid4())+ assignment = ReviewerRules(team=Team.objects.get(id=team_id), report_id=report_id)with transaction.atomic():report = SignalReport.objects.create(+ id=report_id,team_id=team_id,status=SignalReport.Status.READY,title=final_report.title,@@ -75,25 +87,33 @@ def create_custom_agent_ready_report(content=final_report.priority,attribution=attribution,)- if final_report.assignees:- SignalReportArtefact.append_status(+ reviewers = (+ SuggestedReviewers.model_validate([assignee.model_dump(mode="json") for assignee in final_report.assignees])+ if final_report.assignees+ else None+ )+ for artefact_content in registered_artefacts:+ if isinstance(artefact_content, SuggestedReviewers):+ reviewers = artefact_content+ continue+ SignalReportArtefact.append(team_id=team_id,report_id=report_id,- content=SuggestedReviewers.model_validate(- [assignee.model_dump(mode="json") for assignee in final_report.assignees]- ),+ content=artefact_content,attribution=attribution,reevaluate_autostart=False,)-- for artefact_content in registered_artefacts:- SignalReportArtefact.append(+ if reviewers is not None or assignment.enabled:+ reviewers = reviewers or SuggestedReviewers(root=[])+ artefact = SignalReportArtefact.append_status(team_id=team_id,report_id=report_id,- content=artefact_content,+ content=reviewers,attribution=attribution,+ reviewer_proposal=ReviewerProposal(expected_state=ReviewerState(), source="custom_agent"),reevaluate_autostart=False,)+ reviewers = SuggestedReviewers.model_validate_json(artefact.content)if task_id is not None:product, type = agent_identifier@@ -105,26 +125,12 @@ def create_custom_agent_ready_report(task_id=task_id,)- # After the transaction so a telemetry failure can't roll back the report. Telemetry mirrors- # the live reviewer set: suggested_reviewers appends are latest-wins and registered artefacts- # are written after the assignees append, so a registered SuggestedReviewers overrides it —- # including an empty one, which is a persisted "no reviewers" state and must still emit.- reviewer_logins = [assignee.github_login for assignee in final_report.assignees]- reviewer_user_uuids: list[str] = []- reviewers_written = bool(final_report.assignees)- for artefact_content in registered_artefacts:- if isinstance(artefact_content, SuggestedReviewers):- reviewers_written = True- reviewer_logins = [entry.github_login for entry in artefact_content.root if entry.github_login]- reviewer_user_uuids = [- entry.user_uuid for entry in artefact_content.root if entry.user_uuid and not entry.github_login- ]- if reviewers_written:+ if reviewers is not None:capture_suggested_reviewers_resolved(team_id=team_id,report_id=str(report.id),- github_logins=reviewer_logins,- user_uuids=reviewer_user_uuids,+ github_logins=[entry.github_login for entry in reviewers.root if entry.github_login],+ user_uuids=[entry.user_uuid for entry in reviewers.root if entry.user_uuid and not entry.github_login],source="custom_agent",)diff --git a/products/signals/backend/enums.py b/products/signals/backend/enums.pyindex 68e1ab283ca3..19753e2d1689 100644--- a/products/signals/backend/enums.py+++ b/products/signals/backend/enums.py@@ -27,6 +27,19 @@ class ReportTaskActionKind(LabeledStrEnum):SUGGESTED_PROMPT = "suggested_prompt", "Suggested prompt"+class ReviewerSelectionOutcome(LabeledStrEnum):+ SELECTED = "selected", "Selected"+ NO_SUITABLE_OWNER = "no_suitable_owner", "No suitable owner"+ LOOKUP_FAILED = "lookup_failed", "Lookup failed"+++class ReviewerEditAction(LabeledStrEnum):+ ADD = "add", "Add"+ REMOVE = "remove", "Remove"+ REPLACE = "replace", "Replace"+ CONFIRM = "confirm", "Confirm"++class ReportLinkKind(LabeledStrEnum):# How one report relates to another, written as a directed `report_link` artefact on the# report the sentence starts from: "this report DEPENDS_ON that one". A GitHub issue thatdiff --git a/products/signals/backend/models.py b/products/signals/backend/models.pyindex 6e6169500a17..05d10cc55922 100644--- a/products/signals/backend/models.py+++ b/products/signals/backend/models.py@@ -35,8 +35,11 @@ from products.signals.backend.artefact_schemas import (LogArtefactContent,RelatedTo,ReportLink,+ ReviewerEdit,+ ReviewerProposal,SignalFinding,StatusArtefactContent,+ SuggestedReviewers,TaskRunArtefact,artefact_type_for,artefact_type_for_model,@@ -1379,6 +1382,7 @@ class SignalReportArtefact(UUIDModel):SIGNAL_FINDING = "signal_finding"REPO_SELECTION = "repo_selection"SUGGESTED_REVIEWERS = "suggested_reviewers"+ REVIEWER_CORRECTIONS = "reviewer_corrections"CHANNEL_ASSIGNMENT = "channel_assignment"DISMISSAL = "dismissal"CODE_REFERENCE = "code_reference"@@ -1426,6 +1430,7 @@ class SignalReportArtefact(UUIDModel):ArtefactType.PRIORITY_JUDGMENT,ArtefactType.REPO_SELECTION,ArtefactType.SUGGESTED_REVIEWERS,+ ArtefactType.REVIEWER_CORRECTIONS,ArtefactType.CHANNEL_ASSIGNMENT,ArtefactType.IMPLEMENTATION_DECISION,ArtefactType.IMPLEMENTATION_DISPATCH,@@ -1437,6 +1442,7 @@ class SignalReportArtefact(UUIDModel):# no activity a user can see, so the artefact count leaves them out, and the artefact log shows# them to staff only.SYSTEM_SCORING_ARTEFACT_TYPES: frozenset[str] = frozenset({ArtefactType.RANKING_SCORE})+ INTERNAL_ARTEFACT_TYPES: frozenset[str] = frozenset({ArtefactType.REVIEWER_CORRECTIONS})# A `report_link` graph is written by hand or by an agent, one report at a time, so a real# chain is a handful of reports deep. The budgets guard the cycle walk on the write path# against a graph that grew past anything a reader could order. Rows and levels are bounded@@ -1544,7 +1550,7 @@ class SignalReportArtefact(UUIDModel):The inbox list renders this count for every row it returns. A correlated subquery makesPostgres count a report's artefacts before the page limit applies, so the whole team'sreports get counted to render 25. Reports with no artefacts are omitted, and so are- `SYSTEM_SCORING_ARTEFACT_TYPES` rows.+ internal assignment and system scoring rows."""if not report_ids:return {}@@ -1552,6 +1558,7 @@ class SignalReportArtefact(UUIDModel):cls.objects.filter(report_id__in=report_ids).exclude(type__in=cls.SYSTEM_SCORING_ARTEFACT_TYPES+ | cls.INTERNAL_ARTEFACT_TYPES| ({cls.ArtefactType.CHECK_OBSERVATION} if not monitoring_enabled else set())).values("report_id")@@ -1661,6 +1668,8 @@ class SignalReportArtefact(UUIDModel):attribution: ArtefactAttribution,claim_id: str | None = None,reevaluate_autostart: bool = True,+ reviewer_proposal: ReviewerProposal | None = None,+ reviewer_edit: ReviewerEdit | None = None,) -> "SignalReportArtefact":"""Append a new version of a status artefact (see `STATUS_ARTEFACT_TYPES`) and return it.@@ -1674,12 +1683,48 @@ class SignalReportArtefact(UUIDModel):"""if artefact_type_for(content) not in cls.STATUS_ARTEFACT_TYPES:raise ValueError(f"{type(content).__name__} is not a status artefact content model")- artefact = cls._create(+ if artefact_type_for(content) == cls.ArtefactType.REVIEWER_CORRECTIONS:+ raise ArtefactContentValidationError("Use reviewer edits to record corrections.")+ if isinstance(content, SuggestedReviewers):+ # The rules import this model; load them only on a reviewer write.+ from posthog.models.team.team import Team++ from products.signals.backend.report_claims import actor_owns_claim, get_active_claim+ from products.signals.backend.reviewer_rules import ReviewerRules++ rules = ReviewerRules(team=Team.objects.get(id=team_id), report_id=report_id)+ with transaction.atomic():+ SignalReport.objects.select_for_update().exclude(status=SignalReport.Status.DELETED).get(+ team_id=team_id, id=report_id+ )+ if claim_id:+ claim = get_active_claim(team_id=team_id, report_id=report_id)+ if claim is None or str(claim.claim_id) != claim_id or not actor_owns_claim(claim, attribution):+ raise ArtefactContentValidationError("Claim is stale or belongs to another actor.")+ update = rules.prepare(content, attribution=attribution, proposal=reviewer_proposal, edit=reviewer_edit)+ if update.corrections is not None:+ cls._create(+ team_id=team_id,+ report_id=report_id,+ content=update.corrections,+ attribution=attribution,+ claim_id=claim_id,+ )+ if update.current is not None and cls._parse_as(update.current, SuggestedReviewers) == update.reviewers:+ return update.current+ artefact = cls._create(+ team_id=team_id,+ report_id=report_id,+ content=update.reviewers,+ attribution=attribution,+ claim_id=claim_id,+ )+ if reevaluate_autostart and (not update.protected or rules.effects_enabled):+ cls._schedule_autostart_reevaluation(team_id=team_id, report_id=str(report_id))+ return artefact+ return cls._create(team_id=team_id, report_id=report_id, content=content, attribution=attribution, claim_id=claim_id)- if reevaluate_autostart and artefact.type == cls.ArtefactType.SUGGESTED_REVIEWERS:- cls._schedule_autostart_reevaluation(team_id=team_id, report_id=str(report_id))- return artefact@classmethoddef _latest_of(@@ -2052,6 +2097,8 @@ class SignalReportArtefact(UUIDModel):attribution: ArtefactAttribution,claim_id: str | None = None,reevaluate_autostart: bool = True,+ reviewer_proposal: ReviewerProposal | None = None,+ reviewer_edit: ReviewerEdit | None = None,) -> "SignalReportArtefact":"""Append an artefact of any content model, routing to its type's append semantics.@@ -2073,6 +2120,8 @@ class SignalReportArtefact(UUIDModel):content=cast(StatusArtefactContent, content),attribution=attribution,reevaluate_autostart=reevaluate_autostart,+ reviewer_proposal=reviewer_proposal,+ reviewer_edit=reviewer_edit,claim_id=claim_id,)if artefact_type in cls.LOG_ARTEFACT_TYPES:@@ -2095,6 +2144,8 @@ class SignalReportArtefact(UUIDModel):so it re-evaluates auto-start the same way appending a new reviewers row does."""if self.type == self.ArtefactType.IMPACT_MEASUREMENT_PLAN:raise ArtefactContentValidationError("Append a new measurement version instead of editing one.")+ if self.type in {self.ArtefactType.REVIEWER_CORRECTIONS, self.ArtefactType.SUGGESTED_REVIEWERS}:+ raise ArtefactContentValidationError("Append a reviewer change instead of editing history.")parsed = parse_artefact_content(self.type, content)# The `task` FK is the association and is creation-time only; an edit must not let# content.task_id drift away from it.diff --git a/products/signals/backend/reviewer_pr_assignment.py b/products/signals/backend/reviewer_pr_assignment.pyindex 28ddc7a650d2..de376ef2a02c 100644--- a/products/signals/backend/reviewer_pr_assignment.py+++ b/products/signals/backend/reviewer_pr_assignment.py@@ -38,6 +38,7 @@ from posthog.models.integration import GitHubIntegrationfrom posthog.ph_client import feature_enabled_or_falsefrom products.signals.backend.artefact_schemas import TASK_RUN_TYPE_IMPLEMENTATION, TaskRunArtefact+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.models import (SignalActorKind,SignalReport,@@ -87,6 +88,9 @@ def schedule_reviewer_pr_assignment(on a worker instead of holding up a claim, a PR sync, or a reviewer edit. `robust=True` keeps abroker outage from failing a write that already committed."""+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return+# A null state reads as unknown, the same way the rest of the assignment code reads the column,# so a row that never recorded a state is not silently skipped forever.if not pr_url or (pr_state or SignalReportAssignment.PrState.UNKNOWN) not in ASSIGNABLE_PR_STATES:@@ -117,7 +121,7 @@ def _latest_reviewer_rows(report_id: str) -> list[dict[str, Any]]:report_id=report_id,type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,)- .order_by("-created_at")+ .order_by("-created_at", "-id").first())if latest is None:@@ -303,6 +307,8 @@ def _add_assignees("""log = logger.bind(team_id=team_id, report_id=report_id, repository=parsed.repository, pr_number=parsed.number)try:+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return Noneresult = github.add_pull_request_assignees(parsed.repository, parsed.number, logins)except Exception:log.exception("signals.reviewer_pr_assignment.assign_failed")@@ -352,6 +358,8 @@ def _request_reviews(return []try:+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return []result = github.request_pull_request_reviews(parsed.repository, parsed.number, wanted)except Exception:log.exception("signals.reviewer_pr_assignment.review_request_failed")@@ -457,6 +465,9 @@ def assign_reviewers_to_pull_request(*, team_id: int, report_id: str, pr_url: stso a person somebody assigned by hand stays on the pull request. Returns an empty list whenthere is nothing to do or the call failed, and raises nothing."""+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return []+if not SignalReport.objects.filter(id=report_id, team_id=team_id).exists():return []diff --git a/products/signals/backend/reviewer_pr_ready.py b/products/signals/backend/reviewer_pr_ready.pyindex c6d59484756d..e9b798a3ed39 100644--- a/products/signals/backend/reviewer_pr_ready.py+++ b/products/signals/backend/reviewer_pr_ready.py@@ -21,6 +21,7 @@ from posthog.egress.limiter.policies import Priorityfrom posthog.models import Userfrom posthog.models.integration import GitHubIntegration+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.models import (SignalReport,SignalReportArtefact,@@ -69,6 +70,9 @@ def schedule_open_pull_request_ready(run on a worker instead of holding up a claim or a webhook. `robust=True` keeps a broker outagefrom failing a write that already committed."""+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return+if not pr_url or (pr_state or SignalReportAssignment.PrState.UNKNOWN) not in FLIPPABLE_PR_STATES:return@@ -97,7 +101,7 @@ def _resolved_reviewer_users(*, team_id: int, report_id: str) -> list[User]:report_id=report_id,type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,)- .order_by("-created_at")+ .order_by("-created_at", "-id").first())if latest is None:@@ -167,6 +171,9 @@ def open_pull_request_ready_for_review(*, team_id: int, report_id: str, pr_url:that is already ready, closed, or labelled `no-ci`. A failed call also returns False, and thisraises nothing."""+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return False+if not SignalReport.objects.filter(id=report_id, team_id=team_id).exists():return False@@ -193,6 +200,8 @@ def open_pull_request_ready_for_review(*, team_id: int, report_id: str, pr_url:return Falsetry:+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return Falseresult = github.mark_pull_request_ready_for_review(parsed.repository, parsed.number, skip_labels=SKIP_READY_LABELS)diff --git a/products/signals/backend/reviewer_rules.py b/products/signals/backend/reviewer_rules.pynew file mode 100644index 000000000000..d2ff49b7892a--- /dev/null+++ b/products/signals/backend/reviewer_rules.py@@ -0,0 +1,381 @@+from __future__ import annotations++import json+from uuid import UUID++from django.db.models import Q++from posthog.dataclasses import frozen+from posthog.models.activity_logging.activity_log import ActivityLog+from posthog.models.team.team import Team++from products.signals.backend.artefact_attribution import ArtefactAttribution+from products.signals.backend.artefact_schemas import (+ ReviewerCorrections,+ ReviewerEdit,+ ReviewerProposal,+ ReviewerState,+ SuggestedReviewerEntry,+ SuggestedReviewers,+)+from products.signals.backend.assignment_flags import assignment_side_effects_enabled, assignment_writer_enabled+from products.signals.backend.models import SignalReport, SignalReportArtefact+from products.signals.backend.report_generation.resolve_reviewers import (+ bounded_reviewer_reason,+ get_org_member_github_logins_by_user_uuid,+ resolve_org_github_login_to_users,+)+++class ReviewerWriteError(ValueError):+ pass+++class StaleReviewerProposal(ReviewerWriteError):+ pass+++@frozen+class ReviewerSnapshot:+ state: ReviewerState+ reviewers: tuple[SuggestedReviewerEntry, ...]+ corrections: ReviewerCorrections+ invalid_reviewers: bool = False+++@frozen+class ReviewerUpdate:+ protected: bool+ reviewers: SuggestedReviewers+ corrections: ReviewerCorrections | None+ current: SignalReportArtefact | None+++@frozen+class EligibleReviewers:+ reviewers: tuple[SuggestedReviewerEntry, ...]+ ineligible_user_uuids: tuple[str, ...]+ unresolved_candidates: tuple[SuggestedReviewerEntry, ...]+++def same_reviewer(left: SuggestedReviewerEntry, right: SuggestedReviewerEntry) -> bool:+ if left.user_uuid and right.user_uuid:+ return left.user_uuid == right.user_uuid+ return bool(left.github_login and right.github_login and left.github_login.lower() == right.github_login.lower())+++def contains_reviewer(entries: tuple[SuggestedReviewerEntry, ...], reviewer: SuggestedReviewerEntry) -> bool:+ return any(same_reviewer(entry, reviewer) for entry in entries)+++def correct_reviewers(+ corrections: ReviewerCorrections,+ added: tuple[SuggestedReviewerEntry, ...],+ removed: tuple[SuggestedReviewerEntry, ...],+) -> ReviewerCorrections:+ return corrections.model_copy(+ update={+ "pinned": tuple(entry for entry in corrections.pinned if not contains_reviewer(removed + added, entry))+ + added,+ "excluded": tuple(entry for entry in corrections.excluded if not contains_reviewer(added + removed, entry))+ + removed,+ }+ )+++class ReviewerRules:+ def __init__(self, *, team: Team, report_id: str) -> None:+ self.team = team+ self.report_id = report_id+ self.enabled = assignment_writer_enabled(team.id)+ self.effects_enabled = assignment_side_effects_enabled(team.id)++ @staticmethod+ def _read_reviewers(artefact: SignalReportArtefact | None) -> tuple[SuggestedReviewerEntry, ...]:+ if artefact is None:+ return ()+ content = json.loads(artefact.content)+ if isinstance(content, list):+ for entry in content:+ if isinstance(entry, dict):+ entry["reason"] = bounded_reviewer_reason(entry.get("reason"))+ if not isinstance(entry.get("relevant_commits"), list):+ entry["relevant_commits"] = []+ for commit in entry["relevant_commits"]:+ if isinstance(commit, dict):+ commit["reason"] = bounded_reviewer_reason(commit.get("reason")) or ""+ return tuple(SuggestedReviewers.model_validate(content).root)++ @staticmethod+ def _label(entry: SuggestedReviewerEntry) -> str:+ return entry.github_login.lower() if entry.github_login else entry.user_uuid or ""++ @staticmethod+ def _resolve_identities(+ team_id: int, reviewers: tuple[SuggestedReviewerEntry, ...]+ ) -> tuple[SuggestedReviewerEntry, ...]:+ unresolved_logins = {+ entry.github_login.lower() for entry in reviewers if entry.github_login and not entry.user_uuid+ }+ members = resolve_org_github_login_to_users(team_id, unresolved_logins) if unresolved_logins else {}+ return tuple(+ entry.model_copy(update={"user_uuid": str(member.uuid)})+ if entry.github_login and not entry.user_uuid and (member := members.get(entry.github_login.lower()))+ else entry+ for entry in reviewers+ )++ @classmethod+ def _legacy_corrections(cls, *, team_id: int, report_id: str) -> ReviewerCorrections:+ rows = list(+ SignalReportArtefact.objects.filter(+ team_id=team_id, report_id=report_id, type="suggested_reviewers"+ ).order_by("created_at", "id")+ )+ try:+ history = {row.id: cls._read_reviewers(row) for row in rows}+ except ValueError:+ return ReviewerCorrections(needs_review=True)+ unresolved_logins = {+ entry.github_login.lower()+ for reviewers in history.values()+ for entry in reviewers+ if entry.github_login and not entry.user_uuid+ }+ members = resolve_org_github_login_to_users(team_id, unresolved_logins) if unresolved_logins else {}++ def resolve(entries: tuple[SuggestedReviewerEntry, ...]) -> tuple[SuggestedReviewerEntry, ...]:+ return tuple(+ entry.model_copy(update={"user_uuid": str(member.uuid)})+ if entry.github_login and not entry.user_uuid and (member := members.get(entry.github_login.lower()))+ else entry+ for entry in entries+ )++ changes = [+ (log.user_id, change)+ for log in ActivityLog.objects.filter(+ team_id=team_id, scope="SignalReport", item_id=report_id, activity="suggested_reviewers_changed"+ ).order_by("created_at", "id")+ for change in (log.detail or {}).get("changes", [])+ if change.get("field") == "suggested_reviewers"+ ]+ corrections = ReviewerCorrections()+ previous: tuple[SuggestedReviewerEntry, ...] = ()+ for row in rows:+ current = history[row.id]+ if row.actor_kind == "user" or (row.actor_kind is None and row.created_by_id is not None):+ added = tuple(entry for entry in current if not contains_reviewer(previous, entry))+ removed = tuple(entry for entry in previous if not contains_reviewer(current, entry))+ if added or removed:+ before, after = {cls._label(entry) for entry in previous}, {cls._label(entry) for entry in current}+ match = next(+ (+ i+ for i, (user_id, change) in enumerate(changes)+ if user_id == row.created_by_id+ and set(change.get("before") or []) == before+ and set(change.get("after") or []) == after+ ),+ None,+ )+ if match is None:+ return corrections.model_copy(update={"needs_review": True})+ changes.pop(match)+ corrections = correct_reviewers(corrections, resolve(added), resolve(removed))+ previous = current+ return corrections.model_copy(+ update={+ "needs_review": bool(changes)+ or any(not entry.user_uuid for entry in corrections.pinned + corrections.excluded)+ }+ )++ @classmethod+ def read_for_report(cls, *, team_id: int, report_id: str) -> ReviewerSnapshot:+ SignalReport.objects.get(team_id=team_id, id=report_id)+ rows = SignalReportArtefact.objects.filter(team_id=team_id, report_id=report_id)+ reviewers = rows.filter(type="suggested_reviewers").order_by("-created_at", "-id").first()+ corrections = rows.filter(type="reviewer_corrections").order_by("-created_at", "-id").first()+ invalid_reviewers = False+ try:+ entries = cls._read_reviewers(reviewers)+ except ValueError:+ entries = ()+ invalid_reviewers = True+ rules = (+ ReviewerCorrections.model_validate_json(corrections.content)+ if corrections+ else ReviewerCorrections(+ # Until the first protected write recovers old edits, readers must not treat them as absent.+ needs_review=rows.filter(type="suggested_reviewers")+ .filter(Q(actor_kind="user") | Q(actor_kind__isnull=True, created_by__isnull=False))+ .exists()+ )+ )+ if invalid_reviewers:+ rules = rules.model_copy(update={"needs_review": True})+ return ReviewerSnapshot(+ state=ReviewerState(+ reviewers_id=reviewers.id if reviewers else None, corrections_id=corrections.id if corrections else None+ ),+ reviewers=entries,+ corrections=rules,+ invalid_reviewers=invalid_reviewers,+ )++ def read(self) -> ReviewerSnapshot:+ return self.read_for_report(team_id=self.team.id, report_id=self.report_id)++ def _validate_members(self, reviewers: tuple[SuggestedReviewerEntry, ...]) -> EligibleReviewers:+ resolved: list[SuggestedReviewerEntry] = []+ unresolved: list[SuggestedReviewerEntry] = []+ for entry in self._resolve_identities(self.team.id, reviewers):+ if entry.user_uuid:+ try:+ UUID(entry.user_uuid)+ except ValueError as error:+ raise ReviewerWriteError("A reviewer must have a valid user UUID.") from error+ if entry.user_uuid:+ resolved.append(entry)+ else:+ unresolved.append(entry)+ wanted = {entry.user_uuid for entry in resolved if entry.user_uuid}+ eligible = {str(user.uuid) for user in self.team.all_users_with_access(user_uuids=wanted)} if wanted else set()+ logins = get_org_member_github_logins_by_user_uuid(self.team.id, sorted(eligible)) if eligible else {}+ accepted = {+ entry.user_uuid: entry.model_copy(update={"github_login": logins.get(entry.user_uuid)})+ for entry in resolved+ if entry.user_uuid in eligible+ }+ return EligibleReviewers(+ reviewers=tuple(accepted.values()),+ ineligible_user_uuids=tuple(sorted(wanted - eligible)),+ unresolved_candidates=tuple(unresolved),+ )++ def prepare(+ self,+ content: SuggestedReviewers,+ *,+ attribution: ArtefactAttribution,+ proposal: ReviewerProposal | None,+ edit: ReviewerEdit | None,+ ) -> ReviewerUpdate:+ """Called by append_status while it holds the report lock."""+ snapshot = self.read()+ if edit is not None and attribution.kind != "user":+ raise ReviewerWriteError("Only a person can change reviewer corrections.")+ repairing = snapshot.invalid_reviewers+ if repairing and (edit is None or edit.action != "replace"):+ raise ReviewerWriteError(+ "Stored reviewer data is invalid. A person must replace the list with current state."+ )+ current = (+ SignalReportArtefact.objects.get(+ team_id=self.team.id, report_id=self.report_id, id=snapshot.state.reviewers_id+ )+ if snapshot.state.reviewers_id+ else None+ )+ enrolled = snapshot.state.corrections_id is not None+ corrections = snapshot.corrections+ protected = self.enabled or enrolled or repairing+ proposed = tuple(content.root)+ members_validated = False+ expected = edit.expected_state if edit else proposal.expected_state if proposal else None+ if protected:+ if edit is None and not self.enabled:+ proposed = snapshot.reviewers+ elif expected != snapshot.state and (edit is None or edit.action in {"replace", "confirm"}):+ raise StaleReviewerProposal("Reviewers or corrections changed. Read the report again before saving.")+ if not enrolled and corrections.needs_review:+ corrections = self._legacy_corrections(team_id=self.team.id, report_id=self.report_id)+ if edit is not None:+ if edit.action == "confirm":+ if not protected:+ raise ReviewerWriteError("List confirmation is not enabled for this report.")+ corrections = corrections.model_copy(update={"confirmed": True, "needs_review": False})+ proposed = snapshot.reviewers+ else:+ additions = (+ proposed+ if edit.action == "add"+ else tuple(entry for entry in proposed if not contains_reviewer(snapshot.reviewers, entry))+ if edit.action == "replace"+ else ()+ )+ removals = (+ proposed+ if edit.action == "remove"+ else tuple(entry for entry in snapshot.reviewers if not contains_reviewer(proposed, entry))+ if edit.action == "replace"+ else ()+ )+ if protected:+ removals = self._resolve_identities(self.team.id, removals)+ checked = self._validate_members(additions)+ if protected and (checked.ineligible_user_uuids or checked.unresolved_candidates):+ raise ReviewerWriteError("New reviewers must be active members with access to this project.")+ additions = checked.reviewers if protected else additions+ if protected and not repairing:+ corrections = correct_reviewers(corrections, additions, removals)+ if repairing:+ proposed = additions+ members_validated = True+ elif edit.action == "add":+ proposed = snapshot.reviewers + tuple(+ entry for entry in additions if not contains_reviewer(snapshot.reviewers, entry)+ )+ elif edit.action == "remove":+ proposed = tuple(entry for entry in snapshot.reviewers if not contains_reviewer(removals, entry))+ elif protected and self.enabled:+ if proposal and proposal.outcome != "selected" and proposed:+ raise ReviewerWriteError("An unsuccessful selection cannot supply reviewers.")+ failed = proposal is not None and proposal.outcome == "lookup_failed"+ if corrections.confirmed or corrections.needs_review or failed:+ proposed = snapshot.reviewers+ else:+ validated = self._validate_members(proposed)+ if proposed and not validated.reviewers:+ proposed = snapshot.reviewers+ else:+ proposed = tuple(+ entry for entry in validated.reviewers if not contains_reviewer(corrections.excluded, entry)+ )+ extra_pins = tuple(+ entry+ for entry in corrections.pinned+ if not contains_reviewer(validated.reviewers, entry)+ and entry.user_uuid not in validated.ineligible_user_uuids+ and not contains_reviewer(validated.unresolved_candidates, entry)+ )+ proposed += self._validate_members(extra_pins).reviewers if extra_pins else ()+ members_validated = True+ elif (+ proposal+ and proposal.source == "research"+ and (corrections.pinned or corrections.excluded or corrections.needs_review)+ ):+ proposed = snapshot.reviewers+ if protected and not members_validated:+ proposed = self._validate_members(proposed).reviewers+ reviewers = SuggestedReviewers(root=list(proposed))+ if current is not None and edit is None and proposal is not None and proposal.source == "research":+ # Research can rephrase its evidence without changing the selection.+ comparison_exclusions = {+ "__all__": {"reason": True, "github_name": True, "relevant_commits": {"__all__": {"reason"}}}+ }+ previous = SuggestedReviewers(root=list(snapshot.reviewers))+ if previous.model_dump(exclude=comparison_exclusions) == reviewers.model_dump(+ exclude=comparison_exclusions+ ):+ reviewers = previous+ return ReviewerUpdate(+ protected=protected,+ reviewers=reviewers,+ corrections=corrections+ if protected and (repairing or not enrolled or corrections != snapshot.corrections)+ else None,+ current=current,+ )diff --git a/products/signals/backend/scout_harness/serializers.py b/products/signals/backend/scout_harness/serializers.pyindex db0f10dcbb0b..8a517a07b14c 100644--- a/products/signals/backend/scout_harness/serializers.py+++ b/products/signals/backend/scout_harness/serializers.py@@ -114,6 +114,7 @@ from products.signals.backend.scout_harness.tools.structured_output import (from products.signals.backend.serializers import (ReportChartSerializer,ReportMetricWriteSerializer,+ ReviewerProposalSerializer,SignalReportCheckWriteSerializer,)from products.skills.backend.api.skill_serializers import (@@ -1755,7 +1756,7 @@ class EmitReportResponseSerializer(serializers.Serializer):)-class EditReportRequestSerializer(serializers.Serializer):+class EditReportRequestSerializer(ReviewerProposalSerializer):"""Request body for `edit-report`. Can target ANY of the team's inbox reports, not just scout-authored ones."""report_id = serializers.CharField(help_text="Id of the report to edit (must belong to this project).")@@ -1812,7 +1813,8 @@ class EditReportRequestSerializer(serializers.Serializer):"Optional reviewers to set on the report (each a `github_login` and/or `user_uuid`), replacing ""any existing list. Use this to route a report that surfaced with no reviewer — it re-runs ""autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An "- "empty list is a no-op (existing reviewers are left untouched, never cleared)."+ "empty list clears automatic reviewers when correction rules are enabled. Pins, exclusions, and confirmed lists are preserved. "+ "Pass expected_reviewers from the report reviewer_assignment.state read before selection."),)repository = serializers.CharField(diff --git a/products/signals/backend/scout_harness/slack_delivery.py b/products/signals/backend/scout_harness/slack_delivery.pyindex 61ef449a2d76..088d121f4748 100644--- a/products/signals/backend/scout_harness/slack_delivery.py+++ b/products/signals/backend/scout_harness/slack_delivery.py@@ -19,6 +19,7 @@ from posthog.redis import get_clientfrom posthog.slack.formatting import channel_id_from_target, escape_slack_mrkdwnfrom posthog.slack.markdown import SLACK_MARKDOWN_TEXT_MAX_LEN, slack_markdown_block+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.models import SignalReport, SignalReportSlackThread, SignalScoutEmission, SignalScoutRunfrom products.signals.backend.report_urls import ReportLinkSource, build_report_urlfrom products.signals.backend.scout_harness.slack_charts import (@@ -770,6 +771,9 @@ def post_scout_report_to_slack()return+ if not assignment_side_effects_allowed(team_id=report.team_id, report_id=str(report.id)):+ return+# The build can hold the worker for the whole render budget, long enough for the workspace to be# reconnected, which writes a new token to the same row and revokes the one loaded above. Posting# with the stale token fails as permanent, so resolve the row again before the post.diff --git a/products/signals/backend/scout_harness/tools/report.py b/products/signals/backend/scout_harness/tools/report.pyindex 88b839ba2292..1e2551349209 100644--- a/products/signals/backend/scout_harness/tools/report.py+++ b/products/signals/backend/scout_harness/tools/report.py@@ -88,6 +88,7 @@ from products.signals.backend.report_metrics import ()from products.signals.backend.report_prompts import normalize_suggested_prompts, suggested_prompts_batch_errorfrom products.signals.backend.report_urls import ReportLinkSource, build_report_url+from products.signals.backend.reviewer_rules import ReviewerProposal, ReviewerRules, StaleReviewerProposalfrom products.signals.backend.scout_harness.prompt import SELF_IMPROVEMENT_REPORT_TITLE_PREFIXfrom products.signals.backend.scout_harness.skill_loader import resolve_skill_owner_user_uuidsfrom products.signals.backend.scout_harness.slack_delivery_queue import queue_configured_scout_slack_delivery@@ -2448,6 +2449,7 @@ def _do_edit_report(charts: list[ReportChart] | None,metrics: list[ReportMetric] | None,suggested_prompts: list[str] | None,+ reviewer_proposal: ReviewerProposal | None = None,links: list[ReportLink] | None = None,supersedes_implementation: bool = False,corroboration_only: bool = False,@@ -2503,11 +2505,15 @@ def _do_edit_report(corroboration_collapsed = Falsesupersede_recorded = Falsedecision_fields_set: list[str] = []+ reviewer_warnings: tuple[EditReportWarning, ...] = ()implementation_context = (prepare_scout_supersession(team_id=team.id, report_id=report_id, title=title, summary=summary)if supersedes_implementationelse NO_IMPLEMENTATION_CONTEXT)+ assignment = ReviewerRules(team=team, report_id=report_id)+ if reviewers is None and reviewer_proposal is not None and reviewer_proposal.outcome != "selected":+ reviewers = SuggestedReviewers(root=[])# One edit is one transaction, so a rejection part-way through takes the whole edit with it# instead of leaving the report half-changed. The side effects below (autostart, telemetry,# delivery) stay outside, and the `on_commit` hooks these writes register fire on this commit.@@ -2559,20 +2565,23 @@ def _do_edit_report(# added during that wait must not remain an identity candidate.if reviewers is not None:reviewers = _stamp_owner_provenance(team, reviewers, skill_name=author.skill_name)- # Replace the report's `suggested_reviewers` status artefact (latest-wins). This is the routing- # fix — a report authored without a reviewer (so it routes to no one) can have one added after- # the fact. `reviewers` is None for empty/all-blank input, which leaves existing ones untouched.- reviewers_set = (- set_scout_report_reviewers(- team_id=team.id,- report_id=report_id,- suggested_reviewers=reviewers,- attribution=attribution,- author=author.skill_name,+ try:+ reviewers_set = (+ set_scout_report_reviewers(+ team_id=team.id,+ report_id=report_id,+ suggested_reviewers=reviewers,+ proposal=reviewer_proposal,+ service=assignment,+ attribution=attribution,+ author=author.skill_name,+ )+ if reviewers is not None+ else False)- if reviewers is not None- else False- )+ except StaleReviewerProposal as error:+ reviewers_set = False+ reviewer_warnings = (EditReportWarning(field="suggested_reviewers", message=str(error)),)# The other routing fix: a report that surfaced against the wrong codebase is repointed in# place, so the scout corrects it instead of filing a duplicate report to carry the right# repository. Omitting the field leaves the report's selection as it stands.@@ -2869,7 +2878,8 @@ def _do_edit_report(corroboration_collapsed=corroboration_collapsed,links_appended=links_appended,decision_fields_set=tuple(decision_fields_set),- warnings=(+ warnings=reviewer_warnings+ + ((_supersede_warning(updated_fields=updated_fields, content_revision_count=content_revision_count),)if supersedes_implementation and not supersede_recordedelse ()@@ -2998,7 +3008,7 @@ def _validate_edit_inputs(and summary is Noneand append_note is Noneand not append_evidence- and not suggested_reviewers+ and suggested_reviewers is Noneand repository is Noneand charts is Noneand metrics is None@@ -3031,6 +3041,7 @@ async def edit_report(charts: list[ReportChartInput] | None = None,metrics: list[ReportMetricInput] | None = None,suggested_prompts: list[str] | None = None,+ reviewer_proposal: ReviewerProposal | None = None,links: list[ReportLinkInput] | None = None,supersedes_implementation: bool = False,corroboration_only: bool = False,@@ -3048,6 +3059,8 @@ async def edit_report(Content-changing edits pass the same safety judge as `emit_report` before anything is written(see `_raise_if_unsafe_edit`); an unsafe edit is rejected whole and the report keeps what ithad."""+ if reviewer_proposal is not None and reviewer_proposal.outcome != "selected" and suggested_reviewers is None:+ suggested_reviewers = []await database_sync_to_async(_validate_edit_inputs, thread_sensitive=False)(team,author,@@ -3112,7 +3125,10 @@ async def edit_report(summary=summary,append_note=append_note,append_evidence=built_evidence,- reviewers=built_reviewers,+ reviewers=built_reviewers+ if suggested_reviewers is None or built_reviewers is not None+ else SuggestedReviewers(root=[]),+ reviewer_proposal=reviewer_proposal,repository=normalized_repository,charts=built_charts,metrics=built_metrics,@@ -3162,6 +3178,7 @@ def edit_report_sync(charts: list[ReportChartInput] | None = None,metrics: list[ReportMetricInput] | None = None,suggested_prompts: list[str] | None = None,+ reviewer_proposal: ReviewerProposal | None = None,links: list[ReportLinkInput] | None = None,supersedes_implementation: bool = False,corroboration_only: bool = False,@@ -3172,6 +3189,8 @@ def edit_report_sync(priority_explanation: str | None = None,) -> EditReportResult:"""Sync entry used by the DRF view path. Same behavior as `edit_report`, on the calling thread."""+ if reviewer_proposal is not None and reviewer_proposal.outcome != "selected" and suggested_reviewers is None:+ suggested_reviewers = []_validate_edit_inputs(team,author,@@ -3231,7 +3250,10 @@ def edit_report_sync(summary=summary,append_note=append_note,append_evidence=built_evidence,- reviewers=built_reviewers,+ reviewers=built_reviewers+ if suggested_reviewers is None or built_reviewers is not None+ else SuggestedReviewers(root=[]),+ reviewer_proposal=reviewer_proposal,repository=normalized_repository,charts=built_charts,metrics=built_metrics,diff --git a/products/signals/backend/scout_harness/views.py b/products/signals/backend/scout_harness/views.pyindex 4834e7dc6677..a5bbd6cd14d8 100644--- a/products/signals/backend/scout_harness/views.py+++ b/products/signals/backend/scout_harness/views.py@@ -70,6 +70,7 @@ from posthog.temporal.oauth import SCOUT_DEFAULT_WRITE_SCOPES, SCOUT_GRANTABLE_Wfrom posthog.user_permissions import UserPermissionsfrom products.access_control.backend.facade.user_access_control import UserAccessControl+from products.signals.backend.artefact_schemas import ReviewerStatefrom products.signals.backend.background_pilot import OPT_OUT_DELETED, capture_background_scout_opted_outfrom products.signals.backend.models import (SignalProjectProfile,@@ -84,6 +85,7 @@ from products.signals.backend.presentation.scout_permissions import ScoutCanonicfrom products.signals.backend.report_access import may_read_reportsfrom products.signals.backend.report_charts import ChartSizefrom products.signals.backend.report_generation.resolve_reviewers import MAX_PROJECT_MEMBERS, list_project_members+from products.signals.backend.reviewer_rules import ReviewerProposal, ReviewerWriteErrorfrom products.signals.backend.scout_harness.config_registry import enabled_scout_count, ensure_scout_categoryfrom products.signals.backend.scout_harness.create_access import can_create_scoutfrom products.signals.backend.scout_harness.deprecation import deprecation_metadata_of@@ -537,10 +539,8 @@ def _to_report_links(entries: list[dict] | None) -> list[ReportLinkInput] | Nonedef _to_reviewer_inputs(entries: list[dict] | None) -> list[ReviewerInput] | None:- """Map validated `suggested_reviewers` entries to `ReviewerInput`s for the report tools. `user_uuid`- is a `UUID` (from `UUIDField`) — stringified here so the tool layer has no DRF dependency. Empty/None- yields None so the tool treats it as "no reviewers supplied"."""- if not entries:+ """Convert serializer UUIDs to tool inputs, keeping an empty selection distinct from an omitted field."""+ if entries is None:return Nonereturn [ReviewerInput(@@ -1420,11 +1420,20 @@ class SignalScoutRunViewSet(TeamAndOrgViewSetMixin, viewsets.GenericViewSet):run = self._resolve_in_progress_run(kwargs, required_tool="edit_report")data = request.validated_datatry:+ proposal = None+ if data.get("expected_reviewers") is not None:+ proposal = ReviewerProposal(+ expected_state=ReviewerState.model_validate(data["expected_reviewers"]),+ source="scout_edit",+ outcome=data["reviewer_outcome"],+ retry_reason=data.get("reviewer_retry_reason"),+ )result = edit_report_sync(# Canonical team, as in `emit_report` above — avoids a child-env `_assert_team_owns_run` trip.team=run.team,author=ScoutRunReportAuthor(run=run),report_id=data["report_id"],+ reviewer_proposal=proposal,title=data.get("title"),summary=data.get("summary"),append_note=data.get("append_note"),@@ -1443,7 +1452,7 @@ class SignalScoutRunViewSet(TeamAndOrgViewSetMixin, viewsets.GenericViewSet):priority=data.get("priority"),priority_explanation=data.get("priority_explanation"),)- except InvalidScoutReportError as exc:+ except (InvalidScoutReportError, ReviewerWriteError, ValueError) as exc:raise exceptions.ValidationError({"detail": str(exc)})return Response(EditReportResponseSerializer(diff --git a/products/signals/backend/scout_report/persistence.py b/products/signals/backend/scout_report/persistence.pyindex 2c548bb7d810..315da9d9bec3 100644--- a/products/signals/backend/scout_report/persistence.py+++ b/products/signals/backend/scout_report/persistence.py@@ -44,6 +44,7 @@ from posthog.schema import EmbeddingModelNamefrom posthog.api.embedding_worker import emit_embedding_requestfrom posthog.dataclasses import frozen+from posthog.models.team.team import Teamfrom products.signals.backend.artefact_schemas import (SIGNALS_PRODUCT,@@ -55,6 +56,7 @@ from products.signals.backend.artefact_schemas import (NoteArtefact,PriorityAssessment,ReportLink,+ ReviewerState,SafetyJudgment,SuggestedReviewerEntry,SuggestedReviewers,@@ -78,6 +80,7 @@ from products.signals.backend.report_generation.reviewer_telemetry import capturfrom products.signals.backend.report_generation.select_repo import RepoSelectionResult, persisted_repo_selectionfrom products.signals.backend.report_metrics import ReportMetric, metric_batch_errorfrom products.signals.backend.report_prompts import normalize_suggested_prompts, suggested_prompts_batch_error+from products.signals.backend.reviewer_rules import ReviewerProposal, ReviewerRulesfrom products.signals.backend.scout_harness.tools.emit import SCOUT_SIGNAL_WEIGHT, SOURCE_PRODUCT, SOURCE_TYPEfrom products.signals.backend.spend import SignalMetadataChange, submit_signal_metadata_updatesfrom products.signals.backend.supersession import NO_IMPLEMENTATION_CONTEXT, research_implementation_context@@ -242,9 +245,12 @@ def create_scout_report(document_ids = [s.document_id or str(uuid.uuid4()) for s in signals]total_weight = sum(s.weight for s in signals)+ report_id = str(uuid.uuid4())+ assignment = ReviewerRules(team=Team.objects.get(id=team_id), report_id=report_id)try:with transaction.atomic():report = SignalReport.objects.create(+ id=report_id,team_id=team_id,status=status,title=title,@@ -318,14 +324,17 @@ def create_scout_report()except ArtefactContentValidationError as err:raise InvalidScoutReportError(str(err))- if suggested_reviewers is not None and len(suggested_reviewers.root) > 0:- SignalReportArtefact.append_status(+ if (suggested_reviewers is not None and suggested_reviewers.root) or assignment.enabled:+ suggested_reviewers = suggested_reviewers or SuggestedReviewers(root=[])+ artefact = SignalReportArtefact.append_status(team_id=team_id,report_id=report_id,content=suggested_reviewers,attribution=attribution,+ reviewer_proposal=ReviewerProposal(expected_state=ReviewerState(), source="scout"),reevaluate_autostart=False,)+ suggested_reviewers = SuggestedReviewers.model_validate_json(artefact.content)# on_commit, not inline: telemetry must not fire for a rolled-back report, and it must# still fire when the post-commit signal emits below fail (they propagate).transaction.on_commit(@@ -1109,7 +1118,7 @@ def _merge_forward_reviewer_evidence(*, report_id: str, suggested_reviewers: SugSignalReportArtefact.objects.filter(report_id=report_id, type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS)- .order_by("-created_at")+ .order_by("-created_at", "-id").first())if current is None:@@ -1169,66 +1178,46 @@ def set_scout_report_reviewers(suggested_reviewers: SuggestedReviewers,attribution: ArtefactAttribution,author: str | None = None,+ proposal: ReviewerProposal | None = None,+ service: ReviewerRules | None = None,) -> bool:- """Replace an existing report's `suggested_reviewers` status artefact (latest-wins) — the- `edit_report` reviewer path. Returns True when reviewers were written, False when the supplied list- is empty (a no-op that leaves any existing reviewers untouched, never silently clears them).-- Team-scoped fail-closed: a `report_id` the team doesn't own raises. `edit_report` can target ANY- inbox report (pipeline-authored included), so the change is attributed (to the scout's task) and an- audit note is logged, keeping it auditable and distinguishable from pipeline output.-- The append opts out of the model's autostart re-eval hook (`reevaluate_autostart=False`); the caller- (`_do_edit_report`) fires `maybe_autostart_from_report_artefacts` after this returns — never in-txn,- since it spawns a Task — mirroring `create_scout_report`. Autostart is idempotent, so re-running it- for an already-started report no-ops, while a report that lacked a qualifying reviewer can now open a- draft PR.-- Evidence merges forward: a scout can only supply `github_login`/`user_uuid` (+ `reason`), so for- reviewers already on the report's current reviewer list, the prior entry's `relevant_commits`,- `github_name`, and (when the scout supplies none) `reason` are carried over — mirroring the inbox- PUT. Without this, a reason-only re-route would wipe the commit evidence precedent-weighing runs on."""+ """Apply a scout's selection with the report's saved reviewer corrections."""_validate_report_id(report_id)- if len(suggested_reviewers.root) == 0:+ service = service or ReviewerRules(team=Team.objects.get(id=team_id), report_id=report_id)+ if not suggested_reviewers.root and not service.enabled and service.read().state.corrections_id is None:return False- reviewer_labels = [_reviewer_note_label(entry) for entry in suggested_reviewers.root]with transaction.atomic():- # The lock is the team-scoped gate AND serializes the read-merge-append against concurrent- # reviewer edits (same discipline as the inbox PUT) so an interleaved write isn't lost.- if not SignalReport.objects.select_for_update().filter(team_id=team_id, id=report_id).exists():- raise InvalidScoutReportError(f"report {report_id} not found for team {team_id}")+ SignalReport.objects.select_for_update().get(team_id=team_id, id=report_id)merged = _merge_forward_reviewer_evidence(report_id=report_id, suggested_reviewers=suggested_reviewers)- SignalReportArtefact.append_status(+ previous = service.read().state.reviewers_id+ artefact = SignalReportArtefact.append_status(team_id=team_id,report_id=report_id,content=merged,attribution=attribution,+ reviewer_proposal=proposal,reevaluate_autostart=False,)+ if artefact.id == previous:+ return False+ applied = SuggestedReviewers.model_validate_json(artefact.content)+ reviewer_labels = [_reviewer_note_label(entry) for entry in applied.root]SignalReportArtefact.add_log(team_id=team_id,report_id=report_id,content=NoteArtefact(note=f"Set suggested reviewers: {', '.join(reviewer_labels)}", author=author),attribution=attribution,)- # on_commit, not inline: `_do_edit_report` wraps this call in an outer transaction, so an- # inline capture would fire for an edit that later rolls back — and a DB error inside the- # capture, though swallowed, would poison that outer transaction. The merged content is the- # live reviewer set (latest-wins), so telemetry reflects what routing will actually see.transaction.on_commit(partial(capture_suggested_reviewers_resolved,team_id=team_id,report_id=report_id,- github_logins=[entry.github_login for entry in merged.root if entry.github_login],- user_uuids=[entry.user_uuid for entry in merged.root if entry.user_uuid and not entry.github_login],+ github_logins=[entry.github_login for entry in applied.root if entry.github_login],+ user_uuids=[entry.user_uuid for entry in applied.root if entry.user_uuid and not entry.github_login],source="scout_edit",))- logger.info(- "signals_scout.edit_report: reviewers set",- extra={"team_id": team_id, "report_id": report_id, "reviewer_count": len(reviewer_labels)},- )return Truediff --git a/products/signals/backend/serializers.py b/products/signals/backend/serializers.pyindex 26a29def6c7f..60f31fb59fa2 100644--- a/products/signals/backend/serializers.py+++ b/products/signals/backend/serializers.py@@ -33,6 +33,8 @@ from products.signals.backend.contracts import ()from products.signals.backend.enums import (ReportTaskActionKind,+ ReviewerEditAction,+ ReviewerSelectionOutcome,SignalSourceProduct,SignalSourceType,SuggestedSourceProduct,@@ -53,6 +55,7 @@ from products.signals.backend.report_checks import (parse_check_config,)from products.signals.backend.report_content_gates import team_report_monitoring_enabled+from products.signals.backend.reviewer_rules import ReviewerRulesfrom products.warehouse_sources.backend.facade.models import ExternalDataSchemafrom products.warehouse_sources.backend.facade.types import ExternalDataSchemaStatus@@ -1247,6 +1250,56 @@ class SignalReportPriorityUpdateSerializer(serializers.Serializer):)+class ReviewerStateSerializer(serializers.Serializer):+ reviewers_id = serializers.UUIDField(+ allow_null=True, help_text="Current reviewer artefact ID, or null before the first list."+ )+ corrections_id = serializers.UUIDField(+ allow_null=True, help_text="Current corrections artefact ID, or null before corrections are stored."+ )+++class ReviewerProposalSerializer(serializers.Serializer):+ expected_reviewers = ReviewerStateSerializer(+ required=False,+ help_text="Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled.",+ )+ reviewer_outcome = serializers.ChoiceField(+ choices=ReviewerSelectionOutcome.choices,+ default="selected",+ help_text="A successful selection, a deliberate empty result, or an unavailable lookup.",+ )+ reviewer_retry_reason = serializers.CharField(+ required=False, max_length=500, help_text="Reason the reviewer lookup failed."+ )+++class ReviewerControlResponseSerializer(serializers.Serializer):+ state = ReviewerStateSerializer(help_text="State token for a selection, replacement, or list confirmation.")+ pinned_user_uuids = serializers.ListField(+ child=serializers.UUIDField(), help_text="People an automatic selection must retain."+ )+ excluded_user_uuids = serializers.ListField(+ child=serializers.UUIDField(), help_text="People an automatic selection must not restore."+ )+ confirmed = serializers.BooleanField(help_text="A person explicitly confirmed the complete reviewer list.")+ needs_review = serializers.BooleanField(+ help_text="Older edits need recovery on the next protected write, or have incomplete history. Automatic changes are paused until recovery or list confirmation."+ )+ enabled = serializers.BooleanField(help_text="Whether this report uses saved reviewer corrections.")++ def to_representation(self, instance: ReviewerRules) -> dict[str, object]:+ snapshot = instance.read()+ return {+ "state": snapshot.state.model_dump(mode="json"),+ "pinned_user_uuids": [entry.user_uuid for entry in snapshot.corrections.pinned if entry.user_uuid],+ "excluded_user_uuids": [entry.user_uuid for entry in snapshot.corrections.excluded if entry.user_uuid],+ "confirmed": snapshot.corrections.confirmed,+ "needs_review": snapshot.corrections.needs_review,+ "enabled": instance.enabled or snapshot.state.corrections_id is not None,+ }++class SignalReportSerializerExtension(OpenApiSerializerExtension):target_class = "products.signals.backend.serializers.SignalReportSerializer"match_subclasses = True@@ -1261,6 +1314,17 @@ class SignalReportSerializerExtension(OpenApiSerializerExtension):class SignalReportSerializer(serializers.ModelSerializer):+ reviewer_assignment = serializers.SerializerMethodField(+ help_text="Reviewer control and state token for preparing an automatic proposal."+ )++ @extend_schema_field(ReviewerControlResponseSerializer(allow_null=True))+ def get_reviewer_assignment(self, obj: SignalReport) -> dict | None:+ if isinstance(self, SignalReportListSerializer):+ return None+ service = ReviewerRules(team=obj.team, report_id=str(obj.id))+ return dict(ReviewerControlResponseSerializer(service).data)+monitoring_started_at = serializers.DateTimeField(read_only=True,required=False,@@ -1435,6 +1499,7 @@ class SignalReportSerializer(serializers.ModelSerializer):"title","summary","summary_lead",+ "reviewer_assignment","status","monitoring_started_at","total_weight", # Used for priority scoring@@ -2748,25 +2813,37 @@ class SignalReportSuggestedReviewersArtefactSerializer(SignalReportArtefactSeriaclass SignalReportArtefactWriteSerializer(serializers.Serializer):- """PUT body for replacing a `suggested_reviewers` artefact's content.-- Only `suggested_reviewers` artefacts may be modified via this endpoint;- the viewset enforces the type check before validation runs.- """-MAX_ENTRIES = 10- # ListField rather than the serializer with many=True: drf-spectacular returns early for a- # nested many=True serializer, so a cap declared there never reaches the schema as maxItems.+ action = serializers.ChoiceField(+ choices=ReviewerEditAction.choices,+ default="replace",+ help_text="Add or remove only the supplied people, replace the list, or explicitly confirm it.",+ )+ expected_reviewers = ReviewerStateSerializer(+ required=False,+ help_text="State from the last read. Required for replacement and confirmation when corrections are enabled.",+ )content = serializers.ListField(child=SuggestedReviewerEntryWriteSerializer(),allow_empty=True,max_length=MAX_ENTRIES,- help_text=(- f"Full replacement list of reviewers. Empty list clears the artefact. At most {MAX_ENTRIES} entries."- ),+ help_text="People to add, remove, or keep in a replacement. Send an empty list for confirmation.",)+ targets = serializers.ListField(+ child=SuggestedReviewerEntryWriteSerializer(),+ required=False,+ allow_empty=False,+ max_length=MAX_ENTRIES,+ help_text="Explicit add or remove targets. When supplied, content is only a fallback for older servers.",+ )++ def validate(self, attrs: dict) -> dict:+ if "targets" in attrs and attrs["action"] not in {"add", "remove"}:+ raise serializers.ValidationError({"targets": "Targets require an add or remove action."})+ return attrs+# Writable types only — `video_segment` (and any other NON_WRITABLE type) is read-only and rejected# by the write API, so it must not be advertised as an option here.@@ -2787,7 +2864,7 @@ def _validate_artefact_content_is_container(value: object) -> dict | list:return value-class SignalReportArtefactLogCreateSerializer(serializers.Serializer):+class SignalReportArtefactLogCreateSerializer(ReviewerProposalSerializer):"""Body for appending an artefact to a report.Everything is append-only: log artefacts accumulate, status artefacts supersede the previousdiff --git a/products/signals/backend/slack_inbox_notifications.py b/products/signals/backend/slack_inbox_notifications.pyindex b4307aca05dd..4ed5a6ecbaa0 100644--- a/products/signals/backend/slack_inbox_notifications.py+++ b/products/signals/backend/slack_inbox_notifications.py@@ -36,6 +36,7 @@ from posthog.slack.formatting import ()from posthog.slack.markdown import slack_markdown_block as _markdown_block+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.enums import SIGNAL_SOURCE_PRODUCT_LABELSfrom products.signals.backend.models import (AutonomyPriority,@@ -713,6 +714,8 @@ def _deliver_route_notification(ai_enabled = bool(report.team.organization.is_ai_data_processing_approved)if invite := slack_followup_invite(route.integration, utm_tags=_INBOX_INVITE_UTM_TAGS, ai_enabled=ai_enabled):blocks.append(invite)+ if not assignment_side_effects_allowed(team_id=report.team_id, report_id=str(report.id)):+ return Falseresponse = slack.client.chat_postMessage(channel=channel_id, blocks=blocks, text=text)delivered = Truethread_ts = response.get("ts") if hasattr(response, "get") else None@@ -813,6 +816,9 @@ def dispatch_inbox_item_notifications(Best-effort: per-destination Slack errors are logged, not raised."""+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return 0+try:report = SignalReport.objects.get(id=report_id, team_id=team_id)except SignalReport.DoesNotExist:@@ -951,6 +957,9 @@ def dispatch_reviewer_added_notifications(fires for reports that would themselves have notified. `exclude_user_id` drops the actorso someone adding themselves isn't pinged. Best-effort; returns messages sent."""+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return 0+added_logins = {login.lower() for login in _stripped_nonempty(added_github_logins)}added_uuids = _stripped_nonempty(added_user_uuids)if not added_logins and not added_uuids:diff --git a/products/signals/backend/suggested_reviewer_index.py b/products/signals/backend/suggested_reviewer_index.pyindex 5f34bd58c487..baf901441c0e 100644--- a/products/signals/backend/suggested_reviewer_index.py+++ b/products/signals/backend/suggested_reviewer_index.py@@ -21,27 +21,14 @@ from products.signals.backend.models import SignalReportArtefact, SignalReportSulogger = structlog.get_logger(__name__)-# A tie needs at most a handful of rows, and a report's reviewer history is short, so reading the-# newest few and grouping in Python costs one query where a timestamp lookup would cost two.-_TIE_SCAN_LIMIT = 20--def _current_reviewer_artefacts(team_id: int, report_id: str) -> list[SignalReportArtefact]:- """The report's live reviewer artefacts: the newest row, plus any row written at the same- instant. The predicate this replaces ("no newer row of this type exists") also kept every row- at the maximum timestamp, so a tie must stay a union rather than become a pick.- """- newest_first = list(+ return list(SignalReportArtefact.objects.filter(team_id=team_id,report_id=report_id,type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,- ).order_by("-created_at")[:_TIE_SCAN_LIMIT]+ ).order_by("-created_at", "-id")[:1])- if not newest_first:- return []- latest = newest_first[0].created_at- return [artefact for artefact in newest_first if artefact.created_at == latest]def _rows_for_artefact(artefact: SignalReportArtefact) -> list[SignalReportSuggestedReviewer]:diff --git a/products/signals/backend/tasks.py b/products/signals/backend/tasks.pyindex 39dc9d8c26ee..ded251bc71b9 100644--- a/products/signals/backend/tasks.py+++ b/products/signals/backend/tasks.py@@ -27,6 +27,7 @@ from posthog.ph_client import ph_scoped_capturefrom posthog.scoping_audit import skip_team_scope_auditfrom posthog.temporal.common.utils import is_stale_connection_read_only_error+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.billing import current_billing_period_boundsfrom products.signals.backend.first_report_notification_tasks import (dispatch_first_report_notification as dispatch_first_report_notification,@@ -353,6 +354,8 @@ def deliver_scout_slack_thread_replies(report_revision: str | None = None,) -> None:"""Continue a rate-limited report thread without holding or retrying the lead-message worker."""+ if report_id is not None and not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ returnteam = Team.objects.only("project_id").get(id=team_id)integration = _slack_integration_for_project(integration_id=integration_id, project_id=team.project_id)slack = SlackIntegration(integration, source="signals_scout")@@ -519,6 +522,8 @@ def deliver_scout_slack_output(channel=channel,)elif output_type == "report":+ if not assignment_side_effects_allowed(team_id=team_id, report_id=output_id):+ returnreport = SignalReport.objects.select_related("team").filter(id=output_id, team_id=team_id).first()run = SignalScoutRun.objects.select_related("team").filter(id=run_id, team_id=team_id).first()if report is None or run is None:@@ -623,6 +628,8 @@ def enqueue_scout_slack_delivery(# report message to the delivery that is still building it.supersedes = output_type == "report" and edit_note is Nonetry:+ if output_type == "report" and not assignment_side_effects_allowed(team_id=team_id, report_id=output_id):+ return# Claim before publishing: an earlier delivery of the same report reads this marker to decide# whether to yield, and between the two calls it would see no claim and post the report that# this delivery is about to post again.diff --git a/products/signals/backend/temporal/agentic/report.py b/products/signals/backend/temporal/agentic/report.pyindex 7c212bcbdd7e..08bdafebfc52 100644--- a/products/signals/backend/temporal/agentic/report.py+++ b/products/signals/backend/temporal/agentic/report.py@@ -30,15 +30,10 @@ from products.signals.backend.artefact_schemas import (ReportLink,SuggestedReviewers,)+from products.signals.backend.assignment_flags import assignment_writer_enabledfrom products.signals.backend.auto_start import ReviewerContentfrom products.signals.backend.enums import ReportLinkKind, SuggestedSourceProduct-from products.signals.backend.models import (- ArtefactAttribution,- SignalActorKind,- SignalReport,- SignalReportArtefact,- SignalReportCheck,-)+from products.signals.backend.models import ArtefactAttribution, SignalReport, SignalReportArtefact, SignalReportCheckfrom products.signals.backend.receivers import _is_safety_suppressedfrom products.signals.backend.recurrence import fixed_dismissal_atfrom products.signals.backend.repo_corrections import SCOUT_REPOSITORY_CONTENT_NEEDLE, WRONG_REPO_CONTENT_NEEDLE@@ -74,6 +69,7 @@ from products.signals.backend.report_generation.select_repo import RepoSelectionfrom products.signals.backend.report_lifecycle import report_status_filterfrom products.signals.backend.report_metrics import REPORT_METRIC_GOAL_FIELDS, ReportMetric, metric_batch_errorfrom products.signals.backend.report_steering import ReportSteering, load_research_steering+from products.signals.backend.reviewer_rules import ReviewerProposal, ReviewerRules, StaleReviewerProposalfrom products.signals.backend.source_suggestions import unused_suggestable_productsfrom products.signals.backend.supersession import research_implementation_contextfrom products.signals.backend.temporal.agentic import (@@ -592,7 +588,7 @@ def _report_has_live_suggested_reviewers(report_id: str) -> bool:SignalReportArtefact.objects.filter(report_id=report_id, type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS)- .order_by("-created_at")+ .order_by("-created_at", "-id").first())if artefact is None:@@ -673,6 +669,7 @@ def _append_agentic_report_artefacts(report_id: str,artefacts: list[ArtefactDraft],priority_judgment_id: UUID | None = None,+ reviewer_proposal: ReviewerProposal | None = None,) -> bool:# Append-only: each (re-promotion) run adds a new version of its artefacts rather than# replacing the previous ones. The report's current judgments / repo selection / reviewers are@@ -688,38 +685,34 @@ def _append_agentic_report_artefacts(# the title/summary they illustrate, which a later activity writes (`mark_report_ready` /# `mark_report_pending_input`). The research activity only resolves the payload; see# `_resolve_report_charts_payload` and `RunAgenticReportOutput.charts`.+ service = ReviewerRules(team=Team.objects.get(id=team_id), report_id=report_id)with transaction.atomic():# Priority edits take the same lock, so a correction cannot arrive between this check and append.SignalReport.objects.select_for_update().get(id=report_id, team_id=team_id)priority_adjusted_mid_run = any(isinstance(draft.content, PriorityAssessment) for draft in artefacts) and (_priority_adjusted_since(team_id, report_id, priority_judgment_id))- if any(isinstance(draft.content, SuggestedReviewers) for draft in artefacts):- human_selected_reviewers = SignalReportArtefact.objects.filter(- team_id=team_id,- report_id=report_id,- type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,- actor_kind=SignalActorKind.USER,- ).exists()- else:- human_selected_reviewers = Falsewrote_reviewers = Falsefor draft in artefacts:if priority_adjusted_mid_run and isinstance(draft.content, PriorityAssessment):continue- if human_selected_reviewers and isinstance(draft.content, SuggestedReviewers):- continueif isinstance(draft.content, SuggestedReviewers):- previous = SignalReportArtefact.latest_content(- team_id=team_id, report_id=report_id, model=SuggestedReviewers- )- comparison_exclusions = {- "__all__": {"reason": True, "github_name": True, "relevant_commits": {"__all__": {"reason"}}}- }- if previous is not None and previous.model_dump(- exclude=comparison_exclusions- ) == draft.content.model_dump(exclude=comparison_exclusions):- continue+ previous = service.read().state.reviewers_id+ try:+ artefact = SignalReportArtefact.append_status(+ team_id=team_id,+ report_id=report_id,+ content=draft.content,+ attribution=draft.attribution,+ reviewer_proposal=reviewer_proposal+ or ReviewerProposal(expected_state=service.read().state, source="research"),+ reevaluate_autostart=False,+ )+ except StaleReviewerProposal:+ logger.info("signals.assignment.research_proposal_stale", team_id=team_id, report_id=report_id)+ else:+ wrote_reviewers |= artefact.id != previous+ continueSignalReportArtefact.append(team_id=team_id,report_id=report_id,@@ -788,6 +781,7 @@ async def _persist_agentic_report_artefacts(repo_selection: RepoSelectionResult,repo_selection_as_of: datetime | None = None,priority_judgment_id: UUID | None = None,+ reviewer_proposal: ReviewerProposal | None = None,) -> None:reviewer_resolution = Nonereviewers_content: list[ReviewerContent] = []@@ -818,11 +812,17 @@ async def _persist_agentic_report_artefacts(findings=result.effective_findings(),)except Exception as error:+ research_outcome = "research_lookup_failed"logger.warning("Legacy reviewer lookup failed", team_id=team_id, report_id=report_id, error_type=type(error).__name__)else:reviewers_content = reviewer_resolution.reviewers+ diagnostics = reviewer_resolution.diagnostics+ if not reviewers_content and (+ diagnostics.outcome in {"no_github_integration", "github_rate_limited"} or diagnostics.lookups_missing+ ):+ research_outcome = "research_lookup_failed"# Persist only what's new this run; values the agent confirmed unchanged keep their latest# persisted row. An explicit reviewer decision can change even when the findings do not.@@ -893,11 +893,35 @@ async def _persist_agentic_report_artefacts())+ if reviewer_proposal is not None and await database_sync_to_async(+ assignment_writer_enabled, thread_sensitive=False+ )(team_id):+ outcome = (+ "lookup_failed"+ if research_outcome == "research_lookup_failed"+ else "selected"+ if reviewers_content+ else "no_suitable_owner"+ )+ reviewer_proposal = reviewer_proposal.model_copy(+ update={+ "outcome": outcome,+ "retry_reason": "Reviewer lookup unavailable" if outcome == "lookup_failed" else None,+ }+ )+ if not any(isinstance(draft.content, SuggestedReviewers) for draft in artefacts):+ artefacts.append(+ ArtefactDraft(+ content=SuggestedReviewers.model_validate(list(reviewers_content)), attribution=research_attribution+ )+ )+wrote_reviewers = await database_sync_to_async(_append_agentic_report_artefacts, thread_sensitive=False)(team_id=team_id,report_id=report_id,artefacts=artefacts,priority_judgment_id=priority_judgment_id,+ reviewer_proposal=reviewer_proposal,)# Telemetry mirrors persistence: fires when a suggested_reviewers artefact was appended@@ -905,6 +929,10 @@ async def _persist_agentic_report_artefacts(# (a retry of this activity re-captures an identical payload), so consumers read report# state as the latest event per report_id rather than counting raw events.if wrote_reviewers:+ applied_reviewers = await SignalReportArtefact.alatest_content(+ team_id=team_id, report_id=report_id, model=SuggestedReviewers+ )+ reviewers_content = applied_reviewers.model_dump(mode="json") if applied_reviewers else []await database_sync_to_async(capture_suggested_reviewers_resolved, thread_sensitive=False)(team_id=team_id,report_id=report_id,@@ -1063,6 +1091,18 @@ async def run_agentic_report_activity(input: RunAgenticReportInput) -> RunAgentiassert input.repo_selection.repository is not None, "run_agentic_report_activity called without a repository"repository = input.repo_selection.repository+ assignment = await database_sync_to_async(ReviewerRules, thread_sensitive=False)(+ team=await Team.objects.aget(id=input.team_id),+ report_id=input.report_id,+ )+ reviewer_snapshot = await database_sync_to_async(assignment.read, thread_sensitive=False)()+ reviewer_proposal = None+ if assignment.enabled or reviewer_snapshot.state.corrections_id:+ reviewer_proposal = ReviewerProposal(+ expected_state=reviewer_snapshot.state,+ source="research",+ )+async with Heartbeater():# 1. Get context for the sandboxuser_id = await database_sync_to_async(resolve_user_id_for_team, thread_sensitive=False)(input.team_id)@@ -1172,6 +1212,7 @@ async def run_agentic_report_activity(input: RunAgenticReportInput) -> RunAgentiinput.repo_selection,repo_selection_as_of=input.repo_selection_as_of,priority_judgment_id=priority_judgment_id,+ reviewer_proposal=reviewer_proposal,)actionability = result.effective_actionability()priority = result.effective_priority()diff --git a/products/signals/backend/test/test_auto_start.py b/products/signals/backend/test/test_auto_start.pyindex afdf0566bc0b..a0515582d16f 100644--- a/products/signals/backend/test/test_auto_start.py+++ b/products/signals/backend/test/test_auto_start.py@@ -23,7 +23,9 @@ from products.signals.backend.agent_runtime import AgentRuntimefrom products.signals.backend.artefact_schemas import (PullRequestLink,ReportLink,+ ReviewerEdit,SignalFinding,+ SuggestedReviewerEntry,SuggestedReviewers,TaskRunArtefact,)@@ -72,6 +74,7 @@ from products.signals.backend.report_generation.research import (PriorityAssessment,)from products.signals.backend.report_generation.resolve_reviewers import ReviewerIdentitySet+from products.signals.backend.reviewer_rules import ReviewerProposal, ReviewerRulesfrom products.signals.backend.signal_metadata import SignalSourceReferencefrom products.signals.backend.task_run_artefacts import TASK_RUN_TYPE_IMPLEMENTATION, signals_task_idsfrom products.signals.backend.test.test_billing import _seed_canonical_scout_skill@@ -563,6 +566,101 @@ def test_generate_self_driving_head_branch_is_readable_and_valid(title, expectedassert re.fullmatch(rf"posthog-self-driving/{re.escape(expected_slug)}-[0-9a-f]{{6}}", branch)+def test_create_implementation_task_rejects_a_changed_reviewer_list(organization: Organization, team: Team) -> None:+ user = _create_org_member_with_github("[email protected]", organization, "example-reviewer")+ report = SignalReport.objects.create(team=team, status=SignalReport.Status.READY, title="t", summary="s")+ state = ReviewerRules.read_for_report(team_id=team.id, report_id=str(report.id)).state+ SignalReportArtefact.append_status(+ team_id=team.id,+ report_id=str(report.id),+ content=SuggestedReviewers(root=[]),+ attribution=ArtefactAttribution.from_user(user.id),+ reevaluate_autostart=False,+ )++ with patch.object(tasks_facade, "create_and_run_task") as create_task:+ with pytest.raises(ReportChangedDuringAutostart, match="Reviewers changed"):+ _create_implementation_task_if_absent(+ team_id=team.id,+ report_id=str(report.id),+ title="t",+ description="s",+ expected_content=ImplementationReportContent.from_report(report),+ expected_reviewers=state,+ user_id=user.id,+ repository="owner/repo",+ base_branch=None,+ )+ create_task.assert_not_called()++[email protected]_db(transaction=True)[email protected]("has_automatic_reviewer,enrolled", [(False, True), (True, True), (False, False)])+def test_human_pin_does_not_authorize_automatic_execution(+ organization: Organization, team: Team, has_automatic_reviewer: bool, enrolled: bool+) -> None:+ editor = _create_org_member_with_github("[email protected]", organization, "example-editor")+ reviewer = _create_org_member_with_github("[email protected]", organization, "example-reviewer")+ report = SignalReport.objects.create(team=team, status=SignalReport.Status.READY, title="t", summary="s")+ with (+ patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=enrolled),+ patch("products.signals.backend.reviewer_rules.assignment_side_effects_enabled", return_value=False),+ ):+ SignalReportArtefact.append_status(+ team_id=team.id,+ report_id=str(report.id),+ content=SuggestedReviewers(root=[SuggestedReviewerEntry(user_uuid=str(reviewer.uuid))]),+ attribution=ArtefactAttribution.from_user(editor.id),+ reviewer_edit=ReviewerEdit(action="add"),+ )+ automatic = _create_org_member_with_github("[email protected]", organization, "example-automatic")+ if not has_automatic_reviewer:+ reviewer.is_active = False+ reviewer.save(update_fields=["is_active"])+ SignalReportArtefact.append_status(+ team_id=team.id,+ report_id=str(report.id),+ content=SuggestedReviewers(+ root=[SuggestedReviewerEntry(user_uuid=str(automatic.uuid))] if has_automatic_reviewer else []+ ),+ attribution=ArtefactAttribution.system(),+ reviewer_proposal=ReviewerProposal(+ expected_state=ReviewerRules.read_for_report(team_id=team.id, report_id=str(report.id)).state+ ),+ )++ with (+ patch("products.signals.backend.auto_start.assignment_side_effects_allowed", return_value=True),+ patch("products.signals.backend.auto_start.assignment_writer_enabled", return_value=True),+ patch("products.signals.backend.auto_start._resolve_triggering_user", return_value=None) as resolve_editor,+ patch("products.signals.backend.auto_start._resolve_autostart_assignee", return_value=None) as resolve_reviewer,+ patch("products.signals.backend.auto_start._resolve_autostart_fallback_user", return_value=None),+ patch.object(tasks_facade, "create_and_run_task") as create_task,+ ):+ result = async_to_sync(maybe_autostart_implementation_task)(+ team_id=team.id,+ report_id=str(report.id),+ title="t",+ summary="s",+ repository="owner/repo",+ actionability=ActionabilityAssessment(+ explanation="A clear fix",+ actionability=ActionabilityChoice.IMMEDIATELY_ACTIONABLE,+ already_addressed=False,+ ),+ priority=PriorityAssessment(explanation="Affects sessions", priority=Priority.P2),+ reviewers_content=[_reviewer("example-reviewer")],+ )+ assert result.status == "blocked"+ resolve_editor.assert_not_called()+ if has_automatic_reviewer:+ assert [entry["user_uuid"] for entry in resolve_reviewer.call_args.args[2]] == [str(automatic.uuid)]+ else:+ resolve_reviewer.assert_not_called()+ create_task.assert_not_called()++@pytest.mark.django_db@pytest.mark.parametrize("concurrent_change", [None, {"summary": "A newer fix"}, {"run_count": 2}, {"content_revision_count": 1}]diff --git a/products/signals/backend/test/test_custom_agent_log_artefacts.py b/products/signals/backend/test/test_custom_agent_log_artefacts.pyindex b975b7a00263..a24284d5b400 100644--- a/products/signals/backend/test/test_custom_agent_log_artefacts.py+++ b/products/signals/backend/test/test_custom_agent_log_artefacts.py@@ -68,6 +68,28 @@ class TestCustomAgentLogArtefacts(BaseTest):priority=PriorityAssessment(explanation="e", priority=Priority.P1),)+ @patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ def test_registered_reviewers_use_shared_writer(self, _writer) -> None:+ result = create_custom_agent_ready_report(+ team_id=self.team.id,+ final_report=self._final_report(),+ repo_selection=RepoSelectionResult(repository=None, reason="No repository"),+ agent_identifier=("billing", "anomaly_scan"),+ registered_artefacts=[+ SuggestedReviewers(+ root=[+ SuggestedReviewerEntry(user_uuid=str(self.user.uuid)),+ SuggestedReviewerEntry(github_login="unlinked-example"),+ ]+ )+ ],+ )+ reviewers = SignalReportArtefact.latest_content(+ team_id=self.team.id, report_id=result.report_id, model=SuggestedReviewers+ )+ assert reviewers is not None and [entry.user_uuid for entry in reviewers.root] == [str(self.user.uuid)]+ assert SignalReportArtefact.objects.filter(report_id=result.report_id, type="reviewer_corrections").count() == 1+def test_register_artefact_queues_any_content_model(self):agent = self._agent()diff --git a/products/signals/backend/test/test_report_claim_concurrency.py b/products/signals/backend/test/test_report_claim_concurrency.pyindex 0d2f1316e5a5..5e4f5df3db5b 100644--- a/products/signals/backend/test/test_report_claim_concurrency.py+++ b/products/signals/backend/test/test_report_claim_concurrency.py@@ -2,15 +2,18 @@ from concurrent.futures import ThreadPoolExecutorfrom threading import Barrierimport pytest+from unittest.mock import patchfrom django.db import connectionsfrom posthog.models import Organization, Team, Userfrom products.signals.backend.artefact_attribution import ArtefactAttribution+from products.signals.backend.artefact_schemas import SuggestedReviewersfrom products.signals.backend.models import SignalReport, SignalReportArtefact, SignalReportAssignmentfrom products.signals.backend.report_assignments import ReportClaimConflict, claim_reportfrom products.signals.backend.report_claims import get_active_claim+from products.signals.backend.reviewer_rules import ReviewerProposal, ReviewerRules, StaleReviewerProposal@pytest.mark.django_db(transaction=True)@@ -50,3 +53,45 @@ def test_concurrent_claims_have_one_winner() -> None:assert claim.claim_id == artefact.idassert claim.actor_agent == winning_agentassert claim.actor_user_id == user.id++[email protected]_db(transaction=True)[email protected]("legacy_human_edit", [False, True])+def test_concurrent_reviewer_proposals_have_one_winner(legacy_human_edit: bool) -> None:+ organization = Organization.objects.create(name="Assignment test")+ team = Team.objects.create(organization=organization)+ report = SignalReport.objects.create(team=team, status="ready")+ if legacy_human_edit:+ SignalReportArtefact.objects.create(+ team=team, report=report, type="suggested_reviewers", content="[]", actor_kind="user"+ )+ proposal = ReviewerProposal(+ expected_state=ReviewerRules.read_for_report(team_id=team.id, report_id=str(report.id)).state+ )+ barrier = Barrier(2)++ def attempt() -> str:+ try:+ barrier.wait(timeout=10)+ SignalReportArtefact.append_status(+ team_id=team.id,+ report_id=str(report.id),+ content=SuggestedReviewers(root=[]),+ attribution=ArtefactAttribution.system(),+ reviewer_proposal=proposal,+ )+ return "applied"+ except StaleReviewerProposal:+ return "stale"+ finally:+ connections.close_all()++ with (+ patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True),+ patch("products.signals.backend.reviewer_rules.assignment_side_effects_enabled", return_value=False),+ ):+ with ThreadPoolExecutor(max_workers=2) as pool:+ futures = [pool.submit(attempt) for _ in range(2)]+ assert sorted(future.result(timeout=20) for future in futures) == ["applied", "stale"]+ assert report.artefacts.filter(type="suggested_reviewers").count() == 1+ assert report.artefacts.filter(type="reviewer_corrections").count() == 1diff --git a/products/signals/backend/test/test_reviewer_pr_assignment.py b/products/signals/backend/test/test_reviewer_pr_assignment.pyindex 90aaccb44692..5cef8f17cca1 100644--- a/products/signals/backend/test/test_reviewer_pr_assignment.py+++ b/products/signals/backend/test/test_reviewer_pr_assignment.py@@ -144,21 +144,38 @@ class TestOptedInReviewerLogins:class TestAssignReviewersToPullRequest:@pytest.mark.django_db- def test_opted_in_reviewers_are_added_as_assignees(self, org_and_team):+ @pytest.mark.parametrize("disable_during_lookup", [False, True])+ def test_opted_in_reviewers_are_added_as_assignees(self, org_and_team, disable_during_lookup):org, team = org_and_team_make_reviewer(org, "opted-in", opted_in=True)_make_reviewer(org, "opted-out", opted_in=False)report = _make_report(team, ["opted-in", "opted-out"])github = _open_pr_github()- with patch(- "products.signals.backend.reviewer_pr_assignment.GitHubIntegration.first_for_team_repository",- return_value=github,+ with (+ patch(+ "products.signals.backend.reviewer_pr_assignment.assignment_side_effects_allowed", return_value=True+ ) as allowed,+ patch(+ "products.signals.backend.reviewer_pr_assignment.GitHubIntegration.first_for_team_repository",+ return_value=github,+ ),):++ def read_pr(*_args: object) -> dict[str, object]:+ allowed.return_value = not disable_during_lookup+ return github.get_pull_request.return_value++ github.get_pull_request.side_effect = read_prassigned = assign_reviewers_to_pull_request(team_id=team.id, report_id=str(report.id), pr_url=PR_URL)- assert assigned == ["opted-in"]- github.add_pull_request_assignees.assert_called_once_with("PostHog/posthog", 123, ["opted-in"])+ if disable_during_lookup:+ assert assigned == []+ github.add_pull_request_assignees.assert_not_called()+ github.request_pull_request_reviews.assert_not_called()+ else:+ assert assigned == ["opted-in"]+ github.add_pull_request_assignees.assert_called_once_with("PostHog/posthog", 123, ["opted-in"])@pytest.mark.django_dbdef test_no_reviewers_or_assignment_work_skips_github_entirely(self, org_and_team):diff --git a/products/signals/backend/test/test_reviewer_rules.py b/products/signals/backend/test/test_reviewer_rules.pynew file mode 100644index 000000000000..c17d75c0a8ee--- /dev/null+++ b/products/signals/backend/test/test_reviewer_rules.py@@ -0,0 +1,459 @@+import json+from uuid import UUID++from posthog.test.base import BaseTest+from unittest.mock import patch++from django.test import SimpleTestCase+from django.utils import timezone++from parameterized import parameterized+from social_django.models import UserSocialAuth++from posthog.models import OrganizationMembership, User+from posthog.models.activity_logging.activity_log import ActivityLog++from products.signals.backend.artefact_attribution import ArtefactAttribution+from products.signals.backend.artefact_schemas import (+ ArtefactContentValidationError,+ RelevantCommit,+ ReviewerEdit,+ ReviewerProposal,+ ReviewerState,+ SuggestedReviewerEntry,+ SuggestedReviewers,+ 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.report_generation.resolve_reviewers import (+ get_org_member_github_logins_by_user_uuid,+ resolve_org_github_login_to_users,+)+from products.signals.backend.reviewer_rules import ReviewerRules, ReviewerWriteError, StaleReviewerProposal+from products.signals.backend.suggested_reviewer_index import report_ids_naming_reviewers, sync_suggested_reviewer_index+++class TestReviewerRules(BaseTest):+ def setUp(self) -> None:+ super().setUp()+ self.flag = patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ 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)+ 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.actor = ArtefactAttribution.from_user(self.user.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))++ def write(+ self,+ *reviewers: SuggestedReviewerEntry,+ edit: ReviewerEdit | None = None,+ proposal: ReviewerProposal | None = None,+ ) -> SignalReportArtefact:+ return SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=str(self.report.id),+ content=SuggestedReviewers(root=list(reviewers)),+ attribution=self.actor if edit else ArtefactAttribution.system(),+ reviewer_edit=edit,+ reviewer_proposal=proposal or ReviewerProposal(expected_state=self.rules.read().state),+ )++ def test_self_removal_allows_a_new_owner_without_restoring_the_editor(self) -> None:+ self.write(self.me)+ self.write(self.me, edit=ReviewerEdit(action="remove"))+ self.write(self.me, self.other)+ snapshot = self.rules.read()+ assert snapshot.reviewers == (self.other,)+ assert snapshot.corrections.excluded == (self.me,)+ assert not snapshot.corrections.confirmed+ assert (+ list(+ report_ids_naming_reviewers(+ team_id=self.team.id,+ user_uuids=[str(self.user.uuid)],+ github_logins=[],+ logins_match_unidentified_only=True,+ )+ )+ == []+ )++ def test_login_only_removal_survives_identity_change(self) -> None:+ UserSocialAuth.objects.create(+ user=self.member, provider="github", uid="renamed-reviewer", extra_data={"login": "previous-login"}+ )+ self.write(self.other)+ self.write(SuggestedReviewerEntry(github_login="previous-login"), edit=ReviewerEdit(action="remove"))+ assert self.rules.read().corrections.excluded[0].user_uuid == str(self.member.uuid)+ self.member.social_auth.filter(provider="github").update(extra_data={"login": "current-login"})+ self.write(SuggestedReviewerEntry(user_uuid=str(self.member.uuid), github_login="current-login"))+ assert self.rules.read().reviewers == ()++ def test_pin_preserves_only_the_person_added_and_a_later_removal_reverses_it(self) -> None:+ self.write(self.other)+ self.write(self.me, edit=ReviewerEdit(action="add"))+ self.write()+ assert self.rules.read().reviewers == (self.me,)+ self.write(self.me, edit=ReviewerEdit(action="remove"))+ self.write(self.me, self.other)+ assert self.rules.read().reviewers == (self.other,)+ self.write(self.me, edit=ReviewerEdit(action="add"))+ assert self.rules.read().corrections.excluded == ()+ assert self.rules.read().corrections.pinned == (self.me,)++ def test_pin_changes_the_state_token_without_repeating_the_list(self) -> None:+ first = self.write(self.me)+ stale = ReviewerProposal(expected_state=self.rules.read().state)+ pinned = self.write(self.me, edit=ReviewerEdit(action="add"))+ assert pinned.id == first.id+ with self.assertRaises(StaleReviewerProposal):+ self.write(self.other, proposal=stale)+ assert self.rules.read().reviewers == (self.me,)++ @parameterized.expand([False, True])+ def test_confirmation_protects_the_whole_list_including_empty(self, empty: bool) -> None:+ self.write(*(() if empty else (self.me,)))+ self.write(edit=ReviewerEdit(action="confirm", expected_state=self.rules.read().state))+ self.write(self.other)+ assert self.rules.read().reviewers == (() if empty else (self.me,))+ self.write(self.other, edit=ReviewerEdit(action="add"))+ self.write()+ assert self.rules.read().reviewers == ((self.other,) if empty else (self.me, self.other))+ assert self.rules.read().corrections.confirmed++ @parameterized.expand(["replace", "confirm"])+ def test_stale_full_list_operations_do_not_discard_new_people(self, action: str) -> None:+ self.write(self.me)+ stale = self.rules.read().state+ self.write(self.other, edit=ReviewerEdit(action="add"))+ with self.assertRaises(StaleReviewerProposal):+ self.write(self.me, edit=ReviewerEdit(action=action, expected_state=stale))+ assert self.rules.read().reviewers == (self.me, self.other)++ def test_independent_human_operations_merge_against_current_membership(self) -> None:+ self.write(self.me)+ stale = self.rules.read().state+ self.write(self.other, edit=ReviewerEdit(action="add", expected_state=stale))+ self.write(self.me, edit=ReviewerEdit(action="remove", expected_state=stale))+ assert self.rules.read().reviewers == (self.other,)++ @parameterized.expand(["lookup_failed", "invalid"])+ def test_failed_selection_keeps_valid_recipients(self, outcome: str) -> None:+ self.write(self.me)+ if outcome == "invalid":+ self.write(SuggestedReviewerEntry(github_login="unknown-example"))+ else:+ self.write(+ proposal=ReviewerProposal(+ expected_state=self.rules.read().state,+ outcome="lookup_failed",+ retry_reason="Member lookup unavailable",+ )+ )+ assert self.rules.read().reviewers == (self.me,)++ def test_no_owner_clears_automatic_people_but_preserves_pins(self) -> None:+ self.write(self.other)+ self.write(self.me, edit=ReviewerEdit(action="add"))+ self.write(proposal=ReviewerProposal(expected_state=self.rules.read().state, outcome="no_suitable_owner"))+ assert self.rules.read().reviewers == (self.me,)++ @parameterized.expand([(False, False), (True, False), (True, True)])+ def test_automatic_writes_load_each_members_identity_once(self, pinned: bool, selected: bool) -> None:+ self.write(self.me)+ if pinned:+ self.write(self.other, edit=ReviewerEdit(action="add"))+ candidates = (self.me, self.other) if selected else (self.me,)+ expected = (self.me, self.other) if pinned else (self.me,)+ for _ in range(2):+ with patch(+ "products.signals.backend.reviewer_rules.get_org_member_github_logins_by_user_uuid",+ wraps=get_org_member_github_logins_by_user_uuid,+ ) as lookup:+ self.write(*candidates)+ assert sorted(user_uuid for call in lookup.call_args_list for user_uuid in call.args[1]) == sorted(+ entry.user_uuid for entry in expected if entry.user_uuid+ )+ assert self.rules.read().reviewers == expected++ def test_access_checks_override_a_pin_and_confirmation(self) -> None:+ self.write(self.other, edit=ReviewerEdit(action="add"))+ self.write(edit=ReviewerEdit(action="confirm", expected_state=self.rules.read().state))+ self.member.is_active = False+ self.member.save(update_fields=["is_active"])+ self.write(self.me)+ assert self.rules.read().reviewers == ()+ assert self.rules.read().corrections.confirmed+ with self.assertRaises(ReviewerWriteError):+ self.write(self.other, edit=ReviewerEdit(action="add"))++ @parameterized.expand([False, True])+ def test_unchanged_write_creates_no_rows_or_delivery_and_stale_retry_conflicts(self, wording: bool) -> None:+ reviewer = SuggestedReviewerEntry(+ user_uuid=self.me.user_uuid,+ relevant_commits=[RelevantCommit(sha="abcdef0", reason="Fix", url="https://example.com/commit")],+ )+ proposal = ReviewerProposal(expected_state=self.rules.read().state, source="research")+ first = self.write(reviewer, proposal=proposal)+ proposed = reviewer.model_copy(deep=True)+ if wording:+ proposed.reason = "A new explanation for the same selection."+ proposed.github_name = "Reviewer name"+ proposed.relevant_commits[0].reason = "A new explanation for the same commit."+ with (+ patch("products.signals.backend.reviewer_rules.assignment_side_effects_enabled", return_value=True),+ self.captureOnCommitCallbacks(execute=False) as callbacks,+ ):+ same = self.write(+ proposed, proposal=ReviewerProposal(expected_state=self.rules.read().state, source="research")+ )+ assert callbacks == []+ assert same.id == first.id+ assert self.report.artefacts.count() == 2+ with self.assertRaises(StaleReviewerProposal):+ self.write(proposed, proposal=proposal)+ with self.assertRaises(ArtefactContentValidationError):+ first.update_content([])++ def test_rollback_keeps_corrections_and_does_not_enable_delivery(self) -> None:+ self.write(self.me)+ with (+ patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=False),+ patch("products.signals.backend.assignment_flags.assignment_side_effects_enabled", return_value=False),+ self.captureOnCommitCallbacks(execute=False) as callbacks,+ ):+ self.write(self.other)+ assert self.rules.read().reviewers == (self.me,)+ self.write(proposal=ReviewerProposal(expected_state=self.rules.read().state, outcome="no_suitable_owner"))+ assert self.rules.read().reviewers == (self.me,)+ self.write(self.me, edit=ReviewerEdit(action="remove"))+ assert self.rules.read().reviewers == ()+ assert not assignment_side_effects_allowed(team_id=self.team.id, report_id=str(self.report.id))+ assert callbacks == []++ @parameterized.expand([False, True])+ def test_legacy_deltas_protect_only_edits_and_missing_evidence_pauses_automation(self, logged: bool) -> None:+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=False):+ self.write(self.me, self.other)+ self.write(self.me, edit=ReviewerEdit(action="remove"))+ if logged:+ ActivityLog.objects.create(+ team_id=self.team.id,+ user=self.user,+ scope="SignalReport",+ item_id=str(self.report.id),+ activity="suggested_reviewers_changed",+ detail={+ "changes": [+ {+ "field": "suggested_reviewers",+ "before": [str(self.user.uuid), str(self.member.uuid)],+ "after": [str(self.member.uuid)],+ }+ ]+ },+ )+ pending = self.rules.read()+ assert pending.corrections.needs_review+ assert pending.state.corrections_id is None+ assert self.report.artefacts.count() == 2+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=False):+ self.write(self.me, proposal=ReviewerProposal(expected_state=pending.state, source="research"))+ assert self.rules.read().reviewers == (self.other,)+ assert self.report.artefacts.count() == 2+ self.write(self.me)+ snapshot = self.rules.read()+ assert snapshot.reviewers == (() if logged else (self.other,))+ assert snapshot.corrections.needs_review is not logged+ assert not snapshot.corrections.confirmed+ assert not snapshot.corrections.pinned+ ActivityLog.objects.filter(team_id=self.team.id, item_id=str(self.report.id)).delete()+ self.write(self.me)+ assert self.rules.read() == snapshot+ assert self.report.artefacts.filter(type="reviewer_corrections").count() == 1++ def test_unresolved_legacy_identity_requires_review(self) -> None:+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=False):+ self.write(SuggestedReviewerEntry(github_login="former-login"))+ self.write(edit=ReviewerEdit(action="replace"))+ ActivityLog.objects.create(+ team_id=self.team.id,+ user=self.user,+ scope="SignalReport",+ item_id=str(self.report.id),+ activity="suggested_reviewers_changed",+ detail={"changes": [{"field": "suggested_reviewers", "before": ["former-login"], "after": []}]},+ )+ self.write(self.other)+ snapshot = self.rules.read()+ assert snapshot.reviewers == ()+ assert snapshot.corrections.needs_review++ def test_legacy_recovery_resolves_all_logins_once(self) -> None:+ for user, login in [(self.user, "first-reviewer"), (self.member, "second-reviewer")]:+ UserSocialAuth.objects.create(user=user, provider="github", uid=login, extra_data={"login": login})+ lists = [[], ["first-reviewer"], ["first-reviewer", "second-reviewer"], ["second-reviewer"], []]+ for before, after in zip(lists, lists[1:]):+ SignalReportArtefact.objects.create(+ team=self.team,+ report=self.report,+ type="suggested_reviewers",+ actor_kind="user",+ created_by=self.user,+ content=json.dumps([{"github_login": login} for login in after]),+ )+ ActivityLog.objects.create(+ team_id=self.team.id,+ user=self.user,+ scope="SignalReport",+ item_id=str(self.report.id),+ activity="suggested_reviewers_changed",+ detail={"changes": [{"field": "suggested_reviewers", "before": before, "after": after}]},+ )+ with patch(+ "products.signals.backend.reviewer_rules.resolve_org_github_login_to_users",+ wraps=resolve_org_github_login_to_users,+ ) as resolve:+ corrections = self.rules._legacy_corrections(team_id=self.team.id, report_id=str(self.report.id))+ resolve.assert_called_once_with(self.team.id, {"first-reviewer", "second-reviewer"})+ assert not corrections.needs_review+ assert not corrections.pinned+ assert {entry.user_uuid for entry in corrections.excluded} == {str(self.user.uuid), str(self.member.uuid)}++ @parameterized.expand([None, "old-format"])+ def test_legacy_commit_evidence_is_normalized(self, commits: object) -> None:+ SignalReportArtefact.objects.create(+ team=self.team,+ report=self.report,+ type="suggested_reviewers",+ content=json.dumps([{"user_uuid": str(self.user.uuid), "relevant_commits": commits}]),+ )+ assert self.rules.read().reviewers == (self.me,)+ self.write(self.other)+ assert self.rules.read().reviewers == (self.other,)++ @parameterized.expand(["{", "{}", '[{"github_login": "valid-reviewer"}, {}]'])+ def test_invalid_legacy_reviewers_do_not_look_like_an_empty_assignment(self, content: str) -> None:+ row = SignalReportArtefact.objects.create(+ team=self.team, report=self.report, type="suggested_reviewers", content=content+ )+ snapshot = self.rules.read()+ assert snapshot.invalid_reviewers+ assert snapshot.corrections.needs_review+ for enabled in (False, True):+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=enabled):+ with self.assertRaises(ReviewerWriteError):+ self.write(self.other)+ for action in ("add", "remove", "confirm"):+ with self.assertRaises(ReviewerWriteError):+ self.write(self.other, edit=ReviewerEdit(action=action, expected_state=snapshot.state))+ for expected in (None, ReviewerState()):+ with self.assertRaises(StaleReviewerProposal):+ self.write(self.other, edit=ReviewerEdit(action="replace", expected_state=expected))+ with self.assertRaises(ReviewerWriteError):+ self.write(+ SuggestedReviewerEntry(github_login="unknown-example"),+ edit=ReviewerEdit(action="replace", expected_state=snapshot.state),+ )+ with self.assertRaises(ReviewerWriteError):+ SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=str(self.report.id),+ content=SuggestedReviewers(root=[self.other]),+ attribution=ArtefactAttribution.system(),+ reviewer_edit=ReviewerEdit(action="replace", expected_state=snapshot.state),+ )+ row.refresh_from_db()+ assert row.content == content+ assert self.report.artefacts.count() == 1++ @parameterized.expand([(False, False), (False, True), (True, False), (True, True)])+ def test_human_repair_preserves_corrections_and_history(self, enabled: bool, empty: bool) -> None:+ self.write(self.me, self.other)+ self.write(self.me, edit=ReviewerEdit(action="remove"))+ self.write(self.other, edit=ReviewerEdit(action="add"))+ row = SignalReportArtefact.objects.create(+ team=self.team, report=self.report, type="suggested_reviewers", content="{"+ )+ snapshot = self.rules.read()+ replacement = () if empty else (self.other,)+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=enabled):+ self.write(*replacement, edit=ReviewerEdit(action="replace", expected_state=snapshot.state))+ repaired = self.rules.read()+ assert not repaired.invalid_reviewers+ assert repaired.reviewers == replacement+ assert repaired.corrections == snapshot.corrections+ assert repaired.corrections.needs_review+ assert not repaired.corrections.confirmed+ assert repaired.state.corrections_id != snapshot.state.corrections_id+ self.write(self.me, self.other)+ assert self.rules.read() == repaired+ self.write(edit=ReviewerEdit(action="confirm", expected_state=repaired.state))+ assert not self.rules.read().corrections.needs_review+ row.refresh_from_db()+ assert row.content == "{"++ def test_login_exclusion_still_applies_after_member_resolution(self) -> None:+ UserSocialAuth.objects.create(+ user=self.member, provider="github", uid="1234", extra_data={"login": "example-reviewer"}+ )+ self.write(self.other)+ self.write(SuggestedReviewerEntry(github_login="example-reviewer"), edit=ReviewerEdit(action="remove"))+ self.write(self.other)+ assert self.rules.read().reviewers == ()++ def test_claim_must_belong_to_the_writer(self) -> None:+ claim = SignalReportArtefact.add_log(+ team_id=self.team.id, report_id=str(self.report.id), content=WorkClaim(), attribution=self.actor+ )+ with self.assertRaises(ArtefactContentValidationError):+ SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=str(self.report.id),+ content=SuggestedReviewers(root=[self.me]),+ attribution=ArtefactAttribution.system(),+ reviewer_proposal=ReviewerProposal(expected_state=self.rules.read().state),+ claim_id=str(claim.id),+ )+ assert not self.report.artefacts.filter(type="suggested_reviewers").exists()++ def test_state_and_index_choose_the_same_list_when_timestamps_match(self) -> None:+ for number, reviewer in [(1, self.me), (2, self.other)]:+ SignalReportArtefact.objects.create(+ id=UUID(int=number),+ team=self.team,+ report=self.report,+ type="suggested_reviewers",+ content=SuggestedReviewers(root=[reviewer]).model_dump_json(),+ )+ self.report.artefacts.update(created_at=timezone.now())+ sync_suggested_reviewer_index(team_id=self.team.id, report_id=str(self.report.id))+ assert self.rules.read().reviewers == (self.other,)+ assert list(+ report_ids_naming_reviewers(+ team_id=self.team.id,+ user_uuids=[str(self.member.uuid)],+ github_logins=[],+ logins_match_unidentified_only=True,+ )+ ) == [{"report_id": self.report.id}]+++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:+ with patch("products.signals.backend.assignment_flags.Team.objects") as teams:+ teams.values_list.return_value.get.return_value = "example-org"+ with patch(+ "products.signals.backend.assignment_flags.feature_enabled_or_false", return_value=value+ ) as flag:+ assert assignment_writer_enabled(1) is enabled+ assert flag.call_args.kwargs["only_evaluate_locally"] is Truediff --git a/products/signals/backend/test/test_scout_report_api.py b/products/signals/backend/test/test_scout_report_api.pyindex e6bf827dd985..82ad617005eb 100644--- a/products/signals/backend/test/test_scout_report_api.py+++ b/products/signals/backend/test/test_scout_report_api.py@@ -15,6 +15,7 @@ from django.utils import timezonefrom asgiref.sync import async_to_sync, sync_to_asyncfrom parameterized import parameterizedfrom rest_framework import status+from rest_framework.test import APIClientfrom social_django.models import UserSocialAuthfrom posthog.models import Organization, Team, User@@ -1600,6 +1601,86 @@ class TestScoutReportAPI(APIBaseTest):assert autostart.await_args is not Noneassert autostart.await_args.kwargs["report_id"] == response.json()["report_id"]+ @patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ @patch("products.signals.backend.reviewer_rules.assignment_side_effects_enabled", return_value=False)+ def test_human_scout_human_flow_preserves_corrections(self, _effects, _writer) -> None:+ human = APIClient()+ human.force_login(self.user)+ report = SignalReport.objects.create(team=self.team, status=SignalReport.Status.READY, title="A report")+ run = _make_run(self.team)+ root = f"/api/projects/{self.team.id}/signals/reports/{report.id}"+ selected = {"action": "add", "content": [{"user_uuid": str(self.user.uuid)}]}+ assert human.put(f"{root}/reviewers/", selected, format="json").status_code == 200+ before = human.get(f"{root}/").json()["reviewer_assignment"]+ assert before["pinned_user_uuids"] == [str(self.user.uuid)]+ assert (+ human.put(+ f"{root}/reviewers/",+ {"action": "remove", "content": [{"user_uuid": str(self.user.uuid)}]},+ format="json",+ ).status_code+ == 200+ )+ request = {+ "report_id": str(report.id),+ "suggested_reviewers": [{"user_uuid": str(self.user.uuid)}],+ "expected_reviewers": before["state"],+ }+ stale = self.client.post(self._edit_url(str(run.id)), request, format="json")+ assert stale.status_code == 200, stale.json()+ assert stale.json()["warnings"][0]["field"] == "suggested_reviewers"+ assert not stale.json()["reviewers_set"]+ state = human.get(f"{root}/").json()["reviewer_assignment"]+ request.update(expected_reviewers=state["state"])+ with patch(AUTOSTART_PATH, new=AsyncMock()) as autostart:+ for _ in range(2):+ response = self.client.post(self._edit_url(str(run.id)), request, format="json")+ assert response.status_code == 200, response.json()+ assert not response.json()["reviewers_set"]+ autostart.assert_not_called()+ assert report.artefacts.filter(type="suggested_reviewers").count() == 2+ assert human.put(f"{root}/reviewers/", selected, format="json").status_code == 200+ state = human.get(f"{root}/").json()["reviewer_assignment"]+ response = human.post(+ f"{root}/reviewers/resume/",+ {"expected_reviewers": state["state"]},+ format="json",+ )+ assert response.status_code == 404+ assert human.get(f"{root}/").json()["reviewer_assignment"]["pinned_user_uuids"] == [str(self.user.uuid)]+ failed = self.client.post(+ self._edit_url(str(run.id)),+ {+ "report_id": str(report.id),+ "expected_reviewers": state["state"],+ "reviewer_outcome": "lookup_failed",+ "reviewer_retry_reason": "Member lookup unavailable",+ },+ format="json",+ )+ assert failed.status_code == 200, failed.json()+ assert not failed.json()["reviewers_set"]+ reviewers = SignalReportArtefact.latest_content(+ team_id=self.team.id, report_id=str(report.id), model=SuggestedReviewers+ )+ assert reviewers is not None and reviewers.root[0].user_uuid == str(self.user.uuid)+ empty = self.client.post(+ self._edit_url(str(run.id)),+ {+ "report_id": str(report.id),+ "suggested_reviewers": [],+ "expected_reviewers": state["state"],+ "reviewer_outcome": "no_suitable_owner",+ },+ format="json",+ )+ assert empty.status_code == 200, empty.json()+ assert not empty.json()["reviewers_set"]+ reviewers = SignalReportArtefact.latest_content(+ team_id=self.team.id, report_id=str(report.id), model=SuggestedReviewers+ )+ assert reviewers is not None and reviewers.root[0].user_uuid == str(self.user.uuid)+def test_edit_report_sets_reviewers_and_reruns_autostart(self) -> None:# The routing rescue: a report that surfaced with no reviewer can have one set via edit_report,# which writes the suggested_reviewers artefact and re-fires autostart (so a report that alreadydiff --git a/products/signals/backend/test/test_scout_report_persistence.py b/products/signals/backend/test/test_scout_report_persistence.pyindex 4d913baf59cf..95cd5f085c33 100644--- a/products/signals/backend/test/test_scout_report_persistence.py+++ b/products/signals/backend/test/test_scout_report_persistence.py@@ -25,6 +25,7 @@ from products.signals.backend.artefact_schemas import (TaskRunArtefact,TitleChange,)+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.models import (MAX_SCOUT_REPORT_NOTES,ArtefactAttribution,@@ -36,6 +37,7 @@ from products.signals.backend.models import (from products.signals.backend.report_charts import MAX_REPORT_CHARTS, ReportChartfrom products.signals.backend.report_metrics import ReportMetricfrom products.signals.backend.report_prompts import MAX_SUGGESTED_PROMPT_LENGTH, MAX_SUGGESTED_PROMPTS+from products.signals.backend.reviewer_rules import ReviewerRulesfrom products.signals.backend.scout_harness.tools.emit import SOURCE_PRODUCT, SOURCE_TYPEfrom products.signals.backend.scout_report import (InvalidScoutReportError,@@ -99,6 +101,23 @@ class TestScoutReportPersistence(BaseTest):)return run+ def test_empty_selection_enrolls_a_new_report_in_the_writer(self) -> None:+ with (+ patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True),+ patch("products.signals.backend.assignment_flags.feature_enabled_or_false", return_value=False),+ ):+ result = create_scout_report(+ team_id=self.team.id,+ title="A report without reviewers",+ summary="No suitable owner was selected.",+ signals=[ScoutReportSignal(description="A synthetic finding", source_id="example", weight=1.0)],+ attribution=ArtefactAttribution.system(),+ )+ snapshot = ReviewerRules.read_for_report(team_id=self.team.id, report_id=result.report_id)+ assert snapshot.state.corrections_id is not None+ assert snapshot.reviewers == ()+ assert not assignment_side_effects_allowed(team_id=self.team.id, report_id=result.report_id)+@parameterized.expand([("ready", SignalReport.Status.READY, True),diff --git a/products/signals/backend/test/test_scout_slack_delivery.py b/products/signals/backend/test/test_scout_slack_delivery.pyindex 2172b5420428..815e56f22bc8 100644--- a/products/signals/backend/test/test_scout_slack_delivery.py+++ b/products/signals/backend/test/test_scout_slack_delivery.py@@ -17,7 +17,13 @@ from posthog.models.integration import Integrationfrom posthog.redis import get_clientfrom posthog.slack.markdown import SLACK_MARKDOWN_TEXT_MAX_LEN-from products.signals.backend.models import SignalReport, SignalReportSlackThread, SignalScoutEmission, SignalScoutRun+from products.signals.backend.models import (+ SignalReport,+ SignalReportArtefact,+ SignalReportSlackThread,+ SignalScoutEmission,+ SignalScoutRun,+)from products.signals.backend.scout_harness.slack_charts import CHART_BLOCK_ID_PREFIX as PREFIXfrom products.signals.backend.scout_harness.slack_delivery import (MAX_SCOUT_SLACK_DM_TARGETS,@@ -97,6 +103,91 @@ class TestGetScoutSlackDestination(SimpleTestCase):class TestScoutSlackDelivery(BaseTest):+ @parameterized.expand([(False, None), (False, "An update"), (True, None), (True, "An update")])+ def test_trial_report_delivery_checks_side_effect_flag(self, allowed: bool, edit_note: str | None) -> None:+ emission = self._make_emission()+ report = SignalReport.objects.create(team=self.team, status=SignalReport.Status.READY, title="A report")+ SignalReportArtefact.objects.create(team=self.team, report=report, type="reviewer_corrections", content="{}")+ with (+ patch("products.signals.backend.assignment_flags.assignment_side_effects_enabled", return_value=allowed),+ patch.object(deliver_scout_slack_output, "delay") as enqueue,+ patch("products.signals.backend.tasks.post_scout_report_to_slack") as post,+ patch(+ "products.signals.backend.scout_harness.slack_delivery_queue.get_scout_slack_destination",+ return_value=ScoutSlackDestination(integration_id=9, targets=("CSCOUTS",)),+ ),+ ):+ with self.captureOnCommitCallbacks(execute=True):+ queue_configured_scout_slack_delivery(+ run_id=str(emission.scout_run_id),+ output_type="report",+ output_id=str(report.id),+ edit_note=edit_note,+ )+ assert enqueue.called is allowed+ # Exercise a task queued before the flag changed as well.+ deliver_scout_slack_output.run(+ self.team.id,+ "report",+ str(report.id),+ str(emission.scout_run_id),+ str(uuid.uuid4()),+ 9,+ "CSCOUTS",+ edit_note=edit_note,+ )+ assert post.called is allowed++ def test_trial_report_thread_retry_stops_when_side_effects_are_disabled(self) -> None:+ report = SignalReport.objects.create(team=self.team, status=SignalReport.Status.READY, title="A report")+ SignalReportArtefact.objects.create(team=self.team, report=report, type="reviewer_corrections", content="{}")+ with (+ patch("products.signals.backend.assignment_flags.assignment_side_effects_enabled", return_value=False),+ patch("products.signals.backend.tasks.SlackIntegration") as slack,+ ):+ deliver_scout_slack_thread_replies.run(+ team_id=self.team.id,+ integration_id=9,+ channel="CSCOUTS",+ thread_ts="1.2",+ delivery_id=str(uuid.uuid4()),+ reply_blocks=[],+ fallback="Report",+ chunk_offset=0,+ report_id=str(report.id),+ )+ slack.assert_not_called()++ def test_trial_enrollment_during_render_stops_report_delivery(self) -> None:+ emission = self._make_emission()+ report = SignalReport.objects.create(team=self.team, status=SignalReport.Status.READY, title="A report")+ integration = Integration.objects.create(team=self.team, kind=Integration.IntegrationKind.SLACK)++ def enroll_during_render(*args, **kwargs):+ SignalReportArtefact.objects.create(+ team=self.team, report=report, type="reviewer_corrections", content="{}"+ )+ return [], "Report"++ with (+ patch("products.signals.backend.assignment_flags.assignment_side_effects_enabled", return_value=False),+ patch("products.signals.backend.scout_harness.slack_delivery.SlackIntegration") as slack,+ patch(+ "products.signals.backend.scout_harness.slack_delivery.build_scout_report_slack_message",+ side_effect=enroll_during_render,+ ),+ ):+ deliver_scout_slack_output.run(+ self.team.id,+ "report",+ str(report.id),+ str(emission.scout_run_id),+ str(uuid.uuid4()),+ integration.id,+ "CSCOUTS",+ )+ slack.assert_not_called()+def _make_emission(self, description: str = "**Checkout** failures") -> SignalScoutEmission:Task = apps.get_model("tasks", "Task")TaskRun = apps.get_model("tasks", "TaskRun")diff --git a/products/signals/backend/test/test_signal_report_artefact_api.py b/products/signals/backend/test/test_signal_report_artefact_api.pyindex b8ef6bb878b8..df2c0e05d796 100644--- a/products/signals/backend/test/test_signal_report_artefact_api.py+++ b/products/signals/backend/test/test_signal_report_artefact_api.py@@ -22,8 +22,7 @@ from products.signals.backend.artefact_schemas import (Priority,PriorityAssessment,ReportLink,- SuggestedReviewerEntry,- SuggestedReviewers,+ ReviewerCorrections,TaskRunArtefact,)from products.signals.backend.enums import ReportLinkKind@@ -53,11 +52,12 @@ def _attach_github_login(user: User, login: str, *, uid: str | None = None) -> Nclass TestSignalReportArtefactViewSet(APIBaseTest):- def test_retired_measurement_plan_type_cannot_be_written(self) -> None:+ @parameterized.expand([("impact_measurement_plan",), ("reviewer_corrections",)])+ def test_system_decision_type_cannot_be_written(self, artefact_type: str) -> None:report = self._create_report()response = self.client.post(self._list_url(str(report.id)),- {"artefact_type": "impact_measurement_plan", "content": {}},+ {"artefact_type": artefact_type, "content": {}},format="json",)assert response.status_code == status.HTTP_400_BAD_REQUEST@@ -66,6 +66,11 @@ class TestSignalReportArtefactViewSet(APIBaseTest):def _list_url(self, report_id: str) -> str:return f"/api/projects/{self.team.id}/signals/reports/{report_id}/artefacts/"+ def _assignment(self, report: SignalReport) -> dict:+ response = self.client.get(f"/api/projects/{self.team.id}/signals/reports/{report.id}/")+ assert response.status_code == status.HTTP_200_OK+ return response.json()["reviewer_assignment"]+def _detail_url(self, report_id: str, artefact_id: str) -> str:return f"/api/projects/{self.team.id}/signals/reports/{report_id}/artefacts/{artefact_id}/"@@ -123,6 +128,114 @@ class TestSignalReportArtefactViewSet(APIBaseTest):report=report, type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS).count()+ @parameterized.expand([False, True])+ def test_detail_tolerates_legacy_reviewer_data(self, enabled: bool) -> None:+ report = self._create_report()+ row = self._create_artefact(report, content=[{"user_uuid": str(self.user.uuid), "relevant_commits": None}])+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=enabled):+ assert not self._assignment(report)["needs_review"]+ commit = {"sha": "abcdef0", "url": "https://example.com/commit", "reason": "Fix"}+ row.content = json.dumps(+ [+ {+ "user_uuid": str(self.user.uuid),+ "relevant_commits": [commit, {}, "invalid"],+ "source_skill": {},+ },+ {},+ ]+ )+ row.save(update_fields=["content"])+ assignment = self._assignment(report)+ assert assignment["needs_review"]+ response = self.client.put(+ f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/",+ {+ "action": "replace",+ "content": [{"user_uuid": str(self.user.uuid)}],+ "expected_reviewers": assignment["state"],+ },+ format="json",+ )+ assert response.status_code == 200, response.json()+ reviewers = self._latest_reviewers(report)+ assert len(reviewers) == 1+ assert reviewers[0]["user_uuid"] == str(self.user.uuid)+ assert reviewers[0]["relevant_commits"] == [commit]+ assert reviewers[0]["source_skill"] is None+ repaired = self._assignment(report)+ assert repaired["needs_review"]+ assert not repaired["confirmed"]+ assert self._reviewers_count(report) == 2+ original = row.content+ row.refresh_from_db()+ assert row.content == original++ @parameterized.expand([True, False])+ def test_explicit_targets_preserve_people_missing_from_an_old_client_list(self, enabled: bool) -> None:+ report = self._create_report()+ other = self._create_org_member("[email protected]")+ self._create_artefact(report, content=[{"user_uuid": str(self.user.uuid)}, {"user_uuid": str(other.uuid)}])+ url = f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/"+ with patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=enabled):+ response = self.client.put(+ url, {"action": "remove", "targets": [{"user_uuid": str(self.user.uuid)}], "content": []}, format="json"+ )+ assert response.status_code == 200, response.json()+ assert [entry["user_uuid"] for entry in self._latest_reviewers(report)] == [str(other.uuid)]+ assert "reviewer_assignment" not in response.json()+ assert self._assignment(report)["confirmed"] is False++ @patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ def test_confirm_requires_the_displayed_state_and_does_not_repeat_membership(self, _flag) -> None:+ report = self._create_report()+ self._create_artefact(report, content=[])+ url = f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/"+ state = self._assignment(report)["state"]+ added = self.client.put(url, {"action": "add", "content": [{"user_uuid": str(self.user.uuid)}]}, format="json")+ assert added.status_code == 200, added.json()+ stale = self.client.put(url, {"action": "confirm", "content": [], "expected_reviewers": state}, format="json")+ assert stale.status_code == 409+ state = self._assignment(report)["state"]+ confirmed = self.client.put(+ url, {"action": "confirm", "content": [], "expected_reviewers": state}, format="json"+ )+ assert confirmed.status_code == 200, confirmed.json()+ assert self._assignment(report)["confirmed"] is True+ assert "reviewer_assignment" not in self.client.get(self._list_url(str(report.id))).json()+ assert confirmed.json()["id"] == added.json()["id"]+ assert self._reviewers_count(report) == 2++ @patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ def test_full_replacement_without_state_cannot_erase_new_members(self, _flag) -> None:+ report = self._create_report()+ self._create_artefact(report, content=[{"user_uuid": str(self.user.uuid)}])+ response = self.client.put(+ f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/", {"content": []}, format="json"+ )+ assert response.status_code == 409+ assert self._reviewers_count(report) == 1++ @patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ def test_failed_selection_from_user_attributed_api_preserves_recipients(self, _flag) -> None:+ report = self._create_report()+ self._create_artefact(report, content=[{"user_uuid": str(self.user.uuid)}])+ state = self._assignment(report)["state"]+ response = self.client.post(+ self._list_url(str(report.id)),+ {+ "artefact_type": "suggested_reviewers",+ "content": [],+ "expected_reviewers": state,+ "reviewer_outcome": "lookup_failed",+ "reviewer_retry_reason": "Lookup unavailable",+ },+ format="json",+ )+ assert response.status_code == 201, response.json()+ assert [entry["user_uuid"] for entry in self._latest_reviewers(report)] == [str(self.user.uuid)]+ assert self._reviewers_count(report) == 1+# --- GET list ---def test_list_returns_results_envelope(self):@@ -645,7 +758,7 @@ class TestSignalReportArtefactViewSet(APIBaseTest):response = self.client.put(self._detail_url(str(report.id), str(artefact.id)),- data=json.dumps({"content": [{"user_uuid": str(member.uuid)}]}),+ data=json.dumps({"action": "add", "content": [{"user_uuid": str(member.uuid)}]}),content_type="application/json",)assert response.status_code == status.HTTP_200_OK@@ -677,7 +790,7 @@ class TestSignalReportArtefactViewSet(APIBaseTest):response = self.client.put(self._detail_url(str(report.id), str(artefact.id)),- data=json.dumps({"content": [{"user_uuid": str(member.uuid)}]}),+ data=json.dumps({"action": "add", "content": [{"user_uuid": str(member.uuid)}]}),content_type="application/json",)assert response.status_code == status.HTTP_200_OK@@ -699,7 +812,8 @@ class TestSignalReportArtefactViewSet(APIBaseTest):# --- PUT reviewers (report-level, works with no existing artefact) ---- def test_reviewers_action_assigns_first_reviewer_when_none_exist(self):+ @patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True)+ def test_reviewers_action_assigns_first_reviewer_when_none_exist(self, _human_flag):# A report that never had a suggested_reviewers artefact must still be assignable: the# report-level PUT creates the first status row from scratch (the artefact PUT couldn't,# since it required an existing artefact to address).@@ -710,13 +824,40 @@ class TestSignalReportArtefactViewSet(APIBaseTest):url = f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/"response = self.client.put(url,- data=json.dumps({"content": [{"user_uuid": str(member.uuid)}]}),+ data=json.dumps({"action": "add", "content": [{"user_uuid": str(member.uuid)}]}),content_type="application/json",)assert response.status_code == status.HTTP_200_OK, response.json()assert self._reviewers_count(report) == 1assert [r["github_login"] for r in self._latest_reviewers(report)] == ["alicecase"]+ corrections = ReviewerCorrections.model_validate_json(report.artefacts.get(type="reviewer_corrections").content)+ assert [entry.user_uuid for entry in corrections.pinned] == [str(member.uuid)]+ assert not corrections.confirmed+ log = self.client.get(self._list_url(str(report.id))).json()+ assert [entry["type"] for entry in log["results"]] == ["suggested_reviewers"]+ assert SignalReportArtefact.counts_by_report([str(report.id)]) == {str(report.id): 1}++ deletion = self.client.delete(self._detail_url(str(report.id), response.json()["id"]))+ assert deletion.status_code == status.HTTP_400_BAD_REQUEST+ assert "cannot be deleted" in deletion.json()["error"]++ edit = self.client.patch(+ self._detail_url(str(report.id), response.json()["id"]), {"content": []}, format="json"+ )+ assert edit.status_code == status.HTTP_400_BAD_REQUEST+ assert "Append a reviewer change" in edit.json()["error"]+ legacy_write = self.client.post(+ self._list_url(str(report.id)),+ {"artefact_type": "suggested_reviewers", "content": []},+ format="json",+ )+ assert legacy_write.status_code == status.HTTP_409_CONFLICT+ assert "Read the report again" in legacy_write.json()["detail"]+ assert [r["github_login"] for r in self._latest_reviewers(report)] == ["alicecase"]+ decision_artefact = report.artefacts.get(type="reviewer_corrections")+ internal_read = self.client.get(self._detail_url(str(report.id), str(decision_artefact.id)))+ assert internal_read.status_code == status.HTTP_404_NOT_FOUNDdef test_put_user_uuid_not_in_org_returns_400(self):# Random UUID not tied to anyone in this org.@@ -795,8 +936,7 @@ class TestSignalReportArtefactViewSet(APIBaseTest):)assert second.status_code == status.HTTP_200_OKassert self._latest_reviewers(report) == first_current- # Original + two appended rows.- assert self._reviewers_count(report) == 3+ assert self._reviewers_count(report) == 2def test_put_reviewer_change_writes_activity_log_with_diff(self):report = self._create_report()@@ -1046,7 +1186,7 @@ class TestSignalReportArtefactViewSet(APIBaseTest):assert str(report.id) in {row["id"] for row in original_response.json()["results"]}assert str(report.id) not in {row["id"] for row in replacement_response.json()["results"]}- def test_filter_follows_the_reviewers_row_that_survives_a_delete(self):+ def test_reviewer_delete_cannot_restore_a_superseded_list(self):alice = self._create_org_member("[email protected]", github_login="alice")bob = self._create_org_member("[email protected]", github_login="bob")report = self._create_report()@@ -1057,10 +1197,10 @@ class TestSignalReportArtefactViewSet(APIBaseTest):assert not self._reviewer_filter_matches(report, alice)delete_response = self.client.delete(self._detail_url(str(report.id), str(current.id)))- assert delete_response.status_code == status.HTTP_204_NO_CONTENT+ assert delete_response.status_code == status.HTTP_400_BAD_REQUEST- assert self._reviewer_filter_matches(report, alice)- assert not self._reviewer_filter_matches(report, bob)+ assert self._reviewer_filter_matches(report, bob)+ assert not self._reviewer_filter_matches(report, alice)def test_backfill_command_restores_the_filter_for_a_report_missing_its_rows(self):# The state every report written before the reviewer index existed starts in.@@ -1074,6 +1214,104 @@ class TestSignalReportArtefactViewSet(APIBaseTest):assert self._reviewer_filter_matches(report, alice)+ @parameterized.expand(+ [+ ("report", False),+ ("report", True),+ ("artefact", False),+ ("artefact", True),+ ("leave", False),+ ("leave", True),+ ]+ )+ def test_human_writer_rollout_covers_every_reviewer_adapter(self, adapter: str, enabled: bool) -> None:+ member = self._create_org_member("[email protected]", github_login="added-reviewer")+ report = self._create_report()+ artefact = self._create_artefact(report, content=[{"user_uuid": str(self.user.uuid)}])+ with (+ patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=enabled),+ patch("products.signals.backend.assignment_flags.feature_enabled_or_false", return_value=False),+ patch("products.signals.backend.models.SignalReportArtefact._schedule_autostart_reevaluation") as autostart,+ patch("products.signals.backend.views.send_reviewer_added_slack_notifications.delay") as notify,+ patch("products.signals.backend.views.schedule_reviewer_pr_assignment") as assign,+ patch("products.signals.backend.views.forward_reviewer_correction_note") as steer,+ self.captureOnCommitCallbacks(execute=True),+ ):+ if adapter == "leave":+ response = self.client.delete(self._leave_reviewers_url(str(report.id)))+ else:+ url = (+ self._detail_url(str(report.id), str(artefact.id))+ if adapter == "artefact"+ else f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/"+ )+ response = self.client.put(+ url,+ {+ "expected_reviewers": {"reviewers_id": str(artefact.id), "corrections_id": None},+ "content": [{"user_uuid": str(member.uuid)}],+ },+ format="json",+ )+ assert response.status_code == (status.HTTP_204_NO_CONTENT if adapter == "leave" else status.HTTP_200_OK)+ assert [entry["user_uuid"] for entry in self._latest_reviewers(report)] == (+ [] if adapter == "leave" else [str(member.uuid)]+ )+ assert report.artefacts.filter(type="reviewer_corrections").count() == int(enabled)+ assert (+ ActivityLog.objects.filter(team_id=self.team.id, scope="SignalReport", item_id=str(report.id)).exists()+ is True+ )+ if enabled:+ autostart.assert_not_called()+ notify.assert_not_called()+ assign.assert_not_called()+ if adapter == "leave":+ steer.assert_not_called() # This test's departing member has no linked GitHub identity.+ else:+ steer.assert_called_once()++ def test_post_reviewer_payload_uses_shared_writer_after_human_edit(self) -> None:+ human_reviewer = self._create_org_member("[email protected]", github_login="human-reviewer")+ automatic_reviewer = self._create_org_member(+ "[email protected]", github_login="automatic-reviewer"+ )+ report = self._create_report()+ reviewers_url = f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/"++ with (+ patch("products.signals.backend.reviewer_rules.assignment_writer_enabled", return_value=True),+ patch("products.signals.backend.assignment_flags.feature_enabled_or_false", return_value=False),+ patch("products.signals.backend.views.capture_suggested_reviewers_resolved") as telemetry,+ self.captureOnCommitCallbacks(execute=True),+ ):+ human_edit = self.client.put(+ reviewers_url,+ {"action": "add", "content": [{"user_uuid": str(human_reviewer.uuid)}]},+ format="json",+ )+ assert human_edit.status_code == status.HTTP_200_OK, human_edit.json()++ state = self._assignment(report)["state"]+ automatic_edit = self.client.post(+ self._list_url(str(report.id)),+ {+ "artefact_type": "suggested_reviewers",+ "content": [{"user_uuid": str(automatic_reviewer.uuid)}],+ "expected_reviewers": state,+ },+ format="json",+ HTTP_X_POSTHOG_CLIENT="mcp",+ HTTP_X_POSTHOG_MCP_CLIENT_NAME="test-agent",+ )++ assert automatic_edit.status_code == status.HTTP_201_CREATED, automatic_edit.json()+ assert {entry["user_uuid"] for entry in self._latest_reviewers(report)} == {+ str(human_reviewer.uuid),+ str(automatic_reviewer.uuid),+ }+ assert set(telemetry.call_args.kwargs["github_logins"]) == {"human-reviewer", "automatic-reviewer"}+# --- DELETE reviewers/me (step off a report) ---def _leave_reviewers_url(self, report_id: str) -> str:@@ -1135,7 +1373,7 @@ class TestSignalReportArtefactViewSet(APIBaseTest):# The add path still re-evaluates, which is what makes the removal's silence meaningful.put = self.client.put(f"/api/projects/{self.team.id}/signals/reports/{report.id}/reviewers/",- data=json.dumps({"content": [{"user_uuid": str(teammate.uuid)}]}),+ data=json.dumps({"action": "add", "content": [{"user_uuid": str(self.user.uuid)}]}),content_type="application/json",)assert put.status_code == status.HTTP_200_OK@@ -1827,33 +2065,6 @@ class TestSignalReportArtefactLogWriteViewSet(APIBaseTest):assert report_response.status_code == status.HTTP_200_OKassert report_response.json()["priority"] == "P3"- def test_delete_latest_reviewers_artefact_re_emits_surviving_state(self):- # A deleted reviewers row reverts the canonical set to the previous row; without a fresh- # event, latest-per-report telemetry keeps describing the deleted list forever.- report = self._create_report()- for login in ("first-reviewer", "second-reviewer"):- SignalReportArtefact.append_status(- team_id=self.team.id,- report_id=str(report.id),- content=SuggestedReviewers(root=[SuggestedReviewerEntry(github_login=login)]),- attribution=ArtefactAttribution.system(),- )- latest = SignalReportArtefact.objects.filter(- report=report, type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS- ).order_by("-created_at")[0]-- with (- patch("products.signals.backend.views.capture_suggested_reviewers_resolved") as mock_capture,- self.captureOnCommitCallbacks(execute=True),- ):- response = self.client.delete(self._detail_url(str(report.id), str(latest.id)))-- assert response.status_code == status.HTTP_204_NO_CONTENT- assert mock_capture.call_count == 1- kwargs = mock_capture.call_args.kwargs- assert kwargs["github_logins"] == ["first-reviewer"]- assert kwargs["source"] == "api"-def test_delete_other_team_returns_404(self):other_team = Team.objects.create(organization=self.organization, name="Other Team")other_report = self._create_report(team=other_team)diff --git a/products/signals/backend/views.py b/products/signals/backend/views.pyindex 2638fa849069..86ef83c5cac8 100644--- a/products/signals/backend/views.py+++ b/products/signals/backend/views.py@@ -93,11 +93,17 @@ from products.signals.backend.artefact_schemas import (ArtefactContentValidationError,ChannelAssignment,Dismissal,+ RelevantCommit,+ ReviewerEdit,+ ReviewerProposal,+ ReviewerState,+ SuggestedReviewerEntry,SuggestedReviewers,SummaryChange,TitleChange,parse_artefact_content,)+from products.signals.backend.assignment_flags import assignment_side_effects_allowedfrom products.signals.backend.background_pilot import (BACKGROUND_REPORT_DISMISSED_EVENT,BACKGROUND_REPORT_RATED_EVENT,@@ -219,6 +225,7 @@ from products.signals.backend.report_task_actions import ()from products.signals.backend.reviewer_correction_notes import ReviewerCorrection, forward_reviewer_correction_notefrom products.signals.backend.reviewer_pr_assignment import schedule_reviewer_pr_assignment+from products.signals.backend.reviewer_rules import ReviewerRules, ReviewerWriteError, StaleReviewerProposalfrom products.signals.backend.scout_authorship import inbox_hidden_report_existsfrom products.signals.backend.scout_harness.trial_access import trial_state_errors, trial_store_for_requestfrom products.signals.backend.scout_report.trial_inbox import TrialInboxReads, private_report_artefacts@@ -1384,6 +1391,7 @@ class SignalReportViewSet(SignalReportArtefact.objects.filter(report_id=OuterRef("id")).exclude(type__in=SignalReportArtefact.SYSTEM_SCORING_ARTEFACT_TYPES+ | SignalReportArtefact.INTERNAL_ARTEFACT_TYPES| ({SignalReportArtefact.ArtefactType.CHECK_OBSERVATION}if not self._report_monitoring_enabled@@ -2830,15 +2838,12 @@ class SignalReportViewSet()@action(detail=True, methods=["put"], url_path="reviewers", required_scopes=["task:write"])def reviewers(self, request, **kwargs):- """Set a report's suggested reviewers (full-replacement PUT), whether or not the report already- has any. Appends a new latest-wins `suggested_reviewers` status row — the same write the artefact- PUT performs, but addressed by report so a report with zero reviewers (and thus no artefact yet)- can still be assigned one. App-only: agents append reviewers via the artefacts POST instead."""+ """Apply a human reviewer edit, including on reports without a reviewer artefact."""report = cast(SignalReport, self.get_object())write_serializer = SignalReportArtefactWriteSerializer(data=request.data)write_serializer.is_valid(raise_exception=True)- entries = write_serializer.validated_data["content"]+ entries = write_serializer.validated_data.get("targets", write_serializer.validated_data["content"])try:new_artefact = append_suggested_reviewers(@@ -2846,12 +2851,20 @@ class SignalReportViewSet(report_id=str(report.id),entries=entries,request=request,+ edit=ReviewerEdit(+ action=write_serializer.validated_data["action"],+ expected_state=write_serializer.validated_data.get("expected_reviewers"),+ ),)+ except StaleReviewerProposal as e:+ return Response({"detail": str(e)}, status=status.HTTP_409_CONFLICT)except ReviewerWriteError as e:return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)# Return the read-shape (enriched) so the client sees the canonical result, matching the artefact PUT.- read_serializer = SignalReportArtefactSerializer(new_artefact, context=self.get_serializer_context())+ read_serializer = SignalReportSuggestedReviewersArtefactSerializer(+ new_artefact, context=self.get_serializer_context()+ )return Response(read_serializer.data)@extend_schema(@@ -2874,6 +2887,8 @@ class SignalReportViewSet(remove_suggested_reviewer(team=self.team, report_id=str(report.id), user=cast(User, request.user), request=request)+ except StaleReviewerProposal as e:+ return Response({"detail": str(e)}, status=status.HTTP_409_CONFLICT)except ReviewerWriteError as e:return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)return Response(status=status.HTTP_204_NO_CONTENT)@@ -4828,10 +4843,6 @@ _REPORT_ID_PARAMETER = OpenApiParameter()-class ReviewerWriteError(Exception):- """A reviewer write payload that couldn't be resolved. Callers surface it as a 400 `{"error": ...}`."""--@frozenclass _ResolvedReviewerWrite:"""One reviewer write entry after identity resolution, ready to merge onto the stored list.@@ -4880,6 +4891,9 @@ def _schedule_reviewer_added_slack_notifications(request. Best-effort — a Slack failure must never break the reviewer edit."""# robust=True: a broker outage while enqueuing must not 500 an edit that already committed.+ if not assignment_side_effects_allowed(team_id=team_id, report_id=report_id):+ return+transaction.on_commit(lambda: send_reviewer_added_slack_notifications.delay(report_id=report_id,@@ -4898,12 +4912,14 @@ def append_suggested_reviewers(report_id: str,entries: list[dict],request: Request,+ edit: ReviewerEdit | None = None,) -> SignalReportArtefact:"""Append a new `suggested_reviewers` status row for a report, merging forward from the current(latest) reviewers. Works whether or not the report already has a reviewers artefact — the firstwrite for a report with none simply creates the first row. Shared by the app-only reviewers PUTon both the report and artefact viewsets. Returns the new artefact.Raises `ReviewerWriteError` on unresolvable entries."""+ edit = edit or ReviewerEdit(action="replace")# App/user-only write (agents append reviewers via the artefacts POST), so always attribute to# the requesting user — never the X-PostHog-Task-Id header. A task-attributed reviewers row has# no created_by_id, which makes auto-start treat the list as agent-authored and run the@@ -4937,10 +4953,10 @@ def append_suggested_reviewers(user_uuid = entry.get("user_uuid")if user_uuid is not None:member = uuid_to_user.get(str(user_uuid))- if member is None:+ if member is None and edit.action != "remove":raise ReviewerWriteError(f"content[{idx}]: user_uuid '{user_uuid}' is not an org member of this team.")- uuid_str: str | None = str(member.uuid)- member_login = member.get_github_login()+ uuid_str: str | None = str(member.uuid) if member else str(user_uuid)+ member_login = member.get_github_login() if member else Nonelogin_lc = member_login.lower() if member_login else Noneelse:raw_login = entry.get("github_login") or ""@@ -4990,7 +5006,7 @@ def append_suggested_reviewers(report_id=report_id,type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,)- .order_by("-created_at")+ .order_by("-created_at", "-id").first())try:@@ -5039,16 +5055,19 @@ def append_suggested_reviewers(effective_reason = resolved.reason if resolved.explicit_reason else bounded_reviewer_reason(prior_reason)if not resolved.explicit_reason and prior is None:effective_reason = manual_add_reason- safe_commits = (- [- {**commit, "reason": bounded_reviewer_reason(commit.get("reason")) or ""}- if isinstance(commit, dict)- else commit- for commit in prior_commits- ]- if isinstance(prior_commits, list)- else []- )+ safe_commits = []+ for commit in prior_commits if isinstance(prior_commits, list) else []:+ if not isinstance(commit, dict):+ continue+ try:+ safe_commits.append(+ RelevantCommit.model_validate(+ {**commit, "reason": bounded_reviewer_reason(commit.get("reason")) or ""}+ ).model_dump()+ )+ except PydanticValidationError:+ continue+ prior_source_skill = prior.get("source_skill") if prior else Nonenew_content.append({"github_login": resolved.github_login,@@ -5056,20 +5075,31 @@ def append_suggested_reviewers("github_name": effective_name if isinstance(effective_name, str) else None,"relevant_commits": safe_commits,"reason": effective_reason or None,- "source_skill": prior.get("source_skill") if prior else None,+ "source_skill": prior_source_skill if isinstance(prior_source_skill, str) else None,"is_skill_owner": bool(prior.get("is_skill_owner")) if prior else False,})- # Append a new status row rather than mutating in place: a human reviewer edit becomes a- # point-in-time entry in the work log, and latest-wins keeps it current. Appending a- # reviewers status also re-evaluates auto-start (handled in `append_status`, on commit).new_artefact = SignalReportArtefact.append_status(team_id=team.id,report_id=str(report_id),content=SuggestedReviewers.model_validate(new_content),attribution=attribution,+ reviewer_edit=edit,+ reevaluate_autostart=edit.action not in {"remove", "confirm"}+ and any(+ not prior_index.get(user_uuid=entry["user_uuid"], github_login=entry["github_login"])+ for entry in new_content+ ),)+ if current is not None and new_artefact.id == current.id:+ return new_artefact+ new_content = SuggestedReviewers.model_validate_json(new_artefact.content).model_dump(mode="json")+ matched_prior_ids = {+ id(prior)+ for entry in new_content+ if (prior := prior_index.get(user_uuid=entry["user_uuid"], github_login=entry["github_login"])) is not None+ }# Human reviewer corrections are a routing signal (scouts query them via the# activity log to learn who owns an area), so log them — but only genuine# membership changes by a human, not agent writes or order-only rewrites.@@ -5252,7 +5282,7 @@ def remove_suggested_reviewer(*, team: Team, report_id: str, user: User, requestreport_id=report_id,type=SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,)- .order_by("-created_at")+ .order_by("-created_at", "-id").first())try:@@ -5268,17 +5298,19 @@ def remove_suggested_reviewer(*, team: Team, report_id: str, user: User, requestfor entry in priorif not _reviewer_entry_names(entry, user_uuid=str(user.uuid), github_login=github_login)]- if len(kept) == len(prior):- return False-- new_content = [_stored_reviewer_entry(entry) for entry in kept]- SignalReportArtefact.append_status(+ new_artefact = SignalReportArtefact.append_status(team_id=team.id,report_id=str(report_id),- content=SuggestedReviewers.model_validate(new_content),+ content=SuggestedReviewers(+ root=[SuggestedReviewerEntry(user_uuid=str(user.uuid), github_login=github_login)]+ ),attribution=attribution,+ reviewer_edit=ReviewerEdit(action="remove"),reevaluate_autostart=False,)+ if len(kept) == len(prior):+ return False+ new_content = SuggestedReviewers.model_validate_json(new_artefact.content).model_dump(mode="json")log_activity(organization_id=None,@@ -5565,7 +5597,7 @@ class SignalReportArtefactViewSet(permission_classes = [IsAuthenticated, APIScopePermission]scope_object = "task"# select_related: the read serializer renders `created_by` inline.- queryset = SignalReportArtefact.objects.select_related("created_by").order_by("-created_at")+ queryset = SignalReportArtefact.objects.select_related("created_by").order_by("-created_at", "-id")http_method_names = ["get", "post", "put", "patch", "delete", "head", "options"]def _validated_report_id(self) -> str:@@ -5596,7 +5628,10 @@ class SignalReportArtefactViewSet(queryset = queryset.exclude(type=SignalReportArtefact.ArtefactType.CHECK_OBSERVATION)# Scoring rows are staff-only on every artefact route, not only in the log.if not self.request.user.is_staff:- queryset = queryset.exclude(type__in=SignalReportArtefact.SYSTEM_SCORING_ARTEFACT_TYPES)+ queryset = queryset.exclude(+ type__in=SignalReportArtefact.SYSTEM_SCORING_ARTEFACT_TYPES+ | SignalReportArtefact.INTERNAL_ARTEFACT_TYPES+ )return querysetdef retrieve(self, request, *args, **kwargs):@@ -5627,7 +5662,7 @@ class SignalReportArtefactViewSet(if store is not None:synthetic.extend(private_report_artefacts(store, str(self._validated_report_id())))log = (- sorted([*real_artefacts, *synthetic], key=lambda a: a.created_at, reverse=True)+ sorted([*real_artefacts, *synthetic], key=lambda a: (a.created_at, str(a.id)), reverse=True)if syntheticelse real_artefacts)@@ -5663,9 +5698,19 @@ class SignalReportArtefactViewSet(],},)- if page is not None:- return self.get_paginated_response(serializer.data)- return Response(serializer.data)+ response = (+ self.get_paginated_response(serializer.data)+ if page is not None+ else Response(+ {+ "count": len(serializer.data),+ "next": None,+ "previous": None,+ "results": serializer.data,+ }+ )+ )+ return responsedef update(self, request, *args, **kwargs):artefact = cast(SignalReportArtefact, self.get_object())@@ -5685,7 +5730,7 @@ class SignalReportArtefactViewSet(write_serializer = SignalReportArtefactWriteSerializer(data=request.data)write_serializer.is_valid(raise_exception=True)- entries = write_serializer.validated_data["content"]+ entries = write_serializer.validated_data.get("targets", write_serializer.validated_data["content"])try:new_artefact = append_suggested_reviewers(@@ -5693,12 +5738,20 @@ class SignalReportArtefactViewSet(report_id=str(artefact.report_id),entries=entries,request=request,+ edit=ReviewerEdit(+ action=write_serializer.validated_data["action"],+ expected_state=write_serializer.validated_data.get("expected_reviewers"),+ ),)+ except StaleReviewerProposal as e:+ return Response({"detail": str(e)}, status=status.HTTP_409_CONFLICT)except ReviewerWriteError as e:return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)# Return the read-shape (enriched) so the client sees the canonical result.- read_serializer = SignalReportArtefactSerializer(new_artefact, context=self.get_serializer_context())+ read_serializer = SignalReportSuggestedReviewersArtefactSerializer(+ new_artefact, context=self.get_serializer_context()+ )return Response(read_serializer.data)@staticmethod@@ -5721,6 +5774,18 @@ class SignalReportArtefactViewSet(}).data+ def _schedule_suggested_reviewer_telemetry(self, *, content: SuggestedReviewers, report_id: str) -> None:+ transaction.on_commit(+ partial(+ capture_suggested_reviewers_resolved,+ team_id=self.team.id,+ report_id=report_id,+ github_logins=[entry.github_login for entry in content.root if entry.github_login],+ user_uuids=[entry.user_uuid for entry in content.root if entry.user_uuid and not entry.github_login],+ source="api",+ )+ )+@validated_request(request_serializer=SignalReportArtefactLogCreateSerializer,responses={@@ -5792,10 +5857,45 @@ class SignalReportArtefactViewSet()if isinstance(parsed_content, ChannelAssignment):self._validate_channel_assignment(parsed_content, request)+ claim_id = request.validated_data.get("claim_id")+ if isinstance(parsed_content, SuggestedReviewers):+ try:+ expected = request.validated_data.get("expected_reviewers")+ with transaction.atomic():+ SignalReport.objects.select_for_update().get(team_id=self.team.id, id=report_id)+ previous = ReviewerRules.read_for_report(+ team_id=self.team.id, report_id=report_id+ ).state.reviewers_id+ artefact = SignalReportArtefact.append_status(+ team_id=self.team.id,+ report_id=report_id,+ content=parsed_content,+ attribution=attribution,+ reviewer_proposal=ReviewerProposal(+ expected_state=ReviewerState.model_validate(expected),+ outcome=request.validated_data["reviewer_outcome"],+ retry_reason=request.validated_data.get("reviewer_retry_reason"),+ )+ if expected is not None+ else None,+ reviewer_edit=ReviewerEdit(action="replace", expected_state=expected)+ if attribution.kind == "user" and request.validated_data["reviewer_outcome"] == "selected"+ else None,+ claim_id=str(claim_id) if claim_id else None,+ )+ if artefact.id != previous:+ self._schedule_suggested_reviewer_telemetry(+ content=SuggestedReviewers.model_validate_json(artefact.content),+ report_id=report_id,+ )+ except StaleReviewerProposal as e:+ return Response({"detail": str(e)}, status=status.HTTP_409_CONFLICT)+ except ValueError as e:+ return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)+ return Response(self._write_response_data(artefact), status=status.HTTP_201_CREATED)with transaction.atomic():report = SignalReport.objects.select_for_update().get(team_id=self.team.id, id=report_id)import_report_pull_requests(report)- claim_id = request.validated_data.get("claim_id")if claim_id:assignment = get_active_claim(team_id=self.team.id, report_id=report_id)if (@@ -5816,20 +5916,6 @@ class SignalReportArtefactViewSet()except ArtefactContentValidationError as e:return Response({"error": str(e)}, status=status.HTTP_400_BAD_REQUEST)- if isinstance(parsed_content, SuggestedReviewers):- # on_commit so a rolled-back write emits nothing, matching every other reviewer write path.- transaction.on_commit(- partial(- capture_suggested_reviewers_resolved,- team_id=self.team.id,- report_id=report_id,- github_logins=[entry.github_login for entry in parsed_content.root if entry.github_login],- user_uuids=[- entry.user_uuid for entry in parsed_content.root if entry.user_uuid and not entry.github_login- ],- source="api",- )- )return Response(self._write_response_data(artefact), status=status.HTTP_201_CREATED)def _capture_canonical_reviewer_state(self, report_id: str) -> None:@@ -5940,6 +6026,7 @@ class SignalReportArtefactViewSet(artefact = cast(SignalReportArtefact, self.get_object())if artefact.type in {SignalReportArtefact.ArtefactType.TASK_RUN,+ SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERS,SignalReportArtefact.ArtefactType.IMPACT_MEASUREMENT_PLAN,SignalReportArtefact.ArtefactType.WORK_CLAIM,SignalReportArtefact.ArtefactType.WORK_RELEASE,@@ -5961,7 +6048,9 @@ class SignalReportArtefactViewSet()was_reviewers = artefact.type == SignalReportArtefact.ArtefactType.SUGGESTED_REVIEWERSreport_id = str(artefact.report_id)- artefact.delete()+ with transaction.atomic():+ SignalReport.objects.select_for_update().get(team_id=self.team.id, id=report_id)+ artefact.delete()if was_reviewers:# Deleting the latest reviewers row reverts the canonical set to the previous row (or# none) — re-emit so the latest event per report tracks the surviving state.diff --git a/products/signals/frontend/generated/api.schemas.ts b/products/signals/frontend/generated/api.schemas.tsindex c328be32720c..b567212f5a9c 100644--- a/products/signals/frontend/generated/api.schemas.ts+++ b/products/signals/frontend/generated/api.schemas.ts@@ -785,6 +785,34 @@ export interface PauseResponseApi {paused_until: string}+export interface ReviewerStateApi {+ /**+ * Current reviewer artefact ID, or null before the first list.+ * @nullable+ */+ reviewers_id: string | null+ /**+ * Current corrections artefact ID, or null before corrections are stored.+ * @nullable+ */+ corrections_id: string | null+}++export interface ReviewerControlResponseApi {+ /** State token for a selection, replacement, or list confirmation. */+ state: ReviewerStateApi+ /** People an automatic selection must retain. */+ pinned_user_uuids: string[]+ /** People an automatic selection must not restore. */+ excluded_user_uuids: string[]+ /** A person explicitly confirmed the complete reviewer list. */+ confirmed: boolean+ /** Older edits need recovery on the next protected write, or have incomplete history. Automatic changes are paused until recovery or list confirmation. */+ needs_review: boolean+ /** Whether this report uses saved reviewer corrections. */+ enabled: boolean+}+export type SignalReportStatusEnumApi = (typeof SignalReportStatusEnumApi)[keyof typeof SignalReportStatusEnumApi]export const SignalReportStatusEnumApi = {@@ -1314,6 +1342,8 @@ export interface SignalReportListApi {readonly summary: string | null/** The opening of `summary` as plain text on one line: the text before its first section heading, with chart links removed and other links reduced to their text. At most 450 characters. */readonly summary_lead: string+ /** Reviewer control and state token for preparing an automatic proposal. */+ readonly reviewer_assignment: ReviewerControlResponseApi | null/** Current report status. Monitoring reads as resolved when its rollout is disabled. */readonly status: SignalReportStatusEnumApi/**@@ -1558,6 +1588,8 @@ export interface SignalReportApi {readonly summary: string | null/** The opening of `summary` as plain text on one line: the text before its first section heading, with chart links removed and other links reduced to their text. At most 450 characters. */readonly summary_lead: string+ /** Reviewer control and state token for preparing an automatic proposal. */+ readonly reviewer_assignment: ReviewerControlResponseApi | null/** Current report status. Monitoring reads as resolved when its rollout is disabled. */readonly status: SignalReportStatusEnumApi/**@@ -2244,6 +2276,21 @@ export interface SignalReportReingestionStatusApi {report_id: string}+/**+ * * `add` - Add+ * * `remove` - Remove+ * * `replace` - Replace+ * * `confirm` - Confirm+ */+export type ReviewerEditActionEnumApi = (typeof ReviewerEditActionEnumApi)[keyof typeof ReviewerEditActionEnumApi]++export const ReviewerEditActionEnumApi = {+ Add: 'add',+ Remove: 'remove',+ Replace: 'replace',+ Confirm: 'confirm',+} as const+/*** Single entry in a PUT body for a `suggested_reviewers` artefact.*@@ -2272,18 +2319,26 @@ export interface SuggestedReviewerEntryWriteApi {reason?: string | null}-/**- * PUT body for replacing a `suggested_reviewers` artefact's content.- *- * Only `suggested_reviewers` artefacts may be modified via this endpoint;- * the viewset enforces the type check before validation runs.- */export interface SignalReportArtefactWriteApi {- /**- * Full replacement list of reviewers. Empty list clears the artefact. At most 10 entries.+ /** Add or remove only the supplied people, replace the list, or explicitly confirm it.+ *+ * * `add` - Add+ * * `remove` - Remove+ * * `replace` - Replace+ * * `confirm` - Confirm */+ action?: ReviewerEditActionEnumApi+ /** State from the last read. Required for replacement and confirmation when corrections are enabled. */+ expected_reviewers?: ReviewerStateApi+ /**+ * People to add, remove, or keep in a replacement. Send an empty list for confirmation.* @maxItems 10*/content: SuggestedReviewerEntryWriteApi[]+ /**+ * Explicit add or remove targets. When supplied, content is only a fallback for older servers.+ * @maxItems 10+ */+ targets?: SuggestedReviewerEntryWriteApi[]}/**@@ -3759,6 +3814,7 @@ export interface SignalReportStateRequestApi {* * `signal_finding` - Signal Finding* * `repo_selection` - Repo Selection* * `suggested_reviewers` - Suggested Reviewers+ * * `reviewer_corrections` - Reviewer Corrections* * `channel_assignment` - Channel Assignment* * `dismissal` - Dismissal* * `code_reference` - Code Reference@@ -3798,6 +3854,7 @@ export const SignalReportArtefactArtefactTypeEnumApi = {SignalFinding: 'signal_finding',RepoSelection: 'repo_selection',SuggestedReviewers: 'suggested_reviewers',+ ReviewerCorrections: 'reviewer_corrections',ChannelAssignment: 'channel_assignment',Dismissal: 'dismissal',CodeReference: 'code_reference',@@ -3871,6 +3928,20 @@ export interface PaginatedSignalReportArtefactListApi {results: SignalReportArtefactApi[]}+/**+ * * `selected` - Selected+ * * `no_suitable_owner` - No suitable owner+ * * `lookup_failed` - Lookup failed+ */+export type ReviewerSelectionOutcomeEnumApi =+ (typeof ReviewerSelectionOutcomeEnumApi)[keyof typeof ReviewerSelectionOutcomeEnumApi]++export const ReviewerSelectionOutcomeEnumApi = {+ Selected: 'selected',+ NoSuitableOwner: 'no_suitable_owner',+ LookupFailed: 'lookup_failed',+} as const+/*** Body for appending an artefact to a report.*@@ -3879,6 +3950,19 @@ export interface PaginatedSignalReportArtefactListApi {* against the type's schema (see `products/signals/backend/artefact_schemas.py`).*/export interface SignalReportArtefactLogCreateApi {+ /** Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled. */+ expected_reviewers?: ReviewerStateApi+ /** A successful selection, a deliberate empty result, or an unavailable lookup.+ *+ * * `selected` - Selected+ * * `no_suitable_owner` - No suitable owner+ * * `lookup_failed` - Lookup failed */+ reviewer_outcome?: ReviewerSelectionOutcomeEnumApi+ /**+ * Reason the reviewer lookup failed.+ * @maxLength 500+ */+ reviewer_retry_reason?: string/** Active claim to attribute this work to. Must belong to the caller and report. */claim_id?: string/** The artefact type. One of: actionability_judgment, channel_assignment, code_reference, commit, dismissal, note, priority_judgment, related_to, repo_selection, safety_judgment, signal_finding, source_suggestion, suggested_reviewers. Log types accumulate; status types (safety_judgment, actionability_judgment, priority_judgment, repo_selection, suggested_reviewers, channel_assignment, source_suggestion) are latest-wins — appending a new version supersedes the previous one as the report's canonical status. */@@ -7733,6 +7817,19 @@ export const ActionabilityEnumApi = {* Request body for `edit-report`. Can target ANY of the team's inbox reports, not just scout-authored ones.*/export interface EditReportRequestApi {+ /** Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled. */+ expected_reviewers?: ReviewerStateApi+ /** A successful selection, a deliberate empty result, or an unavailable lookup.+ *+ * * `selected` - Selected+ * * `no_suitable_owner` - No suitable owner+ * * `lookup_failed` - Lookup failed */+ reviewer_outcome?: ReviewerSelectionOutcomeEnumApi+ /**+ * Reason the reviewer lookup failed.+ * @maxLength 500+ */+ reviewer_retry_reason?: string/** Id of the report to edit (must belong to this project). */report_id: string/**@@ -7762,7 +7859,7 @@ export interface EditReportRequestApi {*/append_evidence?: ReportEvidenceApi[] | null/**- * Optional reviewers to set on the report (each a `github_login` and/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list is a no-op (existing reviewers are left untouched, never cleared).+ * Optional reviewers to set on the report (each a `github_login` and/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list clears automatic reviewers when correction rules are enabled. Pins, exclusions, and confirmed lists are preserved. Pass expected_reviewers from the report reviewer_assignment.state read before selection.* @maxItems 10*/suggested_reviewers?: SuggestedReviewerApi[]diff --git a/products/signals/frontend/generated/api.ts b/products/signals/frontend/generated/api.tsindex dae271fb9ea9..4ec3814c8ba6 100644--- a/products/signals/frontend/generated/api.ts+++ b/products/signals/frontend/generated/api.ts@@ -928,10 +928,7 @@ export const getSignalsReportsReviewersUpdateUrl = (projectId: string, id: strin}/**- * Set a report's suggested reviewers (full-replacement PUT), whether or not the report already- * has any. Appends a new latest-wins `suggested_reviewers` status row — the same write the artefact- * PUT performs, but addressed by report so a report with zero reviewers (and thus no artefact yet)- * can still be assigned one. App-only: agents append reviewers via the artefacts POST instead.+ * Apply a human reviewer edit, including on reports without a reviewer artefact.* @summary Set a report's suggested reviewers*/export const signalsReportsReviewersUpdate = async (@@ -1157,7 +1154,7 @@ export const getSignalsReportArtefactsDestroyUrl = (projectId: string, reportId:}/**- * Delete an artefact, addressed by id. Deleting the latest row of a status type reverts the report's canonical status to the previous version (latest-wins over what remains). `task_run` artefacts are an append-only work log and cannot be deleted. Neither can the types this API cannot write, which the pipeline owns: `autostart_skip`, `check_cancelled`, `check_expired`, `check_observation`, `check_result`, `check_scheduled`, `code_review`, `impact_measurement_plan`, `implementation_decision`, `implementation_dispatch`, `implementation_handover`, `implementation_replacement`, `pull_request`, `ranking_score`, `report_link`, `summary_change`, `task_run`, `title_change`, `video_segment`, `work_claim`, `work_release`.+ * Delete an artefact, addressed by id. Deleting the latest row of a status type reverts the report's canonical status to the previous version (latest-wins over what remains). `task_run` artefacts are an append-only work log and cannot be deleted. Neither can the types this API cannot write, which the pipeline owns: `autostart_skip`, `check_cancelled`, `check_expired`, `check_observation`, `check_result`, `check_scheduled`, `code_review`, `impact_measurement_plan`, `implementation_decision`, `implementation_dispatch`, `implementation_handover`, `implementation_replacement`, `pull_request`, `ranking_score`, `report_link`, `reviewer_corrections`, `summary_change`, `task_run`, `title_change`, `video_segment`, `work_claim`, `work_release`.* @summary Delete an artefact*/export const signalsReportArtefactsDestroy = async (diff --git a/products/signals/frontend/generated/api.zod.ts b/products/signals/frontend/generated/api.zod.tsindex 709fe412aaa3..fd264b0288e3 100644--- a/products/signals/frontend/generated/api.zod.ts+++ b/products/signals/frontend/generated/api.zod.ts@@ -858,12 +858,10 @@ export const SignalsReportsRefundCreateBody = /* @__PURE__ */ zod.object({})/**- * Set a report's suggested reviewers (full-replacement PUT), whether or not the report already- * has any. Appends a new latest-wins `suggested_reviewers` status row — the same write the artefact- * PUT performs, but addressed by report so a report with zero reviewers (and thus no artefact yet)- * can still be assigned one. App-only: agents append reviewers via the artefacts POST instead.+ * Apply a human reviewer edit, including on reports without a reviewer artefact.* @summary Set a report's suggested reviewers*/+export const signalsReportsReviewersUpdateBodyActionDefault = `replace`export const signalsReportsReviewersUpdateBodyContentItemGithubLoginMax = 200export const signalsReportsReviewersUpdateBodyContentItemGithubNameMax = 200@@ -872,50 +870,109 @@ export const signalsReportsReviewersUpdateBodyContentItemReasonMax = 500export const signalsReportsReviewersUpdateBodyContentMax = 10-export const SignalsReportsReviewersUpdateBody = /* @__PURE__ */ zod- .object({- content: zod- .array(- zod- .object({- github_login: zod- .string()- .max(signalsReportsReviewersUpdateBodyContentItemGithubLoginMax)- .optional()- .describe(- 'GitHub login (case-insensitive). Stored lowercased. Required unless `user_uuid` is given.'- ),- user_uuid: zod- .uuid()- .optional()- .describe(- "PostHog user UUID. Must be an org member on this team; a linked GitHub account is not required. Required unless `github_login` is given. If supplied together with `github_login`, the user's own identity wins."- ),- github_name: zod- .string()- .max(signalsReportsReviewersUpdateBodyContentItemGithubNameMax)- .optional()- .describe(- 'Optional human-readable display name. Not backfilled from GitHub by the server.'- ),- reason: zod- .string()- .max(signalsReportsReviewersUpdateBodyContentItemReasonMax)- .nullish()- .describe(- 'Optional short evidence for why this reviewer was chosen. Omitted entries keep the prior reason for reviewers already on the report.'- ),- })- .describe(- 'Single entry in a PUT body for a `suggested_reviewers` artefact.\n\nEach entry must identify a reviewer by at least one of `github_login` or `user_uuid`. A\n`user_uuid` only has to name an org member on this team — a member with no linked GitHub\naccount is stored by uuid and routes like any other reviewer.'- )- )- .max(signalsReportsReviewersUpdateBodyContentMax)- .describe('Full replacement list of reviewers. Empty list clears the artefact. At most 10 entries.'),- })- .describe(- "PUT body for replacing a `suggested_reviewers` artefact's content.\n\nOnly `suggested_reviewers` artefacts may be modified via this endpoint;\nthe viewset enforces the type check before validation runs."- )+export const signalsReportsReviewersUpdateBodyTargetsItemGithubLoginMax = 200++export const signalsReportsReviewersUpdateBodyTargetsItemGithubNameMax = 200++export const signalsReportsReviewersUpdateBodyTargetsItemReasonMax = 500++export const signalsReportsReviewersUpdateBodyTargetsMax = 10++export const SignalsReportsReviewersUpdateBody = /* @__PURE__ */ zod.object({+ action: zod+ .enum(['add', 'remove', 'replace', 'confirm'])+ .describe('\* `add` - Add\n\* `remove` - Remove\n\* `replace` - Replace\n\* `confirm` - Confirm')+ .default(signalsReportsReviewersUpdateBodyActionDefault)+ .describe(+ 'Add or remove only the supplied people, replace the list, or explicitly confirm it.\n\n\* `add` - Add\n\* `remove` - Remove\n\* `replace` - Replace\n\* `confirm` - Confirm'+ ),+ expected_reviewers: zod+ .object({+ reviewers_id: zod+ .uuid()+ .nullable()+ .describe('Current reviewer artefact ID, or null before the first list.'),+ corrections_id: zod+ .uuid()+ .nullable()+ .describe('Current corrections artefact ID, or null before corrections are stored.'),+ })+ .optional()+ .describe('State from the last read. Required for replacement and confirmation when corrections are enabled.'),+ content: zod+ .array(+ zod+ .object({+ github_login: zod+ .string()+ .max(signalsReportsReviewersUpdateBodyContentItemGithubLoginMax)+ .optional()+ .describe(+ 'GitHub login (case-insensitive). Stored lowercased. Required unless `user_uuid` is given.'+ ),+ user_uuid: zod+ .uuid()+ .optional()+ .describe(+ "PostHog user UUID. Must be an org member on this team; a linked GitHub account is not required. Required unless `github_login` is given. If supplied together with `github_login`, the user's own identity wins."+ ),+ github_name: zod+ .string()+ .max(signalsReportsReviewersUpdateBodyContentItemGithubNameMax)+ .optional()+ .describe('Optional human-readable display name. Not backfilled from GitHub by the server.'),+ reason: zod+ .string()+ .max(signalsReportsReviewersUpdateBodyContentItemReasonMax)+ .nullish()+ .describe(+ 'Optional short evidence for why this reviewer was chosen. Omitted entries keep the prior reason for reviewers already on the report.'+ ),+ })+ .describe(+ 'Single entry in a PUT body for a `suggested_reviewers` artefact.\n\nEach entry must identify a reviewer by at least one of `github_login` or `user_uuid`. A\n`user_uuid` only has to name an org member on this team — a member with no linked GitHub\naccount is stored by uuid and routes like any other reviewer.'+ )+ )+ .max(signalsReportsReviewersUpdateBodyContentMax)+ .describe('People to add, remove, or keep in a replacement. Send an empty list for confirmation.'),+ targets: zod+ .array(+ zod+ .object({+ github_login: zod+ .string()+ .max(signalsReportsReviewersUpdateBodyTargetsItemGithubLoginMax)+ .optional()+ .describe(+ 'GitHub login (case-insensitive). Stored lowercased. Required unless `user_uuid` is given.'+ ),+ user_uuid: zod+ .uuid()+ .optional()+ .describe(+ "PostHog user UUID. Must be an org member on this team; a linked GitHub account is not required. Required unless `github_login` is given. If supplied together with `github_login`, the user's own identity wins."+ ),+ github_name: zod+ .string()+ .max(signalsReportsReviewersUpdateBodyTargetsItemGithubNameMax)+ .optional()+ .describe('Optional human-readable display name. Not backfilled from GitHub by the server.'),+ reason: zod+ .string()+ .max(signalsReportsReviewersUpdateBodyTargetsItemReasonMax)+ .nullish()+ .describe(+ 'Optional short evidence for why this reviewer was chosen. Omitted entries keep the prior reason for reviewers already on the report.'+ ),+ })+ .describe(+ 'Single entry in a PUT body for a `suggested_reviewers` artefact.\n\nEach entry must identify a reviewer by at least one of `github_login` or `user_uuid`. A\n`user_uuid` only has to name an org member on this team — a member with no linked GitHub\naccount is stored by uuid and routes like any other reviewer.'+ )+ )+ .max(signalsReportsReviewersUpdateBodyTargetsMax)+ .optional()+ .describe('Explicit add or remove targets. When supplied, content is only a fallback for older servers.'),+})/*** Transition a report to a new state. The model validates allowed transitions, except that a@@ -999,8 +1056,40 @@ export const SignalsReportsStateCreateBody = /* @__PURE__ */ zod.object({* Append an artefact to a report (see artefact_type for the writable types). Everything is append-only: log entries (code reference, commit, task run, note) accumulate, while status types (safety / actionability / priority judgments, repo selection, suggested reviewers, channel assignments) are latest-wins — appending a new version supersedes the previous one as the report's canonical status. Content is validated against the type's schema.* @summary Append an artefact to a report*/+export const signalsReportArtefactsCreateBodyReviewerOutcomeDefault = `selected`+export const signalsReportArtefactsCreateBodyReviewerRetryReasonMax = 500+export const SignalsReportArtefactsCreateBody = /* @__PURE__ */ zod.object({+ expected_reviewers: zod+ .object({+ reviewers_id: zod+ .uuid()+ .nullable()+ .describe('Current reviewer artefact ID, or null before the first list.'),+ corrections_id: zod+ .uuid()+ .nullable()+ .describe('Current corrections artefact ID, or null before corrections are stored.'),+ })+ .optional()+ .describe(+ 'Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled.'+ ),+ reviewer_outcome: zod+ .enum(['selected', 'no_suitable_owner', 'lookup_failed'])+ .describe(+ '\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ )+ .default(signalsReportArtefactsCreateBodyReviewerOutcomeDefault)+ .describe(+ 'A successful selection, a deliberate empty result, or an unavailable lookup.\n\n\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ ),+ reviewer_retry_reason: zod+ .string()+ .max(signalsReportArtefactsCreateBodyReviewerRetryReasonMax)+ .optional()+ .describe('Reason the reviewer lookup failed.'),claim_id: zod.uuid().optional()@@ -2404,6 +2493,9 @@ export const SignalsScoutRecordCheckResultBody = /* @__PURE__ */ zod* Rewrite a report's title/summary, append a note or fresh evidence, set its suggested reviewers, and/or point it at another repository. Can target ANY of the project's inbox reports, not just scout-authored ones — so the edit is attributed to this scout. Reviewers and repository are how you rescue a report that surfaced routed to no one or against the wrong codebase: each replaces what the report holds and re-runs autostart, so a report that was missing a qualifying reviewer or a repository can open a draft PR. The response carries the repository the report holds after the edit, and the call fails when a repository it named did not land. Set `actionability` and/or `priority` (each with its explanation) when new evidence changed your judgment: each replaces the report's decision and re-runs autostart, without changing the report's inbox status. Title/summary edits are best-effort: the pipeline may later re-research them. Set `supersedes_implementation` alongside a rewrite when the fix changed. Verified automated predecessor PRs close only after the replacement completes with verified open PRs.* @summary Edit an existing report for a run*/+export const signalsScoutEditReportBodyReviewerOutcomeDefault = `selected`+export const signalsScoutEditReportBodyReviewerRetryReasonMax = 500+export const signalsScoutEditReportBodyTitleMax = 300export const signalsScoutEditReportBodySummaryMax = 20000@@ -2454,6 +2546,35 @@ export const signalsScoutEditReportBodyLinksMax = 10export const SignalsScoutEditReportBody = /* @__PURE__ */ zod.object({+ expected_reviewers: zod+ .object({+ reviewers_id: zod+ .uuid()+ .nullable()+ .describe('Current reviewer artefact ID, or null before the first list.'),+ corrections_id: zod+ .uuid()+ .nullable()+ .describe('Current corrections artefact ID, or null before corrections are stored.'),+ })+ .optional()+ .describe(+ 'Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled.'+ ),+ reviewer_outcome: zod+ .enum(['selected', 'no_suitable_owner', 'lookup_failed'])+ .describe(+ '\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ )+ .default(signalsScoutEditReportBodyReviewerOutcomeDefault)+ .describe(+ 'A successful selection, a deliberate empty result, or an unavailable lookup.\n\n\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ ),+ reviewer_retry_reason: zod+ .string()+ .max(signalsScoutEditReportBodyReviewerRetryReasonMax)+ .optional()+ .describe('Reason the reviewer lookup failed.'),report_id: zod.string().describe('Id of the report to edit (must belong to this project).'),title: zod.string()@@ -2535,7 +2656,7 @@ export const SignalsScoutEditReportBody = /* @__PURE__ */ zod.max(signalsScoutEditReportBodySuggestedReviewersMax).optional().describe(- 'Optional reviewers to set on the report (each a `github_login` and\/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list is a no-op (existing reviewers are left untouched, never cleared).'+ 'Optional reviewers to set on the report (each a `github_login` and\/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list clears automatic reviewers when correction rules are enabled. Pins, exclusions, and confirmed lists are preserved. Pass expected_reviewers from the report reviewer_assignment.state read before selection.'),repository: zod.string()diff --git a/products/signals/frontend/inbox/components/detail/ReviewerSearchList.tsx b/products/signals/frontend/inbox/components/detail/ReviewerSearchList.tsxindex 0e21e04ea697..e5a35d888f6e 100644--- a/products/signals/frontend/inbox/components/detail/ReviewerSearchList.tsx+++ b/products/signals/frontend/inbox/components/detail/ReviewerSearchList.tsx@@ -5,6 +5,7 @@ import { IconCheck } from '@posthog/icons'import { LemonInput, Spinner } from '@posthog/lemon-ui'import { PersonDisplay } from 'products/persons/frontend/components/PersonDisplay'+import type { ReviewerEditActionEnumApi } from 'products/signals/frontend/generated/api.schemas'import { captureInboxReportAction, InboxReportActionSurface } from '../../inboxAnalytics'import { inboxReportDetailLogic } from '../../logics/inboxReportDetailLogic'@@ -32,7 +33,11 @@ export function removeSuggestedReviewer({surface: InboxReportActionSurfacetarget: EnrichedReviewerreviewers: EnrichedReviewer[]- updateReviewers: (content: Record<string, string>[], optimistic: EnrichedReviewer[]) => void+ updateReviewers: (+ content: Record<string, string>[],+ optimistic: EnrichedReviewer[],+ action: Extract<ReviewerEditActionEnumApi, 'add' | 'remove'>+ ) => void}): void {removeSuggestedReviewers({ report, surface, targets: [target], reviewers, updateReviewers })}@@ -48,7 +53,11 @@ export function removeSuggestedReviewers({surface: InboxReportActionSurfacetargets: EnrichedReviewer[]reviewers: EnrichedReviewer[]- updateReviewers: (content: Record<string, string>[], optimistic: EnrichedReviewer[]) => void+ updateReviewers: (+ content: Record<string, string>[],+ optimistic: EnrichedReviewer[],+ action: Extract<ReviewerEditActionEnumApi, 'add' | 'remove'>+ ) => void}): void {for (const target of targets) {captureInboxReportAction({@@ -63,7 +72,7 @@ export function removeSuggestedReviewers({}const removed = new Set(targets)const next = reviewers.filter((reviewer) => !removed.has(reviewer))- updateReviewers(reviewersToWriteContent(next), next)+ updateReviewers(reviewersToWriteContent(targets), next, 'remove')}/**@@ -84,12 +93,6 @@ export function ReviewerSearchList({const { displayReviewers, addReviewerOptions, availableReviewersLoading, isUpdatingReviewers, reportArtefacts } =useValues(logic)const { updateReviewers, searchAvailableReviewers } = useActions(logic)- // A write is a full replacement, and `displayReviewers` is null until the artefact log lands. The- // context menu mounts this logic fresh, so the member search can resolve before the artefacts; a- // click in that window would build the write from an empty base and silently wipe every existing- // reviewer. Wait for the artefacts (as the detail pane's `SuggestedReviewersSection` already does)- // before the rows become clickable. `reportArtefacts !== null` with no reviewer artefact is a real- // empty list, so this doesn't block adding the first reviewer.const reviewersLoaded = reportArtefacts !== nullconst [query, setQuery] = useState('')@@ -132,7 +135,7 @@ export function ReviewerSearchList({// under suggested_reviewer_uuid to match the shared cross-client event contract.extra: { suggested_reviewer_uuid: option.user_uuid },})- updateReviewers([...reviewersToWriteContent(baseReviewers), { user_uuid: option.user_uuid }], next)+ updateReviewers([{ user_uuid: option.user_uuid }], next, 'add')}return (diff --git a/products/signals/frontend/inbox/logics/inboxReportDetailLogic.test.ts b/products/signals/frontend/inbox/logics/inboxReportDetailLogic.test.tsindex f31b4a0e59c2..129fe8522fc1 100644--- a/products/signals/frontend/inbox/logics/inboxReportDetailLogic.test.ts+++ b/products/signals/frontend/inbox/logics/inboxReportDetailLogic.test.ts@@ -371,7 +371,7 @@ describe('inboxReportDetailLogic', () => {})expect(logic.values.displayReviewers).toEqual([reviewer])- logic.actions.updateReviewers([], [])+ logic.actions.updateReviewers([{ github_login: reviewer.github_login! }], [], 'remove')expect(logic.values.displayReviewers).toEqual([])try {@@ -394,13 +394,71 @@ describe('inboxReportDetailLogic', () => {},})- logic.actions.updateReviewers([], [])+ logic.actions.updateReviewers([{ github_login: reviewer.github_login! }], [], 'remove')expect(logic.values.displayReviewers).toEqual([])await expectLogic(logic).toFinishAllListeners()expect(logic.values.displayReviewers).toEqual([reviewer])expect(logic.values.isUpdatingReviewers).toBe(false)})++ it.each(['add', 'remove'] as const)(+ 'sends %s targets and a full list to the project endpoint',+ async (action) => {+ logic.unmount()+ initKeaTests(true, { ...MOCK_DEFAULT_TEAM, id: 99, project_id: MOCK_DEFAULT_PROJECT.id })+ logic = inboxReportDetailLogic({ reportId: REPORT.id, report: REPORT })+ logic.mount()+ await expectLogic(logic).toFinishAllListeners()+ const added = { ...reviewer, github_login: 'another-reviewer' }+ const targets = [{ github_login: reviewer.github_login! }]+ const fullList = action === 'add' ? [reviewer, added] : [added]+ const save = jest.fn(async (req) => {+ expect(new URL(req.url).pathname).toBe(+ `/api/projects/${MOCK_DEFAULT_PROJECT.id}/signals/reports/${REPORT.id}/reviewers/`+ )+ expect(await req.json()).toEqual({+ action,+ targets,+ content: fullList.map(({ github_login }) => ({ github_login })),+ })+ return { ...artefact, content: fullList }+ })+ useMocks({ put: { '/api/projects/:team_id/signals/reports/:id/reviewers/': save } })+ logic.actions.updateReviewers(targets, fullList, action)+ await expectLogic(logic).toFinishAllListeners()+ expect(save).toHaveBeenCalledTimes(1)+ }+ )++ it('retains saved reviewers and broadcasts their membership if the refresh fails', async () => {+ const savedReviewer = { ...reviewer, user_uuid: 'saved-reviewer-uuid' }+ const bulk = inboxBulkActionsLogic()+ bulk.mount()+ const broadcast = jest.spyOn(bulk.actions, 'reportReviewersChanged')+ useMocks({+ put: {+ '/api/projects/:team_id/signals/reports/:id/reviewers/': {+ ...artefact,+ content: [savedReviewer],+ },+ },+ get: {+ '/api/projects/:team_id/signals/reports/:id/artefacts/': [500, { detail: 'Refresh failed' }],+ },+ })+ silenceKeaLoadersErrors()+ try {+ logic.actions.updateReviewers([{ github_login: reviewer.github_login! }], [], 'remove')+ await expectLogic(logic).toFinishAllListeners()+ expect(logic.values.displayReviewers).toEqual([savedReviewer])+ expect(logic.values.isUpdatingReviewers).toBe(false)+ expect(broadcast).toHaveBeenCalledWith(REPORT.id, [savedReviewer.user_uuid])+ } finally {+ resumeKeaLoadersErrors()+ bulk.unmount()+ }+ })})describe('implementationSlotClaim', () => {diff --git a/products/signals/frontend/inbox/logics/inboxReportDetailLogic.ts b/products/signals/frontend/inbox/logics/inboxReportDetailLogic.tsindex eca8794ca61a..69a98393316e 100644--- a/products/signals/frontend/inbox/logics/inboxReportDetailLogic.ts+++ b/products/signals/frontend/inbox/logics/inboxReportDetailLogic.ts@@ -43,10 +43,12 @@ import {signalsReportsFeedbackStateRetrieve,signalsReportsSignalsRetrieve,signalsReportsPriorityUpdate,+ signalsReportsReviewersUpdate,} from 'products/signals/frontend/generated/api'import type {CommitDiffResponseApi,PaginatedSignalReportArtefactListApi,+ ReviewerEditActionEnumApi,PullRequestCheckApi,PullRequestCommentApi,PullRequestCommentReactionApi,@@ -648,8 +650,10 @@ export interface inboxReportDetailLogicActions {}updateReviewers: (content: Record<string, string>[],- optimistic: EnrichedReviewer[]+ optimistic: EnrichedReviewer[],+ action: Extract<ReviewerEditActionEnumApi, 'add' | 'remove'>) => {+ action: 'add' | 'remove'content: Record<string, string>[]optimistic: EnrichedReviewer[]}@@ -773,9 +777,14 @@ export const inboxReportDetailLogic = kea<inboxReportDetailLogicType>([// Optimistically replace the reviewer list while the PUT is in flight, then reload from the server.// Addressed by report (not artefact) so a report with no reviewers yet can still be assigned one.// Mirrors desktop `useUpdateSuggestedReviewers` optimistic behavior.- updateReviewers: (content: Record<string, string>[], optimistic: EnrichedReviewer[]) => ({+ updateReviewers: (+ content: Record<string, string>[],+ optimistic: EnrichedReviewer[],+ action: Extract<ReviewerEditActionEnumApi, 'add' | 'remove'>+ ) => ({content,optimistic,+ action,}),setOptimisticReviewers: (reviewers: EnrichedReviewer[] | null) => ({ reviewers }),// Debounced server-side org-member search for the add-reviewer picker.@@ -1493,7 +1502,7 @@ export const inboxReportDetailLogic = kea<inboxReportDetailLogicType>([],}),- listeners(({ actions, asyncActions, values, props, selectors }) => ({+ listeners(({ actions, asyncActions, values, props, selectors, cache }) => ({updatePriority: async ({ priority }) => {const teamId = teamLogic.values.currentTeamIdconst currentReport = values.report@@ -1634,25 +1643,41 @@ export const inboxReportDetailLogic = kea<inboxReportDetailLogicType>([await breakpoint(300)actions.loadAvailableReviewers({ query: query.trim() || undefined })},- // Persist a reviewer add/remove. The optimistic list is already in place (set by the action's- // reducer); on success reload the artefact so we converge on the server's enriched data, and on- // failure clear the optimistic override so the UI snaps back. Mirrors desktop `useUpdateSuggestedReviewers`.- updateReviewers: async ({ content, optimistic }) => {+ updateReviewers: async ({ content, optimistic, action }) => {+ if (cache.reviewerWriteInFlight) {+ return+ }+ cache.reviewerWriteInFlight = truelet saved = falsetry {- await api.signalReports.setReviewers(props.reportId, content)+ const artefact = await signalsReportsReviewersUpdate(+ String(ApiConfig.getCurrentProjectId()),+ props.reportId,+ {+ content: optimistic.map((reviewer) => ({+ github_login: reviewer.github_login ?? undefined,+ user_uuid: reviewer.user?.uuid ?? reviewer.user_uuid ?? undefined,+ })),+ targets: content,+ action,+ }+ )saved = true+ actions.loadReportArtefactsSuccess([+ ...(values.reportArtefacts ?? []).filter((existing) => existing.id !== artefact.id),+ artefact as SignalReportArtefact,+ ])await asyncActions.loadReportArtefacts()} catch (error: any) {lemonToast.error(error?.detail || error?.message || 'Failed to update reviewers')} finally {- // Clear the optimistic override; the freshly-loaded artefact is now the source of truth.+ cache.reviewerWriteInFlight = falseactions.setOptimisticReviewers(null)}// Broadcast last: the list can drop the row that hosts this logic (the context menu picker),// which unmounts it, and kea throws on an action dispatched through an unmounted logic.if (saved) {- const reviewerUuids = optimistic+ const reviewerUuids = (values.displayReviewers ?? []).map((reviewer) => reviewer.user?.uuid ?? reviewer.user_uuid).filter((uuid): uuid is string => !!uuid)inboxBulkActionsLogic.findMounted()?.actions.reportReviewersChanged(props.reportId, reviewerUuids)diff --git a/services/mcp/src/api/generated.ts b/services/mcp/src/api/generated.tsindex 77938f14a06b..1988001e36cd 100644--- a/services/mcp/src/api/generated.ts+++ b/services/mcp/src/api/generated.ts@@ -38666,6 +38666,33 @@ export namespace Schemas {readonly updated_at: string | null;}+ export interface ReviewerState {+ /**+ * Current reviewer artefact ID, or null before the first list.+ * @nullable+ */+ reviewers_id: string | null;+ /**+ * Current corrections artefact ID, or null before corrections are stored.+ * @nullable+ */+ corrections_id: string | null;+ }++ /**+ * * `selected` - Selected+ * * `no_suitable_owner` - No suitable owner+ * * `lookup_failed` - Lookup failed+ */+ export type ReviewerSelectionOutcomeEnum = typeof ReviewerSelectionOutcomeEnum[keyof typeof ReviewerSelectionOutcomeEnum];+++ export const ReviewerSelectionOutcomeEnum = {+ Selected: 'selected',+ NoSuitableOwner: 'no_suitable_owner',+ LookupFailed: 'lookup_failed',+ } as const;+/*** One observation backing an authored report — becomes a bound signal row on the report.*/@@ -38928,6 +38955,19 @@ export namespace Schemas {* Request body for `edit-report`. Can target ANY of the team's inbox reports, not just scout-authored ones.*/export interface EditReportRequest {+ /** Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled. */+ expected_reviewers?: ReviewerState;+ /** A successful selection, a deliberate empty result, or an unavailable lookup.+ *+ * * `selected` - Selected+ * * `no_suitable_owner` - No suitable owner+ * * `lookup_failed` - Lookup failed */+ reviewer_outcome?: ReviewerSelectionOutcomeEnum;+ /**+ * Reason the reviewer lookup failed.+ * @maxLength 500+ */+ reviewer_retry_reason?: string;/** Id of the report to edit (must belong to this project). */report_id: string;/**@@ -38957,7 +38997,7 @@ export namespace Schemas {*/append_evidence?: ReportEvidence[] | null;/**- * Optional reviewers to set on the report (each a `github_login` and/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list is a no-op (existing reviewers are left untouched, never cleared).+ * Optional reviewers to set on the report (each a `github_login` and/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list clears automatic reviewers when correction rules are enabled. Pins, exclusions, and confirmed lists are preserved. Pass expected_reviewers from the report reviewer_assignment.state read before selection.* @maxItems 10*/suggested_reviewers?: SuggestedReviewer[];@@ -75500,6 +75540,7 @@ export namespace Schemas {* * `signal_finding` - Signal Finding* * `repo_selection` - Repo Selection* * `suggested_reviewers` - Suggested Reviewers+ * * `reviewer_corrections` - Reviewer Corrections* * `channel_assignment` - Channel Assignment* * `dismissal` - Dismissal* * `code_reference` - Code Reference@@ -75539,6 +75580,7 @@ export namespace Schemas {SignalFinding: 'signal_finding',RepoSelection: 'repo_selection',SuggestedReviewers: 'suggested_reviewers',+ ReviewerCorrections: 'reviewer_corrections',ChannelAssignment: 'channel_assignment',Dismissal: 'dismissal',CodeReference: 'code_reference',@@ -75769,6 +75811,21 @@ export namespace Schemas {results: SignalReportCheck[];}+ export interface ReviewerControlResponse {+ /** State token for a selection, replacement, or list confirmation. */+ state: ReviewerState;+ /** People an automatic selection must retain. */+ pinned_user_uuids: string[];+ /** People an automatic selection must not restore. */+ excluded_user_uuids: string[];+ /** A person explicitly confirmed the complete reviewer list. */+ confirmed: boolean;+ /** Older edits need recovery on the next protected write, or have incomplete history. Automatic changes are paused until recovery or list confirmation. */+ needs_review: boolean;+ /** Whether this report uses saved reviewer corrections. */+ enabled: boolean;+ }+export type SignalReportStatusEnum = typeof SignalReportStatusEnum[keyof typeof SignalReportStatusEnum];@@ -76164,6 +76221,8 @@ export namespace Schemas {readonly summary: string | null;/** The opening of `summary` as plain text on one line: the text before its first section heading, with chart links removed and other links reduced to their text. At most 450 characters. */readonly summary_lead: string;+ /** Reviewer control and state token for preparing an automatic proposal. */+ readonly reviewer_assignment: ReviewerControlResponse | null;/** Current report status. Monitoring reads as resolved when its rollout is disabled. */readonly status: SignalReportStatusEnum;/**@@ -98075,6 +98134,8 @@ export namespace Schemas {readonly summary: string | null;/** The opening of `summary` as plain text on one line: the text before its first section heading, with chart links removed and other links reduced to their text. At most 450 characters. */readonly summary_lead: string;+ /** Reviewer control and state token for preparing an automatic proposal. */+ readonly reviewer_assignment: ReviewerControlResponse | null;/** Current report status. Monitoring reads as resolved when its rollout is disabled. */readonly status: SignalReportStatusEnum;/**@@ -100883,6 +100944,22 @@ export namespace Schemas {body: string;}+ /**+ * * `add` - Add+ * * `remove` - Remove+ * * `replace` - Replace+ * * `confirm` - Confirm+ */+ export type ReviewerEditActionEnum = typeof ReviewerEditActionEnum[keyof typeof ReviewerEditActionEnum];+++ export const ReviewerEditActionEnum = {+ Add: 'add',+ Remove: 'remove',+ Replace: 'replace',+ Confirm: 'confirm',+ } as const;+export interface RevokeOtherSessionsResponse {/** Number of other login sessions that were revoked. */revoked_count: number;@@ -104456,6 +104533,19 @@ export namespace Schemas {* against the type's schema (see `products/signals/backend/artefact_schemas.py`).*/export interface SignalReportArtefactLogCreate {+ /** Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled. */+ expected_reviewers?: ReviewerState;+ /** A successful selection, a deliberate empty result, or an unavailable lookup.+ *+ * * `selected` - Selected+ * * `no_suitable_owner` - No suitable owner+ * * `lookup_failed` - Lookup failed */+ reviewer_outcome?: ReviewerSelectionOutcomeEnum;+ /**+ * Reason the reviewer lookup failed.+ * @maxLength 500+ */+ reviewer_retry_reason?: string;/** Active claim to attribute this work to. Must belong to the caller and report. */claim_id?: string;/** The artefact type. One of: actionability_judgment, channel_assignment, code_reference, commit, dismissal, note, priority_judgment, related_to, repo_selection, safety_judgment, signal_finding, source_suggestion, suggested_reviewers. Log types accumulate; status types (safety_judgment, actionability_judgment, priority_judgment, repo_selection, suggested_reviewers, channel_assignment, source_suggestion) are latest-wins — appending a new version supersedes the previous one as the report's canonical status. */@@ -104492,18 +104582,26 @@ export namespace Schemas {reason?: string | null;}- /**- * PUT body for replacing a `suggested_reviewers` artefact's content.- *- * Only `suggested_reviewers` artefacts may be modified via this endpoint;- * the viewset enforces the type check before validation runs.- */export interface SignalReportArtefactWrite {+ /** Add or remove only the supplied people, replace the list, or explicitly confirm it.+ *+ * * `add` - Add+ * * `remove` - Remove+ * * `replace` - Replace+ * * `confirm` - Confirm */+ action?: ReviewerEditActionEnum;+ /** State from the last read. Required for replacement and confirmation when corrections are enabled. */+ expected_reviewers?: ReviewerState;/**- * Full replacement list of reviewers. Empty list clears the artefact. At most 10 entries.+ * People to add, remove, or keep in a replacement. Send an empty list for confirmation.* @maxItems 10*/content: SuggestedReviewerEntryWrite[];+ /**+ * Explicit add or remove targets. When supplied, content is only a fallback for older servers.+ * @maxItems 10+ */+ targets?: SuggestedReviewerEntryWrite[];}/**diff --git a/services/mcp/src/generated/signals/api.ts b/services/mcp/src/generated/signals/api.tsindex a443ebaa3771..1b2f22783e4b 100644--- a/services/mcp/src/generated/signals/api.ts+++ b/services/mcp/src/generated/signals/api.ts@@ -659,8 +659,40 @@ export const SignalsReportArtefactsCreateHeader = () => zod.object({),})+export const signalsReportArtefactsCreateBodyReviewerOutcomeDefault = `selected`+export const signalsReportArtefactsCreateBodyReviewerRetryReasonMax = 500+export const SignalsReportArtefactsCreateBody = () => zod.object({+ expected_reviewers: zod+ .object({+ reviewers_id: zod+ .string()+ .nullable()+ .describe('Current reviewer artefact ID, or null before the first list.'),+ corrections_id: zod+ .string()+ .nullable()+ .describe('Current corrections artefact ID, or null before corrections are stored.'),+ })+ .optional()+ .describe(+ 'Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled.'+ ),+ reviewer_outcome: zod+ .enum(['selected', 'no_suitable_owner', 'lookup_failed'])+ .describe(+ '\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ )+ .default(signalsReportArtefactsCreateBodyReviewerOutcomeDefault)+ .describe(+ 'A successful selection, a deliberate empty result, or an unavailable lookup.\n\n\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ ),+ reviewer_retry_reason: zod+ .string()+ .max(signalsReportArtefactsCreateBodyReviewerRetryReasonMax)+ .optional()+ .describe('Reason the reviewer lookup failed.'),claim_id: zod.string().optional()@@ -728,7 +760,7 @@ export const SignalsReportArtefactsPartialUpdateBody = () => zod)/**- * Delete an artefact, addressed by id. Deleting the latest row of a status type reverts the report's canonical status to the previous version (latest-wins over what remains). `task_run` artefacts are an append-only work log and cannot be deleted. Neither can the types this API cannot write, which the pipeline owns: `autostart_skip`, `check_cancelled`, `check_expired`, `check_observation`, `check_result`, `check_scheduled`, `code_review`, `impact_measurement_plan`, `implementation_decision`, `implementation_dispatch`, `implementation_handover`, `implementation_replacement`, `pull_request`, `ranking_score`, `report_link`, `summary_change`, `task_run`, `title_change`, `video_segment`, `work_claim`, `work_release`.+ * Delete an artefact, addressed by id. Deleting the latest row of a status type reverts the report's canonical status to the previous version (latest-wins over what remains). `task_run` artefacts are an append-only work log and cannot be deleted. Neither can the types this API cannot write, which the pipeline owns: `autostart_skip`, `check_cancelled`, `check_expired`, `check_observation`, `check_result`, `check_scheduled`, `code_review`, `impact_measurement_plan`, `implementation_decision`, `implementation_dispatch`, `implementation_handover`, `implementation_replacement`, `pull_request`, `ranking_score`, `report_link`, `reviewer_corrections`, `summary_change`, `task_run`, `title_change`, `video_segment`, `work_claim`, `work_release`.* @summary Delete an artefact*/export const SignalsReportArtefactsDestroyParams = () => zod.object({@@ -2578,6 +2610,9 @@ export const SignalsScoutEditReportParams = () => zod.object({run_id: zod.string().describe('UUID of the `SignalScoutRun` bridge row.'),})+export const signalsScoutEditReportBodyReviewerOutcomeDefault = `selected`+export const signalsScoutEditReportBodyReviewerRetryReasonMax = 500+export const signalsScoutEditReportBodyTitleMax = 300export const signalsScoutEditReportBodySummaryMax = 20000@@ -2628,6 +2663,35 @@ export const signalsScoutEditReportBodyLinksMax = 10export const SignalsScoutEditReportBody = () => zod.object({+ expected_reviewers: zod+ .object({+ reviewers_id: zod+ .string()+ .nullable()+ .describe('Current reviewer artefact ID, or null before the first list.'),+ corrections_id: zod+ .string()+ .nullable()+ .describe('Current corrections artefact ID, or null before corrections are stored.'),+ })+ .optional()+ .describe(+ 'Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled.'+ ),+ reviewer_outcome: zod+ .enum(['selected', 'no_suitable_owner', 'lookup_failed'])+ .describe(+ '\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ )+ .default(signalsScoutEditReportBodyReviewerOutcomeDefault)+ .describe(+ 'A successful selection, a deliberate empty result, or an unavailable lookup.\n\n\* `selected` - Selected\n\* `no_suitable_owner` - No suitable owner\n\* `lookup_failed` - Lookup failed'+ ),+ reviewer_retry_reason: zod+ .string()+ .max(signalsScoutEditReportBodyReviewerRetryReasonMax)+ .optional()+ .describe('Reason the reviewer lookup failed.'),report_id: zod.string().describe('Id of the report to edit (must belong to this project).'),title: zod.string()@@ -2709,7 +2773,7 @@ export const SignalsScoutEditReportBody = () => zod.max(signalsScoutEditReportBodySuggestedReviewersMax).optional().describe(- 'Optional reviewers to set on the report (each a `github_login` and\/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list is a no-op (existing reviewers are left untouched, never cleared).'+ 'Optional reviewers to set on the report (each a `github_login` and\/or `user_uuid`), replacing any existing list. Use this to route a report that surfaced with no reviewer — it re-runs autostart, so a report that was missing a qualifying reviewer can now open a draft PR. An empty list clears automatic reviewers when correction rules are enabled. Pins, exclusions, and confirmed lists are preserved. Pass expected_reviewers from the report reviewer_assignment.state read before selection.'),repository: zod.string()diff --git a/services/mcp/src/tools/generated/signals.ts b/services/mcp/src/tools/generated/signals.tsindex 77dfa604ea4f..260b29ee2828 100644--- a/services/mcp/src/tools/generated/signals.ts+++ b/services/mcp/src/tools/generated/signals.ts@@ -88,6 +88,15 @@ const inboxReportArtefactsCreate = (): ToolBase<handler: async (context: Context, params: z.infer<ReturnType<typeof InboxReportArtefactsCreateSchema>>) => {const projectId = await context.stateManager.getProjectId()const body: Record<string, unknown> = {}+ if (params.expected_reviewers !== undefined) {+ body['expected_reviewers'] = params.expected_reviewers+ }+ if (params.reviewer_outcome !== undefined) {+ body['reviewer_outcome'] = params.reviewer_outcome+ }+ if (params.reviewer_retry_reason !== undefined) {+ body['reviewer_retry_reason'] = params.reviewer_retry_reason+ }if (params.claim_id !== undefined) {body['claim_id'] = params.claim_id}@@ -1297,6 +1306,15 @@ const scoutEditReport = (): ToolBase<ReturnType<typeof ScoutEditReportSchema>, Shandler: async (context: Context, params: z.infer<ReturnType<typeof ScoutEditReportSchema>>) => {const projectId = await context.stateManager.getProjectId()const body: Record<string, unknown> = {}+ if (params.expected_reviewers !== undefined) {+ body['expected_reviewers'] = params.expected_reviewers+ }+ if (params.reviewer_outcome !== undefined) {+ body['reviewer_outcome'] = params.reviewer_outcome+ }+ if (params.reviewer_retry_reason !== undefined) {+ body['reviewer_retry_reason'] = params.reviewer_retry_reason+ }if (params.report_id !== undefined) {body['report_id'] = params.report_id}@@ -2725,6 +2743,15 @@ const signalsScoutEditReport = (): ToolBase<handler: async (context: Context, params: z.infer<ReturnType<typeof SignalsScoutEditReportSchema>>) => {const projectId = await context.stateManager.getProjectId()const body: Record<string, unknown> = {}+ if (params.expected_reviewers !== undefined) {+ body['expected_reviewers'] = params.expected_reviewers+ }+ if (params.reviewer_outcome !== undefined) {+ body['reviewer_outcome'] = params.reviewer_outcome+ }+ if (params.reviewer_retry_reason !== undefined) {+ body['reviewer_retry_reason'] = params.reviewer_retry_reason+ }if (params.report_id !== undefined) {body['report_id'] = params.report_id}diff --git a/services/mcp/tests/unit/__snapshots__/tool-schemas/inbox-report-artefacts-create.json b/services/mcp/tests/unit/__snapshots__/tool-schemas/inbox-report-artefacts-create.jsonindex 97de645762e6..6657d427bb80 100644--- a/services/mcp/tests/unit/__snapshots__/tool-schemas/inbox-report-artefacts-create.json+++ b/services/mcp/tests/unit/__snapshots__/tool-schemas/inbox-report-artefacts-create.json@@ -12,9 +12,49 @@"content": {"description": "The artefact payload as a JSON object or array; shape depends on artefact_type and is validated against its schema."},+ "expected_reviewers": {+ "description": "Report reviewer_assignment.state read before selection began. Required when reviewer corrections are enabled.",+ "properties": {+ "corrections_id": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Current corrections artefact ID, or null before corrections are stored."+ },+ "reviewers_id": {+ "anyOf": [+ {+ "type": "string"+ },+ {+ "type": "null"+ }+ ],+ "description": "Current reviewer artefact ID, or null before the first list."+ }+ },+ "required": ["reviewers_id", "corrections_id"],+ "type": "object"+ },"report_id": {"description": "UUID of the report whose artefacts you're addressing. This must be a report id (the report's own UUID), not a signal id such as `sig_praise` — a non-report id returns 404.","type": "string"+ },+ "reviewer_outcome": {+ "default": "selected",+ "description": "A successful selection, a deliberate empty result, or an unavailable lookup.\n\n* `selected` - Selected\n* `no_suitable_owner` - No suitable owner\n* `lookup_failed` - Lookup failed",+ "enum": ["selected", "no_suitable_owner", "lookup_failed"],+ "type": "string"+ },+ "reviewer_retry_reason": {+ "description": "Reason the reviewer lookup failed.",+ "maxLength": 500,+ "type": "string"}},"required": ["report_id", "artefact_type", "content"],diff --git a/services/mcp/tests/unit/signals-edit-handler.test.ts b/services/mcp/tests/unit/signals-edit-handler.test.tsindex 56e612b69087..6c6448f6f601 100644--- a/services/mcp/tests/unit/signals-edit-handler.test.ts+++ b/services/mcp/tests/unit/signals-edit-handler.test.ts@@ -18,6 +18,7 @@ describe('signals-scout-edit-report handler', () => {const input = { run_id: 'run-1', report_id: 'report-1', append_note: 'Checked again', ...flags }await tool.handler(context, tool.schema.parse(input))expect(request.mock.calls[0]![0].body).toEqual({+ reviewer_outcome: 'selected',report_id: 'report-1',append_note: 'Checked again',...flags,