opencode-swarm 7.141.2 → 7.142.1

package/dist/cli/index-2mb5y2w1.js

@@ -0,0 +1,1372 @@
+// @bun
+import {
+  autoCommitDirty,
+  cleanUntrackedFiles
+} from "./index-bkkxxwcd.js";
+import {
+  validateSwarmPath
+} from "./index-k46me75h.js";
+import {
+  atomicWriteFile,
+  taskEvidencePath,
+  withTaskEvidenceLock
+} from "./index-erfnw81g.js";
+import {
+  isPathWithinDeclaredScope,
+  unsafePathTextReason
+} from "./index-556ja8an.js";
+import {
+  telemetry
+} from "./index-s2rcz51a.js";
+import {
+  bunSpawn
+} from "./index-4nt52yr9.js";
+import {
+  advisoryWarn,
+  init_warning_buffer
+} from "./index-4rhhvd1a.js";
+import {
+  log
+} from "./index-zgwm4ryv.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
+
+// src/gate-evidence.ts
+init_zod();
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync } from "fs";
+import * as path2 from "path";
+
+// 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}"`);
+}
+
+// src/workflow/workflow-wal-file.ts
+import * as fs2 from "fs";
+import { mkdir, open } from "fs/promises";
+import { dirname } from "path";
+
+// src/worktree/merge.ts
+init_warning_buffer();
+
+// src/turbo/lean/recovery.ts
+import * as fs from "fs";
+import * as path from "path";
+var RECOVERY_DIR_NAME = "recovery";
+function recoveryDir(directory) {
+  return path.join(directory, ".swarm", RECOVERY_DIR_NAME);
+}
+function isRecoveryRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const record = value;
+  const validStatus = record.status === "failed" || record.status === "partial" || record.status === "conflict";
+  return typeof record.laneId === "string" && typeof record.sessionId === "string" && typeof record.worktreePath === "string" && validStatus && typeof record.reason === "string" && typeof record.recordedAt === "number" && Number.isFinite(record.recordedAt) && typeof record.replayHint === "string" && (record.branchName === undefined || typeof record.branchName === "string") && (record.conflictFiles === undefined || Array.isArray(record.conflictFiles) && record.conflictFiles.every((file) => typeof file === "string"));
+}
+function readRecoveryRecords(directory) {
+  const dir = recoveryDir(directory);
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return {
+      records: [],
+      errored: fs.existsSync(dir)
+    };
+  }
+  const records = [];
+  let errored = false;
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json"))
+      continue;
+    const full = path.join(dir, entry.name);
+    try {
+      const parsed = JSON.parse(fs.readFileSync(full, "utf-8"));
+      if (isRecoveryRecord(parsed)) {
+        records.push(parsed);
+      } else {
+        errored = true;
+      }
+    } catch {
+      errored = true;
+    }
+  }
+  return { records, errored };
+}
+function listRecoveryRecords(directory) {
+  return readRecoveryRecords(directory).records;
+}
+function hasRecoveryRecordForBranch(directory, branchName) {
+  const records = listRecoveryRecords(directory);
+  return records.some((r) => r.branchName === branchName);
+}
+function recoveryReadErrored(directory) {
+  return readRecoveryRecords(directory).errored;
+}
+
+// src/worktree/merge.ts
+var _internals = {
+  bunSpawn,
+  platform: process.platform,
+  sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+  cleanupOrphanedBranches,
+  startupOrphanRecovery,
+  extractSessionId
+};
+var MERGE_TIMEOUT_MS = 30000;
+async function runGit(args, cwd, timeoutMs = MERGE_TIMEOUT_MS) {
+  const proc = _internals.bunSpawn(["git", ...args], {
+    cwd,
+    timeout: timeoutMs,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: { ...process.env, LC_ALL: "C" }
+  });
+  try {
+    const exitCode = await proc.exited;
+    const stdout = await proc.stdout.text();
+    const stderr = await proc.stderr.text();
+    return { exitCode, stdout, stderr };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+function parseConflictFiles(output) {
+  const files = [];
+  const lines = output.split(`
+`);
+  for (const line of lines) {
+    const match = line.match(/CONFLICT\b.*(?:Merge conflict in |in )(.+)/);
+    if (match?.[1]) {
+      files.push(match[1].trim());
+    }
+  }
+  return files;
+}
+var GIT_OBJECT_ID_PATTERN = /^[0-9a-f]{40}$|^[0-9a-f]{64}$/;
+function getMergeStrategy(config) {
+  return config.mergeStrategy ?? config.merge_strategy ?? "merge";
+}
+async function mergeLaneBranch(primaryDir, branchName, strategy) {
+  let result;
+  switch (strategy) {
+    case "merge":
+      result = await runGit(["merge", "--no-edit", branchName], primaryDir);
+      break;
+    case "rebase":
+      result = await runGit(["rebase", branchName], primaryDir);
+      break;
+    case "cherry-pick": {
+      const mergeBaseResult = await runGit(["merge-base", "HEAD", branchName], primaryDir);
+      if (mergeBaseResult.exitCode === 0 && mergeBaseResult.stdout.trim()) {
+        const mergeBase = mergeBaseResult.stdout.trim();
+        result = await runGit(["cherry-pick", `${mergeBase}..${branchName}`, "-x"], primaryDir);
+      } else {
+        advisoryWarn("[worktree] mergeLaneBranch: git merge-base failed for cherry-pick; falling back to tip-only cherry-pick");
+        result = await runGit(["cherry-pick", branchName, "-x"], primaryDir);
+      }
+      break;
+    }
+  }
+  if (result.exitCode === 0) {
+    return { merged: true, strategy };
+  }
+  const combinedOutput = `${result.stderr}
+${result.stdout}`;
+  const hasConflict = /CONFLICT/i.test(combinedOutput) || /conflict/i.test(combinedOutput);
+  if (hasConflict) {
+    const files = parseConflictFiles(combinedOutput);
+    const abortArgs = strategy === "rebase" ? ["rebase", "--abort"] : strategy === "cherry-pick" ? ["cherry-pick", "--abort"] : ["merge", "--abort"];
+    await runGit(abortArgs, primaryDir);
+    return {
+      conflict: true,
+      files,
+      message: result.stderr.trim()
+    };
+  }
+  return {
+    error: result.stderr.trim() || result.stdout.trim()
+  };
+}
+async function reconcileLandedMerge(primaryDir, provenance) {
+  if (!provenance.operationId || !provenance.sourceHead || !provenance.targetHeadBefore) {
+    return { landed: false, error: "Incomplete merge operation provenance" };
+  }
+  if (!GIT_OBJECT_ID_PATTERN.test(provenance.sourceHead) || !GIT_OBJECT_ID_PATTERN.test(provenance.targetHeadBefore)) {
+    return { landed: false, error: "Malformed merge operation provenance" };
+  }
+  if (provenance.strategy !== "cherry-pick") {
+    const ancestry = await runGit(["merge-base", "--is-ancestor", provenance.sourceHead, "HEAD"], primaryDir);
+    if (ancestry.exitCode === 0) {
+      return { landed: true, method: "ancestry" };
+    }
+    if (ancestry.exitCode === 1) {
+      return { landed: false };
+    }
+    return {
+      landed: false,
+      error: ancestry.stderr.trim() || ancestry.stdout.trim() || `git merge-base exited ${ancestry.exitCode}`
+    };
+  }
+  const exactTrailer = `(cherry picked from commit ${provenance.sourceHead})`;
+  const escapedTrailer = exactTrailer.replace(/[\\.^$|?*+()[\]{}]/g, "\\$&");
+  const trailerSearch = await runGit([
+    "log",
+    "--format=%H",
+    "--extended-regexp",
+    `--grep=^${escapedTrailer}$`,
+    "--max-count=1",
+    `${provenance.targetHeadBefore}..HEAD`,
+    "--"
+  ], primaryDir);
+  if (trailerSearch.exitCode !== 0) {
+    return {
+      landed: false,
+      error: trailerSearch.stderr.trim() || trailerSearch.stdout.trim() || `git log exited ${trailerSearch.exitCode}`
+    };
+  }
+  return trailerSearch.stdout.trim() ? { landed: true, method: "cherry-pick-trailer" } : { landed: false };
+}
+async function postMergeCleanup(directory, branchName) {
+  const deleteResult = await runGit(["branch", "-D", branchName], directory);
+  const deleteOk = deleteResult.exitCode === 0;
+  const pruneResult = await runGit(["worktree", "prune"], directory);
+  const pruneOk = pruneResult.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()}`
+  };
+}
+async function pruneStaleWorktreeMetadata(directory) {
+  const result = await runGit(["worktree", "prune"], directory);
+  if (result.exitCode === 0)
+    return { pruned: true };
+  return {
+    error: result.stderr.trim() || result.stdout.trim() || `git worktree prune exited ${result.exitCode}`
+  };
+}
+async function attemptMergeBackFromDirty(worktreePath, branchName, primaryDir, strategy, options = {}) {
+  let autoCommitted = false;
+  let cleaned = false;
+  let autoCommitFailed = false;
+  let cleanFailed = false;
+  let provenance = options.resume;
+  if (provenance) {
+    if (provenance.branchName !== branchName || provenance.strategy !== strategy || options.operationId !== undefined && provenance.operationId !== options.operationId) {
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: "Stored merge operation identity does not match this dispatch",
+        provenance
+      };
+    }
+    const reconciliation = await reconcileLandedMerge(primaryDir, provenance);
+    if ("error" in reconciliation && reconciliation.error) {
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: `Unable to reconcile prior merge-back: ${reconciliation.error}`,
+        provenance
+      };
+    }
+    if (reconciliation.landed) {
+      return {
+        merged: true,
+        strategy,
+        autoCommitted: false,
+        cleaned: false,
+        reconciled: true,
+        provenance
+      };
+    }
+    const sourceHead = await runGit(["rev-parse", "HEAD"], worktreePath);
+    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) {
+      return {
+        failed: true,
+        stage: "reconciliation",
+        message: "Stored merge operation did not land and its source or target HEAD has changed",
+        provenance
+      };
+    }
+  }
+  if (!provenance) {
+    const commitResult = await autoCommitDirty(worktreePath);
+    if (commitResult.committed) {
+      autoCommitted = true;
+    } else if (commitResult.reason !== "Nothing to commit") {
+      autoCommitFailed = true;
+      log(`[worktree] attemptMergeBackFromDirty: auto-commit failed for worktree "${worktreePath}" branch "${branchName}": ${commitResult.reason}`);
+    }
+  }
+  const cleanResult = await cleanUntrackedFiles(worktreePath);
+  if (cleanResult.cleaned) {
+    cleaned = true;
+  } else {
+    cleanFailed = true;
+    log(`[worktree] attemptMergeBackFromDirty: clean untracked failed for worktree "${worktreePath}" branch "${branchName}": ${cleanResult.error}`);
+  }
+  if (autoCommitFailed && cleanFailed) {
+    return {
+      failed: true,
+      stage: "cleanup",
+      message: "Auto-commit and clean both failed; abandoning worktree",
+      ...provenance ? { provenance } : {}
+    };
+  }
+  if (!provenance && (options.operationId || options.onBeforeMerge)) {
+    if (!options.operationId) {
+      return {
+        failed: true,
+        stage: "pre-merge",
+        message: "A pre-merge callback requires a stable operationId"
+      };
+    }
+    const sourceHead = await runGit(["rev-parse", "HEAD"], worktreePath);
+    const targetHead = await runGit(["rev-parse", "HEAD"], primaryDir);
+    if (sourceHead.exitCode !== 0 || targetHead.exitCode !== 0 || !sourceHead.stdout.trim() || !targetHead.stdout.trim()) {
+      return {
+        failed: true,
+        stage: "pre-merge",
+        message: "Unable to capture source and target HEAD before merge-back"
+      };
+    }
+    provenance = {
+      operationId: options.operationId,
+      sourceHead: sourceHead.stdout.trim(),
+      targetHeadBefore: targetHead.stdout.trim(),
+      branchName,
+      strategy
+    };
+    if (options.onBeforeMerge) {
+      try {
+        await options.onBeforeMerge(provenance);
+      } catch (error) {
+        return {
+          failed: true,
+          stage: "pre-merge",
+          message: `Unable to persist merge operation provenance: ${String(error)}`,
+          provenance
+        };
+      }
+    }
+  }
+  const mergeResult = await mergeLaneBranch(primaryDir, branchName, strategy);
+  if ("merged" in mergeResult && mergeResult.merged) {
+    return {
+      merged: true,
+      strategy,
+      autoCommitted,
+      cleaned,
+      ...provenance ? { reconciled: false, provenance } : {}
+    };
+  }
+  if ("conflict" in mergeResult) {
+    return {
+      partial: true,
+      stage: "merge",
+      autoCommitted,
+      cleaned,
+      message: mergeResult.message,
+      conflictFiles: mergeResult.files,
+      ...provenance ? { provenance } : {}
+    };
+  }
+  if ("error" in mergeResult) {
+    return {
+      failed: true,
+      stage: "merge",
+      message: mergeResult.error,
+      ...provenance ? { provenance } : {}
+    };
+  }
+  return {
+    failed: true,
+    stage: "merge",
+    message: "Merge failed with unexpected result",
+    ...provenance ? { provenance } : {}
+  };
+}
+function extractSessionId(branchName) {
+  const segments = branchName.trim().split("/");
+  if (segments.length >= 3 && segments[0] === "swarm-lane") {
+    return segments[1];
+  }
+  if (segments.length >= 4 && segments[0] === "swarm" && segments[1] === "lane") {
+    return segments[2];
+  }
+  return null;
+}
+async function listLaneBranches(directory) {
+  const branches = new Set;
+  const result = await runGit(["branch", "--format=%(refname:short)"], directory);
+  if (result.exitCode === 0) {
+    for (const line of result.stdout.split(`
+`)) {
+      const branch = line.trim();
+      if (branch.length > 0 && (branch.startsWith("swarm-lane/") || branch.startsWith("swarm/lane/"))) {
+        branches.add(branch);
+      }
+    }
+  }
+  return [...branches];
+}
+async function cleanupOrphanedBranches(directory, activeSessionIds = [], options = {}) {
+  const removed = [];
+  const skipped = [];
+  const skippedRecoveryBranches = [];
+  const errors = [];
+  const recoveryReadError = recoveryReadErrored(directory);
+  if (recoveryReadError) {
+    log("[worktree] cleanupOrphanedBranches: .swarm/recovery/ read error \u2014 skipping all " + "lane-branch deletions this pass (fail-safe for preserved recovery branches).");
+    const branches2 = await listLaneBranches(directory);
+    return {
+      removed,
+      skipped: branches2,
+      skippedRecoveryBranches,
+      errors,
+      recoveryReadError: true
+    };
+  }
+  const branches = await listLaneBranches(directory);
+  for (const branch of branches) {
+    const sessionId = extractSessionId(branch);
+    if (sessionId !== null && activeSessionIds.includes(sessionId)) {
+      skipped.push(branch);
+      continue;
+    }
+    if (hasRecoveryRecordForBranch(directory, branch)) {
+      skippedRecoveryBranches.push(branch);
+      continue;
+    }
+    const deleteResult = await runGit(["branch", options.preserveUnmerged ? "-d" : "-D", branch], directory);
+    if (deleteResult.exitCode === 0) {
+      removed.push(branch);
+    } else {
+      errors.push({
+        branch,
+        error: deleteResult.stderr.trim() || deleteResult.stdout.trim()
+      });
+    }
+  }
+  await runGit(["worktree", "prune"], directory);
+  return {
+    removed,
+    skipped,
+    skippedRecoveryBranches,
+    errors
+  };
+}
+async function startupOrphanRecovery(directory, activeSessionIds = []) {
+  const warnings = [];
+  const pruneResult = await runGit(["worktree", "prune"], directory);
+  if (pruneResult.exitCode !== 0) {
+    warnings.push(`git worktree prune failed: ${pruneResult.stderr.trim() || pruneResult.stdout.trim()}`);
+  }
+  const allBranches = await listLaneBranches(directory);
+  const orphanBranches = [];
+  for (const branch of allBranches) {
+    const sessionId = extractSessionId(branch);
+    if (sessionId === null || !activeSessionIds.includes(sessionId)) {
+      orphanBranches.push(branch);
+      warnings.push(`Orphaned swarm-lane branch "${branch}" detected in "${directory}"`);
+    }
+  }
+  for (const warning of warnings) {
+    log(warning);
+  }
+  return {
+    prunedWorktrees: pruneResult.exitCode === 0,
+    remainingBranches: orphanBranches,
+    warnings
+  };
+}
+
+// src/workflow/workflow-wal-schema.ts
+var TASK_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+var SHA256_PATTERN = /^[0-9a-f]{64}$/;
+var BRANCH_NAME_PATTERN = /^[A-Za-z0-9_][A-Za-z0-9._/-]{0,1023}$/;
+function isSafeGitBranchName(value) {
+  if (typeof value !== "string" || !BRANCH_NAME_PATTERN.test(value)) {
+    return false;
+  }
+  if (value.includes("..") || value.endsWith("/") || value.endsWith(".")) {
+    return false;
+  }
+  return !value.split("/").some((segment) => segment.length === 0 || segment.startsWith(".") || segment.endsWith(".lock"));
+}
+function isSafeWorktreePath(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 4096 && !value.startsWith("-") && unsafePathTextReason(value) === null;
+}
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var WORKFLOW_STATES = new Set([
+  "idle",
+  "coder_delegated",
+  "pre_check_passed",
+  "reviewer_run",
+  "tests_run",
+  "rework_required",
+  "complete",
+  "blocked",
+  "closed"
+]);
+function formatUnreadableMessage(code, filePath, detail, remediation) {
+  throw new Error(`${code}: ${filePath} ${detail}. ${remediation}`);
+}
+function parseWalObject(raw, filePath, code, remediation) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (error) {
+    formatUnreadableMessage(code, filePath, `is not valid JSON (${error instanceof Error ? error.message : String(error)})`, remediation);
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    formatUnreadableMessage(code, filePath, "is not a JSON object", remediation);
+  }
+  return parsed;
+}
+function parseCoderSettlementWal(raw, filePath, expectedTaskId) {
+  const parsed = parseWalObject(raw, filePath, "CODER_SETTLEMENT_WAL_UNREADABLE", "Preserve this file, reconcile the task lane, and only then move it aside.");
+  const context = parsed.context;
+  const baseline = context?.baseline;
+  const worktree = parsed.worktree;
+  const provenance = parsed.mergeProvenance;
+  if (parsed.version !== 1 || !["ABORTED", "COMMITTED", "DISPATCHED", "PREPARED"].includes(String(parsed.state)) || typeof parsed.taskId !== "string" || !TASK_ID_PATTERN.test(parsed.taskId) || typeof parsed.transitionId !== "string" || parsed.transitionId.length === 0 || parsed.transitionId.length > 512 || typeof parsed.actor !== "string" || parsed.actor.length === 0 || parsed.actor.length > 512 || !Number.isInteger(parsed.processId) || (parsed.processId ?? 0) <= 0 || typeof parsed.runtimeId !== "string" || parsed.runtimeId.length === 0 || !Number.isInteger(parsed.expectedGeneration) || (parsed.expectedGeneration ?? -1) < 0 || !context || !baseline || typeof baseline.directory !== "string" || baseline.directory.length === 0 || baseline.directory.length > 4096 || typeof baseline.gitHead !== "string" && baseline.gitHead !== null || typeof baseline.dirtyHash !== "string" && baseline.dirtyHash !== null || typeof baseline.prHeadSha !== "string" && baseline.prHeadSha !== null || typeof baseline.scope !== "string" && baseline.scope !== null || !Array.isArray(baseline.changedFiles) && baseline.changedFiles !== null && baseline.changedFiles !== undefined || Array.isArray(baseline.changedFiles) && (baseline.changedFiles.length > 50000 || baseline.changedFiles.some((candidatePath) => typeof candidatePath !== "string" || candidatePath.length > 4096)) || !Array.isArray(context.declaredFiles) && context.declaredFiles !== null || Array.isArray(context.declaredFiles) && (context.declaredFiles.length > 50000 || context.declaredFiles.some((candidatePath) => typeof candidatePath !== "string" || candidatePath.length > 4096)) || parsed.observedFiles !== undefined && (!Array.isArray(parsed.observedFiles) || parsed.observedFiles.length > 50000 || parsed.observedFiles.some((candidatePath) => typeof candidatePath !== "string" || candidatePath.length > 4096 || !isPathWithinDeclaredScope(candidatePath, context.declaredFiles ?? [], baseline.directory))) || worktree !== undefined && (typeof worktree.callID !== "string" || typeof worktree.parentSessionId !== "string" || typeof worktree.taskId !== "string" || worktree.taskId !== parsed.taskId || !isSafeWorktreePath(worktree.worktreePath) || !isSafeGitBranchName(worktree.branchName) || typeof worktree.worktreeId !== "string" || typeof worktree.worktreeSessionId !== "string" || !["merge", "rebase", "cherry-pick"].includes(String(worktree.mergeStrategy)) || !Number.isInteger(worktree.laneIndex)) || provenance !== undefined && (typeof provenance.operationId !== "string" || provenance.operationId !== parsed.transitionId || typeof provenance.sourceHead !== "string" || !GIT_OBJECT_ID_PATTERN.test(provenance.sourceHead) || typeof provenance.targetHeadBefore !== "string" || !GIT_OBJECT_ID_PATTERN.test(provenance.targetHeadBefore) || !isSafeGitBranchName(provenance.branchName) || worktree !== undefined && (provenance.branchName !== worktree.branchName || provenance.strategy !== worktree.mergeStrategy) || !["merge", "rebase", "cherry-pick"].includes(String(provenance.strategy))) || typeof parsed.recordedAt !== "string" || parsed.state === "PREPARED" && typeof parsed.accepted !== "boolean" || parsed.cleanupComplete !== undefined && typeof parsed.cleanupComplete !== "boolean" || parsed.settlementFailed !== undefined && typeof parsed.settlementFailed !== "boolean") {
+    formatUnreadableMessage("CODER_SETTLEMENT_WAL_UNREADABLE", filePath, "is not a valid v1 coder-settlement WAL", "Preserve this file, reconcile the task lane, and only then move it aside.");
+  }
+  if (expectedTaskId && parsed.taskId !== expectedTaskId) {
+    formatUnreadableMessage("CODER_SETTLEMENT_WAL_TASK_MISMATCH", filePath, `records task ${parsed.taskId} but was read for task ${expectedTaskId}`, "Preserve this file, reconcile the task lane, and only then move it aside.");
+  }
+  return parsed;
+}
+function parseTaskRepairWal(raw, filePath, expectedTaskId) {
+  const parsed = parseWalObject(raw, filePath, "TASK_REPAIR_WAL_UNREADABLE", "Preserve this file, reconcile the repair transition, and only then move it aside.");
+  if (parsed.version !== 1 || parsed.state !== "PREPARED" && parsed.state !== "COMMITTED" && parsed.state !== "ABORTED" || typeof parsed.taskId !== "string" || !TASK_ID_PATTERN.test(parsed.taskId) || typeof parsed.transitionId !== "string" || parsed.transitionId.length === 0 || parsed.transitionId.length > 512 || typeof parsed.reason !== "string" || parsed.reason.length === 0 || parsed.reason.length > 4096 || typeof parsed.actor !== "string" || parsed.actor.length === 0 || parsed.actor.length > 512 || typeof parsed.oldPlanStatus !== "string" || parsed.oldPlanStatus.length === 0 || parsed.oldPlanStatus.length > 128 || parsed.newPlanStatus !== "in_progress" || typeof parsed.oldWorkflowState !== "string" || !WORKFLOW_STATES.has(parsed.oldWorkflowState) || parsed.newWorkflowState !== "idle" || !Number.isInteger(parsed.generation) || (parsed.generation ?? -1) < 0 || !Number.isInteger(parsed.oldGeneration) || (parsed.oldGeneration ?? -1) < 0 || parsed.generation !== (parsed.oldGeneration ?? -1) + 1 || typeof parsed.recordedAt !== "string" || !Number.isFinite(Date.parse(parsed.recordedAt))) {
+    formatUnreadableMessage("TASK_REPAIR_WAL_UNREADABLE", filePath, "is not a valid v1 repair WAL (unexpected shape or version)", "Preserve this file, reconcile the repair transition, and only then move it aside.");
+  }
+  if (expectedTaskId && parsed.taskId !== expectedTaskId) {
+    formatUnreadableMessage("TASK_REPAIR_WAL_TASK_MISMATCH", filePath, `records task ${parsed.taskId} but was read for task ${expectedTaskId}`, "Preserve this file, reconcile the repair transition, and only then move it aside.");
+  }
+  return parsed;
+}
+function parseTaskTerminalWal(raw, filePath, expectedTaskId) {
+  const parsed = parseWalObject(raw, filePath, "TASK_TERMINAL_WAL_UNREADABLE", "Preserve this file and reconcile the task terminal transition before moving it aside.");
+  if (parsed.version !== 1 && parsed.version !== 2 || parsed.state !== "PREPARED" && parsed.state !== "COMMITTED" && parsed.state !== "ABORTED" || typeof parsed.taskId !== "string" || !TASK_ID_PATTERN.test(parsed.taskId) || typeof parsed.transitionId !== "string" || parsed.transitionId.length === 0 || parsed.transitionId.length > 512 || typeof parsed.actor !== "string" || parsed.actor.length === 0 || parsed.actor.length > 512 || typeof parsed.oldPlanStatus !== "string" || parsed.oldPlanStatus.length === 0 || parsed.oldPlanStatus.length > 128 || parsed.newPlanStatus !== "completed" && parsed.newPlanStatus !== "blocked" && parsed.newPlanStatus !== "closed" || typeof parsed.oldWorkflowState !== "string" || !WORKFLOW_STATES.has(parsed.oldWorkflowState) || parsed.newWorkflowState !== "complete" && parsed.newWorkflowState !== "blocked" && parsed.newWorkflowState !== "closed" || !Number.isInteger(parsed.generation) || (parsed.generation ?? -1) < 0 || typeof parsed.qaExempt !== "boolean" || typeof parsed.recordedAt !== "string" || !Number.isFinite(Date.parse(parsed.recordedAt))) {
+    formatUnreadableMessage("TASK_TERMINAL_WAL_UNREADABLE", filePath, "is not a valid terminal WAL", "Preserve this file and reconcile the task terminal transition before moving it aside.");
+  }
+  if (parsed.version === 2 && (typeof parsed.planIdentityHash !== "string" || !SHA256_PATTERN.test(parsed.planIdentityHash) || typeof parsed.planEpoch !== "string" || !UUID_PATTERN.test(parsed.planEpoch))) {
+    formatUnreadableMessage("TASK_TERMINAL_WAL_UNREADABLE", filePath, "is missing the v2 plan identity fields", "Preserve this file and reconcile the task terminal transition before moving it aside.");
+  }
+  if (parsed.version === 1 && (parsed.newPlanStatus === "closed" || parsed.newWorkflowState === "closed")) {
+    formatUnreadableMessage("TASK_TERMINAL_WAL_UNREADABLE", filePath, "claims a closed transition in a legacy v1 terminal WAL", "Preserve this file and reconcile the task terminal transition before moving it aside.");
+  }
+  if (!(parsed.newPlanStatus === "completed" && parsed.newWorkflowState === "complete" || parsed.newPlanStatus === "blocked" && parsed.newWorkflowState === "blocked" || parsed.newPlanStatus === "closed" && parsed.newWorkflowState === "closed")) {
+    throw new Error(`TASK_TERMINAL_WAL_STATE_MISMATCH: ${filePath} encodes ${String(parsed.newPlanStatus)} -> ${String(parsed.newWorkflowState)}`);
+  }
+  if (expectedTaskId && parsed.taskId !== expectedTaskId) {
+    formatUnreadableMessage("TASK_TERMINAL_WAL_TASK_MISMATCH", filePath, `records task ${parsed.taskId} but was read for task ${expectedTaskId}`, "Preserve this file and reconcile the task terminal transition before moving it aside.");
+  }
+  return parsed;
+}
+
+// src/workflow/workflow-wal-file.ts
+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 = {
+  openFile: open,
+  openFileSync: fs2.openSync,
+  readFileSync: fs2.readSync,
+  closeFileSync: fs2.closeSync
+};
+function maxBytesFor(kind) {
+  return kind === "coder-settlement" ? CODER_SETTLEMENT_MAX_BYTES : SMALL_WORKFLOW_WAL_MAX_BYTES;
+}
+function remediationFor(kind) {
+  switch (kind) {
+    case "coder-settlement":
+      return "Preserve this file, reconcile the task lane, and only then move it aside.";
+    case "task-repair":
+      return "Preserve this file, reconcile the repair transition, and only then move it aside.";
+    case "task-terminal":
+      return "Preserve this file and reconcile the task terminal transition before moving it aside.";
+  }
+}
+function unreadableCode(kind) {
+  switch (kind) {
+    case "coder-settlement":
+      return "CODER_SETTLEMENT_WAL_UNREADABLE";
+    case "task-repair":
+      return "TASK_REPAIR_WAL_UNREADABLE";
+    case "task-terminal":
+      return "TASK_TERMINAL_WAL_UNREADABLE";
+  }
+}
+function walIoError(kind, filePath, action, error) {
+  const detail = error instanceof Error ? error.message : String(error);
+  return new Error(`${unreadableCode(kind)}: could not ${action} ${filePath} (${detail}). ${remediationFor(kind)}`, { cause: error });
+}
+function oversizeCode(kind) {
+  switch (kind) {
+    case "coder-settlement":
+      return "CODER_SETTLEMENT_WAL_OVERSIZE";
+    case "task-repair":
+      return "TASK_REPAIR_WAL_OVERSIZE";
+    case "task-terminal":
+      return "TASK_TERMINAL_WAL_OVERSIZE";
+  }
+}
+function oversizeMessage(kind, filePath, maxBytes) {
+  if (kind === "coder-settlement") {
+    throw new Error(`${oversizeCode(kind)}: ${filePath} exceeds the 64 MiB safety limit. Preserve this file, reconcile the lane, reduce or partition the declared scope, and only then move the WAL aside.`);
+  }
+  throw new Error(`${oversizeCode(kind)}: ${filePath} exceeds the ${maxBytes} byte safety limit. ${remediationFor(kind)}`);
+}
+function decodeUtf8(kind, filePath, bytes) {
+  try {
+    return UTF8_FATAL_DECODER.decode(bytes);
+  } catch (error) {
+    throw new Error(`${unreadableCode(kind)}: ${filePath} is not valid UTF-8 (${error instanceof Error ? error.message : String(error)}). ${remediationFor(kind)}`);
+  }
+}
+function validateWal(kind, raw, filePath, expectedTaskId) {
+  switch (kind) {
+    case "coder-settlement":
+      return parseCoderSettlementWal(raw, filePath, expectedTaskId);
+    case "task-repair":
+      return parseTaskRepairWal(raw, filePath, expectedTaskId);
+    case "task-terminal":
+      return parseTaskTerminalWal(raw, filePath, expectedTaskId);
+  }
+}
+async function readBoundedBytes(kind, filePath, maxBytes) {
+  let handle;
+  try {
+    handle = await _internals2.openFile(filePath, "r");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw walIoError(kind, filePath, "open", error);
+  }
+  let result = new Uint8Array;
+  let failure = null;
+  try {
+    const limit = maxBytes + 1;
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const remaining = limit - total;
+      if (remaining <= 0)
+        break;
+      const buffer = Buffer.alloc(Math.min(CHUNK_BYTES, remaining));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+      if (bytesRead === 0)
+        break;
+      total += bytesRead;
+      chunks.push(buffer.subarray(0, bytesRead));
+      if (total > maxBytes)
+        break;
+    }
+    result = Buffer.concat(chunks, total);
+  } catch (error) {
+    failure = walIoError(kind, filePath, "read", error);
+  }
+  try {
+    await handle.close();
+  } catch (error) {
+    failure ??= walIoError(kind, filePath, "close", error);
+  }
+  if (failure)
+    throw failure;
+  return result;
+}
+function readBoundedBytesSync(kind, filePath, maxBytes) {
+  let fd;
+  try {
+    fd = _internals2.openFileSync(filePath, "r");
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw walIoError(kind, filePath, "open", error);
+  }
+  let result = new Uint8Array;
+  let failure = null;
+  try {
+    const limit = maxBytes + 1;
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const remaining = limit - total;
+      if (remaining <= 0)
+        break;
+      const buffer = Buffer.alloc(Math.min(CHUNK_BYTES, remaining));
+      const bytesRead = _internals2.readFileSync(fd, buffer, 0, buffer.length, null);
+      if (bytesRead === 0)
+        break;
+      total += bytesRead;
+      chunks.push(buffer.subarray(0, bytesRead));
+      if (total > maxBytes)
+        break;
+    }
+    result = Buffer.concat(chunks, total);
+  } catch (error) {
+    failure = walIoError(kind, filePath, "read", error);
+  }
+  try {
+    _internals2.closeFileSync(fd);
+  } catch (error) {
+    failure ??= walIoError(kind, filePath, "close", error);
+  }
+  if (failure)
+    throw failure;
+  return result;
+}
+async function readWorkflowWalFile(kind, filePath, expectedTaskId) {
+  const maxBytes = maxBytesFor(kind);
+  const bytes = await readBoundedBytes(kind, filePath, maxBytes);
+  if (bytes === null)
+    return null;
+  if (bytes.length === 0) {
+    throw new Error(`${unreadableCode(kind)}: ${filePath} is empty. ${remediationFor(kind)}`);
+  }
+  if (bytes.length > maxBytes)
+    oversizeMessage(kind, filePath, maxBytes);
+  return validateWal(kind, decodeUtf8(kind, filePath, bytes), filePath, expectedTaskId);
+}
+function readWorkflowWalFileSync(kind, filePath, expectedTaskId) {
+  const maxBytes = maxBytesFor(kind);
+  const bytes = readBoundedBytesSync(kind, filePath, maxBytes);
+  if (bytes === null)
+    return null;
+  if (bytes.length === 0) {
+    throw new Error(`${unreadableCode(kind)}: ${filePath} is empty. ${remediationFor(kind)}`);
+  }
+  if (bytes.length > maxBytes)
+    oversizeMessage(kind, filePath, maxBytes);
+  return validateWal(kind, decodeUtf8(kind, filePath, bytes), filePath, expectedTaskId);
+}
+async function writeWorkflowWalFile(kind, filePath, wal) {
+  const serialized = `${JSON.stringify(wal, null, 2)}
+`;
+  const maxBytes = maxBytesFor(kind);
+  if (Buffer.byteLength(serialized, "utf8") > maxBytes) {
+    oversizeMessage(kind, filePath, maxBytes);
+  }
+  validateWal(kind, serialized, filePath, wal.taskId);
+  await mkdir(dirname(filePath), { recursive: true });
+  await atomicWriteFile(filePath, serialized);
+}
+
+// src/gate-evidence.ts
+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"
+];
+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}`);
+  }
+  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 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()
+});
+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(),
+  test_engineer_exempt: exports_external.boolean().optional(),
+  workflow: TaskWorkflowMetadataSchema.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;
+}
+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";
+  }
+}
+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, 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) {
+  return snapshot.authoritative && typeof event.transitionId === "string" && event.transitionId.length > 0 && snapshot.lastTransitionId === event.transitionId && snapshot.lastOutcome === getEventOutcome(event);
+}
+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")) {
+    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 } : {}
+  };
+  switch (event.type) {
+    case "dispatch_attempted":
+      return base;
+    case "dispatch_no_mutation":
+      return {
+        ...base,
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1
+      };
+    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":
+      if (event.context?.settlementFailed === true) {
+        return {
+          ...base,
+          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
+        };
+      }
+      return {
+        ...base,
+        generation: current.generation + 1,
+        state: "coder_delegated"
+      };
+    case "stage_a_passed":
+      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed") {
+        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot pass Stage A from ${current.state}`);
+      }
+      return {
+        ...base,
+        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}`);
+      }
+      return {
+        ...base,
+        state: hasAllRequiredGatesPassed(context.requiredGates, context.gates) ? "tests_run" : "reviewer_run"
+      };
+    case "gate_recorded":
+      return {
+        ...base,
+        state: current.state
+      };
+    case "task_completed":
+      if (event.qaExempt !== true && current.state !== "tests_run" && current.state !== "complete" && !(current.state === "pre_check_passed" && context.gates.council != null)) {
+        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, ...withoutForced } = base;
+      return {
+        ...withoutForced,
+        generation: current.generation + 1,
+        state: "idle",
+        retryCount: 0,
+        retryHistory: [],
+        retryEpoch: 0
+      };
+    }
+  }
+}
+function getEvidenceDir(directory) {
+  const swarmDir = path2.resolve(directory, ".swarm");
+  const evidenceDir = path2.join(swarmDir, "evidence");
+  mkdirSync2(evidenceDir, { recursive: true });
+  let resolvedSwarmDir;
+  let resolvedEvidenceDir;
+  try {
+    resolvedSwarmDir = path2.normalize(realpathSync(swarmDir));
+    resolvedEvidenceDir = path2.normalize(realpathSync(evidenceDir));
+  } catch (error) {
+    throw new Error(`Unable to resolve evidence directory: ${error.message}`);
+  }
+  const swarmPrefix = `${resolvedSwarmDir}${path2.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 readExisting(evidencePath, taskId) {
+  try {
+    const raw = readFileSync2(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
+  };
+}
+async function transitionTaskWorkflowEvidence(directory, taskId, event) {
+  assertValidTaskId(taskId);
+  let updatedEvidence = null;
+  await withTaskEvidenceTransaction(directory, taskId, event.type, async (transaction) => {
+    updatedEvidence = await transaction.transition(event);
+  });
+  return updatedEvidence ?? {
+    taskId,
+    required_gates: [],
+    gates: {},
+    workflow: createDefaultWorkflowMetadata(new Date().toISOString())
+  };
+}
+async function withTaskEvidenceTransaction(directory, taskId, agent, callback) {
+  assertValidTaskId(taskId);
+  return withTaskEvidenceLock(directory, taskId, agent, async () => {
+    const resolvedEvidenceDir = getEvidenceDir(directory);
+    const evidencePath = path2.join(resolvedEvidenceDir, `${taskId}.json`);
+    let current = null;
+    try {
+      current = readExisting(evidencePath, taskId);
+    } catch (error) {
+      telemetry.gateParseError(taskId, error);
+      throw error;
+    }
+    const persist = async (nextEvidence) => {
+      const validated = TaskEvidenceSchema.parse({
+        ...nextEvidence,
+        taskId
+      });
+      await atomicWriteFile(evidencePath, JSON.stringify(validated, null, 2));
+      current = validated;
+      return validated;
+    };
+    return callback({
+      taskId,
+      read: () => current,
+      transition: async (event) => {
+        assertTaskEvidenceWriteAllowed(directory, taskId, event);
+        const nextEvidence = updateEvidenceForTransition(current, event);
+        nextEvidence.taskId = taskId;
+        return persist(nextEvidence);
+      }
+    });
+  });
+}
+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,
+    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 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) {
+  try {
+    assertValidTaskId(taskId);
+    return readExisting(getEvidencePath(directory, taskId), taskId);
+  } catch {
+    return null;
+  }
+}
+function readTaskEvidenceRaw(directory, taskId) {
+  assertValidTaskId(taskId);
+  const evidencePath = getEvidencePath(directory, taskId);
+  try {
+    const raw = readFileSync2(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) {
+  const evidence = await readTaskEvidence(directory, taskId);
+  if (!evidence)
+    return false;
+  if (!Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0)
+    return false;
+  return evidence.required_gates.every((gate) => evidence.gates[gate] != null);
+}
+function compareTaskWorkflowStateRank(left, right) {
+  return WORKFLOW_STATE_RANK[left] - WORKFLOW_STATE_RANK[right];
+}
+
+export { sanitizeTaskId, listRecoveryRecords, _internals, getMergeStrategy, reconcileLandedMerge, postMergeCleanup, pruneStaleWorktreeMetadata, attemptMergeBackFromDirty, cleanupOrphanedBranches, startupOrphanRecovery, readWorkflowWalFile, writeWorkflowWalFile, TASK_WORKFLOW_SCHEMA_MARKER, assertTaskEvidenceWriteAllowed, parseTaskEvidence, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, withTaskEvidenceTransaction, recordGateEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };