opencode-swarm 7.140.4 → 7.140.6

package/dist/cli/{worktree-collision-ownership-f28r473k.js → worktree-collision-ownership-wm5pse49.js}

@@ -1,27 +1,27 @@
 // @bun
+import {
+  scanWorktreeMergeFailuresForRecovery
+} from "./index-zsrtt42s.js";
 import {
   WORKTREE_PROVISIONING_OWNER_LEASE_MS,
   removeWorktreeProvisioningOwner,
   scanWorktreeProvisioningOwnersForRecovery
-} from "./index-1kyex7z2.js";
-import {
-  scanWorktreeMergeFailuresForRecovery
-} from "./index-b8zgtz81.js";
+} from "./index-qwm6vdyv.js";
 import {
   scanDelegationFallbacksForRecovery,
   scanDelegationsForRecovery
-} from "./index-rrb6cz2f.js";
+} from "./index-s1v0wza5.js";
 import"./index-k46me75h.js";
 import"./index-ee3x66a5.js";
-import"./index-ed5ykebp.js";
-import"./index-35qep0v7.js";
+import"./index-912qz4y0.js";
 import"./index-7g4c7s5r.js";
+import"./index-ed5ykebp.js";
 import {
   bunSpawn
 } from "./index-4nt52yr9.js";
 import"./index-zgwm4ryv.js";
 import"./index-zjygnfay.js";
-import"./index-bfhwtdsw.js";
+import"./index-epvhf50h.js";
 import"./index-bpmtbmy9.js";
 import"./index-a76rekgs.js";
 

package/dist/cli/worktree-isolation-zgk7314k.js

@@ -0,0 +1,102 @@
+// @bun
+import {
+  MAX_TRACKED_STANDARD_WORKTREE_CALLS,
+  _internals,
+  abortStandardWorktreeDispatch,
+  awaitingMergeByCallID,
+  checkStandardWorktreeSerializationRelease,
+  cleanupStandardWorktreeForCallId,
+  computeLaneRuntimeProfile,
+  finishStandardWorktreeDispatch,
+  isLaneOwnedByCurrentSession,
+  parseLeanLaneIndex,
+  preProvisionCollisionCheck,
+  precreateStandardWorktreeSession,
+  preserveBackgroundWorktreeOwnershipForCallId,
+  preserveDirtyWorktreeAtPath,
+  preserveDirtyWorktreeForCallId,
+  readLaneEnvFileFromDisk,
+  resetStandardWorktreeIsolationState,
+  sanitizeWorktreeTaskId,
+  standardWorktreeByCallID,
+  standardWorktreeSerializationSessions
+} from "./index-nakkgkkt.js";
+import"./index-4905hd2m.js";
+import"./index-41hkt36g.js";
+import"./index-c432knmy.js";
+import"./index-1p72dtym.js";
+import"./index-c8s9a3zh.js";
+import"./index-p2ty3eee.js";
+import"./index-56rqw2hs.js";
+import"./index-134d35c1.js";
+import"./index-t5pytnca.js";
+import"./index-y8552snf.js";
+import"./index-9ss2m4rs.js";
+import"./index-74hpm6sh.js";
+import"./index-z3s0a44b.js";
+import"./index-z0z9pe7b.js";
+import"./index-h01wb18g.js";
+import"./index-v2xrer41.js";
+import"./index-m9xrdjn0.js";
+import"./index-bjqpdr83.js";
+import"./index-556ja8an.js";
+import"./index-4zxrkk1h.js";
+import"./index-zsrtt42s.js";
+import"./index-dtqjxfw9.js";
+import"./index-qwm6vdyv.js";
+import"./index-tjqzr3jc.js";
+import"./index-s1v0wza5.js";
+import"./index-8fwhhayc.js";
+import"./index-q1exe2b3.js";
+import"./index-92n3d5ky.js";
+import"./index-k46me75h.js";
+import"./index-ee3x66a5.js";
+import"./index-y9q9f6ms.js";
+import"./index-qy1nq52t.js";
+import"./index-rtry5xyf.js";
+import"./index-fejfzy2j.js";
+import"./index-ae75rja9.js";
+import"./index-vh05t3w5.js";
+import"./index-p8kk34am.js";
+import"./index-912qz4y0.js";
+import"./index-7g4c7s5r.js";
+import"./index-ed5ykebp.js";
+import"./index-4nt52yr9.js";
+import {
+  resolveWorktreeIsolationConfig
+} from "./index-p04qrwck.js";
+import"./index-gprxjmm7.js";
+import"./index-n832052r.js";
+import"./index-zd4qhnr7.js";
+import"./index-4rhhvd1a.js";
+import"./index-zgwm4ryv.js";
+import"./index-thp186x0.js";
+import"./index-jqsfsqbx.js";
+import"./index-zjygnfay.js";
+import"./index-bk5tah7q.js";
+import"./index-epvhf50h.js";
+import"./index-bpmtbmy9.js";
+import"./index-a76rekgs.js";
+export {
+  standardWorktreeSerializationSessions,
+  standardWorktreeByCallID,
+  sanitizeWorktreeTaskId,
+  resolveWorktreeIsolationConfig,
+  resetStandardWorktreeIsolationState,
+  readLaneEnvFileFromDisk,
+  preserveDirtyWorktreeForCallId,
+  preserveDirtyWorktreeAtPath,
+  preserveBackgroundWorktreeOwnershipForCallId,
+  precreateStandardWorktreeSession,
+  preProvisionCollisionCheck,
+  parseLeanLaneIndex,
+  isLaneOwnedByCurrentSession,
+  finishStandardWorktreeDispatch,
+  computeLaneRuntimeProfile,
+  cleanupStandardWorktreeForCallId,
+  checkStandardWorktreeSerializationRelease,
+  awaitingMergeByCallID,
+  abortStandardWorktreeDispatch,
+  _internals,
+  MAX_TRACKED_STANDARD_WORKTREE_CALLS
+};

package/dist/cli/worktree-provisioning-owner-sjh7te1h.js

@@ -0,0 +1,22 @@
+// @bun
+import {
+  WORKTREE_LIFECYCLE_LOCK_FILE,
+  WORKTREE_PROVISIONING_OWNER_LEASE_MS,
+  recordWorktreeProvisioningOwner,
+  removeWorktreeProvisioningOwner,
+  scanWorktreeProvisioningOwnersForRecovery
+} from "./index-qwm6vdyv.js";
+import"./index-k46me75h.js";
+import"./index-ee3x66a5.js";
+import"./index-ed5ykebp.js";
+import"./index-4nt52yr9.js";
+import"./index-zgwm4ryv.js";
+import"./index-zjygnfay.js";
+import"./index-a76rekgs.js";
+export {
+  scanWorktreeProvisioningOwnersForRecovery,
+  removeWorktreeProvisioningOwner,
+  recordWorktreeProvisioningOwner,
+  WORKTREE_PROVISIONING_OWNER_LEASE_MS,
+  WORKTREE_LIFECYCLE_LOCK_FILE
+};

package/dist/commands/acknowledge-spec-drift.d.ts

@@ -5,13 +5,12 @@
  * the resulting event mis-attributed the action. Callers now pass an
  * explicit actor so events.jsonl can distinguish the legitimate paths
  * ('user' from chat slash command, 'cli' from a real terminal) from any
- * unidentified caller ('unknown'). The Bash guardrail
- * (`src/hooks/guardrails.ts` section 23) blocks the agent-shell bypass at
- * the runtime layer; this parameter exists for forensic clarity.
+ * unidentified caller ('unknown').
  */
 export type SpecDriftAcknowledgedBy = 'user' | 'cli' | 'unknown';
 /**
- * Handle /swarm acknowledge-spec-drift command
- * Acknowledges and clears a previously detected spec drift staleness warning
+ * Handle /swarm acknowledge-spec-drift command.
+ * Acknowledges a previously detected spec-drift marker after reconciling
+ * plan hash, snapshot, and audit state in a retry-safe order.
  */
 export declare function handleAcknowledgeSpecDriftCommand(directory: string, _args: string[], acknowledgedBy?: SpecDriftAcknowledgedBy): Promise<string>;

package/dist/config/evidence-schema.d.ts

@@ -228,8 +228,8 @@ export declare const RetrospectiveEvidenceSchema: z.ZodObject<{
         }>;
         scope: z.ZodEnum<{
             global: "global";
-            session: "session";
             project: "project";
+            session: "session";
         }>;
     }, z.core.$strip>>>;
     approaches_tried: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -751,8 +751,8 @@ export declare const EvidenceSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         }>;
         scope: z.ZodEnum<{
             global: "global";
-            session: "session";
             project: "project";
+            session: "session";
         }>;
     }, z.core.$strip>>>;
     approaches_tried: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -1241,8 +1241,8 @@ export declare const EvidenceBundleSchema: z.ZodObject<{
             }>;
             scope: z.ZodEnum<{
                 global: "global";
-                session: "session";
                 project: "project";
+                session: "session";
             }>;
         }, z.core.$strip>>>;
         approaches_tried: z.ZodDefault<z.ZodArray<z.ZodObject<{

package/dist/config/index.d.ts

@@ -17,8 +17,8 @@ import { loadPluginConfigWithMeta } from './loader';
 export declare const _internals: {
     loadPluginConfigWithMeta: typeof loadPluginConfigWithMeta;
 };
-export type { MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskStatus, } from './plan-schema';
-export { MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
+export type { ExecutionProfile, MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskStatus, } from './plan-schema';
+export { ExecutionProfileSchema, MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
 export type { AgentOverrideConfig, ApplyPatchConfig, AutomationCapabilities, AutomationConfig, AutomationMode, AutoReviewBurnInDecision, AutoReviewConfig, AutoReviewReleaseContext, LeanTurboConfig, MemoryConfig, ModelPricingConfig, PhaseCompleteConfig, PipelineConfig, PluginConfig, PricingConfig, RepoGraphConfig, SkillPropagationConfig, SwarmConfig, TurboConfig, WorktreeIsolationConfig, } from './schema';
 export { AgentOverrideConfigSchema, ApplyPatchConfigSchema, AUTO_REVIEW_V8_BURN_IN_DECISION, AutomationCapabilitiesSchema, AutomationConfigSchema, AutomationModeSchema, AutoReviewConfigSchema, LeanTurboConfigSchema, MemoryConfigSchema, ModelPricingConfigSchema, PhaseCompleteConfigSchema, PipelineConfigSchema, PluginConfigSchema, PricingConfigSchema, RepoGraphConfigSchema, resolveAutoReviewConfig, SkillPropagationConfigSchema, SwarmConfigSchema, TurboConfigSchema, WorktreeIsolationConfigSchema, } from './schema';
 export type { DeltaSpec, Obligation, SpecDelta, SpecRequirement, SpecScenario, SpecSection, SwarmSpec, } from './spec-schema';

package/dist/config/plan-schema.d.ts

@@ -6,6 +6,10 @@ export declare const ExecutionProfileSchema: z.ZodObject<{
     locked: z.ZodDefault<z.ZodBoolean>;
     auto_proceed: z.ZodDefault<z.ZodBoolean>;
     commit_after_each_completed_task: z.ZodDefault<z.ZodBoolean>;
+    planning_profile: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        strict: "strict";
+    }>>;
 }, z.core.$strip>;
 export type ExecutionProfile = z.infer<typeof ExecutionProfileSchema>;
 export declare const TaskStatusSchema: z.ZodEnum<{
@@ -173,6 +177,10 @@ export declare const PlanSchema: z.ZodObject<{
         locked: z.ZodDefault<z.ZodBoolean>;
         auto_proceed: z.ZodDefault<z.ZodBoolean>;
         commit_after_each_completed_task: z.ZodDefault<z.ZodBoolean>;
+        planning_profile: z.ZodOptional<z.ZodEnum<{
+            balanced: "balanced";
+            strict: "strict";
+        }>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type Plan = z.infer<typeof PlanSchema>;

package/dist/config/schema.d.ts

@@ -359,8 +359,8 @@ export declare const PhaseCompleteConfigSchema: z.ZodObject<{
     enabled: z.ZodDefault<z.ZodBoolean>;
     required_agents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
         reviewer: "reviewer";
-        test_engineer: "test_engineer";
         coder: "coder";
+        test_engineer: "test_engineer";
     }>>>;
     require_docs: z.ZodDefault<z.ZodBoolean>;
     policy: z.ZodDefault<z.ZodEnum<{
@@ -1770,8 +1770,8 @@ export declare const PluginConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         required_agents: z.ZodDefault<z.ZodArray<z.ZodEnum<{
             reviewer: "reviewer";
-            test_engineer: "test_engineer";
             coder: "coder";
+            test_engineer: "test_engineer";
         }>>>;
         require_docs: z.ZodDefault<z.ZodBoolean>;
         policy: z.ZodDefault<z.ZodEnum<{

package/dist/council/council-evidence-writer.d.ts

@@ -24,5 +24,5 @@ import type { CouncilSynthesis } from './types';
 export declare const _internals: {
     withTaskEvidenceLock: typeof withTaskEvidenceLock;
 };
-export declare function writeCouncilEvidence(workingDir: string, synthesis: CouncilSynthesis, attemptId?: string): Promise<void>;
+export declare function writeCouncilEvidence(workingDir: string, synthesis: CouncilSynthesis, attemptId?: string, expectedGeneration?: number): Promise<void>;
 export declare function hasCouncilEvidenceAttempt(workingDir: string, taskId: string, attemptId: string, roundNumber: number): boolean;

package/dist/gate-evidence.d.ts

@@ -15,11 +15,30 @@
  * authorization against a process with arbitrary same-user workspace access;
  * that requires a protected trust root outside the project workspace.
  */
+import type { TaskWorkflowState } from './state';
 export interface GateEvidence {
     sessionId: string;
     timestamp: string;
     agent: string;
 }
+export declare const TASK_WORKFLOW_SCHEMA_MARKER: "exact-task-v1";
+declare const TASK_WORKFLOW_OUTCOMES: readonly ["none", "dispatch_attempted", "dispatch_no_mutation", "accepted_mutation", "accepted_mutation_failed", "stage_a_passed", "stage_a_failed", "stage_b_completed", "stage_b_failed", "gate_recorded", "task_completed", "task_blocked", "repair_idle"];
+export type TaskWorkflowTransitionOutcome = (typeof TASK_WORKFLOW_OUTCOMES)[number];
+export interface TaskWorkflowMetadata {
+    schema: typeof TASK_WORKFLOW_SCHEMA_MARKER;
+    generation: number;
+    state: TaskWorkflowState;
+    retryCount: number;
+    retryHistory: TaskWorkflowTransitionOutcome[];
+    /** Stable circuit-breaker cycle across accepted repair mutations. */
+    retryEpoch: number;
+    lastOutcome: TaskWorkflowTransitionOutcome;
+    lastTransitionId: string | null;
+    updatedAt: string;
+}
+export interface TaskWorkflowSnapshot extends TaskWorkflowMetadata {
+    authoritative: boolean;
+}
 export interface TaskEvidence {
     taskId: string;
     required_gates: string[];
@@ -27,11 +46,90 @@ export interface TaskEvidence {
     turbo?: boolean;
     /** Durable proof that the coder dispatch was classified as exact Markdown-only. */
     test_engineer_exempt?: boolean;
+    /** Exact-task workflow metadata. Missing on legacy evidence written before #2098. */
+    workflow?: TaskWorkflowMetadata;
+}
+/**
+ * Fence ordinary evidence writers while a terminal or repair plan/evidence
+ * transaction is PREPARED. Only the owning WAL transition may proceed.
+ */
+export declare function assertTaskEvidenceWriteAllowed(directory: string, taskId: string, event?: TaskWorkflowTransitionEvent): void;
+export type TaskWorkflowTransitionEvent = {
+    type: 'dispatch_attempted';
+    agentType?: string;
+    context?: GateDerivationContext;
+    turbo?: boolean;
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'dispatch_no_mutation';
+    agentType?: string;
+    context?: GateDerivationContext;
+    turbo?: boolean;
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'accepted_mutation';
+    agentType?: string;
+    context?: GateDerivationContext;
+    turbo?: boolean;
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'stage_a_passed';
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'stage_a_failed';
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'stage_b_completed';
+    gate: 'reviewer' | 'test_engineer';
+    sessionId: string;
+    turbo?: boolean;
+    ensureDefaultStageB?: boolean;
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'stage_b_failed';
+    gate: 'reviewer' | 'test_engineer';
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'gate_recorded';
+    gate: string;
+    sessionId: string;
+    turbo?: boolean;
+    expectedGeneration?: number;
+    transitionId?: string;
+} | {
+    type: 'task_completed';
+    /** Locked plan phase explicitly declares that reviewer QA is not required. */
+    qaExempt?: boolean;
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'task_blocked';
+    expectedGeneration: number;
+    transitionId?: string;
+} | {
+    type: 'repair_idle';
+    expectedGeneration: number;
+    transitionId?: string;
+};
+export interface TaskEvidenceTransaction {
+    taskId: string;
+    read(): TaskEvidence | null;
+    transition(event: TaskWorkflowTransitionEvent): Promise<TaskEvidence>;
 }
+export declare function parseTaskEvidence(raw: string, expectedTaskId: string): TaskEvidence;
 export declare const DEFAULT_REQUIRED_GATES: string[];
 export interface GateDerivationContext {
     /** Trusted pre/post workspace classification; false/absent fails closed. */
     testEngineerExempt?: boolean;
+    /** The shared-root coder changed files but returned a failed/cancelled result. */
+    settlementFailed?: boolean;
 }
 /**
  * Canonical task-id validation helper.
@@ -39,6 +137,12 @@ export interface GateDerivationContext {
  * Re-exported for backward compatibility with existing callers.
  */
 export declare function isValidTaskId(taskId: string): boolean;
+export declare function getTaskWorkflowSnapshot(evidence: TaskEvidence | null | undefined): TaskWorkflowSnapshot;
+export declare function reduceTaskWorkflowSnapshot(current: TaskWorkflowSnapshot, event: TaskWorkflowTransitionEvent, context: {
+    requiredGates: string[];
+    gates: Record<string, GateEvidence>;
+    nowIso: string;
+}): TaskWorkflowMetadata;
 /**
  * Maps the first-dispatched agent type to the initial required_gates array.
  * Unknown agent types fall back to the safe default ["reviewer", "test_engineer"].
@@ -49,17 +153,24 @@ export declare function deriveRequiredGates(agentType: string, context?: GateDer
  * Sorted, deduplicated. Gates can only grow, never shrink.
  */
 export declare function expandRequiredGates(existingGates: string[], newAgentType: string, context?: GateDerivationContext): string[];
+export declare function transitionTaskWorkflowEvidence(directory: string, taskId: string, event: TaskWorkflowTransitionEvent): Promise<TaskEvidence>;
+export declare function withTaskEvidenceTransaction<T>(directory: string, taskId: string, agent: string, callback: (transaction: TaskEvidenceTransaction) => Promise<T>): Promise<T>;
 /**
  * Creates or updates .swarm/evidence/{taskId}.json with a gate pass entry.
  * If file doesn't exist: creates with required_gates from deriveRequiredGates(gate).
  * If file exists: merges gate entry, expands required_gates via expandRequiredGates.
  * Atomic write: temp file + rename.
  */
-export declare function recordGateEvidence(directory: string, taskId: string, gate: string, sessionId: string, turbo?: boolean): Promise<void>;
+export declare function recordGateEvidence(directory: string, taskId: string, gate: string, sessionId: string, turbo?: boolean, options?: {
+    expectedGeneration?: number;
+    transitionId?: string;
+    ensureDefaultStageB?: boolean;
+}): Promise<void>;
 /**
- * Sets or expands required_gates WITHOUT recording a gate pass.
- * Used when non-gate agents are dispatched (coder, explorer, sme, etc.).
- * Creates evidence file if it doesn't exist yet.
+ * Compatibility API for a settled non-gate dispatch. Coder callers represent
+ * an accepted mutation and therefore rotate the workflow generation; mere
+ * attempts must call `transitionTaskWorkflowEvidence(dispatch_attempted)` and
+ * failed/no-op settlements must use `dispatch_no_mutation` instead.
  */
 export declare function recordAgentDispatch(directory: string, taskId: string, agentType: string, turbo?: boolean, context?: GateDerivationContext): Promise<void>;
 /**
@@ -78,3 +189,5 @@ export declare function readTaskEvidenceRaw(directory: string, taskId: string):
  * Returns false if no evidence file exists.
  */
 export declare function hasPassedAllGates(directory: string, taskId: string): Promise<boolean>;
+export declare function compareTaskWorkflowStateRank(left: TaskWorkflowState, right: TaskWorkflowState): number;
+export {};

package/dist/hooks/delegation-gate.d.ts

@@ -6,6 +6,8 @@
  */
 import type { BackgroundDelegationRecord } from '../background/pending-delegations.js';
 import type { PluginConfig } from '../config';
+import type { Plan } from '../config/plan-schema';
+import { type QaGates } from '../db/qa-gate-profile.js';
 import { loadPlanJsonOnly } from '../plan/manager';
 import type { AgentSessionState } from '../state';
 import type { DelegationEnvelope, EnvelopeValidationResult } from '../types/delegation.js';
@@ -282,6 +284,18 @@ declare function extractPlanCriticVerdict(output: unknown): 'APPROVED' | 'NEEDS_
  * approval. Does not throw — returns `false` for any failure (fail-closed).
  */
 export declare function isPlanCriticApproved(directory: string): Promise<boolean>;
+/**
+ * Resolve the effective critic-pre-plan policy for coder execution.
+ *
+ * Missing or unreadable profiles preserve the historical default (`true`). A
+ * persisted `false` is honored, while session overrides can only ratchet it
+ * back to `true` through `getEffectiveGates`.
+ */
+export interface PlanCriticPolicyDecision {
+    required: boolean;
+    source: 'persisted_profile' | 'session_ratchet' | 'default_missing_profile' | 'corrupt_profile_conservative';
+}
+export declare function resolvePlanCriticPolicyForExecution(directory: string, plan: Plan, sessionOverrides?: Partial<QaGates>): PlanCriticPolicyDecision;
 /**
  * Escape hatch for the ratchet-tighter `critic_pre_plan` gate (issue #2012).
  *
@@ -348,6 +362,13 @@ declare function describeCoderScopeFailure(args: Record<string, unknown>, planTa
  * @returns Map of taskId -> verdict string
  */
 export declare function parsePerTaskVerdicts(outputText: string): Map<string, string>;
+export declare function canRunWhileTaskAwaitsCompletion(input: {
+    directory: string | undefined;
+    normalizedTool: string;
+    args: Record<string, unknown>;
+    awaitingTaskId: string;
+    requestedTaskId: string | null;
+}): boolean;
 declare function buildParallelExecutionGuidance(directory: string | undefined, sessionID: string, session: AgentSessionState): Promise<string | null>;
 /**
  * Resolves the correct task ID for evidence recording by chaining:

package/dist/hooks/pr-workflow-gate.d.ts

@@ -555,6 +555,8 @@ export declare const _test_exports: {
     extractCandidateIds: typeof extractCandidateIds;
     parseCanonicalCandidateRows: typeof parseCanonicalCandidateRows;
     resolvePrReviewRowFamily: typeof resolvePrReviewRowFamily;
+    pipeFieldsCapped: typeof pipeFieldsCapped;
+    reviewerVerdictRowDigest: typeof reviewerVerdictRowDigest;
     workflowGateStateRelativePath: typeof workflowGateStateRelativePath;
     workflowGateStateLockRelativePath: typeof workflowGateStateLockRelativePath;
     workflowCheckoutMutationLockRelativePath: typeof workflowCheckoutMutationLockRelativePath;
@@ -843,10 +845,28 @@ declare function analyzePrReviewBatchRecordIntegrity(args: {
 export declare function validatePrReviewDiscoveryLaneCompletion(input: PrReviewDiscoveryLaneValidationInput): PrReviewLaneValidationResult;
 /** Require at least one semantically valid discovery row or CLEAN attestation. */
 export declare function prReviewDiscoveryArtifactCoversLane(text: string, expectedWorkflowLane: string, ownedWorkflowLanes?: readonly string[], mode?: string): boolean;
+/**
+ * Digest of the FULL canonical reviewer row, not the classification/severity
+ * pair a reviewer verdict projects to. Only 2 of the 10 required fields survive
+ * that projection, so a tuple binding would still match a row whose evidence,
+ * file:line and root cause all changed. Fields are joined on NUL, which
+ * `pipeFields` can never produce, so no field boundary is forgeable.
+ */
+declare function reviewerVerdictRowDigest(fields: readonly string[]): string;
 declare function parseCriticVerdict(text: string, itemId: string, reviewerSeverity?: string): {
     status: string;
     severity: string;
 } | null;
+/**
+ * `pipeFields` capped at the row's canonical field count: separators beyond the
+ * expected count merge back into the trailing (free-text) field. Verdict rows
+ * ([REVIEWED], [CRITIC], [FEEDBACK-VERIFIED]) carry prose evidence in their
+ * last field, and prose containing literal pipes (regex text, `,;|`, shell
+ * snippets) otherwise splits the row past its strict field-count check and the
+ * whole verdict becomes unparseable. Deterministic: the enumerated leading
+ * fields are never merged.
+ */
+declare function pipeFieldsCapped(line: string, expectedFieldCount: number): string[];
 declare function workflowCheckoutMutationLockRelativePath(): string;
 declare function openCheckoutLockFile(lockPath: string): Promise<fsp.FileHandle>;
 declare function removeCheckoutLockFile(lockPath: string): Promise<void>;