opencode-swarm 7.140.3 → 7.140.5

package/dist/cli/worktree-isolation-bwc6ra8e.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-z90nvqj3.js";
+import"./index-4905hd2m.js";
+import"./index-41hkt36g.js";
+import"./index-c432knmy.js";
+import"./index-ptn13xjn.js";
+import"./index-c8s9a3zh.js";
+import"./index-z7h37d63.js";
+import"./index-2bg901qt.js";
+import"./index-134d35c1.js";
+import"./index-t5pytnca.js";
+import"./index-y8552snf.js";
+import"./index-9ss2m4rs.js";
+import"./index-74hpm6sh.js";
+import"./index-kb5q9v34.js";
+import"./index-e0mpz2j3.js";
+import"./index-ztgn70jz.js";
+import"./index-v2xrer41.js";
+import"./index-m9xrdjn0.js";
+import"./index-wkt9fj06.js";
+import"./index-556ja8an.js";
+import"./index-wrb0gykj.js";
+import"./index-zsrtt42s.js";
+import"./index-8rp1y4ab.js";
+import"./index-qwm6vdyv.js";
+import"./index-tjqzr3jc.js";
+import"./index-s1v0wza5.js";
+import"./index-8fwhhayc.js";
+import"./index-q1exe2b3.js";
+import"./index-affh1gtg.js";
+import"./index-k46me75h.js";
+import"./index-ee3x66a5.js";
+import"./index-386ts4tm.js";
+import"./index-qy1nq52t.js";
+import"./index-rtry5xyf.js";
+import"./index-01ggt2mj.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-nyjtzmsj.js";
+import"./index-gprxjmm7.js";
+import"./index-n832052r.js";
+import"./index-nwrwy8eb.js";
+import"./index-4rhhvd1a.js";
+import"./index-zgwm4ryv.js";
+import"./index-jm4cpp4n.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/commands/ci-simulate.d.ts

@@ -14,20 +14,24 @@
  * merge-queue kick-outs.
  *
  * Input contract:
- *   /swarm ci-simulate              → uses current HEAD branch
- *   /swarm ci-simulate <pr-ref>     → uses the specified branch/ref
+ *   /swarm ci-simulate                        → uses current HEAD branch
+ *   /swarm ci-simulate <pr-ref>               → uses the specified branch/ref
+ *   /swarm ci-simulate <pr-ref> --base <ref>  → validated explicit base for
+ *                                               stacked/release-branch PRs
  */
 import * as fs from 'node:fs';
-import { getDefaultBaseBranch } from '../git/branch.js';
+import { detectDefaultRemoteBranch, getDefaultBaseBranch } from '../git/branch.js';
 import { runExternalTool } from '../utils/external-tool-runner.js';
 export declare const _internals: {
     runExternalTool: typeof runExternalTool;
     getDefaultBaseBranch: typeof getDefaultBaseBranch;
+    detectDefaultRemoteBranch: typeof detectDefaultRemoteBranch;
     platform: string;
     osTmpdir: () => string;
     fs: {
         existsSync: typeof fs.existsSync;
         rmSync: typeof fs.rmSync;
+        realpathSync: (p: fs.PathLike) => string;
     };
 };
 /**

package/dist/commands/close.d.ts

@@ -6,6 +6,14 @@ import { createCuratorLLMDelegate } from '../hooks/curator-llm-factory';
 import { runCuratorPostMortem } from '../hooks/curator-postmortem';
 import { checkHivePromotions } from '../hooks/hive-promoter';
 import { curateAndStoreSwarm } from '../hooks/knowledge-curator';
+import { reconcilePhaseClose } from '../hooks/knowledge-receipt-ledger.js';
+/** Narrow seam for receipt/plan ordering tests. */
+export declare const closeReceiptLifecycleInternals: {
+    recordPhaseCloseIntent: (directory: string, phase: string, sessionId?: string, taskId?: string) => Promise<import("../hooks/knowledge-receipt-ledger.js").ReceiptLedgerResult<{
+        event_id: string;
+    }>>;
+    reconcilePhaseClose: typeof reconcilePhaseClose;
+};
 import { runFinalizeRewardSweep } from '../memory/finalize-reward-sweep';
 import { closePlanTerminalState } from '../plan/manager';
 import { type SessionReflectionResult } from '../services/session-reflection';

package/dist/commands/registry.d.ts

@@ -701,8 +701,8 @@ export declare const COMMAND_REGISTRY: {
     readonly 'ci-simulate': {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Create a temporary merge-result worktree and run CI before merge queue entry";
-        readonly args: "[--base origin/main] [--head <ref>]";
-        readonly details: "Creates a detached temporary worktree under .swarm/ci-simulate from the base ref, merges the current worktree HEAD (or --head ref), runs fixed local CI gates (typecheck, Biome CI, build, unit/integration/security/smoke tests, drift check), then removes the worktree and prunes metadata. Intended as a pre-queue merge_group simulation helper.";
+        readonly args: "[pr-ref] [--base <ref>]";
+        readonly details: "Creates a detached temporary worktree under the OS temp dir (swarm-ci-simulate) from the base — an explicit validated --base <ref> when given (stacked/release-branch PRs), otherwise the detected default remote branch (origin/HEAD, init.defaultBranch, origin/main, origin/master, verified to exist) — merges the given PR ref (or the current ref), runs fixed local CI gates (typecheck, lint, build, test), then removes the worktree non-force and prunes metadata. Worktree removal is fail-closed: a blocked or dirty worktree is surfaced, never force-deleted. Intended as a pre-queue merge_group simulation helper.";
         readonly category: "agent";
         readonly toolPolicy: "agent";
     };

package/dist/commands/sdd.d.ts

@@ -16,6 +16,21 @@ interface ParsedSddArgs {
     feature?: string;
     error?: string;
 }
+/**
+ * Returns true when `value` contains characters that are unsafe in a directory
+ * name id: path separators, traversal sequences, bracket characters, or control/bidi
+ * characters.
+ *
+ * Shared by both --change and --feature so the same rejection logic is reused
+ * (task 2.2 explicit requirement; matches the pre-task baseline).
+ */
+/**
+ * Issue #2131 criterion G: the allowed-mutations policy derived from the
+ * effective spec's source kind. Only a native swarm spec may be created,
+ * refined, or archived through the swarm tooling; projected sources
+ * (openspec / speckit) are read-only inputs — refine them in their own tool.
+ */
+export declare function allowedMutationsFor(source: 'swarm' | 'openspec_projection' | 'speckit_projection'): string[];
 declare function parseArgs(args: string[]): ParsedSddArgs;
 export declare function handleSddStatusCommand(directory: string, args: string[]): Promise<string>;
 export declare function handleSddValidateCommand(directory: string, args: string[]): Promise<string>;

package/dist/config/bundled-skills.d.ts

@@ -1,4 +1,4 @@
-export declare const BUNDLED_PROJECT_SKILLS: readonly ["brainstorm", "specify", "clarify-spec", "resume", "clarify", "discover", "consult", "pre-phase-briefing", "council", "deep-dive", "deep-research", "codebase-review-swarm", "swarm-implement", "design-docs", "swarm-pr-review", "swarm", "swarm-pr-feedback", "swarm-pr-subscribe", "swarm-ci-monitor", "issue-ingest", "plan", "critic-gate", "execute", "phase-wrap", "loop", "writing-tests", "running-tests", "engineering-conventions", "commit-pr", "ci-failure-batching", "gate-attribution", "merge-queue-readiness", "skill-edit-validation", "worktree-retry-cleanup", "test-file-split", "fork-pr-operations", "parallel-work-check", "ci-fix-monitor", "issue-tracer"];
+export declare const BUNDLED_PROJECT_SKILLS: readonly ["brainstorm", "specify", "clarify-spec", "resume", "clarify", "discover", "consult", "pre-phase-briefing", "council", "deep-dive", "deep-research", "codebase-review-swarm", "swarm-implement", "design-docs", "swarm-pr-review", "swarm", "swarm-pr-feedback", "swarm-pr-subscribe", "swarm-ci-monitor", "issue-ingest", "plan", "critic-gate", "execute", "phase-wrap", "loop", "writing-tests", "running-tests", "engineering-conventions", "commit-pr", "ci-failure-batching", "gate-attribution", "merge-queue-readiness", "skill-edit-validation", "worktree-retry-cleanup", "test-file-split", "fork-pr-operations", "parallel-work-check", "ci-fix-monitor", "issue-tracer", "orchestrating-subagents", "durable-session-state"];
 export type BundledProjectSkill = (typeof BUNDLED_PROJECT_SKILLS)[number];
 /**
  * Project-private runtime location for plugin-owned skills. Repository-native

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<{
@@ -676,6 +676,7 @@ export declare const KnowledgeConfigSchema: z.ZodObject<{
     evergreen_utility: z.ZodDefault<z.ZodNumber>;
     low_utility_threshold: z.ZodDefault<z.ZodNumber>;
     min_retrievals_for_utility: z.ZodDefault<z.ZodNumber>;
+    receipt_close_grace_days: z.ZodDefault<z.ZodNumber>;
     schema_version: z.ZodDefault<z.ZodNumber>;
     directive_min_confidence: z.ZodDefault<z.ZodNumber>;
     same_project_weight: z.ZodDefault<z.ZodNumber>;
@@ -1769,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<{
@@ -2121,6 +2122,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         evergreen_utility: z.ZodDefault<z.ZodNumber>;
         low_utility_threshold: z.ZodDefault<z.ZodNumber>;
         min_retrievals_for_utility: z.ZodDefault<z.ZodNumber>;
+        receipt_close_grace_days: z.ZodDefault<z.ZodNumber>;
         schema_version: z.ZodDefault<z.ZodNumber>;
         directive_min_confidence: z.ZodDefault<z.ZodNumber>;
         same_project_weight: z.ZodDefault<z.ZodNumber>;

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/git/branch.d.ts

@@ -142,7 +142,7 @@ export interface ResetToRemoteBranchResult {
 /**
  * Detect the default remote branch using multiple fallback methods
  */
-declare function detectDefaultRemoteBranch(cwd: string): string | null;
+export declare function detectDefaultRemoteBranch(cwd: string): string | null;
 /**
  * Reset local branch to align with its remote counterpart.
  * Safely handles uncommitted changes, unpushed commits, and detached HEAD states.

package/dist/hooks/delegate-ack-collector.d.ts

@@ -53,6 +53,11 @@ export interface CollectDelegateAcksResult {
      * promotion evidence.
      */
     unacknowledgedNonCritical: string[];
+    /** Typed authority failure: no V2 mutation was attempted. */
+    unverifiable?: {
+        code: 'missing_session_id';
+        detail: string;
+    };
 }
 /**
  * Core reconciliation used by both the runtime hook and tests. Returns a summary

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/hive-promoter.d.ts

@@ -81,10 +81,9 @@ export declare const _internals: {
     transactHiveStore: typeof transactHiveStore;
     validateLesson: typeof validateLesson;
     authorizeCuration: typeof authorizeCuration;
-    /** (#1849) Loads validated terminal-application evidence per swarm entry id
-     *  from .swarm/knowledge-promotion-evidence.jsonl. Empty when no validated
-     *  receipts exist yet (conservative: no synthetic credit). */
-    loadPromotionEvidence: (directory: string) => Promise<Record<string, PromotionEvidenceRecord[]>>;
+    /** Loads authoritative terminal-application evidence per swarm entry id.
+     *  Empty on receipt-ledger uncertainty (conservative: no synthetic credit). */
+    loadPromotionEvidence: (directory: string, canonicalCohortId?: string) => Promise<Record<string, PromotionEvidenceRecord[]>>;
     /** Loads the default KnowledgeConfig (schema defaults) for manual promotion
      *  paths when the command did not load one. */
     loadDefaultKnowledgeConfig: () => {
@@ -105,6 +104,7 @@ export declare const _internals: {
         evergreen_utility: number;
         low_utility_threshold: number;
         min_retrievals_for_utility: number;
+        receipt_close_grace_days: number;
         schema_version: number;
         directive_min_confidence: number;
         same_project_weight: number;

package/dist/hooks/issue-trace-reducer.d.ts

@@ -55,6 +55,10 @@ export interface WorkflowArtifacts {
     reproductionPermitted: boolean;
     /** A verifiable publication receipt has been observed (issue #2131 2.4). */
     publicationObserved: boolean;
+    /** A valid recurrence-sweep receipt exists (issue #2131 residual B). */
+    recurrenceSweepVerified: boolean;
+    /** Fresh reviewer + critic APPROVE verdicts recorded (issue #2131 residual B). */
+    implementationReviewVerified: boolean;
 }
 export interface TransitionResult {
     nextMode: string | null;
@@ -82,7 +86,9 @@ export interface ComputeNextModeParams {
  *   (f-block) Spec exists, no plan, reproduction NOT permitted → no-op
  *   (g) Plan exists but critic not approved              → no-op
  *   (h) Critic approved, phases incomplete, not yet PLAN_TO_EXECUTE → EXECUTE
- *   (i) All phases complete, not yet EXECUTE_TO_COMMIT   → publication_handoff + COMMIT directive
+ *   (i-pre1) Phases complete, impl-review receipt missing → one-shot REVIEW_GATE directive
+ *   (i-pre2) Impl-review ok, recurrence-sweep receipt missing → one-shot RECURRENCE_GATE directive
+ *   (i) All phases complete + both gates verified, not yet EXECUTE_TO_COMMIT → publication_handoff + COMMIT directive
  *
  * Idempotency: rows (f), (h), (i) return no-op when
  * `traceState.lastTransition` already equals the target transition value.