opencode-swarm 7.173.0 → 7.174.0

package/dist/parallel/review-router.d.ts

@@ -16,10 +16,16 @@ export interface SemanticRoutingResult {
     routing: ReviewRouting;
     classifications: ClassifiedChange[];
 }
+/**
+ * One bounded budget covers the complete route computation.  The AST helper
+ * has its own per-file guard, but that alone does not bound the surrounding
+ * complexity scan plus the sequence of git/AST operations.
+ */
+export declare const REVIEW_ROUTING_TIMEOUT_MS = 10000;
 /**
  * Compute complexity metrics for a set of files
  */
-export declare function computeComplexity(directory: string, changedFiles: string[]): Promise<ComplexityMetrics>;
+export declare function computeComplexity(directory: string, changedFiles: string[], deadline?: number): Promise<ComplexityMetrics>;
 /**
  * Determine review routing based on complexity
  */
@@ -28,7 +34,7 @@ export declare function routeReview(metrics: ComplexityMetrics): ReviewRouting;
  * Attempt AST-based semantic classification of changes.
  * Returns null if AST analysis is unavailable, times out, or exceeds bounds.
  */
-export declare function computeSemanticClassifications(directory: string, changedFiles: string[]): Promise<ClassifiedChange[] | null>;
+export declare function computeSemanticClassifications(directory: string, changedFiles: string[], deadline?: number): Promise<ClassifiedChange[] | null>;
 /**
  * Route review based on semantic classifications.
  * High-risk categories (GUARD_REMOVED, SIGNATURE_CHANGE, API_CHANGE,

package/dist/pr-review/completion.d.ts

@@ -39,6 +39,7 @@ import { z } from 'zod';
 import { type LaneOutputArtifact } from '../background/lane-output-store.js';
 import { type BackgroundDelegationRecord, type BackgroundDelegationResult, type BackgroundDelegationWorkflowLaneFailureClass } from '../background/pending-delegations.js';
 import { type PrReviewBaseDimensionId, type PrReviewResultReceipt } from '../background/pr-review-contract.js';
+import { type FinalPolicyFinding } from './finding-policy.js';
 /** Declared lane shape of a base dispatch, as the settlement reads it. */
 export interface PrReviewCompletionLane {
     laneId: string;
@@ -202,7 +203,7 @@ export type PrReviewReportVerdict = (typeof PR_REVIEW_REPORT_VERDICTS)[number];
  * is a forced INCOMPLETE operational report. Neither may ever APPROVE or
  * claim a full review.
  */
-export declare function allowedPrReviewReportVerdicts(kind: PrReviewTerminalCoverageKind): readonly PrReviewReportVerdict[];
+export declare function allowedPrReviewReportVerdicts(kind: PrReviewTerminalCoverageKind, findings?: ReadonlyArray<FinalPolicyFinding>): readonly PrReviewReportVerdict[];
 export interface PrReviewTerminalCoverageSettlement {
     kind: PrReviewTerminalCoverageKind;
     coveredDimensions: PrReviewBaseDimensionId[];

package/dist/pr-review/finding-policy.d.ts

@@ -0,0 +1,194 @@
+/**
+ * Versioned PR-review finding synthesis and terminal projection policy.
+ *
+ * This is the policy boundary between authenticated lane output and the
+ * terminal report/handoff projections.  It intentionally has no dependency on
+ * the workflow gate so it can be exercised in isolation and reused by every
+ * settlement caller.
+ */
+import { type CoreEventCoverage } from '../events/core-events.js';
+export declare const FINDING_POLICY_VERSION: 1;
+export type FindingSeverity = 'CRITICAL' | 'HIGH' | 'MEDIUM' | 'LOW' | 'INFO' | 'NONE';
+export type FindingAction = 'route_to_reviewer' | 'route_to_critic' | 'report' | 'suppress_with_reason' | 'handoff_to_feedback';
+export type FindingStatus = 'UNRESOLVED' | 'CONFIRMED' | 'DISPROVED' | 'NON_ACTIONABLE' | 'PRE_EXISTING';
+export type ConfidenceLabel = 'LOW' | 'MEDIUM' | 'HIGH';
+export type CriticOutcome = 'UPHELD' | 'DOWNGRADED' | 'DISPROVED' | 'NEEDS_MORE_EVIDENCE';
+export interface ParsedCandidateConfidence {
+    label: ConfidenceLabel;
+    score: number;
+}
+/** Parse the version-1 categorical confidence vocabulary. */
+export declare function parseCandidateConfidence(value: unknown): ParsedCandidateConfidence;
+export interface FindingProvenance {
+    identity: string;
+    lane?: string;
+    [key: string]: unknown;
+}
+export interface FindingLocation {
+    file: string;
+    line: number;
+    lineEnd?: number;
+}
+export interface FindingCandidateInput {
+    finding: string;
+    severity: FindingSeverity | string;
+    action?: FindingAction | string;
+    confidence: ConfidenceLabel | string;
+    category: string;
+    location: FindingLocation;
+    provenance: FindingProvenance | FindingProvenance[];
+    status?: FindingStatus | string;
+    [key: string]: unknown;
+}
+export interface SynthesizedFinding {
+    id: string;
+    finding: string;
+    severity: FindingSeverity;
+    action: FindingAction;
+    confidence: ConfidenceLabel;
+    confidenceScore: number;
+    agreementCount: number;
+    category: string;
+    location: FindingLocation;
+    provenance: FindingProvenance[];
+    status: FindingStatus;
+    sourceFindingIds: string[];
+}
+export interface CriticSettlementRecord {
+    findingId: string;
+    terminal: boolean;
+    status: CriticOutcome;
+    finalFinding: CriticSettlementInput['finding'];
+    handoffFindingIds: string[];
+}
+export interface FindingSynthesis {
+    policyVersion: typeof FINDING_POLICY_VERSION;
+    findings: SynthesizedFinding[];
+    diagnostics: string[];
+    criticSettlements?: CriticSettlementRecord[];
+}
+/**
+ * Keep synthesis bounded independently of the JSONL byte ceiling.  A review
+ * result may carry at most this many findings, and synthesis uses the same
+ * bound so a caller cannot turn the pairwise agreement pass into an
+ * unbounded CPU cost (issue #2491 F-017).
+ */
+export declare const MAX_FINDING_SYNTHESIS_CANDIDATES = 256;
+/** Synthesize semantically equivalent findings and independent agreement. */
+export declare function synthesizePrReviewFindings(input: {
+    candidates: FindingCandidateInput[];
+}): FindingSynthesis;
+export interface FinalPolicyFinding {
+    id?: string;
+    severity: FindingSeverity | string;
+    action: FindingAction | string;
+    status: FindingStatus | string;
+    [key: string]: unknown;
+}
+export interface FinalPolicyCoverage {
+    kind: 'base' | 'micro';
+    quality: 'complete' | 'degraded' | 'partial' | 'none' | string;
+    provenance?: 'valid' | 'invalid' | string;
+    disclosed?: boolean;
+}
+export interface FinalFindingPolicyInput {
+    policyVersion: number;
+    finalStatus: 'COMPLETE' | 'INCOMPLETE' | string;
+    coverage: FinalPolicyCoverage;
+    findings: FinalPolicyFinding[];
+}
+export interface FinalFindingPolicyProjection {
+    policyVersion: typeof FINDING_POLICY_VERSION;
+    /** The registered terminal report vocabulary; no internal-only verdicts. */
+    permittedVerdicts: Array<'APPROVE' | 'REQUEST_CHANGES' | 'INCOMPLETE'>;
+    coverageDisposition: 'COMPLETE' | 'PARTIAL' | 'DEGRADED_DISCLOSED' | 'INVALID_PROVENANCE' | 'NO_COVERAGE';
+    blockingFindingIds: string[];
+}
+/** Project final finding status/action and coverage through policy v1. */
+export declare function evaluateFinalFindingPolicy(input: FinalFindingPolicyInput): FinalFindingPolicyProjection;
+export interface CriticSettlementInput {
+    finding: {
+        id: string;
+        severity: FindingSeverity | string;
+        action: FindingAction | string;
+        status: FindingStatus | string;
+    };
+    outcome: CriticOutcome;
+    finalSeverity?: FindingSeverity | string;
+    finalAction?: FindingAction | string;
+}
+export interface CriticSettlement {
+    terminal: boolean;
+    status: CriticOutcome;
+    finalFinding: CriticSettlementInput['finding'];
+    handoffFindingIds: string[];
+}
+/** Apply critic settlement; NEEDS_MORE_EVIDENCE remains explicitly open. */
+export declare function settleCriticFinding(input: CriticSettlementInput): CriticSettlement;
+/**
+ * Derive the feedback handoff set from the final ledger projection only.
+ * Earlier reviewer/candidate records and caller-supplied IDs are deliberately
+ * ignored; this keeps handoff membership tied to terminal CONFIRMED records.
+ */
+export declare function deriveFeedbackHandoffFindingIds(records: ReadonlyArray<{
+    finding_id: string;
+    status: string;
+    next_action: string;
+}>): string[];
+export interface TerminalReceipt {
+    id: string;
+    valid: boolean;
+}
+export interface TerminalReadinessInput {
+    baseReceipt: TerminalReceipt | null;
+    reviewerReceipts: TerminalReceipt[];
+    criticReceipt: TerminalReceipt | null;
+    coverage: FinalPolicyCoverage;
+    council: {
+        enabled: boolean;
+        receipt?: TerminalReceipt | null;
+    };
+    criticSettlements?: Array<{
+        terminal: boolean;
+        status?: CriticOutcome;
+    }>;
+}
+export interface TerminalReadiness {
+    ready: boolean;
+    blockers: string[];
+    degradedCoverageDisclosed: boolean;
+}
+export declare function assessTerminalReadiness(input: TerminalReadinessInput): TerminalReadiness;
+export interface ReviewOutcomeRouteReceipt {
+    kind: string;
+    version: number;
+    sessionId: string;
+    taskId: string;
+    [key: string]: unknown;
+}
+export interface PersistReviewOutcomeInput {
+    projectRoot: string;
+    routeReceipt: ReviewOutcomeRouteReceipt;
+    synthesis: Record<string, unknown>;
+}
+export interface PersistReviewOutcomeResult {
+    persisted: true;
+    evidencePath: string;
+    eventsPath: string;
+}
+/** Digest the exact JSON projection carried by finding-policy evidence. */
+export declare function reviewOutcomeSynthesisDigest(synthesis: unknown): string;
+/** Persist policy evidence plus canonical, identity-only audit events. */
+export declare function persistReviewOutcome(input: PersistReviewOutcomeInput): Promise<PersistReviewOutcomeResult>;
+export interface ReadReviewOutcomeInput {
+    projectRoot: string;
+    sessionId: string;
+    taskId: string;
+}
+export interface ReadReviewOutcomeResult {
+    evidence: Record<string, unknown>;
+    events: Array<Record<string, unknown>>;
+    /** Coverage of the bounded core-event audit window used for this read. */
+    auditCoverage: CoreEventCoverage;
+}
+export declare function readReviewOutcome(input: ReadReviewOutcomeInput): Promise<ReadReviewOutcomeResult>;

package/dist/review/routing-enforcement.d.ts

@@ -0,0 +1,163 @@
+/**
+ * Versioned semantic-review routing receipts (issue #2491).
+ *
+ * A route is an authorization input for Stage B, not an advisory message. A
+ * successful receipt names the exact reviewer/test-engineer identities that
+ * owe an independent completion. Router failures have a separate typed
+ * receipt; an absent or malformed success receipt never receives fail-open
+ * treatment.
+ */
+import { z } from 'zod';
+export declare const REVIEW_ROUTE_RECEIPT_VERSION: 1;
+export declare const ReviewRouteReceiptSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"review_route_receipt">;
+    version: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+    complexity: z.ZodString;
+    semanticRisk: z.ZodString;
+    required: z.ZodObject<{
+        reviewers: z.ZodNumber;
+        testEngineers: z.ZodNumber;
+    }, z.core.$strip>;
+    identities: z.ZodObject<{
+        reviewers: z.ZodArray<z.ZodString>;
+        testEngineers: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+    slots: z.ZodOptional<z.ZodObject<{
+        reviewers: z.ZodArray<z.ZodString>;
+        testEngineers: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    mac: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export declare const ReviewRouteRouterErrorReceiptSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"review_route_router_error">;
+    version: z.ZodLiteral<1>;
+    code: z.ZodEnum<{
+        NO_CHANGED_FILES: "NO_CHANGED_FILES";
+        ROUTER_UNAVAILABLE: "ROUTER_UNAVAILABLE";
+        ROUTER_FAILED: "ROUTER_FAILED";
+    }>;
+    failOpen: z.ZodLiteral<true>;
+    sessionId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    detail: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    mac: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const ReviewRoutePendingReceiptSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"review_route_pending">;
+    version: z.ZodLiteral<1>;
+    sessionId: z.ZodString;
+    taskId: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    mac: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ReviewRouteReceipt = z.infer<typeof ReviewRouteReceiptSchema>;
+export type ReviewRouteRouterErrorReceipt = z.infer<typeof ReviewRouteRouterErrorReceiptSchema>;
+export type ReviewRouteRecord = ReviewRouteReceipt | ReviewRouteRouterErrorReceipt | ReviewRoutePendingReceipt;
+export type ReviewRoutePendingReceipt = z.infer<typeof ReviewRoutePendingReceiptSchema>;
+export interface BuildReviewRouteReceiptArgs {
+    sessionId: string;
+    taskId: string;
+    complexity: string;
+    semanticRisk: string;
+    requiredReviewers: readonly string[];
+    requiredTestEngineers: readonly string[];
+    /** Optional explicit slot IDs. If absent they are deterministic by index. */
+    reviewerSlots?: readonly string[];
+    testEngineerSlots?: readonly string[];
+    createdAt?: string;
+}
+export interface ReviewRouteEvidence {
+    role: 'reviewer' | 'test_engineer';
+    identity: string;
+    /** Optional exact route binding fields used by live Stage-B callers. */
+    sessionId?: string;
+    taskId?: string;
+    slotId?: string;
+    callId?: string;
+    childSessionId?: string;
+    generation?: number;
+}
+export interface EnforceReviewRouteReceiptArgs {
+    enforcementEnabled: boolean;
+    routeReceipt: unknown;
+    receipts: readonly ReviewRouteEvidence[];
+    sessionId?: string;
+    taskId?: string;
+    /** Live callers must provide the full call/child/generation-bound tuple. */
+    requireEvidenceBindings?: boolean;
+    /** Current live dispatch tuple, when a caller is authorizing one completion. */
+    expectedDispatch?: Pick<ReviewRouteEvidence, 'role' | 'identity' | 'callId' | 'childSessionId' | 'generation'>;
+    /**
+     * When false, authorize the current exact dispatch tuple without requiring
+     * every route slot. Callers use this admission check before publishing the
+     * completion; the full-route check remains the advancement barrier.
+     */
+    requireCompleteEvidence?: boolean;
+}
+export interface EnforceReviewRouteReceiptResult {
+    canAdvance: boolean;
+    mode?: 'enforced' | 'disabled' | 'fail_open' | 'legacy_unrouted';
+    reason?: string;
+    routerFailure?: ReviewRouteRouterErrorReceipt['code'];
+}
+export declare function buildReviewRouteReceipt(input: BuildReviewRouteReceiptArgs): ReviewRouteReceipt;
+export declare function buildReviewRouteRouterError(input: {
+    code: ReviewRouteRouterErrorReceipt['code'];
+    sessionId: string;
+    taskId: string;
+    detail?: string;
+    createdAt?: string;
+}): ReviewRouteRouterErrorReceipt;
+export declare function buildReviewRoutePending(input: {
+    sessionId: string;
+    taskId: string;
+    createdAt?: string;
+}): ReviewRoutePendingReceipt;
+export declare function persistReviewRouteReceipt(input: {
+    projectRoot: string;
+    receipt: ReviewRouteRecord;
+}): Promise<{
+    persisted: true;
+    path: string;
+}>;
+export declare function readReviewRouteReceipt(input: {
+    projectRoot: string;
+    sessionId: string;
+    taskId: string;
+}): Promise<ReviewRouteRecord | null>;
+/** Synchronous twin for the existing synchronous reviewer-gate predicate. */
+export declare function readReviewRouteReceiptSync(input: {
+    projectRoot: string;
+    sessionId: string;
+    taskId: string;
+}): ReviewRouteRecord | null;
+/**
+ * Authorize Stage-B advancement from the exact route receipt. The explicit
+ * router error is the only enabled fail-open branch; malformed/absent records
+ * fail closed. Optional identity fields on evidence are checked when present
+ * so old callers can migrate without fabricating bindings.
+ */
+export declare function enforceReviewRouteReceipt(input: EnforceReviewRouteReceiptArgs): EnforceReviewRouteReceiptResult;
+export declare function routeReceiptPathForTask(directory: string, sessionId: string, taskId: string): string;
+/**
+ * Read and enforce one task's persisted route using the synchronous gate
+ * contract. A missing receipt is intentionally a hard failure for new work;
+ * callers that have positively identified pre-version legacy state may opt
+ * into the disclosed one-release compatibility result.
+ */
+export declare function enforcePersistedReviewRouteReceipt(input: {
+    projectRoot: string;
+    sessionId: string;
+    taskId: string;
+    receipts: readonly ReviewRouteEvidence[];
+    enforcementEnabled: boolean;
+    legacyUnrouted?: boolean;
+    requireEvidenceBindings?: boolean;
+    expectedDispatch?: EnforceReviewRouteReceiptArgs['expectedDispatch'];
+    requireCompleteEvidence?: boolean;
+}): EnforceReviewRouteReceiptResult;
+export {};

package/dist/session/snapshot-writer.d.ts

@@ -83,6 +83,8 @@ export interface SerializedAgentSession {
     sessionRehydratedAt?: number;
     /** Stage B completion tracking: per-task set of completed Stage B agents. Optional for backward compat with old snapshots. */
     stageBCompletion?: Record<string, string[]>;
+    /** v1 review-routing requirement markers, persisted so missing receipts fail closed after restart. */
+    stageBRouteRequiredTasks?: string[];
     /** Session-scoped concurrency override for max_concurrent_tasks (Issue #761) */
     maxConcurrencyOverride?: number;
     /** Session-level auto-proceed override (Phase 1) */

package/dist/state.d.ts

@@ -13,6 +13,7 @@ import { type EnvironmentProfile } from './environment/profile.js';
 import { type TaskWorkflowMetadata } from './gate-evidence';
 import type { EscalationTracker } from './prm/escalation.js';
 import type { PatternMatch } from './prm/types.js';
+import type { ReviewRouteEvidence } from './review/routing-enforcement.js';
 import { AgentRunContext } from './state/agent-run-context.js';
 export { AgentRunContext } from './state/agent-run-context.js';
 /**
@@ -244,6 +245,13 @@ export interface AgentSessionState {
      * Always populated — Stage B is unconditionally parallel.
      */
     stageBCompletion?: Map<string, Set<'reviewer' | 'test_engineer'>>;
+    /** Exact route-bound Stage B evidence; role presence alone is not authoritative. */
+    stageBRouteEvidence?: Map<string, ReviewRouteEvidence[]>;
+    /**
+     * Tasks dispatched through v1 review routing. This positive marker prevents a
+     * missing route receipt from being mistaken for pre-v1 legacy state.
+     */
+    stageBRouteRequiredTasks?: Set<string>;
     /** v6.71+ Council mode: per-task council verdict, recorded by delegation-gate when submit_council_verdicts resolves. */
     taskCouncilApproved?: Map<string, {
         verdict: 'APPROVE' | 'REJECT' | 'CONCERNS';
@@ -1262,6 +1270,26 @@ export declare function getTaskState(session: AgentSessionState, taskId: string)
  * @param agent - Which Stage B agent completed ('reviewer' or 'test_engineer')
  */
 export declare function recordStageBCompletion(session: AgentSessionState, taskId: string, agent: 'reviewer' | 'test_engineer'): void;
+/**
+ * Reserve a bounded in-memory route-evidence slot and return a rollback for
+ * callers that still have to publish the corresponding durable evidence.
+ *
+ * The reservation remains visible while the caller awaits its durable write,
+ * which prevents concurrent completions from oversubscribing the 32-entry
+ * projection. If that write fails, invoking the rollback restores the exact
+ * prior slot (or removes a newly-added slot), so a retry is not poisoned by a
+ * failed attempt.
+ */
+export declare function reserveStageBRouteEvidence(session: AgentSessionState, taskId: string, evidence: ReviewRouteEvidence): (() => void) | null;
+export declare function recordStageBRouteEvidence(session: AgentSessionState, taskId: string, evidence: ReviewRouteEvidence): boolean;
+export declare function getStageBRouteEvidence(session: AgentSessionState, taskId: string): ReviewRouteEvidence[];
+export declare function clearStageBRouteEvidence(session: AgentSessionState, taskId: string): void;
+/** Mark a task as requiring the versioned review-route receipt contract. */
+export declare function markStageBRouteRequired(session: AgentSessionState, taskId: string): void;
+/** True only for a task positively marked as v1-routed in this session. */
+export declare function isStageBRouteRequired(session: AgentSessionState, taskId: string): boolean;
+/** Clear the route requirement after a task reaches its terminal state. */
+export declare function clearStageBRouteRequired(session: AgentSessionState, taskId: string): void;
 /**
  * PR 2 Stage B barrier: returns true iff both 'reviewer' and 'test_engineer' have
  * been recorded for the given task in this session.

package/dist/tools/complete-pr-workflow.d.ts

@@ -1,4 +1,4 @@
-import { completePrWorkflow, readPrReviewTerminalCoverageForReport, readPrWorkflowGateState, settlePresumedStalePrWorkflowLanes } from '../hooks/pr-workflow-gate.js';
+import { completePrWorkflow, readPrReviewFinalFindingPolicyForReport, readPrReviewTerminalCoverageForReport, readPrWorkflowGateState, settlePresumedStalePrWorkflowLanes } from '../hooks/pr-workflow-gate.js';
 import { createSwarmTool } from './create-tool.js';
 import { listPendingPrWorkflowCheckoutRestores } from './prepare-pr-workflow-checkout.js';
 export declare function executeCompletePrWorkflow(args: unknown, directory: string, context?: {
@@ -10,5 +10,6 @@ export declare const _internals: {
     listPendingPrWorkflowCheckoutRestores: typeof listPendingPrWorkflowCheckoutRestores;
     readPrWorkflowGateState: typeof readPrWorkflowGateState;
     readPrReviewTerminalCoverageForReport: typeof readPrReviewTerminalCoverageForReport;
+    readPrReviewFinalFindingPolicyForReport: typeof readPrReviewFinalFindingPolicyForReport;
     settlePresumedStalePrWorkflowLanes: typeof settlePresumedStalePrWorkflowLanes;
 };

package/dist/tools/tool-metadata.d.ts

@@ -35,7 +35,7 @@ export interface ToolMeta {
 export declare const TOOL_METADATA: {
     diff: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic_oversight" | "critic_finding_validator" | "architect")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic_oversight" | "critic_finding_validator" | "architect")[];
         prWorkflow: {
             modes: ("PR_REVIEW" | "PR_FEEDBACK")[];
             capability: "observe";
@@ -51,7 +51,7 @@ export declare const TOOL_METADATA: {
     };
     syntax_check: {
         description: string;
-        agents: ("coder" | "test_engineer" | "architect")[];
+        agents: ("test_engineer" | "coder" | "architect")[];
         prWorkflow: {
             modes: "PR_REVIEW"[];
             capability: "validate";
@@ -67,7 +67,7 @@ export declare const TOOL_METADATA: {
     };
     imports: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_finding_validator" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_finding_validator" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier")[];
         prWorkflow: {
             modes: ("PR_REVIEW" | "PR_FEEDBACK")[];
             capability: "observe";
@@ -75,7 +75,7 @@ export declare const TOOL_METADATA: {
     };
     lint: {
         description: string;
-        agents: ("coder" | "reviewer" | "critic_finding_validator" | "architect")[];
+        agents: ("reviewer" | "coder" | "critic_finding_validator" | "architect")[];
         prWorkflow: {
             modes: "PR_REVIEW"[];
             capability: "validate";
@@ -99,7 +99,7 @@ export declare const TOOL_METADATA: {
     };
     build_check: {
         description: string;
-        agents: ("coder" | "test_engineer" | "architect")[];
+        agents: ("test_engineer" | "coder" | "architect")[];
     };
     pre_check_batch: {
         description: string;
@@ -115,7 +115,7 @@ export declare const TOOL_METADATA: {
     };
     symbols: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_finding_validator" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "spec_writer")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_finding_validator" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "spec_writer")[];
     };
     complexity_hotspots: {
         description: string;
@@ -299,7 +299,7 @@ export declare const TOOL_METADATA: {
     };
     retrieve_summary: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_finding_validator" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "spec_writer")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_finding_validator" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "spec_writer")[];
         prWorkflow: {
             modes: ("PR_REVIEW" | "PR_FEEDBACK")[];
             capability: "observe";
@@ -315,7 +315,7 @@ export declare const TOOL_METADATA: {
     };
     extract_code_blocks: {
         description: string;
-        agents: ("coder" | "test_engineer" | "docs" | "docs_design" | "designer" | "spec_writer")[];
+        agents: ("test_engineer" | "coder" | "docs" | "docs_design" | "designer" | "spec_writer")[];
     };
     phase_complete: {
         description: string;
@@ -395,7 +395,7 @@ export declare const TOOL_METADATA: {
     };
     knowledge_recall: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_oversight" | "critic_finding_validator" | "explorer" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "curator_init" | "curator_phase" | "skill_improver" | "spec_writer")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_oversight" | "critic_finding_validator" | "explorer" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "curator_init" | "curator_phase" | "skill_improver" | "spec_writer")[];
     };
     knowledge_remove: {
         description: string;
@@ -411,11 +411,11 @@ export declare const TOOL_METADATA: {
     };
     search: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic_oversight" | "critic_finding_validator" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer" | "critic_hallucination_verifier" | "skill_improver" | "spec_writer")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic_oversight" | "critic_finding_validator" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer" | "critic_hallucination_verifier" | "skill_improver" | "spec_writer")[];
     };
     ast_grep: {
         description: string;
-        agents: ("coder" | "test_engineer" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "critic_hallucination_verifier" | "spec_writer")[];
+        agents: ("test_engineer" | "coder" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "critic_hallucination_verifier" | "spec_writer")[];
     };
     actionlint_scan: {
         description: string;
@@ -467,7 +467,7 @@ export declare const TOOL_METADATA: {
     };
     repo_map: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_oversight" | "critic_finding_validator" | "explorer" | "architect" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_oversight" | "critic_finding_validator" | "explorer" | "architect" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor")[];
         prWorkflow: {
             modes: ("PR_REVIEW" | "PR_FEEDBACK")[];
             capability: "observe";
@@ -535,7 +535,7 @@ export declare const TOOL_METADATA: {
     };
     knowledge_receipt: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_finding_validator" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "curator_init" | "curator_phase" | "skill_improver" | "spec_writer")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_finding_validator" | "architect" | "sme" | "docs" | "docs_design" | "designer" | "critic_sounding_board" | "critic_drift_verifier" | "critic_hallucination_verifier" | "critic_architecture_supervisor" | "curator_init" | "curator_phase" | "skill_improver" | "spec_writer")[];
     };
     knowledge_archive: {
         description: string;
@@ -555,7 +555,7 @@ export declare const TOOL_METADATA: {
     };
     swarm_command: {
         description: string;
-        agents: ("coder" | "reviewer" | "test_engineer" | "critic" | "critic_finding_validator" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer")[];
+        agents: ("reviewer" | "test_engineer" | "coder" | "critic" | "critic_finding_validator" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer")[];
     };
     dispatch_lanes: {
         description: string;
@@ -571,7 +571,7 @@ export declare const TOOL_METADATA: {
     };
     summarize_work: {
         description: string;
-        agents: ("coder" | "test_engineer" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer")[];
+        agents: ("test_engineer" | "coder" | "explorer" | "architect" | "sme" | "researcher" | "docs" | "docs_design" | "designer")[];
     };
     write_architecture_supervisor_evidence: {
         description: string;
@@ -607,7 +607,7 @@ export declare const TOOL_METADATA: {
     };
     swarm_apply_patch: {
         description: string;
-        agents: ("coder" | "test_engineer")[];
+        agents: ("test_engineer" | "coder")[];
     };
     external_skill_discover: {
         description: string;

package/dist/tools/update-task-status.d.ts

@@ -84,16 +84,6 @@ export interface ReviewerGateResult {
     nextAction?: string;
 }
 declare function hasPassedDurableGateEvidence(workingDirectory: string, taskId: string): boolean;
-/**
- * Check if a task has passed required QA gates using the state machine.
- * Requires the task to be in 'tests_run' or 'complete' state, which means
- * both reviewer delegation and test_engineer runs have been recorded.
- * @param taskId - The task ID to check gate state for
- * @param workingDirectory - Optional working directory for plan.json fallback
- * @param stageBParallelEnabled - When true, also accept both-markers-present as passing (PR 2 barrier)
- * @param sessionID - Optional session ID to scope Lean Turbo bypass to the current tool-execution context
- * @returns ReviewerGateResult indicating whether the gate is blocked
- */
 export declare function checkReviewerGate(taskId: string, workingDirectory?: string, stageBParallelEnabled?: boolean, sessionID?: string, fallbackDir?: string): ReviewerGateResult;
 /**
  * Wrapper around checkReviewerGate that appends a diff-scope advisory warning.

package/dist/tools/write-pr-review-artifact.d.ts

@@ -2,6 +2,7 @@ import { z } from 'zod';
 import type { FindingsSeverity } from '../background/candidate-contract.js';
 import { PrReviewFindingSchema } from '../background/pr-review-contract.js';
 import { assertPrReviewArtifactBoundary } from '../hooks/pr-workflow-gate.js';
+import { type CriticSettlementRecord } from '../pr-review/finding-policy.js';
 import { createSwarmTool } from './create-tool.js';
 /**
  * READ shape. Deliberately tolerant of a missing `severity`: `readFindings`
@@ -22,9 +23,15 @@ export declare const _internals: {
     atomicWrite: typeof atomicWrite;
     atomicCreate: typeof atomicCreate;
     assertBoundary: typeof assertPrReviewArtifactBoundary;
+    assertCriticSettlements: typeof assertCriticSettlements;
     /** Exposed so the #2383 read/migration boundary is testable directly. */
     readFindings: typeof readFindings;
 };
+type FindingsRecord = z.infer<typeof PrReviewFindingSchema>;
+declare function assertCriticSettlements(records: readonly FindingsRecord[], existing: readonly PersistedFinding[], authoritativeCriticVerdicts: ReadonlyMap<string, {
+    status: string;
+    severity: string;
+}>): CriticSettlementRecord[];
 export declare function executeWritePrReviewArtifact(args: unknown, directory: string, context?: {
     sessionID?: string;
 }): Promise<string>;