opencode-swarm 7.200.9 → 7.200.10

package/dist/cli/{index-4ya4krts.js → index-r3wyt8za.js}

@@ -1,35 +1,22 @@
 // @bun
 import {
+  assertSettlementArtifactsRemovable,
   autoCommitDirty,
-  cleanUntrackedFiles
-} from "./index-rdyfrdcp.js";
+  cleanUntrackedFiles,
+  withSettlementArtifactLifecycle
+} from "./index-vm3j8fvn.js";
 import {
   isSpawnCwdMissing,
   isSpawnCwdUnreadable
 } from "./index-spggmr30.js";
-import {
-  validateSwarmPath
-} from "./index-4krkevgc.js";
-import {
-  derivePlanId,
-  derivePlanIdentityHash
-} from "./index-7pmbnjvj.js";
 import {
   init_path_identity,
   isPathWithinDeclaredScope,
   unsafePathTextReason
 } from "./index-9rwhas09.js";
 import {
-  atomicWriteFile,
-  taskEvidencePath,
-  withTaskEvidenceLock
-} from "./index-yyrnkc3a.js";
-import {
-  assertProjectRoot
-} from "./index-t7hmqgjy.js";
-import {
-  telemetry
-} from "./index-c2k7q723.js";
+  atomicWriteFile
+} from "./index-6m551cng.js";
 import {
   advisoryWarn,
   init_git_executable,
@@ -43,368 +30,9 @@ import {
 import {
   log
 } from "./index-zgwm4ryv.js";
-import {
-  exports_external,
-  init_zod
-} from "./index-gknz3bv1.js";
-
-// src/gate-evidence.ts
-init_zod();
-import { createHash as createHash2 } from "crypto";
-import { mkdirSync as mkdirSync3, readFileSync as readFileSync3, realpathSync as realpathSync2, statSync as statSync2 } from "fs";
-import * as path4 from "path";
-
-// src/evidence/task-gate-requirements.ts
-init_zod();
-import { createHash } from "crypto";
-import * as fs from "fs";
-import * as path from "path";
-var MAX_TASK_GATE_REQUIREMENTS_BYTES = 256 * 1024;
-var TaskGateRequirementsReceiptSchema = exports_external.object({
-  schemaVersion: exports_external.literal(1),
-  taskId: exports_external.string().min(1).max(120),
-  generation: exports_external.number().int().min(0),
-  normalizedRole: exports_external.string().min(1).max(120),
-  testEngineerExempt: exports_external.boolean().nullable(),
-  requiredGates: exports_external.array(exports_external.string()).min(1).max(16),
-  sourceEvent: exports_external.string().min(1).max(120),
-  sourceTransitionId: exports_external.string().min(1).max(200).nullable(),
-  recordedAt: exports_external.string().min(1).max(128),
-  routeBinding: exports_external.object({
-    role: exports_external.enum(["reviewer", "test_engineer"]),
-    identity: exports_external.string().trim().min(1).max(256),
-    sessionId: exports_external.string().trim().min(1).max(256),
-    taskId: exports_external.string().trim().min(1).max(120),
-    slotId: exports_external.string().trim().min(1).max(256),
-    callId: exports_external.string().trim().min(1).max(256),
-    childSessionId: exports_external.string().trim().min(1).max(256),
-    generation: exports_external.number().int().nonnegative()
-  }).strict().optional(),
-  previousChainHash: exports_external.string().regex(/^[a-f0-9]{64}$/).nullable(),
-  chainHash: exports_external.string().regex(/^[a-f0-9]{64}$/)
-}).strict();
-function samePath(left, right) {
-  const normalize = (value) => process.platform === "win32" ? path.resolve(value).toLowerCase() : path.resolve(value);
-  return normalize(left) === normalize(right);
-}
-function assertSafeRequirementsParent(directory, create) {
-  assertProjectRoot(directory, undefined, "task gate requirements");
-  const rootStat = fs.lstatSync(directory);
-  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
-    throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: project root is not a regular directory");
-  }
-  const canonicalRoot = fs.realpathSync(directory);
-  const segments = [".swarm", "evidence", "task-gate-requirements"];
-  let current = canonicalRoot;
-  for (const segment of segments) {
-    current = path.join(current, segment);
-    let info;
-    try {
-      info = fs.lstatSync(current);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        if (!create)
-          return current;
-        try {
-          fs.mkdirSync(current);
-        } catch (mkdirError) {
-          if (mkdirError.code !== "EEXIST") {
-            throw mkdirError;
-          }
-        }
-        info = fs.lstatSync(current);
-      } else {
-        throw error;
-      }
-    }
-    if (info.isSymbolicLink() || !info.isDirectory()) {
-      throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt parent is redirected or not a directory");
-    }
-    const canonicalCurrent = fs.realpathSync(current);
-    if (!samePath(canonicalCurrent, current)) {
-      throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt parent escaped the project root");
-    }
-  }
-  return current;
-}
-function safeTaskGateRequirementsReceiptPath(directory, taskId, createParent) {
-  const parent = assertSafeRequirementsParent(directory, createParent);
-  return path.join(parent, `${taskId}.jsonl`);
-}
-function sha256(value) {
-  return createHash("sha256").update(value).digest("hex");
-}
-function canonicalReceiptPayload(receipt) {
-  const routeBinding = receipt.routeBinding ? {
-    role: receipt.routeBinding.role,
-    identity: receipt.routeBinding.identity,
-    sessionId: receipt.routeBinding.sessionId,
-    taskId: receipt.routeBinding.taskId,
-    slotId: receipt.routeBinding.slotId,
-    callId: receipt.routeBinding.callId,
-    childSessionId: receipt.routeBinding.childSessionId,
-    generation: receipt.routeBinding.generation
-  } : undefined;
-  return JSON.stringify({
-    schemaVersion: receipt.schemaVersion,
-    taskId: receipt.taskId,
-    generation: receipt.generation,
-    normalizedRole: receipt.normalizedRole,
-    testEngineerExempt: receipt.testEngineerExempt,
-    requiredGates: [...receipt.requiredGates],
-    sourceEvent: receipt.sourceEvent,
-    sourceTransitionId: receipt.sourceTransitionId,
-    recordedAt: receipt.recordedAt,
-    ...routeBinding ? { routeBinding } : {},
-    previousChainHash: receipt.previousChainHash
-  });
-}
-function computeChainHash(receipt) {
-  return sha256(canonicalReceiptPayload(receipt));
-}
-function routeBindingFromEvent(event) {
-  if (event.type !== "stage_b_completed" || !event.routeBinding)
-    return;
-  const binding = event.routeBinding;
-  if (binding.role !== event.gate || !binding.sessionId || !binding.taskId || !binding.slotId || !binding.callId || !binding.childSessionId || typeof binding.generation !== "number") {
-    return;
-  }
-  return binding;
-}
-function readBoundedTextFile(filePath) {
-  let pathStat;
-  try {
-    pathStat = fs.lstatSync(filePath);
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return null;
-    throw error;
-  }
-  if (pathStat.isSymbolicLink() || !pathStat.isFile()) {
-    throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt path is not a regular file");
-  }
-  if (pathStat.size > MAX_TASK_GATE_REQUIREMENTS_BYTES) {
-    throw new Error(`TASK_GATE_REQUIREMENTS_OVERSIZED: ${pathStat.size} bytes exceeds ${MAX_TASK_GATE_REQUIREMENTS_BYTES}`);
-  }
-  const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
-  try {
-    const openedStat = fs.fstatSync(descriptor);
-    if (!openedStat.isFile() || openedStat.dev !== pathStat.dev || openedStat.ino !== pathStat.ino) {
-      throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt changed while being opened");
-    }
-    if (openedStat.size > MAX_TASK_GATE_REQUIREMENTS_BYTES) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_OVERSIZED: ${openedStat.size} bytes exceeds ${MAX_TASK_GATE_REQUIREMENTS_BYTES}`);
-    }
-    return fs.readFileSync(descriptor, "utf-8");
-  } finally {
-    fs.closeSync(descriptor);
-  }
-}
-async function readTaskGateRequirementsReceipts(directory, taskId) {
-  const filePath = safeTaskGateRequirementsReceiptPath(directory, taskId, false);
-  const text = readBoundedTextFile(filePath);
-  if (text === null)
-    return [];
-  const receipts = [];
-  for (const line of text.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    const parsed = TaskGateRequirementsReceiptSchema.parse(JSON.parse(line));
-    if (parsed.taskId !== taskId || parsed.routeBinding !== undefined && parsed.routeBinding.taskId !== taskId) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_IDENTITY_MISMATCH: expected ${taskId}, found ${parsed.taskId}`);
-    }
-    const { chainHash, ...withoutChainHash } = parsed;
-    const expectedHash = computeChainHash(withoutChainHash);
-    if (expectedHash !== chainHash) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed hash validation`);
-    }
-    const previousChainHash = receipts.at(-1)?.chainHash ?? null;
-    if (parsed.previousChainHash !== previousChainHash) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed linkage validation`);
-    }
-    receipts.push(parsed);
-  }
-  return receipts;
-}
-function readTaskGateRequirementsReceiptsSync(directory, taskId) {
-  const filePath = safeTaskGateRequirementsReceiptPath(directory, taskId, false);
-  const text = readBoundedTextFile(filePath);
-  if (text === null)
-    return [];
-  const receipts = [];
-  for (const line of text.split(`
-`)) {
-    if (!line.trim())
-      continue;
-    const parsed = TaskGateRequirementsReceiptSchema.parse(JSON.parse(line));
-    if (parsed.taskId !== taskId || parsed.routeBinding !== undefined && parsed.routeBinding.taskId !== taskId) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_IDENTITY_MISMATCH: expected ${taskId}, found ${parsed.taskId}`);
-    }
-    const { chainHash, ...withoutChainHash } = parsed;
-    if (computeChainHash(withoutChainHash) !== chainHash) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed hash validation`);
-    }
-    const previousChainHash = receipts.at(-1)?.chainHash ?? null;
-    if (parsed.previousChainHash !== previousChainHash) {
-      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed linkage validation`);
-    }
-    receipts.push(parsed);
-  }
-  return receipts;
-}
-function routeEvidenceFromTaskGateRequirements(receipts) {
-  const latestByDispatch = new Map;
-  for (const receipt of receipts) {
-    const binding = receipt.routeBinding;
-    if (!binding)
-      continue;
-    const dispatchKey = [
-      binding.role,
-      binding.sessionId,
-      binding.taskId,
-      binding.callId,
-      binding.childSessionId,
-      String(binding.generation)
-    ].join("\x00");
-    latestByDispatch.set(dispatchKey, binding);
-  }
-  return [...latestByDispatch.values()];
-}
-function isLegacyTaskGateRequirementsChain(receipts) {
-  return receipts.length > 0 && receipts.every((receipt) => !receipt.routeBinding);
-}
-function deriveReceiptRole(event) {
-  switch (event.type) {
-    case "accepted_mutation":
-    case "dispatch_attempted":
-    case "dispatch_no_mutation":
-      if (typeof event.agentType === "string" && event.agentType.trim().length > 0) {
-        return {
-          normalizedRole: event.agentType.trim(),
-          testEngineerExempt: event.agentType === "coder" ? event.context?.testEngineerExempt === true : null
-        };
-      }
-      return null;
-    case "stage_b_completed":
-    case "gate_recorded":
-      return {
-        normalizedRole: event.gate,
-        testEngineerExempt: null
-      };
-    default:
-      return null;
-  }
-}
-function shouldAppendReceipt(current, next, role) {
-  if (next.required_gates.length === 0)
-    return false;
-  const currentGeneration = current?.workflow?.generation ?? -1;
-  const nextGeneration = next.workflow?.generation ?? -1;
-  if (current === null)
-    return true;
-  if (JSON.stringify(current.required_gates) !== JSON.stringify(next.required_gates)) {
-    return true;
-  }
-  if ((current.test_engineer_exempt ?? null) !== role.testEngineerExempt) {
-    return true;
-  }
-  return currentGeneration !== nextGeneration;
-}
-async function appendTaskGateRequirementsReceiptIfNeeded(directory, taskId, current, next, event) {
-  const role = deriveReceiptRole(event);
-  const routeBinding = routeBindingFromEvent(event);
-  if (routeBinding && routeBinding.taskId !== taskId) {
-    throw new Error(`TASK_GATE_REQUIREMENTS_ROUTE_IDENTITY_MISMATCH: expected ${taskId}, found ${routeBinding.taskId}`);
-  }
-  if (!role || !shouldAppendReceipt(current, next, role) && !routeBinding) {
-    return;
-  }
-  const filePath = safeTaskGateRequirementsReceiptPath(directory, taskId, true);
-  const receipts = await readTaskGateRequirementsReceipts(directory, taskId);
-  const latest = receipts.at(-1);
-  const baseReceipt = {
-    schemaVersion: 1,
-    taskId,
-    generation: next.workflow?.generation ?? 0,
-    normalizedRole: role.normalizedRole,
-    testEngineerExempt: role.testEngineerExempt,
-    requiredGates: [...next.required_gates],
-    sourceEvent: event.type,
-    sourceTransitionId: event.transitionId ?? null,
-    recordedAt: new Date().toISOString(),
-    previousChainHash: latest?.chainHash ?? null,
-    ...routeBinding ? { routeBinding } : {}
-  };
-  const receipt = {
-    ...baseReceipt,
-    chainHash: computeChainHash(baseReceipt)
-  };
-  if (latest && latest.generation === receipt.generation && latest.normalizedRole === receipt.normalizedRole && latest.testEngineerExempt === receipt.testEngineerExempt && JSON.stringify(latest.requiredGates) === JSON.stringify(receipt.requiredGates) && latest.sourceTransitionId === receipt.sourceTransitionId && JSON.stringify(latest.routeBinding ?? null) === JSON.stringify(receipt.routeBinding ?? null)) {
-    return;
-  }
-  const lines = [...receipts, receipt].map((entry) => JSON.stringify(entry));
-  assertSafeRequirementsParent(directory, false);
-  await atomicWriteFile(filePath, `${lines.join(`
-`)}
-`);
-  assertSafeRequirementsParent(directory, false);
-}
-
-// src/validation/task-id.ts
-var STRICT_TASK_ID_PATTERN = /^\d+\.\d+(\.\d+)*$/;
-var RETRO_TASK_ID_REGEX = /^retro-\d+$/;
-var INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build|secretscan)$/;
-var GENERAL_TASK_ID_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
-function checkUnsafeChars(taskId) {
-  if (!taskId || taskId.length === 0) {
-    return "Invalid task ID: empty string";
-  }
-  if (/\0/.test(taskId)) {
-    return "Invalid task ID: contains null bytes";
-  }
-  for (let i = 0;i < taskId.length; i++) {
-    if (taskId.charCodeAt(i) < 32) {
-      return "Invalid task ID: contains control characters";
-    }
-  }
-  if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
-    return "Invalid task ID: path traversal detected";
-  }
-  return;
-}
-function isStrictTaskId(taskId) {
-  if (!taskId)
-    return false;
-  const unsafeMsg = checkUnsafeChars(taskId);
-  if (unsafeMsg)
-    return false;
-  return STRICT_TASK_ID_PATTERN.test(taskId);
-}
-function assertStrictTaskId(taskId) {
-  if (!isStrictTaskId(taskId)) {
-    throw new Error(`Invalid taskId: "${taskId}". Must match N.M or N.M.P (e.g. "1.1", "1.2.3").`);
-  }
-}
-function sanitizeTaskId(taskId) {
-  const unsafeMsg = checkUnsafeChars(taskId);
-  if (unsafeMsg) {
-    throw new Error(unsafeMsg);
-  }
-  if (STRICT_TASK_ID_PATTERN.test(taskId) || RETRO_TASK_ID_REGEX.test(taskId) || INTERNAL_TOOL_ID_REGEX.test(taskId) || GENERAL_TASK_ID_REGEX.test(taskId)) {
-    return taskId;
-  }
-  throw new Error(`Invalid task ID: must be alphanumeric (ASCII) with optional hyphens, underscores, or dots, got "${taskId}"`);
-}
-function validateTaskIdFormat(taskId) {
-  if (!STRICT_TASK_ID_PATTERN.test(taskId)) {
-    return `Invalid taskId "${taskId}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`;
-  }
-  return;
-}
 
 // src/workflow/workflow-wal-file.ts
-import * as fs4 from "fs";
+import * as fs3 from "fs";
 import { mkdir, open } from "fs/promises";
 import { dirname } from "path";
 
@@ -413,15 +41,15 @@ init_path_identity();
 
 // src/worktree/merge.ts
 init_warning_buffer();
-import * as fs3 from "fs";
+import * as fs2 from "fs";
 import * as path3 from "path";
 
 // src/turbo/lean/recovery.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
+import * as fs from "fs";
+import * as path from "path";
 var RECOVERY_DIR_NAME = "recovery";
 function recoveryDir(directory) {
-  return path2.join(directory, ".swarm", RECOVERY_DIR_NAME);
+  return path.join(directory, ".swarm", RECOVERY_DIR_NAME);
 }
 function isRecoveryRecord(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -435,11 +63,11 @@ function readRecoveryRecords(directory) {
   const dir = recoveryDir(directory);
   let entries;
   try {
-    entries = fs2.readdirSync(dir, { withFileTypes: true });
+    entries = fs.readdirSync(dir, { withFileTypes: true });
   } catch {
     return {
       records: [],
-      errored: fs2.existsSync(dir)
+      errored: fs.existsSync(dir)
     };
   }
   const records = [];
@@ -447,9 +75,9 @@ function readRecoveryRecords(directory) {
   for (const entry of entries) {
     if (!entry.isFile() || !entry.name.endsWith(".json"))
       continue;
-    const full = path2.join(dir, entry.name);
+    const full = path.join(dir, entry.name);
     try {
-      const parsed = JSON.parse(fs2.readFileSync(full, "utf-8"));
+      const parsed = JSON.parse(fs.readFileSync(full, "utf-8"));
       if (isRecoveryRecord(parsed)) {
         records.push(parsed);
       } else {
@@ -475,7 +103,169 @@ function recoveryReadErrored(directory) {
 // src/worktree/merge.ts
 init_bun_compat();
 init_git_executable();
-var _internals = {
+
+// src/worktree/settlement-source-recovery.ts
+init_bun_compat();
+init_git_executable();
+import { stat } from "fs/promises";
+import * as path2 from "path";
+var _internals = { bunSpawn, resolveGitExecutable };
+var OID = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/;
+var REPO_REDIRECT_ENV = new Set([
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_INDEX_FILE",
+  "GIT_COMMON_DIR",
+  "GIT_OBJECT_DIRECTORY",
+  "GIT_ALTERNATE_OBJECT_DIRECTORIES",
+  "GIT_NAMESPACE"
+]);
+function gitEnvWithoutRepoRedirectors() {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!REPO_REDIRECT_ENV.has(key.toUpperCase()))
+      env[key] = value;
+  }
+  env.LC_ALL = "C";
+  return env;
+}
+async function git(directory, args) {
+  let proc;
+  try {
+    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), ...args], {
+      cwd: directory,
+      stdin: "ignore",
+      stdout: "pipe",
+      stderr: "pipe",
+      timeout: 1e4,
+      maxBuffer: 65536,
+      env: gitEnvWithoutRepoRedirectors()
+    });
+    if (proc.spawnError)
+      throw proc.spawnError;
+    const [exitCode, stdout, stderr] = await Promise.all([
+      proc.exited,
+      proc.stdout.text(),
+      proc.stderr.text()
+    ]);
+    if (proc.spawnError)
+      throw proc.spawnError;
+    return { exitCode, stdout, stderr };
+  } finally {
+    try {
+      proc?.kill();
+    } catch {}
+  }
+}
+function requireOid(oid) {
+  if (!OID.test(oid))
+    throw new Error("CODER_SETTLEMENT_SOURCE_UNCERTAIN: malformed source OID");
+}
+async function probeSettlementSource(directory, oid) {
+  requireOid(oid);
+  const result = await git(directory, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    `${oid}^{commit}`
+  ]);
+  if (result.exitCode === 0 && result.stdout.trim() === oid)
+    return "present";
+  if (result.exitCode === 1 && !result.stderr.trim() && !result.stdout.trim()) {
+    const objects = await git(directory, [
+      "rev-parse",
+      "--git-path",
+      "objects"
+    ]);
+    const objectsPath = objects.exitCode === 0 ? objects.stdout.trim() : "";
+    const objectsUsable = objectsPath !== "" && await stat(path2.resolve(directory, objectsPath)).then((entry) => entry.isDirectory(), () => false);
+    if (!objectsUsable) {
+      throw new Error(`CODER_SETTLEMENT_SOURCE_UNCERTAIN: object database unavailable for ${oid}`);
+    }
+    const health = await git(directory, ["count-objects", "-v"]);
+    if (health.exitCode !== 0 || health.stderr.trim())
+      throw new Error(`CODER_SETTLEMENT_SOURCE_UNCERTAIN: object database unreadable for ${oid}`);
+    return "absent";
+  }
+  throw new Error(`CODER_SETTLEMENT_SOURCE_UNCERTAIN: ${oid}: ${result.stderr.trim() || "Git object probe failed"}`);
+}
+function settlementBackupRef(oid) {
+  requireOid(oid);
+  return `refs/swarm/coder-settlements/${oid}`;
+}
+async function readDirectRef(directory, ref) {
+  const symbolic = await git(directory, ["symbolic-ref", "-q", ref]);
+  if (symbolic.exitCode !== 1)
+    throw new Error(`CODER_SETTLEMENT_REF_UNCERTAIN: symbolic or unreadable ref ${ref}`);
+  const result = await git(directory, [
+    "rev-parse",
+    "--verify",
+    "--quiet",
+    ref
+  ]);
+  if (result.exitCode === 0 && OID.test(result.stdout.trim()))
+    return result.stdout.trim();
+  if (result.exitCode === 1 && !result.stderr.trim() && !result.stdout.trim())
+    return null;
+  throw new Error(`CODER_SETTLEMENT_REF_UNCERTAIN: ${ref}`);
+}
+async function createExactRef(directory, ref, oid) {
+  requireOid(oid);
+  const current = await readDirectRef(directory, ref);
+  if (current === oid)
+    return false;
+  if (current !== null)
+    throw new Error(`RECOVERABLE_ORPHAN_COMMIT: ${oid}; occupied ref ${ref}`);
+  const result = await git(directory, [
+    "update-ref",
+    "--no-deref",
+    ref,
+    oid,
+    "0".repeat(oid.length)
+  ]);
+  if (await readDirectRef(directory, ref) !== oid)
+    throw new Error(`RECOVERABLE_ORPHAN_COMMIT: ${oid}; cannot preserve ${ref}: ${result.stderr.trim()}`);
+  return true;
+}
+async function preserveSettlementSource(directory, oid) {
+  const ref = settlementBackupRef(oid);
+  await createExactRef(directory, ref, oid);
+  return ref;
+}
+async function restoreSettlementBranch(directory, branch, oid) {
+  const ref = `refs/heads/${branch}`;
+  const valid = await git(directory, ["check-ref-format", ref]);
+  if (valid.exitCode !== 0)
+    throw new Error("CODER_SETTLEMENT_REF_UNCERTAIN: malformed lane branch");
+  return createExactRef(directory, ref, oid);
+}
+async function releaseSettlementSource(directory, oid) {
+  const ref = settlementBackupRef(oid);
+  const current = await readDirectRef(directory, ref);
+  if (current === null)
+    return;
+  if (current !== oid)
+    throw new Error(`CODER_SETTLEMENT_REF_UNCERTAIN: occupied backup ${ref}`);
+  await git(directory, ["update-ref", "--no-deref", "-d", ref, oid]);
+  if (await readDirectRef(directory, ref) !== null)
+    throw new Error(`CODER_SETTLEMENT_REF_UNCERTAIN: cannot release ${ref}`);
+}
+async function validateSettlementLane(directory, branchName, expectedHead) {
+  requireOid(expectedHead);
+  if ((await git(directory, ["check-ref-format", `refs/heads/${branchName}`])).exitCode !== 0)
+    throw new Error("CODER_SETTLEMENT_DISPATCH_ARTIFACT_CHANGED: invalid branch");
+  const [branch, head] = await Promise.all([
+    git(directory, ["symbolic-ref", "--short", "HEAD"]),
+    git(directory, ["rev-parse", "--verify", "HEAD"])
+  ]);
+  if (branch.exitCode !== 0 || branch.stdout.trim() !== branchName || head.exitCode !== 0 || head.stdout.trim() !== expectedHead)
+    throw new Error("CODER_SETTLEMENT_DISPATCH_ARTIFACT_CHANGED: lane branch or HEAD changed");
+}
+
+// src/worktree/merge.ts
+var _internals2 = {
+  withSettlementArtifactLifecycle,
+  assertSettlementArtifactsRemovable,
   bunSpawn,
   platform: process.platform,
   sleep: (ms) => new Promise((resolve3) => setTimeout(resolve3, ms)),
@@ -513,7 +303,7 @@ function gitSpawnFailureResult(error, cwd, args) {
 async function runGit(args, cwd, timeoutMs = MERGE_TIMEOUT_MS) {
   let proc;
   try {
-    proc = _internals.bunSpawn([_internals.resolveGitExecutable(), ...args], {
+    proc = _internals2.bunSpawn([_internals2.resolveGitExecutable(), ...args], {
       cwd,
       timeout: timeoutMs,
       stdin: "ignore",
@@ -587,7 +377,7 @@ async function matchesSourceHeadWorkingTree(primaryDir, sourceHead) {
       return { landed: false };
     if (status === "A") {
       const worktreePath = path3.join(primaryDir, filePath);
-      if (!fs3.existsSync(worktreePath))
+      if (!fs2.existsSync(worktreePath))
         return { landed: false };
       const expected = await runGit(["rev-parse", `${sourceHead}:${filePath}`], primaryDir);
       const actual = await runGit(["hash-object", "--", filePath], primaryDir);
@@ -654,13 +444,13 @@ async function detectInProgressOperation(primaryDir) {
     if (!rawPath)
       continue;
     const markerPath = path3.isAbsolute(rawPath) ? rawPath : path3.resolve(primaryDir, rawPath);
-    if (fs3.existsSync(markerPath))
+    if (fs2.existsSync(markerPath))
       return { inProgress: true };
   }
   return { inProgress: false };
 }
 function currentPathCasePolicy() {
-  return _internals.platform === "win32" ? "insensitive" : "sensitive";
+  return _internals2.platform === "win32" ? "insensitive" : "sensitive";
 }
 function normalizeGitPath(rawPath, casePolicy) {
   if (rawPath.includes("\x00")) {
@@ -890,6 +680,258 @@ function sameOverlapSnapshot(left, right) {
 function getMergeStrategy(config) {
   return config.mergeStrategy ?? config.merge_strategy ?? "merge";
 }
+var FINGERPRINT_BATCH = 200;
+var FINGERPRINT_ARG_BUDGET = 24000;
+async function hashWorktreeFiles(primaryDir, files) {
+  const hashed = await runGit(["hash-object", "--", ...files], primaryDir);
+  if (hashed.exitCode !== 0)
+    return `hash-object: ${hashed.stderr.trim() || hashed.stdout.trim() || `git exited ${hashed.exitCode}`}`;
+  const oids = hashed.stdout.split(/\r?\n/).filter(Boolean);
+  return oids.length === files.length ? oids : "hash-object: unexpected output length";
+}
+async function fingerprintWorktreePaths(primaryDir, paths, tolerant = false) {
+  const fingerprints = new Map;
+  const regular = [];
+  for (const p of paths) {
+    let stat2;
+    try {
+      stat2 = fs2.lstatSync(path3.join(primaryDir, p));
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") {
+        fingerprints.set(p, "absent");
+        continue;
+      }
+      if (!tolerant)
+        return `worktree stat for ${p}: ${error.message}`;
+      fingerprints.set(p, "unreadable");
+      continue;
+    }
+    if (stat2.isFile())
+      regular.push(p);
+    else
+      fingerprints.set(p, "other");
+  }
+  const batches = [];
+  let batch = [];
+  let length = 0;
+  for (const p of regular) {
+    if (batch.length > 0 && (batch.length >= FINGERPRINT_BATCH || length + p.length + 1 > FINGERPRINT_ARG_BUDGET)) {
+      batches.push(batch);
+      batch = [];
+      length = 0;
+    }
+    batch.push(p);
+    length += p.length + 1;
+  }
+  if (batch.length > 0)
+    batches.push(batch);
+  for (const current of batches) {
+    const oids = await hashWorktreeFiles(primaryDir, current);
+    if (typeof oids !== "string") {
+      for (const [index, p] of current.entries())
+        fingerprints.set(p, oids[index]);
+      continue;
+    }
+    if (!tolerant)
+      return oids;
+    for (const p of current) {
+      const single = await hashWorktreeFiles(primaryDir, [p]);
+      fingerprints.set(p, typeof single === "string" ? "unreadable" : single[0]);
+    }
+  }
+  return fingerprints;
+}
+function unmergedIndexPaths(index) {
+  const unmerged = new Set;
+  for (const [name, records] of index) {
+    if (records.split(`
+`).some((record) => !record.endsWith(" 0")))
+      unmerged.add(name);
+  }
+  return unmerged;
+}
+async function takeSquashStateSnapshot(primaryDir, incomingPaths) {
+  const describe = (result, operation) => `${operation}: ${result.stderr.trim() || result.stdout.trim() || `git exited ${result.exitCode}`}`;
+  const listing = await runGit(["ls-files", "-s", "-z"], primaryDir);
+  if (listing.exitCode !== 0)
+    return describe(listing, "index listing");
+  const index = new Map;
+  for (const record of listing.stdout.split("\x00")) {
+    const tab = record.indexOf("\t");
+    if (tab < 0)
+      continue;
+    const name = record.slice(tab + 1);
+    const entry = record.slice(0, tab);
+    index.set(name, index.has(name) ? `${index.get(name)}
+${entry}` : entry);
+  }
+  const worktree = await fingerprintWorktreePaths(primaryDir, incomingPaths);
+  if (typeof worktree === "string")
+    return worktree;
+  const differing = await runGit(["diff", "--name-only", "--no-renames", "-z", "HEAD"], primaryDir);
+  if (differing.exitCode !== 0)
+    return describe(differing, "HEAD diff listing");
+  const flagged = await runGit(["ls-files", "-v", "-z"], primaryDir);
+  if (flagged.exitCode !== 0)
+    return describe(flagged, "index tag listing");
+  const incoming = new Set(incomingPaths);
+  const outside = new Set;
+  for (const name of differing.stdout.split("\x00")) {
+    if (name !== "" && !incoming.has(name))
+      outside.add(name);
+  }
+  for (const record of flagged.stdout.split("\x00")) {
+    if (!/^[a-z] /.test(record))
+      continue;
+    const name = record.slice(2);
+    if (!incoming.has(name))
+      outside.add(name);
+  }
+  const dirty = await fingerprintWorktreePaths(primaryDir, [...outside], true);
+  if (typeof dirty === "string")
+    return dirty;
+  return { index, worktree, dirty };
+}
+async function restoreFailedSquashPaths(primaryDir, branchName, incomingPaths, before) {
+  const describe = (result, operation) => `${operation}: ${result.stderr.trim() || result.stdout.trim() || `git exited ${result.exitCode}`}`;
+  const after = await takeSquashStateSnapshot(primaryDir, incomingPaths);
+  if (typeof after === "string")
+    return after;
+  const incoming = new Set(incomingPaths);
+  const reported = [];
+  const indexChanged = new Set;
+  const indexNames = new Set([...before.index.keys(), ...after.index.keys()]);
+  for (const name of indexNames) {
+    if (incoming.has(name))
+      continue;
+    if (before.index.get(name) !== after.index.get(name)) {
+      reported.push(`changed outside the incoming paths: ${name}`);
+      indexChanged.add(name);
+    }
+  }
+  const headListing = await runGit(["--literal-pathspecs", "ls-tree", "-z", "HEAD", "--", ...incomingPaths], primaryDir);
+  if (headListing.exitCode !== 0)
+    return describe(headListing, "HEAD listing");
+  const headTypes = new Map;
+  for (const record of headListing.stdout.split("\x00")) {
+    const tab = record.indexOf("\t");
+    if (tab < 0)
+      continue;
+    const [, type] = record.slice(0, tab).split(" ");
+    headTypes.set(record.slice(tab + 1), type);
+  }
+  const laneListing = await runGit([
+    "--literal-pathspecs",
+    "ls-tree",
+    "-z",
+    branchName,
+    "--",
+    ...incomingPaths
+  ], primaryDir);
+  const laneBlobs = new Map;
+  if (laneListing.exitCode !== 0)
+    reported.push(describe(laneListing, "lane listing"));
+  const laneRecords = laneListing.exitCode === 0 ? laneListing.stdout.split("\x00") : [];
+  for (const record of laneRecords) {
+    const tab = record.indexOf("\t");
+    if (tab < 0)
+      continue;
+    const [mode, type, oid] = record.slice(0, tab).split(" ");
+    if (type === "blob" && mode !== "120000" && oid)
+      laneBlobs.set(record.slice(tab + 1), oid);
+  }
+  const changed = [];
+  for (const p of incomingPaths) {
+    if (before.index.get(p) !== after.index.get(p)) {
+      changed.push(p);
+      continue;
+    }
+    if (before.worktree.get(p) === after.worktree.get(p))
+      continue;
+    if (headTypes.get(p) !== "blob") {
+      changed.push(p);
+      continue;
+    }
+    const state = after.worktree.get(p);
+    if (state === "absent" || state !== "other" && state === laneBlobs.get(p)) {
+      changed.push(p);
+    } else {
+      reported.push(`left in place (working tree changed without an index change): ${p}`);
+    }
+  }
+  if (changed.length > 0) {
+    const trackedBlobs = changed.filter((p) => headTypes.get(p) === "blob");
+    const absentFromHead = changed.filter((p) => !headTypes.has(p));
+    for (const p of changed) {
+      const type = headTypes.get(p);
+      if (type !== undefined && type !== "blob")
+        reported.push(`not restored (directory or submodule in HEAD): ${p}`);
+    }
+    const restorable = [...trackedBlobs, ...absentFromHead];
+    if (restorable.length > 0) {
+      const reset = await runGit(["--literal-pathspecs", "reset", "-q", "HEAD", "--", ...restorable], primaryDir);
+      if (reset.exitCode !== 0)
+        return describe(reset, "index reset");
+    }
+    if (trackedBlobs.length > 0) {
+      const checkout = await runGit([
+        "--literal-pathspecs",
+        "checkout",
+        "-q",
+        "HEAD",
+        "--",
+        ...trackedBlobs
+      ], primaryDir);
+      if (checkout.exitCode !== 0)
+        return describe(checkout, "checkout");
+    }
+    const candidates = [];
+    for (const p of absentFromHead) {
+      const state = after.worktree.get(p);
+      if (state === "other")
+        reported.push(`left in place (not a regular file): ${p}`);
+      else if (state !== "absent")
+        candidates.push(p);
+    }
+    for (const p of candidates) {
+      if (laneBlobs.get(p) !== after.worktree.get(p)) {
+        reported.push(`left in place (not the exact lane bytes): ${p}`);
+        continue;
+      }
+      const current = await runGit(["hash-object", "--", p], primaryDir);
+      if (current.exitCode !== 0 || current.stdout.trim() !== laneBlobs.get(p)) {
+        reported.push(`left in place (changed since it was checked): ${p}`);
+        continue;
+      }
+      try {
+        fs2.unlinkSync(path3.join(primaryDir, p));
+      } catch (error) {
+        if (error.code !== "ENOENT")
+          reported.push(`could not remove ${p}: ${error.message}`);
+      }
+    }
+  }
+  const dirtyNames = new Set([...before.dirty.keys(), ...after.dirty.keys()]);
+  for (const name of dirtyNames) {
+    if (!indexChanged.has(name) && before.dirty.get(name) !== after.dirty.get(name))
+      reported.push(`working tree outside the incoming paths changed during the failed squash: ${name}`);
+  }
+  const remaining = await runGit(["ls-files", "-u", "-z"], primaryDir);
+  if (remaining.exitCode !== 0)
+    return describe(remaining, "unmerged listing after restore");
+  const unmergedBefore = unmergedIndexPaths(before.index);
+  for (const record of remaining.stdout.split("\x00")) {
+    const tab = record.indexOf("\t");
+    if (tab < 0)
+      continue;
+    const name = record.slice(tab + 1);
+    if (!unmergedBefore.has(name))
+      reported.push(`unmerged: ${name}`);
+  }
+  const unique = [...new Set(reported)];
+  return unique.length === 0 ? null : `not restored: ${unique.join("; ")}`;
+}
 async function mergeLaneBranch(primaryDir, branchName, strategy, commitMessage) {
   let result;
   switch (strategy) {
@@ -933,26 +975,33 @@ async function mergeLaneBranch(primaryDir, branchName, strategy, commitMessage)
         };
       }
       const incomingPaths = [...parsedIncoming.paths.values()];
+      const squashSnapshot = await takeSquashStateSnapshot(primaryDir, incomingPaths);
+      if (typeof squashSnapshot === "string") {
+        return {
+          error: `could not record pre-merge state before squash of ${branchName}: ${squashSnapshot}`
+        };
+      }
       const squashResult = await runGit(["merge", "--squash", "--no-commit", branchName], primaryDir);
       if (squashResult.exitCode !== 0) {
         const combined = `${squashResult.stderr}
 ${squashResult.stdout}`;
-        const restore = await runGit(["checkout", "-q", "HEAD", "--", ...incomingPaths], primaryDir);
+        const restoreFailure = await restoreFailedSquashPaths(primaryDir, branchName, incomingPaths, squashSnapshot);
+        if (restoreFailure !== null) {
+          advisoryWarn(`[worktree] mergeLaneBranch: squash merge failed and targeted restore also failed for ${branchName}: ${restoreFailure}`);
+        }
+        const restoreSuffix = restoreFailure === null ? "" : `; restore of pre-merge state incomplete, partial merge state may remain: ${restoreFailure}`;
         if (/CONFLICT/i.test(combined)) {
           return {
             conflict: true,
             files: parseConflictFiles(combined),
-            message: squashResult.stderr.trim() || squashResult.stdout.trim() || "squash merge reported a conflict"
+            message: `${squashResult.stderr.trim() || squashResult.stdout.trim() || "squash merge reported a conflict"}${restoreSuffix}`
           };
         }
-        if (restore.exitCode !== 0) {
-          advisoryWarn(`[worktree] mergeLaneBranch: squash merge failed and targeted restore also failed for ${branchName}: ${restore.stderr.trim() || restore.stdout.trim()}`);
-        }
         return {
-          error: squashResult.stderr.trim() || squashResult.stdout.trim() || "squash merge failed"
+          error: `${squashResult.stderr.trim() || squashResult.stdout.trim() || "squash merge failed"}${restoreSuffix}`
         };
       }
-      const resetResult = await runGit(["reset", "-q", "HEAD", "--", ...incomingPaths], primaryDir);
+      const resetResult = await runGit(["--literal-pathspecs", "reset", "-q", "HEAD", "--", ...incomingPaths], primaryDir);
       if (resetResult.exitCode !== 0) {
         advisoryWarn(`[worktree] mergeLaneBranch: targeted unstage failed for ${branchName} (${resetResult.stderr.trim() || resetResult.stdout.trim()}); lane changes remain staged`);
       }
@@ -1008,7 +1057,7 @@ async function readOrderedCommitRange(primaryDir, fromExclusive, toInclusive, de
   }
   return { commits };
 }
-async function recoverMergeBackFromImmutableCoordinates(primaryDir, coordinates) {
+async function recoverMergeBackFromImmutableCoordinates(primaryDir, coordinates, options) {
   if (!GIT_OBJECT_ID_PATTERN.test(coordinates.sourceBaseOid) || !GIT_OBJECT_ID_PATTERN.test(coordinates.sourceHeadOid) || !GIT_OBJECT_ID_PATTERN.test(coordinates.targetHeadOid)) {
     return {
       error: "Malformed preserved lane recovery coordinates"
@@ -1045,7 +1094,10 @@ async function recoverMergeBackFromImmutableCoordinates(primaryDir, coordinates)
     };
   }
   if (coordinates.strategy === "merge") {
-    return finalizeMergeStrategyResult(primaryDir, "merge", await runGit(["merge", "--no-edit", coordinates.sourceHeadOid], primaryDir), {});
+    if (options?.landUnstaged) {
+      return mergeLaneBranch(primaryDir, coordinates.sourceHeadOid, "squash-unstaged");
+    }
+    return mergeLaneBranch(primaryDir, coordinates.sourceHeadOid, "merge", options?.landingCommitMessage);
   }
   if (coordinates.strategy === "rebase") {
     return finalizeMergeStrategyResult(primaryDir, "rebase", await runGit([
@@ -1135,22 +1187,31 @@ async function reconcileLandedMerge(primaryDir, provenance) {
   return trailerSearch.stdout.trim() ? { landed: true, method: "cherry-pick-trailer" } : { landed: false };
 }
 async function postMergeCleanup(directory, branchName) {
-  const pruneResult = await runGit(["worktree", "prune"], directory);
-  const pruneOk = pruneResult.exitCode === 0;
-  const deleteResult = await runGit(["branch", "-D", branchName], directory);
-  const deleteOk = deleteResult.exitCode === 0;
-  if (deleteOk && pruneOk) {
-    return { cleaned: true };
-  }
-  if (!deleteOk && pruneOk) {
-    return {
-      error: `Branch delete failed: ${deleteResult.stderr.trim() || deleteResult.stdout.trim()}`,
-      partial: true
-    };
+  try {
+    return await _internals2.withSettlementArtifactLifecycle(directory, async () => {
+      await _internals2.assertSettlementArtifactsRemovable(directory, {
+        branch: branchName
+      });
+      const pruneResult = await runGit(["worktree", "prune"], directory);
+      const pruneOk = pruneResult.exitCode === 0;
+      const deleteResult = await runGit(["branch", "-D", branchName], directory);
+      const deleteOk = deleteResult.exitCode === 0;
+      if (deleteOk && pruneOk) {
+        return { cleaned: true };
+      }
+      if (!deleteOk && pruneOk) {
+        return {
+          error: `Branch delete failed: ${deleteResult.stderr.trim() || deleteResult.stdout.trim()}`,
+          partial: true
+        };
+      }
+      return {
+        error: deleteOk ? `Worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}` : `Branch delete failed: ${deleteResult.stderr.trim() || deleteResult.stdout.trim()}; worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}`
+      };
+    });
+  } catch (error) {
+    return { error: String(error) };
   }
-  return {
-    error: deleteOk ? `Worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}` : `Branch delete failed: ${deleteResult.stderr.trim() || deleteResult.stdout.trim()}; worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}`
-  };
 }
 async function pruneStaleWorktreeMetadata(directory) {
   const result = await runGit(["worktree", "prune"], directory);
@@ -1193,6 +1254,13 @@ async function handleSourceWorktreeGone(branchHead, worktreePath, branchName, pr
   advisoryWarn(`STALE_LANE_WORKTREE_DETECTED: lane worktree "${worktreePath}" no longer exists. ` + `Its stale git registration was pruned, and the merge-back for branch "${branchName}" ` + `is being taken from "${primaryDir}" instead. Any uncommitted work in that worktree is ` + "unrecoverable; every commit on the branch is preserved.");
   return null;
 }
+async function releaseVerifiedSettlementSource(primaryDir, sourceHead, context) {
+  try {
+    await releaseSettlementSource(primaryDir, sourceHead);
+  } catch (error) {
+    advisoryWarn(`[worktree] attemptMergeBackFromDirty: landing verified (${context}) but releasing preserved settlement source ${sourceHead} failed; outcome unchanged, backup ref left in place:`, error);
+  }
+}
 async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, strategy, options = {}) {
   let autoCommitted = false;
   let cleaned = false;
@@ -1209,6 +1277,34 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
         provenance
       };
     }
+    let orphanRestored = false;
+    try {
+      if (await probeSettlementSource(primaryDir, provenance.sourceHead) === "absent") {
+        return {
+          failed: true,
+          stage: SOURCE_WORKTREE_GONE_STAGE,
+          message: "Recorded source commit is absent",
+          provenance
+        };
+      }
+    } catch (error) {
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: String(error),
+        provenance
+      };
+    }
+    try {
+      await preserveSettlementSource(primaryDir, provenance.sourceHead);
+    } catch (error) {
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: String(error),
+        provenance
+      };
+    }
     const reconciliation = await reconcileLandedMerge(primaryDir, provenance);
     if ("error" in reconciliation && reconciliation.error) {
       return {
@@ -1219,6 +1315,9 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       };
     }
     if (reconciliation.landed) {
+      if (reconciliation.method !== "worktree-match") {
+        await releaseVerifiedSettlementSource(primaryDir, provenance.sourceHead, "resume reconciliation");
+      }
       return {
         merged: true,
         strategy: reconciliation.method === "worktree-match" ? "squash-unstaged" : strategy,
@@ -1228,6 +1327,16 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
         provenance
       };
     }
+    try {
+      orphanRestored = await restoreSettlementBranch(primaryDir, branchName, provenance.sourceHead);
+    } catch (error) {
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: String(error),
+        provenance
+      };
+    }
     const source = await captureLaneSourceHead(worktreePath, branchName, primaryDir, false);
     if (source.sourceWorktreeMissing) {
       const unrecoverable = await handleSourceWorktreeGone(source.result, worktreePath, branchName, primaryDir, provenance);
@@ -1237,7 +1346,7 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
     }
     const sourceHead = source.result;
     const targetHead = await runGit(["rev-parse", "HEAD"], primaryDir);
-    if (sourceHead.exitCode !== 0 || targetHead.exitCode !== 0 || sourceHead.stdout.trim() !== provenance.sourceHead || targetHead.stdout.trim() !== provenance.targetHeadBefore) {
+    if (sourceHead.exitCode !== 0 || targetHead.exitCode !== 0 || sourceHead.stdout.trim() !== provenance.sourceHead) {
       return {
         failed: true,
         stage: "reconciliation",
@@ -1245,6 +1354,61 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
         provenance
       };
     }
+    if (strategy === "merge" && (orphanRestored || targetHead.stdout.trim() !== provenance.targetHeadBefore)) {
+      const relation = await runGit([
+        "merge-base",
+        "--is-ancestor",
+        provenance.targetHeadBefore,
+        targetHead.stdout.trim()
+      ], primaryDir);
+      if (relation.exitCode !== 0)
+        return {
+          failed: true,
+          stage: "reconciliation",
+          message: "Current primary HEAD no longer descends from recorded target",
+          provenance
+        };
+      const base = await runGit(["merge-base", targetHead.stdout.trim(), provenance.sourceHead], primaryDir);
+      if (base.exitCode !== 0)
+        return {
+          failed: true,
+          stage: "reconciliation",
+          message: "Unable to derive current immutable merge base",
+          provenance
+        };
+      const result = await recoverMergeBackFromImmutableCoordinates(primaryDir, {
+        sourceBaseOid: base.stdout.trim(),
+        sourceHeadOid: provenance.sourceHead,
+        targetHeadOid: targetHead.stdout.trim(),
+        strategy
+      }, options.commitLanding ? { landingCommitMessage: options.landingCommitMessage } : { landUnstaged: true });
+      if ("merged" in result) {
+        if (result.strategy !== "squash-unstaged") {
+          await releaseVerifiedSettlementSource(primaryDir, provenance.sourceHead, "retarget recovery");
+        }
+        return {
+          merged: true,
+          strategy: result.strategy === "squash-unstaged" ? "squash-unstaged" : strategy,
+          autoCommitted: false,
+          cleaned: false,
+          reconciled: false,
+          provenance
+        };
+      }
+      return {
+        failed: true,
+        stage: "merge",
+        message: "error" in result ? result.error : result.message,
+        provenance
+      };
+    }
+    if (targetHead.stdout.trim() !== provenance.targetHeadBefore)
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: "Stored merge operation target HEAD has changed",
+        provenance
+      };
   }
   if (!provenance && !sourceWorktreeMissing) {
     const commitResult = await autoCommitDirty(worktreePath);
@@ -1283,7 +1447,7 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       };
     }
   }
-  const initialOverlapSnapshot = await _internals.captureMergeOverlapSnapshot(primaryDir, branchName);
+  const initialOverlapSnapshot = await _internals2.captureMergeOverlapSnapshot(primaryDir, branchName);
   if ("error" in initialOverlapSnapshot) {
     return {
       failed: true,
@@ -1320,7 +1484,7 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
       }
     }
   }
-  const finalOverlapSnapshot = await _internals.captureMergeOverlapSnapshot(primaryDir, branchName);
+  const finalOverlapSnapshot = await _internals2.captureMergeOverlapSnapshot(primaryDir, branchName);
   if ("error" in finalOverlapSnapshot) {
     return {
       failed: true,
@@ -1353,6 +1517,12 @@ async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, s
   const landingStrategy = strategy === "merge" && !options.commitLanding ? "squash-unstaged" : strategy;
   const mergeResult = await mergeLaneBranch(primaryDir, branchName, landingStrategy, landingStrategy === "merge" && options.commitLanding ? options.landingCommitMessage : undefined);
   if ("merged" in mergeResult && mergeResult.merged) {
+    if (provenance && landingStrategy !== "squash-unstaged") {
+      const landed = await reconcileLandedMerge(primaryDir, provenance);
+      if (landed.landed && landed.method !== "worktree-match") {
+        await releaseVerifiedSettlementSource(primaryDir, provenance.sourceHead, "fresh landing");
+      }
+    }
     return {
       merged: true,
       strategy: landingStrategy,
@@ -1440,7 +1610,19 @@ async function cleanupOrphanedBranches(directory, activeSessionIds = [], options
       skippedRecoveryBranches.push(branch);
       continue;
     }
-    const deleteResult = await runGit(["branch", options.preserveUnmerged ? "-d" : "-D", branch], directory);
+    let deleteResult;
+    try {
+      deleteResult = await _internals2.withSettlementArtifactLifecycle(directory, async () => {
+        await _internals2.assertSettlementArtifactsRemovable(directory, {
+          branch
+        });
+        return runGit(["branch", options.preserveUnmerged ? "-d" : "-D", branch], directory);
+      });
+    } catch (error) {
+      skipped.push(branch);
+      errors.push({ branch, error: String(error) });
+      continue;
+    }
     if (deleteResult.exitCode === 0) {
       removed.push(branch);
     } else {
@@ -1577,11 +1759,11 @@ var UTF8_FATAL_DECODER = new TextDecoder("utf-8", { fatal: true });
 var CODER_SETTLEMENT_MAX_BYTES = 64 * 1024 * 1024;
 var SMALL_WORKFLOW_WAL_MAX_BYTES = 1024 * 1024;
 var CHUNK_BYTES = 64 * 1024;
-var _internals2 = {
+var _internals3 = {
   openFile: open,
-  openFileSync: fs4.openSync,
-  readFileSync: fs4.readSync,
-  closeFileSync: fs4.closeSync
+  openFileSync: fs3.openSync,
+  readFileSync: fs3.readSync,
+  closeFileSync: fs3.closeSync
 };
 function maxBytesFor(kind) {
   return kind === "coder-settlement" ? CODER_SETTLEMENT_MAX_BYTES : SMALL_WORKFLOW_WAL_MAX_BYTES;
@@ -1646,7 +1828,7 @@ function validateWal(kind, raw, filePath, expectedTaskId) {
 async function readBoundedBytes(kind, filePath, maxBytes) {
   let handle;
   try {
-    handle = await _internals2.openFile(filePath, "r");
+    handle = await _internals3.openFile(filePath, "r");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -1687,7 +1869,7 @@ async function readBoundedBytes(kind, filePath, maxBytes) {
 function readBoundedBytesSync(kind, filePath, maxBytes) {
   let fd;
   try {
-    fd = _internals2.openFileSync(filePath, "r");
+    fd = _internals3.openFileSync(filePath, "r");
   } catch (error) {
     if (error.code === "ENOENT")
       return null;
@@ -1704,7 +1886,7 @@ function readBoundedBytesSync(kind, filePath, maxBytes) {
       if (remaining <= 0)
         break;
       const buffer = Buffer.alloc(Math.min(CHUNK_BYTES, remaining));
-      const bytesRead = _internals2.readFileSync(fd, buffer, 0, buffer.length, null);
+      const bytesRead = _internals3.readFileSync(fd, buffer, 0, buffer.length, null);
       if (bytesRead === 0)
         break;
       total += bytesRead;
@@ -1717,7 +1899,7 @@ function readBoundedBytesSync(kind, filePath, maxBytes) {
     failure = walIoError(kind, filePath, "read", error);
   }
   try {
-    _internals2.closeFileSync(fd);
+    _internals3.closeFileSync(fd);
   } catch (error) {
     failure ??= walIoError(kind, filePath, "close", error);
   }
@@ -1761,951 +1943,4 @@ async function writeWorkflowWalFile(kind, filePath, wal) {
   await atomicWriteFile(filePath, serialized);
 }
 
-// src/gate-evidence.ts
-var _internals3 = {
-  appendTaskGateRequirementsReceiptIfNeeded
-};
-var TASK_WORKFLOW_SCHEMA_MARKER = "exact-task-v1";
-var TASK_WORKFLOW_STATES = [
-  "idle",
-  "coder_delegated",
-  "pre_check_passed",
-  "reviewer_run",
-  "tests_run",
-  "rework_required",
-  "complete",
-  "blocked",
-  "closed"
-];
-var TASK_WORKFLOW_OUTCOMES = [
-  "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",
-  "task_closed",
-  "repair_idle",
-  "external_evidence_attested",
-  "external_evidence_revoked"
-];
-var MAX_PLAN_SCOPE_INSPECTION_BYTES = 4 * 1024 * 1024;
-function readCurrentTaskDeclaredFiles(directory, taskId) {
-  try {
-    const planPath = validateSwarmPath(directory, "plan.json");
-    const stat = statSync2(planPath);
-    if (!stat.isFile() || stat.size > MAX_PLAN_SCOPE_INSPECTION_BYTES) {
-      return null;
-    }
-    const parsed = JSON.parse(readFileSync3(planPath, "utf8"));
-    if (!Array.isArray(parsed.phases))
-      return null;
-    let declaredFiles = null;
-    for (const phase of parsed.phases) {
-      if (!phase || typeof phase !== "object")
-        return null;
-      const tasks = phase.tasks;
-      if (!Array.isArray(tasks))
-        return null;
-      for (const task of tasks) {
-        if (!task || typeof task !== "object")
-          return null;
-        const record = task;
-        if (record.id !== taskId)
-          continue;
-        if (!Array.isArray(record.files_touched) || !record.files_touched.every((file) => typeof file === "string")) {
-          return null;
-        }
-        if (declaredFiles !== null)
-          return null;
-        declaredFiles = [...record.files_touched];
-      }
-    }
-    return declaredFiles;
-  } catch {
-    return null;
-  }
-}
-var TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL = "requirements_reconstruction";
-function assertTaskEvidenceWriteAllowed(directory, taskId, event) {
-  assertValidTaskId(taskId);
-  const coderWalPath = validateSwarmPath(directory, `coder-settlements/${taskId}.json`);
-  const coderWal = readWorkflowWalFileSync("coder-settlement", coderWalPath, taskId);
-  if ((coderWal?.state === "DISPATCHED" || coderWal?.state === "PREPARED") && !(event != null && event.transitionId === coderWal.transitionId && (event.type === "dispatch_attempted" || event.type === "dispatch_no_mutation" || event.type === "accepted_mutation"))) {
-    throw new Error(`CODER_SETTLEMENT_IN_PROGRESS: transition ${String(coderWal.transitionId)} owns evidence for task ${taskId}. Wait for the owning transition to settle or run /swarm recover ${taskId} (or /swarm reset-session), then retry; do not remove the WAL by hand.`);
-  }
-  const terminalWalPath = validateSwarmPath(directory, `task-terminals/${taskId}.json`);
-  const terminalWal = readWorkflowWalFileSync("task-terminal", terminalWalPath, taskId);
-  if (terminalWal?.state === "PREPARED") {
-    const matchingTerminalEvent = event != null && event.transitionId === terminalWal.transitionId && (event.type === "task_completed" && terminalWal.newPlanStatus === "completed" || event.type === "task_blocked" && terminalWal.newPlanStatus === "blocked" || event.type === "task_closed" && terminalWal.newPlanStatus === "closed");
-    if (!matchingTerminalEvent) {
-      throw new Error(`TASK_TERMINAL_PREPARED: transition ${String(terminalWal.transitionId)} owns evidence for task ${taskId}`);
-    }
-  }
-  const repairWalPath = validateSwarmPath(directory, `task-repairs/${taskId}.json`);
-  const repairWal = readWorkflowWalFileSync("task-repair", repairWalPath, taskId);
-  if (repairWal?.state === "PREPARED" && !(event?.type === "repair_idle" && event.transitionId === repairWal.transitionId)) {
-    throw new Error(`TASK_REPAIR_PREPARED: transition ${String(repairWal.transitionId)} owns evidence for task ${taskId}`);
-  }
-}
-var GateEvidenceSchema = exports_external.object({
-  sessionId: exports_external.string(),
-  timestamp: exports_external.string(),
-  agent: exports_external.string()
-}).passthrough();
-var ExternalEvidenceBundleSchema = exports_external.object({
-  class: exports_external.literal("external_git"),
-  transitionId: exports_external.string().min(1).max(512),
-  declarationDigest: exports_external.string().regex(/^[a-f0-9]{64}$/),
-  anchors: exports_external.array(exports_external.object({
-    command: exports_external.string().min(1).max(400),
-    expect: exports_external.string().max(4096).optional(),
-    expect_prefix: exports_external.string().min(1).max(4096).optional(),
-    matched: exports_external.boolean(),
-    exit_code: exports_external.number().int(),
-    stdout: exports_external.string().max(4096)
-  })).min(1).max(16).superRefine((anchors, ctx) => {
-    anchors.forEach((anchor, index) => {
-      if (anchor.expect === undefined && anchor.expect_prefix === undefined) {
-        ctx.addIssue({
-          code: exports_external.ZodIssueCode.custom,
-          message: `anchor ${index} must carry expect and/or a non-empty expect_prefix`,
-          path: [index]
-        });
-      }
-    });
-  }),
-  attestedAt: exports_external.string().min(1)
-});
-var TaskWorkflowMetadataSchema = exports_external.object({
-  schema: exports_external.literal(TASK_WORKFLOW_SCHEMA_MARKER),
-  generation: exports_external.number().int().min(0),
-  state: exports_external.enum(TASK_WORKFLOW_STATES),
-  retryCount: exports_external.number().int().min(0).default(0),
-  retryHistory: exports_external.array(exports_external.enum(TASK_WORKFLOW_OUTCOMES)).max(3).default([]),
-  retryEpoch: exports_external.number().int().min(0).default(0),
-  lastOutcome: exports_external.enum(TASK_WORKFLOW_OUTCOMES).default("none"),
-  lastTransitionId: exports_external.string().min(1).nullable().optional().default(null),
-  updatedAt: exports_external.string(),
-  forcedCompletion: exports_external.boolean().optional(),
-  supervisedRecovery: exports_external.boolean().optional(),
-  settlementRecovery: exports_external.boolean().optional(),
-  noMutationSettlement: exports_external.object({
-    generation: exports_external.literal(0),
-    transitionId: exports_external.string().min(1).max(512),
-    declaredFiles: exports_external.array(exports_external.string()).length(0)
-  }).optional(),
-  externalEvidence: ExternalEvidenceBundleSchema.optional()
-});
-var TaskEvidenceSchema = exports_external.object({
-  taskId: exports_external.string(),
-  required_gates: exports_external.array(exports_external.string()).default([]),
-  gates: exports_external.record(exports_external.string(), GateEvidenceSchema),
-  turbo: exports_external.boolean().optional(),
-  requirements_state: exports_external.enum(["known", "unknown"]).optional(),
-  test_engineer_exempt: exports_external.boolean().optional(),
-  planId: exports_external.string().optional(),
-  planIdentityHash: exports_external.string().regex(/^[a-f0-9]{64}$/).optional(),
-  workflow: TaskWorkflowMetadataSchema.optional(),
-  repair_provenance: exports_external.object({
-    source_sha256: exports_external.string().regex(/^[a-f0-9]{64}$/).nullable(),
-    source_generation: exports_external.number().int().min(0).nullable(),
-    requirements_receipt_hash: exports_external.string().regex(/^[a-f0-9]{64}$/).nullable()
-  }).optional(),
-  todo_scan: exports_external.object({
-    priority: exports_external.string(),
-    count: exports_external.number().int().min(0),
-    details: exports_external.array(exports_external.string()).max(200).optional(),
-    recorded_at: exports_external.string().optional()
-  }).optional()
-});
-function parseTaskEvidence(raw, expectedTaskId) {
-  const parsed = TaskEvidenceSchema.parse(JSON.parse(raw));
-  if (parsed.taskId !== expectedTaskId) {
-    throw new Error(`TASK_EVIDENCE_IDENTITY_MISMATCH: expected ${expectedTaskId}, found ${parsed.taskId}`);
-  }
-  return parsed;
-}
-function resolveCurrentPlanIdentitySync(directory) {
-  if (!directory)
-    return null;
-  try {
-    const planPath = path4.join(directory, ".swarm", "plan.json");
-    const raw = readFileSync3(planPath, "utf8");
-    const plan = JSON.parse(raw);
-    if (typeof plan.swarm !== "string" || typeof plan.title !== "string")
-      return null;
-    return {
-      planId: derivePlanId(plan),
-      planIdentityHash: derivePlanIdentityHash(plan)
-    };
-  } catch {
-    return null;
-  }
-}
-function evidenceStampedForDifferentPlan(evidence, currentPlanIdentityHash) {
-  if (evidence == null || currentPlanIdentityHash == null)
-    return false;
-  return typeof evidence.planIdentityHash === "string" && evidence.planIdentityHash !== currentPlanIdentityHash;
-}
-function planStampForPersist(nextEvidence, previous, planIdentity, campaignRestart) {
-  if (nextEvidence.planIdentityHash !== undefined)
-    return {};
-  const carriesGates = Object.keys(nextEvidence.gates ?? {}).length > 0;
-  if (carriesGates && previous != null && !campaignRestart) {
-    return previous.planIdentityHash !== undefined ? {
-      ...previous.planId !== undefined ? { planId: previous.planId } : {},
-      planIdentityHash: previous.planIdentityHash
-    } : {};
-  }
-  return planIdentity ? {
-    planId: planIdentity.planId,
-    planIdentityHash: planIdentity.planIdentityHash
-  } : {};
-}
-var DEFAULT_REQUIRED_GATES = ["reviewer", "test_engineer"];
-var DEFAULT_WORKFLOW_STATE = "idle";
-var WORKFLOW_STATE_RANK = {
-  idle: 0,
-  coder_delegated: 1,
-  pre_check_passed: 2,
-  reviewer_run: 3,
-  tests_run: 4,
-  rework_required: 5,
-  blocked: 6,
-  closed: 7,
-  complete: 8
-};
-function isValidTaskId(taskId) {
-  return isStrictTaskId(taskId);
-}
-function assertValidTaskId(taskId) {
-  assertStrictTaskId(taskId);
-}
-function createDefaultWorkflowMetadata(nowIso) {
-  return {
-    schema: TASK_WORKFLOW_SCHEMA_MARKER,
-    generation: 0,
-    state: DEFAULT_WORKFLOW_STATE,
-    retryCount: 0,
-    retryHistory: [],
-    retryEpoch: 0,
-    lastOutcome: "none",
-    lastTransitionId: null,
-    updatedAt: nowIso
-  };
-}
-function getEventOutcome(event) {
-  switch (event.type) {
-    case "dispatch_attempted":
-      return "dispatch_attempted";
-    case "dispatch_no_mutation":
-      return "dispatch_no_mutation";
-    case "accepted_mutation":
-      return event.context?.settlementFailed === true ? "accepted_mutation_failed" : "accepted_mutation";
-    case "stage_a_passed":
-      return "stage_a_passed";
-    case "stage_a_failed":
-      return "stage_a_failed";
-    case "stage_b_completed":
-      return "stage_b_completed";
-    case "stage_b_failed":
-      return "stage_b_failed";
-    case "gate_recorded":
-      return "gate_recorded";
-    case "task_completed":
-      return "task_completed";
-    case "task_blocked":
-      return "task_blocked";
-    case "task_closed":
-      return "task_closed";
-    case "repair_idle":
-      return "repair_idle";
-    case "external_evidence_attested":
-      return "external_evidence_attested";
-    case "external_evidence_revoked":
-      return "external_evidence_revoked";
-  }
-}
-function isAuthoritativeWorkflowMetadata(workflow) {
-  return workflow?.schema === TASK_WORKFLOW_SCHEMA_MARKER;
-}
-function getTaskWorkflowSnapshot(evidence) {
-  if (isAuthoritativeWorkflowMetadata(evidence?.workflow)) {
-    return { ...evidence.workflow, authoritative: true };
-  }
-  return {
-    ...createDefaultWorkflowMetadata(""),
-    authoritative: false
-  };
-}
-function maybeExpandRequiredGates(existing, event) {
-  if (event.type === "accepted_mutation") {
-    const agentType = event.agentType;
-    if (typeof agentType === "string" && agentType.trim() !== "") {
-      return existing ? expandRequiredGates(existing.required_gates.filter((gate) => gate !== TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL), agentType, event.context ?? {}) : deriveRequiredGates(agentType, event.context ?? {});
-    }
-  }
-  if (event.type === "stage_b_completed" && event.ensureDefaultStageB === true) {
-    return expandRequiredGates(existing?.required_gates ?? [], "coder", {
-      testEngineerExempt: false
-    });
-  }
-  if (event.type === "stage_b_completed" || event.type === "gate_recorded") {
-    return existing ? expandRequiredGates(existing.required_gates, event.gate) : deriveRequiredGates(event.gate);
-  }
-  return existing?.required_gates ?? [];
-}
-function hasAllRequiredGatesPassed(requiredGates, gates) {
-  return requiredGates.length > 0 && requiredGates.every((gate) => gates[gate] != null);
-}
-function shouldTreatGateAsStageB(gate) {
-  return gate === "reviewer" || gate === "test_engineer";
-}
-function clearWorkflowGateProof(gates) {
-  const retained = { ...gates };
-  delete retained.pre_check;
-  delete retained.reviewer;
-  delete retained.test_engineer;
-  delete retained.council;
-  delete retained.critic;
-  delete retained.critic_sounding_board;
-  return retained;
-}
-function assertExpectedGeneration(snapshot, event) {
-  if (typeof event.expectedGeneration === "number" && event.expectedGeneration !== snapshot.generation) {
-    throw new Error(`TASK_WORKFLOW_GENERATION_MISMATCH: expected ${event.expectedGeneration}, current ${snapshot.generation}`);
-  }
-}
-function isDuplicateTransition(snapshot, event) {
-  if (event.type === "dispatch_no_mutation" && event.context?.declaredFiles?.length === 0 && event.context.settlementTransitionId === event.transitionId && !snapshot.noMutationSettlement) {
-    return false;
-  }
-  return snapshot.authoritative && typeof event.transitionId === "string" && event.transitionId.length > 0 && snapshot.lastTransitionId === event.transitionId && snapshot.lastOutcome === getEventOutcome(event);
-}
-function isNoMutationSettlementMetadata(workflow) {
-  const settlement = workflow.noMutationSettlement;
-  if (!workflow.authoritative || workflow.generation !== 0 || settlement?.generation !== 0 || typeof settlement.transitionId !== "string" || settlement.transitionId.length === 0 || !Array.isArray(settlement.declaredFiles) || settlement.declaredFiles.length !== 0)
-    return false;
-  return workflow.state === "idle" || workflow.state === "complete";
-}
-function deriveApplicableGateSet(evidence, options) {
-  if (!evidence) {
-    return {
-      requiredGates: ["pre_check"],
-      satisfiedGates: [],
-      missingGates: ["pre_check"],
-      readOnlyNoMutation: false
-    };
-  }
-  const workflow = getTaskWorkflowSnapshot(evidence);
-  const readOnlyNoMutation = isNoMutationSettlementMetadata(workflow) && (options?.currentDeclaredFiles === undefined ? true : options.currentDeclaredFiles !== null && options.currentDeclaredFiles.length === 0);
-  const externalEvidenceMatched = workflow.lastOutcome === "external_evidence_attested" && (workflow.externalEvidence?.anchors.length ?? 0) > 0 && workflow.externalEvidence.anchors.every((anchor) => anchor.matched);
-  const requiredGates = [...new Set(evidence.required_gates ?? [])];
-  if (!readOnlyNoMutation && !externalEvidenceMatched && !requiredGates.includes("pre_check")) {
-    requiredGates.unshift("pre_check");
-  }
-  const satisfiedGates = requiredGates.filter((gate) => evidence.gates?.[gate] != null);
-  return {
-    requiredGates,
-    satisfiedGates,
-    missingGates: requiredGates.filter((gate) => evidence.gates?.[gate] == null),
-    readOnlyNoMutation
-  };
-}
-function isReadOnlyNoMutationEligible(evidence, options) {
-  return deriveApplicableGateSet(evidence, options).readOnlyNoMutation;
-}
-function computeExternalDeclarationDigest(input) {
-  const canonical = {
-    taskId: input.taskId,
-    evidence_class: input.evidence_class,
-    evidence_anchors: input.evidence_anchors.map((anchor) => ({
-      command: anchor.command,
-      expect: anchor.expect,
-      expect_prefix: anchor.expect_prefix
-    })),
-    plan_title: input.plan_title,
-    plan_swarm: input.plan_swarm,
-    generation: input.generation
-  };
-  return createHash2("sha256").update(JSON.stringify(canonical)).digest("hex");
-}
-function externalProofCurrent(plan, planTask, evidence) {
-  if (planTask.evidence_class !== "external_git")
-    return false;
-  const workflow = evidence?.workflow;
-  if (!workflow)
-    return false;
-  const bundle = workflow.externalEvidence;
-  if (!bundle || bundle.anchors.length === 0)
-    return false;
-  if (!bundle.anchors.every((anchor) => anchor.matched))
-    return false;
-  return bundle.declarationDigest === computeExternalDeclarationDigest({
-    taskId: planTask.id,
-    evidence_class: "external_git",
-    evidence_anchors: planTask.evidence_anchors ?? [],
-    plan_title: plan.title,
-    plan_swarm: plan.swarm,
-    generation: workflow.generation
-  });
-}
-function isExternalEvidenceInitialCompletionEligible(plan, planTask, evidence) {
-  if (!externalProofCurrent(plan, planTask, evidence))
-    return false;
-  const snapshot = getTaskWorkflowSnapshot(evidence);
-  return snapshot.authoritative && snapshot.state === "idle";
-}
-function reduceTaskWorkflowSnapshot(current, event, context) {
-  if ((current.state === "complete" || current.state === "blocked" || current.state === "closed") && event.type !== "repair_idle" && !(current.state === "complete" && event.type === "task_completed" || current.state === "blocked" && event.type === "task_blocked" || current.state === "blocked" && event.type === "task_closed" || current.state === "blocked" && event.type === "stage_a_passed" && event.settlementRecovery === true)) {
-    throw new Error(`TASK_WORKFLOW_TERMINAL: cannot apply ${event.type} from ${current.state}`);
-  }
-  const outcome = getEventOutcome(event);
-  const base = {
-    schema: TASK_WORKFLOW_SCHEMA_MARKER,
-    generation: current.generation,
-    state: current.state,
-    retryCount: current.retryCount,
-    retryHistory: current.retryHistory,
-    retryEpoch: current.retryEpoch,
-    lastOutcome: outcome,
-    lastTransitionId: event.transitionId ?? current.lastTransitionId,
-    updatedAt: context.nowIso,
-    ...current.forcedCompletion === true ? { forcedCompletion: true } : {},
-    ...current.supervisedRecovery === true ? { supervisedRecovery: true } : {},
-    ...current.settlementRecovery === true ? { settlementRecovery: true } : {},
-    ...current.noMutationSettlement ? { noMutationSettlement: current.noMutationSettlement } : {},
-    ...current.externalEvidence ? { externalEvidence: current.externalEvidence } : {}
-  };
-  switch (event.type) {
-    case "dispatch_attempted": {
-      const {
-        noMutationSettlement: _clearedSettlement,
-        externalEvidence: _clearedExternalEvidence,
-        ...withoutSettlement
-      } = base;
-      return withoutSettlement;
-    }
-    case "dispatch_no_mutation": {
-      const {
-        noMutationSettlement: _clearedSettlement,
-        externalEvidence: _clearedExternalEvidence,
-        ...withoutSettlement
-      } = base;
-      return {
-        ...withoutSettlement,
-        retryCount: Math.min(current.retryCount + 1, 3),
-        retryHistory: [...current.retryHistory, outcome].slice(-3),
-        retryEpoch: current.retryEpoch || current.generation + 1,
-        ...current.generation === 0 && event.transitionId && Array.isArray(event.context?.declaredFiles) && event.context.declaredFiles.length === 0 && event.context.settlementTransitionId === event.transitionId ? {
-          noMutationSettlement: {
-            generation: 0,
-            transitionId: event.transitionId,
-            declaredFiles: []
-          }
-        } : {}
-      };
-    }
-    case "stage_b_failed":
-      if (current.state !== "pre_check_passed" && current.state !== "reviewer_run" && current.state !== "tests_run" && current.state !== "rework_required") {
-        throw new Error(`TASK_WORKFLOW_STAGE_A_REQUIRED: cannot reject ${event.gate} from ${current.state}`);
-      }
-      return {
-        ...base,
-        state: "rework_required",
-        retryCount: Math.min(current.retryCount + 1, 3),
-        retryHistory: [...current.retryHistory, outcome].slice(-3),
-        retryEpoch: current.retryEpoch || current.generation + 1
-      };
-    case "accepted_mutation": {
-      const {
-        noMutationSettlement: _clearedSettlement,
-        externalEvidence: _clearedExternalEvidence,
-        ...withoutSettlement
-      } = base;
-      if (event.context?.settlementFailed === true) {
-        return {
-          ...withoutSettlement,
-          generation: current.generation + 1,
-          state: "rework_required",
-          retryCount: Math.min(current.retryCount + 1, 3),
-          retryHistory: [...current.retryHistory, outcome].slice(-3),
-          retryEpoch: current.retryEpoch || current.generation + 1,
-          supervisedRecovery: undefined,
-          settlementRecovery: undefined
-        };
-      }
-      return {
-        ...withoutSettlement,
-        generation: current.generation + 1,
-        state: "coder_delegated",
-        supervisedRecovery: undefined,
-        settlementRecovery: undefined
-      };
-    }
-    case "stage_a_passed":
-      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed" && !(current.state === "rework_required" && event.supervisedRecovery === true) && !(event.settlementRecovery === true && (current.state === "idle" || current.state === "blocked"))) {
-        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot pass Stage A from ${current.state}`);
-      }
-      return {
-        ...base,
-        ...event.supervisedRecovery === true ? { supervisedRecovery: true } : {},
-        ...event.settlementRecovery === true ? { settlementRecovery: true } : {},
-        state: "pre_check_passed"
-      };
-    case "stage_a_failed":
-      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed" && current.state !== "rework_required") {
-        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot fail Stage A from ${current.state}`);
-      }
-      return {
-        ...base,
-        state: "rework_required",
-        retryCount: Math.min(current.retryCount + 1, 3),
-        retryHistory: [...current.retryHistory, outcome].slice(-3),
-        retryEpoch: current.retryEpoch || current.generation + 1
-      };
-    case "stage_b_completed":
-      if (current.state !== "pre_check_passed" && current.state !== "reviewer_run" && current.state !== "tests_run") {
-        throw new Error(`TASK_WORKFLOW_STAGE_A_REQUIRED: cannot record ${event.gate} from ${current.state}`);
-      }
-      if (event.routeComplete === false) {
-        return {
-          ...base,
-          state: event.gate === "reviewer" || current.state === "reviewer_run" ? "reviewer_run" : current.state
-        };
-      }
-      if (event.routeComplete === true) {
-        return { ...base, state: "tests_run" };
-      }
-      return {
-        ...base,
-        state: hasAllRequiredGatesPassed(context.requiredGates, context.gates) ? "tests_run" : "reviewer_run"
-      };
-    case "gate_recorded":
-      return {
-        ...base,
-        state: current.state
-      };
-    case "external_evidence_attested": {
-      if (current.state !== "idle") {
-        throw new Error(`TASK_WORKFLOW_EXTERNAL_ATTEST_STATE: external evidence can only be attested from idle (task never entered the coder QA lifecycle), not ${current.state}`);
-      }
-      if (current.externalEvidence?.transitionId === event.bundle.transitionId) {
-        return { ...base };
-      }
-      return { ...base, externalEvidence: event.bundle };
-    }
-    case "external_evidence_revoked": {
-      const {
-        externalEvidence: _revokedExternalEvidence,
-        ...withoutExternalEvidence
-      } = base;
-      return withoutExternalEvidence;
-    }
-    case "task_completed": {
-      const readOnlyNoMutation = event.readOnlyNoMutation === true && current.state === "idle" && current.generation === 0 && isNoMutationSettlementMetadata(current) && context.requiredGates.every((gate) => context.gates[gate] != null);
-      const externalAdmitted = event.externalEvidence === true && current.externalEvidence !== undefined && current.externalEvidence.anchors.length > 0 && current.externalEvidence.anchors.every((anchor) => anchor.matched) && (current.state === "idle" || current.state === "complete");
-      if (event.qaExempt !== true && current.state !== "tests_run" && current.state !== "complete" && !(current.state === "pre_check_passed" && context.gates.council != null) && !readOnlyNoMutation && !externalAdmitted) {
-        throw new Error(`TASK_WORKFLOW_QA_REQUIRED: cannot complete from ${current.state}`);
-      }
-      return {
-        ...base,
-        state: "complete",
-        ...event.qaExempt === true ? { forcedCompletion: true } : {}
-      };
-    }
-    case "task_blocked":
-      return {
-        ...base,
-        state: "blocked"
-      };
-    case "task_closed":
-      return {
-        ...base,
-        state: "closed"
-      };
-    case "repair_idle": {
-      const {
-        forcedCompletion: _cleared,
-        supervisedRecovery: _clearedMarker,
-        settlementRecovery: _clearedSettlementMarker,
-        noMutationSettlement: _clearedSettlement,
-        externalEvidence: _clearedExternalEvidence,
-        ...withoutForced
-      } = base;
-      return {
-        ...withoutForced,
-        generation: current.generation + 1,
-        state: "idle",
-        retryCount: 0,
-        retryHistory: [],
-        retryEpoch: 0
-      };
-    }
-  }
-}
-function getEvidenceDir(directory) {
-  const swarmDir = path4.resolve(directory, ".swarm");
-  const evidenceDir = path4.join(swarmDir, "evidence");
-  mkdirSync3(evidenceDir, { recursive: true });
-  let resolvedSwarmDir;
-  let resolvedEvidenceDir;
-  try {
-    resolvedSwarmDir = path4.normalize(realpathSync2(swarmDir));
-    resolvedEvidenceDir = path4.normalize(realpathSync2(evidenceDir));
-  } catch (error) {
-    throw new Error(`Unable to resolve evidence directory: ${error.message}`);
-  }
-  const swarmPrefix = `${resolvedSwarmDir}${path4.sep}`;
-  const withinSwarmBoundary = process.platform === "win32" ? resolvedEvidenceDir.toLowerCase().startsWith(swarmPrefix.toLowerCase()) : resolvedEvidenceDir.startsWith(swarmPrefix);
-  if (!withinSwarmBoundary) {
-    throw new Error(`Evidence path escapes .swarm boundary: ${resolvedEvidenceDir}`);
-  }
-  return resolvedEvidenceDir;
-}
-function getEvidencePath(directory, taskId) {
-  assertValidTaskId(taskId);
-  return taskEvidencePath(directory, taskId);
-}
-function bindTrustedNoMutationSettlement(directory, taskId, event) {
-  if (event.type !== "dispatch_no_mutation")
-    return event;
-  const context = event.context;
-  if (!context || event.transitionId === undefined) {
-    return { ...event, context: undefined };
-  }
-  try {
-    const wal = readWorkflowWalFileSync("coder-settlement", validateSwarmPath(directory, `coder-settlements/${taskId}.json`), taskId);
-    const declaredFiles = wal?.context?.declaredFiles;
-    const trusted = wal !== null && (wal.state === "PREPARED" || wal.state === "COMMITTED") && wal.accepted === false && wal.transitionId === event.transitionId && Array.isArray(declaredFiles) && declaredFiles.length === 0 && Array.isArray(context.declaredFiles) && context.declaredFiles.length === 0;
-    return {
-      ...event,
-      context: trusted ? {
-        ...context,
-        declaredFiles,
-        settlementTransitionId: wal.transitionId
-      } : { ...context, settlementTransitionId: undefined }
-    };
-  } catch {
-    return {
-      ...event,
-      context: { ...context, settlementTransitionId: undefined }
-    };
-  }
-}
-function readExisting(evidencePath, taskId) {
-  try {
-    const raw = readFileSync3(evidencePath, "utf-8");
-    return parseTaskEvidence(raw, taskId);
-  } catch (error) {
-    if (error.code === "ENOENT")
-      return null;
-    telemetry.gateParseError(taskId, error);
-    throw error;
-  }
-}
-function deriveRequiredGates(agentType, context = {}) {
-  switch (agentType) {
-    case "coder":
-      return context.testEngineerExempt === true ? ["reviewer"] : ["reviewer", "test_engineer"];
-    case "docs":
-      return ["docs"];
-    case "designer":
-      return ["designer", "reviewer", "test_engineer"];
-    case "explorer":
-      return ["explorer"];
-    case "sme":
-      return ["sme"];
-    case "reviewer":
-      return ["reviewer"];
-    case "test_engineer":
-      return ["test_engineer"];
-    case "critic":
-      return ["critic"];
-    case "critic_sounding_board":
-      return ["critic_sounding_board"];
-    case "critic_drift_verifier":
-      return ["critic_drift_verifier"];
-    case "critic_hallucination_verifier":
-      return ["critic_hallucination_verifier"];
-    case "critic_architecture_supervisor":
-      return ["critic_architecture_supervisor"];
-    default:
-      return ["reviewer", "test_engineer"];
-  }
-}
-function expandRequiredGates(existingGates, newAgentType, context = {}) {
-  const newGates = deriveRequiredGates(newAgentType, context);
-  const combined = [...new Set([...existingGates ?? [], ...newGates])];
-  return combined.sort();
-}
-function updateEvidenceForTransition(existing, event) {
-  const nowIso = new Date().toISOString();
-  const requiredGates = maybeExpandRequiredGates(existing, event);
-  let gates = {
-    ...existing?.gates ?? {}
-  };
-  if (event.type === "accepted_mutation" || event.type === "repair_idle") {
-    gates = clearWorkflowGateProof(gates);
-  }
-  if (event.type === "stage_a_passed") {
-    gates = {
-      ...gates,
-      pre_check: {
-        sessionId: "system",
-        timestamp: nowIso,
-        agent: "pre_check"
-      }
-    };
-  }
-  if (event.type === "stage_a_failed") {
-    delete gates.pre_check;
-  }
-  if (event.type === "stage_b_failed") {
-    delete gates.reviewer;
-    delete gates.test_engineer;
-  }
-  if (event.type === "stage_b_completed" || event.type === "gate_recorded") {
-    gates = {
-      ...gates,
-      [event.gate]: {
-        sessionId: event.sessionId,
-        timestamp: nowIso,
-        agent: event.gate
-      }
-    };
-  }
-  const snapshot = getTaskWorkflowSnapshot(existing);
-  assertExpectedGeneration(snapshot, event);
-  if (isDuplicateTransition(snapshot, event) && existing) {
-    return existing;
-  }
-  const workflow = reduceTaskWorkflowSnapshot(snapshot, event, {
-    requiredGates,
-    gates,
-    nowIso
-  });
-  return {
-    taskId: existing?.taskId ?? "",
-    required_gates: requiredGates,
-    gates,
-    turbo: "turbo" in event && event.turbo === true ? true : ("turbo" in event) && event.turbo === false ? existing?.turbo : existing?.turbo,
-    test_engineer_exempt: (event.type === "dispatch_attempted" || event.type === "dispatch_no_mutation" || event.type === "accepted_mutation") && event.agentType === "coder" ? event.context?.testEngineerExempt === true && !requiredGates.includes("test_engineer") : existing?.test_engineer_exempt,
-    workflow,
-    requirements_state: existing?.requirements_state,
-    ...existing?.repair_provenance ? { repair_provenance: existing.repair_provenance } : {},
-    ...existing?.todo_scan ? { todo_scan: existing.todo_scan } : {}
-  };
-}
-async function transitionTaskWorkflowEvidence(directory, taskId, event) {
-  const { evidence } = await transitionTaskWorkflowEvidenceWithStatus(directory, taskId, event);
-  return evidence;
-}
-async function transitionTaskWorkflowEvidenceWithStatus(directory, taskId, event) {
-  assertValidTaskId(taskId);
-  let updatedEvidence = null;
-  let duplicated = false;
-  await withTaskEvidenceTransaction(directory, taskId, event.type, async (transaction) => {
-    if (transaction.transitionWithStatus) {
-      const result = await transaction.transitionWithStatus(event);
-      updatedEvidence = result.evidence;
-      duplicated = result.duplicated;
-      return;
-    }
-    updatedEvidence = await transaction.transition(event);
-  });
-  return {
-    evidence: updatedEvidence ?? {
-      taskId,
-      required_gates: [],
-      gates: {},
-      workflow: createDefaultWorkflowMetadata(new Date().toISOString())
-    },
-    duplicated
-  };
-}
-async function withTaskEvidenceTransaction(directory, taskId, agent, callback) {
-  assertValidTaskId(taskId);
-  return withTaskEvidenceLock(directory, taskId, agent, async () => {
-    const resolvedEvidenceDir = getEvidenceDir(directory);
-    const evidencePath = path4.join(resolvedEvidenceDir, `${taskId}.json`);
-    let current = null;
-    try {
-      current = readExisting(evidencePath, taskId);
-    } catch (error) {
-      telemetry.gateParseError(taskId, error);
-      throw error;
-    }
-    const persist = async (nextEvidence, event) => {
-      const planIdentity = resolveCurrentPlanIdentitySync(directory);
-      const validated = TaskEvidenceSchema.parse({
-        ...nextEvidence,
-        taskId,
-        ...planStampForPersist(nextEvidence, current, planIdentity, event?.type === "accepted_mutation" && event.agentType === "coder" && nextEvidence !== current)
-      });
-      await atomicWriteFile(evidencePath, JSON.stringify(validated, null, 2));
-      if (event) {
-        await _internals3.appendTaskGateRequirementsReceiptIfNeeded(directory, taskId, current, validated, event);
-      }
-      current = validated;
-      return validated;
-    };
-    const transitionWithStatusImpl = async (event) => {
-      const boundEvent = bindTrustedNoMutationSettlement(directory, taskId, event);
-      assertTaskEvidenceWriteAllowed(directory, taskId, boundEvent);
-      const nextEvidence = updateEvidenceForTransition(current, boundEvent);
-      const duplicated = nextEvidence === current;
-      nextEvidence.taskId = taskId;
-      const evidence = await persist(nextEvidence, boundEvent);
-      return { evidence, duplicated };
-    };
-    const saveImpl = async (nextEvidence) => {
-      assertTaskEvidenceWriteAllowed(directory, taskId, undefined);
-      nextEvidence.taskId = taskId;
-      return persist(nextEvidence);
-    };
-    return callback({
-      taskId,
-      read: () => current,
-      transition: async (event) => {
-        const { evidence } = await transitionWithStatusImpl(event);
-        return evidence;
-      },
-      transitionWithStatus: transitionWithStatusImpl,
-      save: saveImpl
-    });
-  });
-}
-async function ensureTaskGateRequirementsReceiptForSettledTransition(directory, taskId, evidence, event) {
-  assertValidTaskId(taskId);
-  const validated = TaskEvidenceSchema.parse({ ...evidence, taskId });
-  await _internals3.appendTaskGateRequirementsReceiptIfNeeded(directory, taskId, null, validated, event);
-}
-async function recordGateEvidence(directory, taskId, gate, sessionId, turbo, options = {}) {
-  assertValidTaskId(taskId);
-  if (shouldTreatGateAsStageB(gate) && typeof options.expectedGeneration !== "number") {
-    throw new Error(`TASK_WORKFLOW_GENERATION_REQUIRED: ${gate} for task ${taskId} must be bound at dispatch`);
-  }
-  await transitionTaskWorkflowEvidence(directory, taskId, shouldTreatGateAsStageB(gate) ? {
-    type: "stage_b_completed",
-    gate,
-    sessionId,
-    routeBinding: options.routeBinding,
-    routeComplete: options.routeComplete,
-    turbo,
-    ensureDefaultStageB: options.ensureDefaultStageB,
-    expectedGeneration: options.expectedGeneration,
-    transitionId: options.transitionId
-  } : {
-    type: "gate_recorded",
-    gate,
-    sessionId,
-    turbo,
-    expectedGeneration: options.expectedGeneration,
-    transitionId: options.transitionId
-  });
-  telemetry.gatePassed(sessionId, gate, taskId);
-}
-async function recordTodoScanEvidence(directory, taskId, scan) {
-  assertValidTaskId(taskId);
-  await withTaskEvidenceTransaction(directory, taskId, "todo_scan_recorded", async (transaction) => {
-    const existing = transaction.read();
-    const base = existing ?? {
-      taskId,
-      required_gates: [],
-      gates: {},
-      workflow: createDefaultWorkflowMetadata(new Date().toISOString())
-    };
-    if (!transaction.save) {
-      throw new Error(`TASK_EVIDENCE_SAVE_UNAVAILABLE: transaction for task ${taskId} does not support supplementary writes`);
-    }
-    await transaction.save({ ...base, todo_scan: scan });
-  });
-}
-async function recordAgentDispatch(directory, taskId, agentType, turbo, context = {}) {
-  assertValidTaskId(taskId);
-  const expectedGeneration = getTaskWorkflowSnapshot(await readTaskEvidence(directory, taskId)).generation;
-  await transitionTaskWorkflowEvidence(directory, taskId, agentType === "coder" ? {
-    type: "accepted_mutation",
-    agentType,
-    turbo,
-    context,
-    expectedGeneration
-  } : {
-    type: "dispatch_attempted",
-    agentType,
-    turbo,
-    context,
-    expectedGeneration
-  });
-}
-async function readTaskEvidence(directory, taskId) {
-  const state = await readTaskEvidenceState(directory, taskId);
-  return state.kind === "ok" ? state.evidence : null;
-}
-async function readTaskEvidenceState(directory, taskId) {
-  try {
-    assertValidTaskId(taskId);
-  } catch {
-    return { kind: "missing" };
-  }
-  try {
-    const evidencePath = getEvidencePath(directory, taskId);
-    const raw = readFileSync3(evidencePath, "utf-8");
-    const evidence = parseTaskEvidence(raw, taskId);
-    return { kind: "ok", evidence };
-  } catch (error) {
-    const evidencePath = getEvidencePathSafe(directory, taskId);
-    const code = error.code;
-    if (code === "ENOENT" || code === "ENAMETOOLONG") {
-      return { kind: "missing" };
-    }
-    telemetry.gateParseError(taskId, error);
-    return { kind: "unparseable", evidencePath, error };
-  }
-}
-function getEvidencePathSafe(directory, taskId) {
-  try {
-    return getEvidencePath(directory, taskId);
-  } catch {
-    return `${directory}/.swarm/evidence/${taskId}.json`;
-  }
-}
-function readTaskEvidenceRaw(directory, taskId) {
-  assertValidTaskId(taskId);
-  const evidencePath = getEvidencePath(directory, taskId);
-  try {
-    const raw = readFileSync3(evidencePath, "utf-8");
-    return parseTaskEvidence(raw, taskId);
-  } catch (error) {
-    const code = error.code;
-    if (code === "ENOENT" || code === "ENAMETOOLONG")
-      return null;
-    throw error;
-  }
-}
-async function hasPassedAllGates(directory, taskId, currentDeclaredFiles) {
-  const evidence = await readTaskEvidence(directory, taskId);
-  if (!evidence)
-    return false;
-  if (!Array.isArray(evidence.required_gates))
-    return false;
-  if (currentDeclaredFiles === undefined) {
-    if (deriveApplicableGateSet(evidence).readOnlyNoMutation)
-      return false;
-    return hasAllRequiredGatesPassed(evidence.required_gates, evidence.gates);
-  }
-  return deriveApplicableGateSet(evidence, { currentDeclaredFiles }).missingGates.length === 0;
-}
-function compareTaskWorkflowStateRank(left, right) {
-  return WORKFLOW_STATE_RANK[left] - WORKFLOW_STATE_RANK[right];
-}
-
-export { readTaskGateRequirementsReceiptsSync, routeEvidenceFromTaskGateRequirements, isLegacyTaskGateRequirementsChain, isStrictTaskId, sanitizeTaskId, validateTaskIdFormat, listRecoveryRecords, recoveryReadErrored, _internals, SOURCE_WORKTREE_GONE_STAGE, SOURCE_WORKTREE_UNCERTAIN_STAGE, getMergeStrategy, recoverMergeBackFromImmutableCoordinates, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, readWorkflowWalFile, writeWorkflowWalFile, _internals3 as _internals1, TASK_WORKFLOW_SCHEMA_MARKER, readCurrentTaskDeclaredFiles, TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL, assertTaskEvidenceWriteAllowed, ExternalEvidenceBundleSchema, parseTaskEvidence, resolveCurrentPlanIdentitySync, evidenceStampedForDifferentPlan, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, deriveApplicableGateSet, isReadOnlyNoMutationEligible, computeExternalDeclarationDigest, externalProofCurrent, isExternalEvidenceInitialCompletionEligible, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, transitionTaskWorkflowEvidenceWithStatus, withTaskEvidenceTransaction, ensureTaskGateRequirementsReceiptForSettledTransition, recordGateEvidence, recordTodoScanEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceState, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };
+export { listRecoveryRecords, recoveryReadErrored, probeSettlementSource, preserveSettlementSource, releaseSettlementSource, validateSettlementLane, _internals2 as _internals, SOURCE_WORKTREE_GONE_STAGE, SOURCE_WORKTREE_UNCERTAIN_STAGE, getMergeStrategy, recoverMergeBackFromImmutableCoordinates, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, _internals3 as _internals1, readWorkflowWalFile, readWorkflowWalFileSync, writeWorkflowWalFile };