opencode-swarm 7.154.0 → 7.154.2

package/dist/cli/index-9avdncr2.js

@@ -0,0 +1,875 @@
+// @bun
+import {
+  removeWorktreeProvisioningOwner
+} from "./index-4xqa0sgz.js";
+import {
+  SOURCE_WORKTREE_GONE_STAGE,
+  getTaskWorkflowSnapshot,
+  readWorkflowWalFile,
+  reconcileLandedMerge,
+  withTaskEvidenceTransaction,
+  writeWorkflowWalFile
+} from "./index-8v69hfpt.js";
+import {
+  canonicalRootKeyFresh
+} from "./index-ddszzne4.js";
+import {
+  captureWorkspaceSnapshot,
+  changedFilesSinceSnapshot
+} from "./index-vnn7qq8c.js";
+import {
+  appendCoreEventSync
+} from "./index-xdy28ngt.js";
+import {
+  isPathWithinDeclaredScope
+} from "./index-556ja8an.js";
+import {
+  validateSwarmPath
+} from "./index-4cgee5vh.js";
+import {
+  init_git_executable,
+  resolveGitExecutable
+} from "./index-9e6fdz2h.js";
+import {
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-4rhhvd1a.js";
+import {
+  tryAcquireLock
+} from "./index-xagq35tf.js";
+import {
+  criticalWarn,
+  init_logger
+} from "./index-zgwm4ryv.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
+
+// src/workflow/coder-settlement.ts
+import { spawnSync } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { readdir } from "fs/promises";
+
+// src/gate-evidence-classification.ts
+import * as path from "path";
+function normalizeCandidate(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return null;
+  if ([...value].some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint === 127;
+  }))
+    return null;
+  if (path.win32.isAbsolute(value) || path.posix.isAbsolute(value))
+    return null;
+  const normalized = value.replace(/\\/g, "/");
+  const segments = normalized.split("/");
+  if (segments.some((segment) => segment === "" || segment === "." || segment === "..")) {
+    return null;
+  }
+  return normalized;
+}
+function isExactMarkdownPath(value) {
+  const normalized = normalizeCandidate(value);
+  return normalized !== null && path.posix.extname(normalized) === ".md";
+}
+function isMarkdownOnlyDeclaredScope(value) {
+  return Array.isArray(value) && value.length > 0 && value.every(isExactMarkdownPath);
+}
+function isMarkdownOnlyTaskChange(declaredFiles, observedFiles) {
+  if (!Array.isArray(declaredFiles) || !Array.isArray(observedFiles))
+    return false;
+  if (!isMarkdownOnlyDeclaredScope(declaredFiles) || observedFiles.length === 0)
+    return false;
+  if (!observedFiles.every(isExactMarkdownPath))
+    return false;
+  const declared = new Set(declaredFiles.map(normalizeCandidate).filter((value) => value !== null));
+  return observedFiles.every((value) => {
+    const normalized = normalizeCandidate(value);
+    return normalized !== null && declared.has(normalized);
+  });
+}
+
+// src/workflow/coder-settlement.ts
+init_warning_buffer();
+init_git_executable();
+init_logger();
+var LIVE_DISPATCHES_SYMBOL = Symbol.for("opencode-swarm.workflow.coder-settlement.live-dispatches");
+var globalRegistry = globalThis;
+if (!globalRegistry[LIVE_DISPATCHES_SYMBOL]) {
+  globalRegistry[LIVE_DISPATCHES_SYMBOL] = new Set;
+}
+var liveDispatches = globalRegistry[LIVE_DISPATCHES_SYMBOL];
+var runtimeId = randomUUID();
+var MAX_LIVE_DISPATCHES = 512;
+function dispatchKey(directory, taskId, transitionId) {
+  return `${canonicalRootKeyFresh(directory)}\x00${taskId}\x00${transitionId}`;
+}
+function walPath(directory, taskId) {
+  return validateSwarmPath(directory, `coder-settlements/${taskId}.json`);
+}
+async function readWal(filePath, taskId) {
+  return readWorkflowWalFile("coder-settlement", filePath, taskId);
+}
+async function withSettlementLock(directory, taskId, actor, operation) {
+  const target = `coder-settlements/${taskId}.json`;
+  const lock = await tryAcquireLock(directory, target, actor, `coder-settlement-${taskId}-${Date.now()}`);
+  if (!lock.acquired) {
+    throw new Error(`CODER_SETTLEMENT_LOCKED: task ${taskId}`);
+  }
+  try {
+    return await operation();
+  } finally {
+    await lock.lock._release?.().catch(() => {
+      return;
+    });
+  }
+}
+async function writeWal(filePath, wal) {
+  await writeWorkflowWalFile("coder-settlement", filePath, wal);
+}
+async function appendSettlementEvent(directory, action, wal, extra) {
+  try {
+    appendCoreEventSync(directory, {
+      type: "coder_settlement",
+      action,
+      timestamp: new Date().toISOString(),
+      taskId: wal.taskId,
+      transitionId: wal.transitionId,
+      actor: wal.actor,
+      ...extra ?? {}
+    });
+  } catch (error) {
+    criticalWarn(`[coder-settlement] lifecycle event write failed (${action} ${wal.taskId}): ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function baselineAttributionDoomed(baseline) {
+  if (baseline.gitHead === null)
+    return true;
+  return Array.isArray(baseline.changedFiles) && baseline.changedFiles.length > 0;
+}
+function doomedReason(baseline) {
+  if (baseline.gitHead === null)
+    return "launch workspace has no git baseline (not a git repository, or git unavailable at dispatch)";
+  return `launch baseline was dirty with ${String(baseline.changedFiles?.length ?? 0)} pre-existing uncommitted/untracked change(s)`;
+}
+function isProcessAlive(processId) {
+  if (processId === process.pid)
+    return true;
+  try {
+    process.kill(processId, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function scopedObservedFiles(directory, context) {
+  const baseline = { ...context.baseline, directory };
+  const observed = changedFilesSinceSnapshot(directory, baseline);
+  if (!observed || !context.declaredFiles)
+    return null;
+  return observed.filter((filePath) => isPathWithinDeclaredScope(filePath, context.declaredFiles ?? [], directory));
+}
+async function commitPrepared(directory, wal) {
+  return withTaskEvidenceTransaction(directory, wal.taskId, wal.actor, async (transaction) => {
+    let lockedWal = await readWal(walPath(directory, wal.taskId), wal.taskId);
+    if (lockedWal === null)
+      throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+    if (lockedWal.transitionId !== wal.transitionId) {
+      throw new Error("CODER_SETTLEMENT_WAL_REPLACED");
+    }
+    const snapshot = getTaskWorkflowSnapshot(transaction.read());
+    const evidenceAlreadySettled = lockedWal.accepted === true ? snapshot.authoritative && snapshot.state === (lockedWal.settlementFailed === true ? "rework_required" : "coder_delegated") && snapshot.generation === lockedWal.expectedGeneration + 1 && snapshot.lastOutcome === (lockedWal.settlementFailed === true ? "accepted_mutation_failed" : "accepted_mutation") && snapshot.lastTransitionId === lockedWal.transitionId : snapshot.generation === lockedWal.expectedGeneration && snapshot.lastOutcome === "dispatch_no_mutation" && snapshot.lastTransitionId === lockedWal.transitionId;
+    if (evidenceAlreadySettled) {
+      if (lockedWal.state !== "COMMITTED") {
+        lockedWal = {
+          ...lockedWal,
+          state: "COMMITTED",
+          cleanupComplete: lockedWal.worktree === undefined
+        };
+        await writeWal(walPath(directory, wal.taskId), lockedWal);
+        await appendSettlementEvent(directory, "settled", lockedWal, {
+          resumed: true
+        });
+      }
+      return {
+        evidence: transaction.read(),
+        accepted: lockedWal.accepted === true,
+        alreadyApplied: true
+      };
+    }
+    if (lockedWal.state !== "PREPARED") {
+      throw new Error("CODER_SETTLEMENT_NOT_PREPARED");
+    }
+    const evidence = await transaction.transition(lockedWal.accepted ? {
+      type: "accepted_mutation",
+      agentType: "coder",
+      context: {
+        testEngineerExempt: lockedWal.testEngineerExempt === true,
+        settlementFailed: lockedWal.settlementFailed === true
+      },
+      expectedGeneration: lockedWal.expectedGeneration,
+      transitionId: lockedWal.transitionId
+    } : {
+      type: "dispatch_no_mutation",
+      agentType: "coder",
+      expectedGeneration: lockedWal.expectedGeneration,
+      transitionId: lockedWal.transitionId
+    });
+    lockedWal = {
+      ...lockedWal,
+      state: "COMMITTED",
+      cleanupComplete: lockedWal.worktree === undefined
+    };
+    await writeWal(walPath(directory, wal.taskId), lockedWal);
+    await appendSettlementEvent(directory, "settled", lockedWal);
+    return {
+      evidence,
+      accepted: lockedWal.accepted === true,
+      alreadyApplied: false
+    };
+  });
+}
+async function beginCoderSettlement(options) {
+  if (options.context.baseline.gitHead === null) {
+    const rootBaseline = captureWorkspaceSnapshot(options.directory);
+    if (rootBaseline.gitHead !== null) {
+      throw new Error(`CODER_SETTLEMENT_BASELINE_UNAVAILABLE: the launch baseline for task ${options.taskId} has no git HEAD \u2014 the observation directory (${options.context.baseline.directory}) is not a git repository or git is unavailable there. ` + "An unregistered worktree lane (a lane directory that git worktree list does not know) produces exactly this. " + 'The task was not dispatched and no settlement state was created; retry the dispatch, or set worktree.policy "disabled" to run coders in the primary tree.');
+    }
+  }
+  const filePath = walPath(options.directory, options.taskId);
+  let ownsActiveDispatch = false;
+  await withSettlementLock(options.directory, options.taskId, options.actor, () => withTaskEvidenceTransaction(options.directory, options.taskId, options.actor, async (transaction) => {
+    const snapshot = getTaskWorkflowSnapshot(transaction.read());
+    if (snapshot.generation !== options.expectedGeneration) {
+      throw new Error(`TASK_WORKFLOW_GENERATION_MISMATCH: expected ${options.expectedGeneration}, found ${snapshot.generation}`);
+    }
+    const existing = await readWal(filePath, options.taskId);
+    if (existing !== null) {
+      if ((existing.state === "DISPATCHED" || existing.state === "PREPARED") && existing.transitionId !== options.transitionId) {
+        throw new Error(`CODER_SETTLEMENT_IN_PROGRESS: transition ${existing.transitionId} owns task ${options.taskId}, so transition ${options.transitionId} cannot dispatch it (${filePath}, state ${existing.state}). Wait for the owning transition to settle or run /swarm recover ${options.taskId} (or /swarm reset-session), then retry; do not remove the WAL by hand.`);
+      }
+      if (existing.transitionId === options.transitionId) {
+        const immutableMatches = existing.actor === options.actor && existing.expectedGeneration === options.expectedGeneration && JSON.stringify(existing.context) === JSON.stringify(options.context) && JSON.stringify(existing.worktree) === JSON.stringify(options.worktree);
+        if (!immutableMatches) {
+          throw new Error("CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT");
+        }
+        if (existing.state === "ABORTED") {
+          throw new Error("CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT");
+        }
+        ownsActiveDispatch = existing.state === "DISPATCHED" && existing.runtimeId === runtimeId;
+        return;
+      }
+    }
+    await transaction.transition({
+      type: "dispatch_attempted",
+      agentType: "coder",
+      expectedGeneration: options.expectedGeneration,
+      transitionId: options.transitionId
+    });
+    await writeWal(filePath, {
+      version: 1,
+      state: "DISPATCHED",
+      taskId: options.taskId,
+      transitionId: options.transitionId,
+      actor: options.actor,
+      processId: process.pid,
+      runtimeId,
+      expectedGeneration: options.expectedGeneration,
+      context: options.context,
+      ...options.worktree ? { worktree: options.worktree } : {},
+      recordedAt: new Date().toISOString()
+    });
+    ownsActiveDispatch = true;
+    await appendSettlementEvent(options.directory, "dispatched", {
+      taskId: options.taskId,
+      transitionId: options.transitionId,
+      actor: options.actor
+    });
+  }));
+  if (ownsActiveDispatch) {
+    const key = dispatchKey(options.directory, options.taskId, options.transitionId);
+    if (!liveDispatches.has(key) && liveDispatches.size >= MAX_LIVE_DISPATCHES) {
+      throw new Error("CODER_SETTLEMENT_CAPACITY_EXCEEDED");
+    }
+    liveDispatches.add(key);
+  }
+}
+async function settleCoderDispatch(options) {
+  return withSettlementLock(options.directory, options.taskId, "coder-settlement", async () => {
+    const filePath = walPath(options.directory, options.taskId);
+    const wal = await readWal(filePath, options.taskId);
+    if (wal === null)
+      throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+    if (wal.transitionId !== options.transitionId) {
+      throw new Error("CODER_SETTLEMENT_WAL_REPLACED");
+    }
+    if (wal.state === "COMMITTED") {
+      if (wal.accepted !== options.accepted || wal.testEngineerExempt !== options.testEngineerExempt || wal.settlementFailed !== (options.settlementFailed === true)) {
+        throw new Error("CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT");
+      }
+      return commitPrepared(options.directory, wal);
+    }
+    if (wal.state === "ABORTED") {
+      throw new Error("CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT");
+    }
+    if (wal.state === "PREPARED" && (wal.accepted !== options.accepted || wal.testEngineerExempt !== options.testEngineerExempt || wal.settlementFailed !== (options.settlementFailed === true))) {
+      throw new Error("CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT");
+    }
+    const prepared = {
+      ...wal,
+      state: "PREPARED",
+      accepted: options.accepted,
+      testEngineerExempt: options.testEngineerExempt,
+      settlementFailed: options.settlementFailed === true
+    };
+    if (wal.state !== "PREPARED")
+      await writeWal(filePath, prepared);
+    liveDispatches.delete(dispatchKey(options.directory, options.taskId, options.transitionId));
+    try {
+      return await commitPrepared(options.directory, prepared);
+    } finally {
+      const finalWal = await readWal(filePath, options.taskId);
+      if (finalWal !== null && finalWal.state === "COMMITTED") {
+        liveDispatches.delete(dispatchKey(options.directory, options.taskId, options.transitionId));
+      }
+    }
+  });
+}
+async function abortCoderSettlement(options) {
+  const { outcome, worktree } = await withSettlementLock(options.directory, options.taskId, "coder-abort", async () => abortDispatchedWalUnderLock(options.directory, options.taskId, options.transitionId, options.reason));
+  if (worktree && outcome !== "not-dispatched") {
+    try {
+      await completeCoderSettlementCleanup(options.directory, options.taskId, options.transitionId);
+    } catch (error) {
+      criticalWarn(`[coder-settlement] aborted settlement worktree cleanup failed for task ${options.taskId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return outcome;
+}
+async function transferCoderSettlementToBackground(options) {
+  return withSettlementLock(options.directory, options.taskId, "coder-background-transfer", async () => {
+    const filePath = walPath(options.directory, options.taskId);
+    const wal = await readWal(filePath, options.taskId);
+    if (wal === null)
+      return "missing";
+    if (wal.taskId !== options.taskId || wal.transitionId !== options.transitionId) {
+      throw new Error("CODER_SETTLEMENT_WAL_REPLACED");
+    }
+    if (wal.state === "PREPARED") {
+      throw new Error("CODER_SETTLEMENT_IN_PROGRESS");
+    }
+    if (wal.state !== "DISPATCHED") {
+      liveDispatches.delete(dispatchKey(options.directory, options.taskId, options.transitionId));
+      return "already-terminal";
+    }
+    const reason = "ownership transferred to durable background completion";
+    await writeWal(filePath, {
+      ...wal,
+      state: "ABORTED",
+      abortReason: reason,
+      cleanupComplete: true
+    });
+    liveDispatches.delete(dispatchKey(options.directory, options.taskId, options.transitionId));
+    await appendSettlementEvent(options.directory, "aborted", wal, {
+      reason,
+      ownership: "background-delegation"
+    });
+    return "transferred";
+  });
+}
+async function abortDispatchedWalUnderLock(directory, taskId, transitionId, reason) {
+  const filePath = walPath(directory, taskId);
+  const wal = await readWal(filePath, taskId);
+  if (wal === null)
+    throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+  if (wal.transitionId !== transitionId) {
+    throw new Error("CODER_SETTLEMENT_WAL_REPLACED");
+  }
+  if (wal.state === "ABORTED") {
+    return { outcome: "already-aborted", worktree: wal.worktree !== undefined };
+  }
+  if (wal.state !== "DISPATCHED") {
+    return { outcome: "not-dispatched", worktree: false };
+  }
+  await writeWal(filePath, {
+    ...wal,
+    state: "ABORTED",
+    abortReason: reason
+  });
+  liveDispatches.delete(dispatchKey(directory, taskId, transitionId));
+  await appendSettlementEvent(directory, "aborted", wal, { reason });
+  return { outcome: "aborted", worktree: wal.worktree !== undefined };
+}
+async function abortCoderSettlementIfDoomed(options) {
+  const filePath = walPath(options.directory, options.taskId);
+  let wal;
+  try {
+    wal = await readWal(filePath, options.taskId);
+  } catch {
+    return "not-doomed";
+  }
+  if (wal === null)
+    return "not-doomed";
+  if (wal.state === "ABORTED")
+    return "already-aborted";
+  if (wal.transitionId !== options.transitionId || wal.state !== "DISPATCHED") {
+    return "not-doomed";
+  }
+  if (!baselineAttributionDoomed(wal.context.baseline))
+    return "not-doomed";
+  const outcome = await abortCoderSettlement({
+    directory: options.directory,
+    taskId: options.taskId,
+    transitionId: options.transitionId,
+    reason: doomedReason(wal.context.baseline)
+  });
+  return outcome === "aborted" || outcome === "already-aborted" ? outcome : "not-doomed";
+}
+async function recordCoderMergeProvenance(options) {
+  await withSettlementLock(options.directory, options.taskId, "coder-merge-provenance", async () => {
+    const filePath = walPath(options.directory, options.taskId);
+    const wal = await readWal(filePath, options.taskId);
+    if (wal === null)
+      throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+    if (wal.taskId !== options.taskId || wal.transitionId !== options.transitionId) {
+      throw new Error("CODER_SETTLEMENT_WAL_REPLACED");
+    }
+    if (wal.state !== "DISPATCHED") {
+      const sameProvenance = JSON.stringify(wal.mergeProvenance) === JSON.stringify(options.provenance) && JSON.stringify(wal.observedFiles) === JSON.stringify(options.observedFiles);
+      if (!sameProvenance)
+        throw new Error("CODER_SETTLEMENT_IDEMPOTENCY_CONFLICT");
+      return;
+    }
+    await writeWal(filePath, {
+      ...wal,
+      mergeProvenance: options.provenance,
+      observedFiles: [...options.observedFiles]
+    });
+  });
+}
+function probeBranchExists(directory, branchName) {
+  const result = spawnSync(resolveGitExecutable(), [
+    "-C",
+    directory,
+    "show-ref",
+    "--verify",
+    "--quiet",
+    `refs/heads/${branchName}`
+  ], {
+    cwd: directory,
+    stdio: ["ignore", "ignore", "ignore"],
+    timeout: 5000,
+    windowsHide: true
+  });
+  if (result.error)
+    throw result.error;
+  if (result.status === 0)
+    return true;
+  if (result.status === 1)
+    return false;
+  throw new Error(`CODER_SETTLEMENT_CLEANUP_UNCERTAIN: git show-ref exited with status ${String(result.status)}`);
+}
+async function cleanupRecoveredWorktree(directory, descriptor) {
+  const branchExists = () => _internals.branchExists(directory, descriptor.branchName);
+  const hasResidue = existsSync(descriptor.worktreePath) || branchExists();
+  const {
+    awaitingMergeByCallID,
+    cleanupStandardWorktreeForCallId,
+    standardWorktreeByCallID
+  } = await import("./worktree-isolation-xsy14t5a.js");
+  standardWorktreeByCallID.delete(descriptor.callID);
+  if (hasResidue)
+    awaitingMergeByCallID.set(descriptor.callID, {
+      callID: descriptor.callID,
+      parentSessionID: descriptor.parentSessionId,
+      taskId: descriptor.taskId,
+      ...descriptor.planTaskId ? { planTaskId: descriptor.planTaskId } : {},
+      branch: descriptor.branchName,
+      worktreePath: descriptor.worktreePath,
+      mergeStrategy: descriptor.mergeStrategy,
+      queuedAt: Date.now()
+    });
+  if (hasResidue) {
+    await cleanupStandardWorktreeForCallId(descriptor.callID, "success", directory, descriptor.worktreeDir ?? undefined);
+  }
+  if (existsSync(descriptor.worktreePath) || branchExists()) {
+    throw new Error("CODER_SETTLEMENT_WORKTREE_CLEANUP_UNVERIFIED");
+  }
+  const provisioningOwner = descriptor.provisioningOwner ?? (descriptor.reservationId !== undefined && descriptor.generation !== undefined ? {
+    reservationId: descriptor.reservationId,
+    generation: descriptor.generation,
+    branchName: descriptor.branchName
+  } : undefined);
+  if (!_internals.removeWorktreeProvisioningOwner(directory, descriptor.callID, provisioningOwner)) {
+    throw new Error("CODER_SETTLEMENT_OWNER_CLEANUP_FAILED");
+  }
+}
+async function completeCoderSettlementCleanup(directory, taskId, transitionId) {
+  await withSettlementLock(directory, taskId, "coder-cleanup", async () => {
+    const filePath = walPath(directory, taskId);
+    const wal = await readWal(filePath, taskId);
+    if (wal === null)
+      throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+    if (wal.taskId !== taskId || wal.transitionId !== transitionId) {
+      throw new Error("CODER_SETTLEMENT_WAL_REPLACED");
+    }
+    if (wal.state !== "COMMITTED" && wal.state !== "ABORTED") {
+      throw new Error("CODER_SETTLEMENT_NOT_COMMITTED");
+    }
+    if (!wal.worktree || wal.cleanupComplete === true)
+      return;
+    await cleanupRecoveredWorktree(directory, wal.worktree);
+    await writeWal(filePath, { ...wal, cleanupComplete: true });
+  });
+}
+async function selfHealMissingLaneWorktree(directory, filePath, taskId, transitionId, descriptor, detail) {
+  if (existsSync(descriptor.worktreePath))
+    return false;
+  if (_internals.branchExists(directory, descriptor.branchName))
+    return false;
+  const reason = `CODER_SETTLEMENT_SELF_HEALED_MISSING_WORKTREE: ${detail}`;
+  const aborted = await abortDispatchedWalUnderLock(directory, taskId, transitionId, reason);
+  if (aborted.outcome === "not-dispatched")
+    return false;
+  try {
+    await cleanupRecoveredWorktree(directory, descriptor);
+    const healedWal = await readWal(filePath, taskId);
+    if (healedWal !== null) {
+      await writeWal(filePath, { ...healedWal, cleanupComplete: true });
+    }
+  } catch (error) {
+    criticalWarn(`[coder-settlement] self-healed task ${taskId} but residual cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  const message = `STALE_CODER_SETTLEMENT_SELF_HEALED: task ${taskId} was blocked by a coder settlement whose lane worktree "${descriptor.worktreePath}" and lane branch "${descriptor.branchName}" no longer exist. Nothing was recoverable, so the write-ahead log at "${filePath}" was marked terminal (ABORTED) and the task was unblocked. Re-dispatch the task if its work still needs doing.`;
+  criticalWarn(message);
+  advisoryWarn(message);
+  return true;
+}
+async function recoverCoderSettlement(directory, taskId) {
+  return withSettlementLock(directory, taskId, "coder-recovery", async () => {
+    const filePath = walPath(directory, taskId);
+    const existingWal = await readWal(filePath, taskId);
+    if (existingWal === null)
+      return null;
+    let wal = existingWal;
+    if (wal.state === "ABORTED")
+      return null;
+    if (wal.state === "COMMITTED") {
+      if (wal.worktree && wal.cleanupComplete !== true) {
+        await cleanupRecoveredWorktree(directory, wal.worktree);
+        await writeWal(filePath, { ...wal, cleanupComplete: true });
+      }
+      return null;
+    }
+    const key = dispatchKey(directory, taskId, wal.transitionId);
+    if (liveDispatches.has(key) || wal.processId !== process.pid && isProcessAlive(wal.processId)) {
+      throw new Error(`CODER_DISPATCH_IN_PROGRESS: transition ${wal.transitionId} still owns task ${taskId} (${filePath}, state ${wal.state}, pid ${wal.processId}). Wait for that dispatch to settle or run /swarm recover ${taskId} (or /swarm reset-session) to unwedge it; do not remove the WAL by hand.`);
+    }
+    if (wal.state === "DISPATCHED") {
+      if (wal.worktree) {
+        const worktree = wal.worktree;
+        const observed2 = wal.observedFiles ?? scopedObservedFiles(worktree.worktreePath, wal.context);
+        if (observed2 === null) {
+          throw new Error(`CODER_SETTLEMENT_RECOVERY_UNCERTAIN: isolated task ${taskId} changes could not be attributed safely`);
+        }
+        if (wal.mergeProvenance) {
+          const landed = await reconcileLandedMerge(directory, wal.mergeProvenance);
+          if (landed.landed) {
+            wal = {
+              ...wal,
+              state: "PREPARED",
+              observedFiles: observed2,
+              accepted: observed2.length > 0,
+              testEngineerExempt: isMarkdownOnlyTaskChange(wal.context.declaredFiles, observed2)
+            };
+            await writeWal(filePath, wal);
+            const committed2 = await commitPrepared(directory, wal);
+            await cleanupRecoveredWorktree(directory, worktree);
+            await writeWal(filePath, {
+              ...wal,
+              state: "COMMITTED",
+              cleanupComplete: true
+            });
+            return committed2;
+          }
+          if (landed.error) {
+            throw new Error(`CODER_SETTLEMENT_RECOVERY_UNCERTAIN: ${landed.error}`);
+          }
+        }
+        const {
+          awaitingMergeByCallID,
+          finishStandardWorktreeDispatch,
+          standardWorktreeByCallID
+        } = await import("./worktree-isolation-xsy14t5a.js");
+        const descriptor = wal.worktree;
+        const reconstructedDispatch = {
+          callID: descriptor.callID,
+          parentSessionID: descriptor.parentSessionId,
+          taskId: descriptor.taskId,
+          ...descriptor.planTaskId ? { planTaskId: descriptor.planTaskId } : {},
+          handle: {
+            worktreePath: descriptor.worktreePath,
+            branchName: descriptor.branchName,
+            purpose: "lane",
+            id: descriptor.worktreeId,
+            sessionId: descriptor.worktreeSessionId
+          },
+          mergeStrategy: descriptor.mergeStrategy,
+          laneIndex: descriptor.laneIndex,
+          ...descriptor.worktreeDir ? { worktree_dir: descriptor.worktreeDir } : {}
+        };
+        standardWorktreeByCallID.delete(descriptor.callID);
+        awaitingMergeByCallID.set(descriptor.callID, {
+          callID: descriptor.callID,
+          parentSessionID: descriptor.parentSessionId,
+          taskId: descriptor.taskId,
+          ...descriptor.planTaskId ? { planTaskId: descriptor.planTaskId } : {},
+          branch: descriptor.branchName,
+          worktreePath: descriptor.worktreePath,
+          mergeStrategy: descriptor.mergeStrategy,
+          queuedAt: Date.now()
+        });
+        let recovered = null;
+        const mergeResult = await finishStandardWorktreeDispatch(directory, reconstructedDispatch, undefined, descriptor.callID, {
+          operationId: wal.transitionId,
+          ...wal.mergeProvenance ? { resume: wal.mergeProvenance } : {},
+          onBeforeMerge: async (provenance) => {
+            wal = {
+              ...wal,
+              mergeProvenance: provenance,
+              observedFiles: observed2
+            };
+            await writeWal(filePath, wal);
+          },
+          onMerged: async () => {
+            wal = {
+              ...wal,
+              state: "PREPARED",
+              accepted: observed2.length > 0,
+              testEngineerExempt: isMarkdownOnlyTaskChange(wal.context.declaredFiles, observed2)
+            };
+            await writeWal(filePath, wal);
+            recovered = await commitPrepared(directory, wal);
+          }
+        });
+        if (mergeResult.outcome !== "merged" || recovered === null) {
+          if (mergeResult.outcome === "failed" && mergeResult.stage === SOURCE_WORKTREE_GONE_STAGE && await selfHealMissingLaneWorktree(directory, filePath, taskId, wal.transitionId, descriptor, mergeResult.message)) {
+            return null;
+          }
+          throw new Error(`CODER_SETTLEMENT_MERGE_RECOVERY_REQUIRED: ${mergeResult.outcome === "failed" ? mergeResult.message : mergeResult.outcome}`);
+        }
+        await cleanupRecoveredWorktree(directory, descriptor);
+        const committedWal = await readWal(filePath, taskId);
+        if (committedWal === null) {
+          throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+        }
+        await writeWal(filePath, {
+          ...committedWal,
+          cleanupComplete: true
+        });
+        return recovered;
+      }
+      const rawObserved = changedFilesSinceSnapshot(directory, wal.context.baseline);
+      let observed;
+      if (rawObserved === null) {
+        if (baselineAttributionDoomed(wal.context.baseline)) {
+          const aborted = await abortDispatchedWalUnderLock(directory, taskId, wal.transitionId, doomedReason(wal.context.baseline));
+          if (aborted.outcome === "aborted" || aborted.outcome === "already-aborted") {
+            return null;
+          }
+        }
+        observed = null;
+      } else if (wal.context.declaredFiles === null) {
+        observed = [];
+      } else {
+        observed = rawObserved.filter((filePath2) => isPathWithinDeclaredScope(filePath2, wal.context.declaredFiles ?? [], directory));
+      }
+      if (observed === null) {
+        throw new Error(`CODER_SETTLEMENT_RECOVERY_UNCERTAIN: task ${taskId} workspace changes could not be attributed safely`);
+      }
+      wal = {
+        ...wal,
+        state: "PREPARED",
+        accepted: observed.length > 0,
+        testEngineerExempt: isMarkdownOnlyTaskChange(wal.context.declaredFiles, observed)
+      };
+      await writeWal(filePath, wal);
+    }
+    const committed = await commitPrepared(directory, wal);
+    if (wal.worktree) {
+      await cleanupRecoveredWorktree(directory, wal.worktree);
+      const committedWal = await readWal(filePath, taskId);
+      if (committedWal === null) {
+        throw new Error("CODER_SETTLEMENT_WAL_MISSING");
+      }
+      await writeWal(filePath, { ...committedWal, cleanupComplete: true });
+    }
+    return committed;
+  });
+}
+function releaseCoderDispatchOwnership(directory, taskId, transitionId) {
+  liveDispatches.delete(dispatchKey(directory, taskId, transitionId));
+}
+async function assertNoUnsettledCoderDispatch(directory, taskId) {
+  const filePath = walPath(directory, taskId);
+  const wal = await readWal(filePath, taskId);
+  if (wal === null)
+    return;
+  if (wal.state === "DISPATCHED" || wal.state === "PREPARED") {
+    throw new Error(`CODER_SETTLEMENT_RECOVERY_REQUIRED: transition ${wal.transitionId} must settle before task ${taskId} can change plan status (${filePath}, state ${wal.state}). Run /swarm recover ${taskId} (or /swarm reset-session), then retry.`);
+  }
+}
+var MAX_SETTLEMENT_WAL_SCAN = 200;
+var SETTLEMENT_WAL_FILE_PATTERN = /^[\w.\-:]+\.json$/;
+async function listCoderSettlementWalStates(directory) {
+  let entries;
+  try {
+    const dirPath = validateSwarmPath(directory, "coder-settlements");
+    entries = await readdir(dirPath);
+  } catch {
+    return { states: [], truncated: false };
+  }
+  const matching = entries.filter((entry) => SETTLEMENT_WAL_FILE_PATTERN.test(entry));
+  const states = [];
+  for (const entry of matching.sort().slice(0, MAX_SETTLEMENT_WAL_SCAN)) {
+    const taskId = entry.slice(0, -".json".length);
+    try {
+      const wal = await readWal(walPath(directory, taskId), taskId);
+      if (wal === null)
+        continue;
+      states.push({
+        taskId,
+        state: wal.state,
+        transitionId: wal.transitionId,
+        processId: wal.processId,
+        recordedAt: wal.recordedAt,
+        accepted: wal.accepted === true ? true : undefined,
+        declaredFiles: wal.context?.declaredFiles ?? null,
+        ownedInProcess: liveDispatches.has(dispatchKey(directory, taskId, wal.transitionId)),
+        ownedByLiveForeignPid: wal.processId !== process.pid && isProcessAlive(wal.processId)
+      });
+    } catch {
+      states.push({
+        taskId,
+        state: "unreadable",
+        ownedInProcess: false,
+        ownedByLiveForeignPid: false
+      });
+    }
+  }
+  return { states, truncated: matching.length > MAX_SETTLEMENT_WAL_SCAN };
+}
+async function recoverStaleCoderSettlements(directory, options) {
+  const { states: listed, truncated } = await listCoderSettlementWalStates(directory);
+  const filter = options?.taskIds ? new Set(options.taskIds) : undefined;
+  const results = [];
+  for (const entry of listed) {
+    if (filter && !filter.has(entry.taskId))
+      continue;
+    if (entry.state === "unreadable") {
+      results.push({ taskId: entry.taskId, outcome: "unreadable_wal" });
+      continue;
+    }
+    if (entry.state === "ABORTED" || entry.state === "COMMITTED") {
+      try {
+        await _internals.recoverCoderSettlement(directory, entry.taskId);
+        results.push({
+          taskId: entry.taskId,
+          outcome: "already_terminal",
+          state: entry.state
+        });
+      } catch (error) {
+        results.push({
+          taskId: entry.taskId,
+          outcome: "error",
+          message: error instanceof Error ? error.message : String(error)
+        });
+      }
+      continue;
+    }
+    if (entry.ownedInProcess && options?.force !== true) {
+      results.push({
+        taskId: entry.taskId,
+        outcome: "owned_in_process",
+        transitionId: entry.transitionId ?? ""
+      });
+      continue;
+    }
+    if (entry.ownedByLiveForeignPid) {
+      results.push({
+        taskId: entry.taskId,
+        outcome: "owned_by_live_foreign_pid",
+        processId: entry.processId ?? -1
+      });
+      continue;
+    }
+    const forced = entry.ownedInProcess && options?.force === true;
+    if (forced && entry.transitionId) {
+      releaseCoderDispatchOwnership(directory, entry.taskId, entry.transitionId);
+      await appendSettlementEvent(directory, "recovered", {
+        taskId: entry.taskId,
+        transitionId: entry.transitionId,
+        actor: "swarm-recovery"
+      }, { forced: true, stage: "ownership-release" });
+    }
+    try {
+      const recovered = await _internals.recoverCoderSettlement(directory, entry.taskId);
+      if (recovered === null) {
+        let current = null;
+        try {
+          current = await readWal(walPath(directory, entry.taskId), entry.taskId);
+        } catch {
+          current = null;
+        }
+        if (current && (current.state === "COMMITTED" || current.state === "ABORTED")) {
+          results.push({
+            taskId: entry.taskId,
+            outcome: "already_terminal",
+            state: current.state
+          });
+          continue;
+        }
+        results.push({
+          taskId: entry.taskId,
+          outcome: "error",
+          message: "settlement WAL disappeared during recovery"
+        });
+        continue;
+      }
+      await appendSettlementEvent(directory, "recovered", {
+        taskId: entry.taskId,
+        transitionId: entry.transitionId ?? "",
+        actor: "swarm-recovery"
+      }, { forced, accepted: recovered.accepted });
+      results.push({
+        taskId: entry.taskId,
+        outcome: "recovered",
+        accepted: recovered.accepted,
+        forced
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      await appendSettlementEvent(directory, "recovery-failed", {
+        taskId: entry.taskId,
+        transitionId: entry.transitionId ?? "",
+        actor: "swarm-recovery"
+      }, { forced, error: message });
+      results.push({
+        taskId: entry.taskId,
+        outcome: "error",
+        message
+      });
+    }
+  }
+  return { results, truncated };
+}
+var _internals = {
+  liveDispatches,
+  removeWorktreeProvisioningOwner,
+  branchExists: probeBranchExists,
+  recoverCoderSettlement
+};
+
+export { beginCoderSettlement, settleCoderDispatch, abortCoderSettlement, transferCoderSettlementToBackground, abortCoderSettlementIfDoomed, recordCoderMergeProvenance, completeCoderSettlementCleanup, recoverCoderSettlement, releaseCoderDispatchOwnership, assertNoUnsettledCoderDispatch, listCoderSettlementWalStates, recoverStaleCoderSettlements, _internals };