opencode-swarm 7.173.1 → 7.175.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/pr-review/types.d.ts

@@ -155,6 +155,14 @@ export type PrReviewEvent = {
     semanticEnvelopeDigest: string;
     outcome: 'CLEAN' | 'FINDINGS' | 'INCOMPLETE';
     existingReceiptDigest?: string | undefined;
+    /**
+     * Provenance marker on the reducer event. Currently no consumer reads
+     * this field — the durable provenance record is the receipt-side
+     * `submittedBy` / `submittedByParentSessionId` (see
+     * `PrReviewResultReceiptSchema`). Kept for ledger parity with the
+     * receipt.
+     */
+    submittedBy?: 'workflow_parent' | undefined;
 } | {
     type: 'circuit_advance_requested';
     nowMs: number;

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/dispatch-lanes.d.ts

@@ -364,6 +364,7 @@ export declare const _internals: {
 };
 export declare const _test_exports: {
     validatePrReviewMicroDispatch: typeof validatePrReviewMicroDispatch;
+    resolveCollectExpectedWorkflowIdentity: typeof resolveCollectExpectedWorkflowIdentity;
     applyCommonPrompt: typeof applyCommonPrompt;
     applyExplorerFormatSuffix: typeof applyExplorerFormatSuffix;
     applyPrWorkflowPromptContract: typeof applyPrWorkflowPromptContract;
@@ -526,6 +527,34 @@ type LaneDiagnostics = Map<string, Set<string>>;
  */
 declare function assembleCollectionDiagnostics(hostTimeouts: ReadonlySet<string>, settleFailureLogs: LaneDiagnostics, collectionResourceFailures: LaneDiagnostics): string[];
 declare function addLaneDiagnostic(diagnostics: LaneDiagnostics, laneLabel: string, message: string): void;
+/**
+ * Issue #2585 live-proof defect (found by AC11 case-01 against the real host,
+ * present byte-identically on main 3ea01cbc7): the collect-time discovery
+ * validation built its `expected` WITHOUT the workflow identity triple, so
+ * `validateExactStructuredReceiptCoverage` rejected EVERY child-submitted
+ * structured receipt with `missing live workflow instance/revision/base
+ * identity` — deterministic, prompt-insensitive, unrepairable from the
+ * orchestrator — and every base dimension settled as a contract failure
+ * (NO_COVERAGE → forced INCOMPLETE). The dispatch-side record carries the
+ * instance (jobId binding) and revision (workflowGeneration); the live gate
+ * state of the dispatching parent carries the merge-base. Derive the triple
+ * from those two authoritative sources instead of leaving it undefined.
+ *
+ * Pure: exported through `_test_exports` for the regression test. Returns
+ * undefined whenever any leg is missing — callers then keep the validator's
+ * explicit missing-identity rejection (today's behavior) rather than guessing.
+ */
+/** Minimal structural slice of the PR_REVIEW gate state the identity needs. */
+interface PrReviewCollectParentStateSlice {
+    mode?: string;
+    workflowInstanceId?: string;
+    prReviewBaseSha?: string;
+}
+export declare function resolveCollectExpectedWorkflowIdentity(record: BackgroundDelegationRecord, parentState: PrReviewCollectParentStateSlice | null): {
+    workflowInstanceId: string;
+    workflowRevision: number;
+    baseSha: string;
+} | undefined;
 declare function consumePrReviewReceiptAppendFailureLog(loggedFailures: Set<string>, parentSessionId: string, correlationId: string): boolean;
 declare function startAsyncLanePrompt(args: {
     session: SessionOps;