opencode-swarm 7.200.9 → 7.200.10

package/dist/cli/index-xkavxqf2.js

@@ -0,0 +1,1330 @@
+// @bun
+import {
+  derivePlanId,
+  derivePlanIdentityHash
+} from "./index-7pmbnjvj.js";
+import {
+  readWorkflowWalFileSync
+} from "./index-r3wyt8za.js";
+import {
+  validateSwarmPath
+} from "./index-001tkp0j.js";
+import {
+  atomicWriteFile,
+  taskEvidencePath,
+  withTaskEvidenceLock
+} from "./index-6m551cng.js";
+import {
+  assertProjectRoot
+} from "./index-t7hmqgjy.js";
+import {
+  telemetry
+} from "./index-6cppzd9c.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-gknz3bv1.js";
+
+// src/gate-evidence.ts
+init_zod();
+import { createHash as createHash2 } from "crypto";
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync2, realpathSync as realpathSync2, statSync } from "fs";
+import * as path2 from "path";
+
+// src/evidence/task-gate-requirements.ts
+init_zod();
+import { createHash } from "crypto";
+import * as fs from "fs";
+import * as path from "path";
+var MAX_TASK_GATE_REQUIREMENTS_BYTES = 256 * 1024;
+var TaskGateRequirementsReceiptSchema = exports_external.object({
+  schemaVersion: exports_external.literal(1),
+  taskId: exports_external.string().min(1).max(120),
+  generation: exports_external.number().int().min(0),
+  normalizedRole: exports_external.string().min(1).max(120),
+  testEngineerExempt: exports_external.boolean().nullable(),
+  requiredGates: exports_external.array(exports_external.string()).min(1).max(16),
+  sourceEvent: exports_external.string().min(1).max(120),
+  sourceTransitionId: exports_external.string().min(1).max(200).nullable(),
+  recordedAt: exports_external.string().min(1).max(128),
+  routeBinding: exports_external.object({
+    role: exports_external.enum(["reviewer", "test_engineer"]),
+    identity: exports_external.string().trim().min(1).max(256),
+    sessionId: exports_external.string().trim().min(1).max(256),
+    taskId: exports_external.string().trim().min(1).max(120),
+    slotId: exports_external.string().trim().min(1).max(256),
+    callId: exports_external.string().trim().min(1).max(256),
+    childSessionId: exports_external.string().trim().min(1).max(256),
+    generation: exports_external.number().int().nonnegative()
+  }).strict().optional(),
+  previousChainHash: exports_external.string().regex(/^[a-f0-9]{64}$/).nullable(),
+  chainHash: exports_external.string().regex(/^[a-f0-9]{64}$/)
+}).strict();
+function samePath(left, right) {
+  const normalize = (value) => process.platform === "win32" ? path.resolve(value).toLowerCase() : path.resolve(value);
+  return normalize(left) === normalize(right);
+}
+function assertSafeRequirementsParent(directory, create) {
+  assertProjectRoot(directory, undefined, "task gate requirements");
+  const rootStat = fs.lstatSync(directory);
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+    throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: project root is not a regular directory");
+  }
+  const canonicalRoot = fs.realpathSync(directory);
+  const segments = [".swarm", "evidence", "task-gate-requirements"];
+  let current = canonicalRoot;
+  for (const segment of segments) {
+    current = path.join(current, segment);
+    let info;
+    try {
+      info = fs.lstatSync(current);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        if (!create)
+          return current;
+        try {
+          fs.mkdirSync(current);
+        } catch (mkdirError) {
+          if (mkdirError.code !== "EEXIST") {
+            throw mkdirError;
+          }
+        }
+        info = fs.lstatSync(current);
+      } else {
+        throw error;
+      }
+    }
+    if (info.isSymbolicLink() || !info.isDirectory()) {
+      throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt parent is redirected or not a directory");
+    }
+    const canonicalCurrent = fs.realpathSync(current);
+    if (!samePath(canonicalCurrent, current)) {
+      throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt parent escaped the project root");
+    }
+  }
+  return current;
+}
+function safeTaskGateRequirementsReceiptPath(directory, taskId, createParent) {
+  const parent = assertSafeRequirementsParent(directory, createParent);
+  return path.join(parent, `${taskId}.jsonl`);
+}
+function sha256(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function canonicalReceiptPayload(receipt) {
+  const routeBinding = receipt.routeBinding ? {
+    role: receipt.routeBinding.role,
+    identity: receipt.routeBinding.identity,
+    sessionId: receipt.routeBinding.sessionId,
+    taskId: receipt.routeBinding.taskId,
+    slotId: receipt.routeBinding.slotId,
+    callId: receipt.routeBinding.callId,
+    childSessionId: receipt.routeBinding.childSessionId,
+    generation: receipt.routeBinding.generation
+  } : undefined;
+  return JSON.stringify({
+    schemaVersion: receipt.schemaVersion,
+    taskId: receipt.taskId,
+    generation: receipt.generation,
+    normalizedRole: receipt.normalizedRole,
+    testEngineerExempt: receipt.testEngineerExempt,
+    requiredGates: [...receipt.requiredGates],
+    sourceEvent: receipt.sourceEvent,
+    sourceTransitionId: receipt.sourceTransitionId,
+    recordedAt: receipt.recordedAt,
+    ...routeBinding ? { routeBinding } : {},
+    previousChainHash: receipt.previousChainHash
+  });
+}
+function computeChainHash(receipt) {
+  return sha256(canonicalReceiptPayload(receipt));
+}
+function routeBindingFromEvent(event) {
+  if (event.type !== "stage_b_completed" || !event.routeBinding)
+    return;
+  const binding = event.routeBinding;
+  if (binding.role !== event.gate || !binding.sessionId || !binding.taskId || !binding.slotId || !binding.callId || !binding.childSessionId || typeof binding.generation !== "number") {
+    return;
+  }
+  return binding;
+}
+function readBoundedTextFile(filePath) {
+  let pathStat;
+  try {
+    pathStat = fs.lstatSync(filePath);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    throw error;
+  }
+  if (pathStat.isSymbolicLink() || !pathStat.isFile()) {
+    throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt path is not a regular file");
+  }
+  if (pathStat.size > MAX_TASK_GATE_REQUIREMENTS_BYTES) {
+    throw new Error(`TASK_GATE_REQUIREMENTS_OVERSIZED: ${pathStat.size} bytes exceeds ${MAX_TASK_GATE_REQUIREMENTS_BYTES}`);
+  }
+  const descriptor = fs.openSync(filePath, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+  try {
+    const openedStat = fs.fstatSync(descriptor);
+    if (!openedStat.isFile() || openedStat.dev !== pathStat.dev || openedStat.ino !== pathStat.ino) {
+      throw new Error("TASK_GATE_REQUIREMENTS_UNREADABLE: receipt changed while being opened");
+    }
+    if (openedStat.size > MAX_TASK_GATE_REQUIREMENTS_BYTES) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_OVERSIZED: ${openedStat.size} bytes exceeds ${MAX_TASK_GATE_REQUIREMENTS_BYTES}`);
+    }
+    return fs.readFileSync(descriptor, "utf-8");
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+async function readTaskGateRequirementsReceipts(directory, taskId) {
+  const filePath = safeTaskGateRequirementsReceiptPath(directory, taskId, false);
+  const text = readBoundedTextFile(filePath);
+  if (text === null)
+    return [];
+  const receipts = [];
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const parsed = TaskGateRequirementsReceiptSchema.parse(JSON.parse(line));
+    if (parsed.taskId !== taskId || parsed.routeBinding !== undefined && parsed.routeBinding.taskId !== taskId) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_IDENTITY_MISMATCH: expected ${taskId}, found ${parsed.taskId}`);
+    }
+    const { chainHash, ...withoutChainHash } = parsed;
+    const expectedHash = computeChainHash(withoutChainHash);
+    if (expectedHash !== chainHash) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed hash validation`);
+    }
+    const previousChainHash = receipts.at(-1)?.chainHash ?? null;
+    if (parsed.previousChainHash !== previousChainHash) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed linkage validation`);
+    }
+    receipts.push(parsed);
+  }
+  return receipts;
+}
+function readTaskGateRequirementsReceiptsSync(directory, taskId) {
+  const filePath = safeTaskGateRequirementsReceiptPath(directory, taskId, false);
+  const text = readBoundedTextFile(filePath);
+  if (text === null)
+    return [];
+  const receipts = [];
+  for (const line of text.split(`
+`)) {
+    if (!line.trim())
+      continue;
+    const parsed = TaskGateRequirementsReceiptSchema.parse(JSON.parse(line));
+    if (parsed.taskId !== taskId || parsed.routeBinding !== undefined && parsed.routeBinding.taskId !== taskId) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_IDENTITY_MISMATCH: expected ${taskId}, found ${parsed.taskId}`);
+    }
+    const { chainHash, ...withoutChainHash } = parsed;
+    if (computeChainHash(withoutChainHash) !== chainHash) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed hash validation`);
+    }
+    const previousChainHash = receipts.at(-1)?.chainHash ?? null;
+    if (parsed.previousChainHash !== previousChainHash) {
+      throw new Error(`TASK_GATE_REQUIREMENTS_CHAIN_MISMATCH: receipt for ${taskId} failed linkage validation`);
+    }
+    receipts.push(parsed);
+  }
+  return receipts;
+}
+function routeEvidenceFromTaskGateRequirements(receipts) {
+  const latestByDispatch = new Map;
+  for (const receipt of receipts) {
+    const binding = receipt.routeBinding;
+    if (!binding)
+      continue;
+    const dispatchKey = [
+      binding.role,
+      binding.sessionId,
+      binding.taskId,
+      binding.callId,
+      binding.childSessionId,
+      String(binding.generation)
+    ].join("\x00");
+    latestByDispatch.set(dispatchKey, binding);
+  }
+  return [...latestByDispatch.values()];
+}
+function isLegacyTaskGateRequirementsChain(receipts) {
+  return receipts.length > 0 && receipts.every((receipt) => !receipt.routeBinding);
+}
+function deriveReceiptRole(event) {
+  switch (event.type) {
+    case "accepted_mutation":
+    case "dispatch_attempted":
+    case "dispatch_no_mutation":
+      if (typeof event.agentType === "string" && event.agentType.trim().length > 0) {
+        return {
+          normalizedRole: event.agentType.trim(),
+          testEngineerExempt: event.agentType === "coder" ? event.context?.testEngineerExempt === true : null
+        };
+      }
+      return null;
+    case "stage_b_completed":
+    case "gate_recorded":
+      return {
+        normalizedRole: event.gate,
+        testEngineerExempt: null
+      };
+    default:
+      return null;
+  }
+}
+function shouldAppendReceipt(current, next, role) {
+  if (next.required_gates.length === 0)
+    return false;
+  const currentGeneration = current?.workflow?.generation ?? -1;
+  const nextGeneration = next.workflow?.generation ?? -1;
+  if (current === null)
+    return true;
+  if (JSON.stringify(current.required_gates) !== JSON.stringify(next.required_gates)) {
+    return true;
+  }
+  if ((current.test_engineer_exempt ?? null) !== role.testEngineerExempt) {
+    return true;
+  }
+  return currentGeneration !== nextGeneration;
+}
+async function appendTaskGateRequirementsReceiptIfNeeded(directory, taskId, current, next, event) {
+  const role = deriveReceiptRole(event);
+  const routeBinding = routeBindingFromEvent(event);
+  if (routeBinding && routeBinding.taskId !== taskId) {
+    throw new Error(`TASK_GATE_REQUIREMENTS_ROUTE_IDENTITY_MISMATCH: expected ${taskId}, found ${routeBinding.taskId}`);
+  }
+  if (!role || !shouldAppendReceipt(current, next, role) && !routeBinding) {
+    return;
+  }
+  const filePath = safeTaskGateRequirementsReceiptPath(directory, taskId, true);
+  const receipts = await readTaskGateRequirementsReceipts(directory, taskId);
+  const latest = receipts.at(-1);
+  const baseReceipt = {
+    schemaVersion: 1,
+    taskId,
+    generation: next.workflow?.generation ?? 0,
+    normalizedRole: role.normalizedRole,
+    testEngineerExempt: role.testEngineerExempt,
+    requiredGates: [...next.required_gates],
+    sourceEvent: event.type,
+    sourceTransitionId: event.transitionId ?? null,
+    recordedAt: new Date().toISOString(),
+    previousChainHash: latest?.chainHash ?? null,
+    ...routeBinding ? { routeBinding } : {}
+  };
+  const receipt = {
+    ...baseReceipt,
+    chainHash: computeChainHash(baseReceipt)
+  };
+  if (latest && latest.generation === receipt.generation && latest.normalizedRole === receipt.normalizedRole && latest.testEngineerExempt === receipt.testEngineerExempt && JSON.stringify(latest.requiredGates) === JSON.stringify(receipt.requiredGates) && latest.sourceTransitionId === receipt.sourceTransitionId && JSON.stringify(latest.routeBinding ?? null) === JSON.stringify(receipt.routeBinding ?? null)) {
+    return;
+  }
+  const lines = [...receipts, receipt].map((entry) => JSON.stringify(entry));
+  assertSafeRequirementsParent(directory, false);
+  await atomicWriteFile(filePath, `${lines.join(`
+`)}
+`);
+  assertSafeRequirementsParent(directory, false);
+}
+
+// src/validation/task-id.ts
+var STRICT_TASK_ID_PATTERN = /^\d+\.\d+(\.\d+)*$/;
+var RETRO_TASK_ID_REGEX = /^retro-\d+$/;
+var INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build|secretscan)$/;
+var GENERAL_TASK_ID_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function checkUnsafeChars(taskId) {
+  if (!taskId || taskId.length === 0) {
+    return "Invalid task ID: empty string";
+  }
+  if (/\0/.test(taskId)) {
+    return "Invalid task ID: contains null bytes";
+  }
+  for (let i = 0;i < taskId.length; i++) {
+    if (taskId.charCodeAt(i) < 32) {
+      return "Invalid task ID: contains control characters";
+    }
+  }
+  if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
+    return "Invalid task ID: path traversal detected";
+  }
+  return;
+}
+function isStrictTaskId(taskId) {
+  if (!taskId)
+    return false;
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg)
+    return false;
+  return STRICT_TASK_ID_PATTERN.test(taskId);
+}
+function assertStrictTaskId(taskId) {
+  if (!isStrictTaskId(taskId)) {
+    throw new Error(`Invalid taskId: "${taskId}". Must match N.M or N.M.P (e.g. "1.1", "1.2.3").`);
+  }
+}
+function sanitizeTaskId(taskId) {
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg) {
+    throw new Error(unsafeMsg);
+  }
+  if (STRICT_TASK_ID_PATTERN.test(taskId) || RETRO_TASK_ID_REGEX.test(taskId) || INTERNAL_TOOL_ID_REGEX.test(taskId) || GENERAL_TASK_ID_REGEX.test(taskId)) {
+    return taskId;
+  }
+  throw new Error(`Invalid task ID: must be alphanumeric (ASCII) with optional hyphens, underscores, or dots, got "${taskId}"`);
+}
+function validateTaskIdFormat(taskId) {
+  if (!STRICT_TASK_ID_PATTERN.test(taskId)) {
+    return `Invalid taskId "${taskId}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`;
+  }
+  return;
+}
+
+// src/gate-evidence.ts
+var _internals = {
+  appendTaskGateRequirementsReceiptIfNeeded
+};
+var TASK_WORKFLOW_SCHEMA_MARKER = "exact-task-v1";
+var TASK_WORKFLOW_STATES = [
+  "idle",
+  "coder_delegated",
+  "pre_check_passed",
+  "reviewer_run",
+  "tests_run",
+  "rework_required",
+  "complete",
+  "blocked",
+  "closed"
+];
+var TASK_WORKFLOW_OUTCOMES = [
+  "none",
+  "dispatch_attempted",
+  "dispatch_no_mutation",
+  "accepted_mutation",
+  "accepted_mutation_failed",
+  "stage_a_passed",
+  "stage_a_failed",
+  "stage_b_completed",
+  "stage_b_failed",
+  "gate_recorded",
+  "task_completed",
+  "task_blocked",
+  "task_closed",
+  "repair_idle",
+  "external_evidence_attested",
+  "external_evidence_revoked"
+];
+var MAX_PLAN_SCOPE_INSPECTION_BYTES = 4 * 1024 * 1024;
+function readCurrentTaskDeclaredFiles(directory, taskId) {
+  try {
+    const planPath = validateSwarmPath(directory, "plan.json");
+    const stat = statSync(planPath);
+    if (!stat.isFile() || stat.size > MAX_PLAN_SCOPE_INSPECTION_BYTES) {
+      return null;
+    }
+    const parsed = JSON.parse(readFileSync2(planPath, "utf8"));
+    if (!Array.isArray(parsed.phases))
+      return null;
+    let declaredFiles = null;
+    for (const phase of parsed.phases) {
+      if (!phase || typeof phase !== "object")
+        return null;
+      const tasks = phase.tasks;
+      if (!Array.isArray(tasks))
+        return null;
+      for (const task of tasks) {
+        if (!task || typeof task !== "object")
+          return null;
+        const record = task;
+        if (record.id !== taskId)
+          continue;
+        if (!Array.isArray(record.files_touched) || !record.files_touched.every((file) => typeof file === "string")) {
+          return null;
+        }
+        if (declaredFiles !== null)
+          return null;
+        declaredFiles = [...record.files_touched];
+      }
+    }
+    return declaredFiles;
+  } catch {
+    return null;
+  }
+}
+var TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL = "requirements_reconstruction";
+function assertTaskEvidenceWriteAllowed(directory, taskId, event) {
+  assertValidTaskId(taskId);
+  const coderWalPath = validateSwarmPath(directory, `coder-settlements/${taskId}.json`);
+  const coderWal = readWorkflowWalFileSync("coder-settlement", coderWalPath, taskId);
+  if ((coderWal?.state === "DISPATCHED" || coderWal?.state === "PREPARED") && !(event != null && event.transitionId === coderWal.transitionId && (event.type === "dispatch_attempted" || event.type === "dispatch_no_mutation" || event.type === "accepted_mutation"))) {
+    throw new Error(`CODER_SETTLEMENT_IN_PROGRESS: transition ${String(coderWal.transitionId)} owns evidence for task ${taskId}. Wait for the owning transition to settle or run /swarm recover ${taskId} (or /swarm reset-session), then retry; do not remove the WAL by hand.`);
+  }
+  const terminalWalPath = validateSwarmPath(directory, `task-terminals/${taskId}.json`);
+  const terminalWal = readWorkflowWalFileSync("task-terminal", terminalWalPath, taskId);
+  if (terminalWal?.state === "PREPARED") {
+    const matchingTerminalEvent = event != null && event.transitionId === terminalWal.transitionId && (event.type === "task_completed" && terminalWal.newPlanStatus === "completed" || event.type === "task_blocked" && terminalWal.newPlanStatus === "blocked" || event.type === "task_closed" && terminalWal.newPlanStatus === "closed");
+    if (!matchingTerminalEvent) {
+      throw new Error(`TASK_TERMINAL_PREPARED: transition ${String(terminalWal.transitionId)} owns evidence for task ${taskId}`);
+    }
+  }
+  const repairWalPath = validateSwarmPath(directory, `task-repairs/${taskId}.json`);
+  const repairWal = readWorkflowWalFileSync("task-repair", repairWalPath, taskId);
+  if (repairWal?.state === "PREPARED" && !(event?.type === "repair_idle" && event.transitionId === repairWal.transitionId)) {
+    throw new Error(`TASK_REPAIR_PREPARED: transition ${String(repairWal.transitionId)} owns evidence for task ${taskId}`);
+  }
+}
+var GateEvidenceSchema = exports_external.object({
+  sessionId: exports_external.string(),
+  timestamp: exports_external.string(),
+  agent: exports_external.string()
+}).passthrough();
+var ExternalEvidenceBundleSchema = exports_external.object({
+  class: exports_external.literal("external_git"),
+  transitionId: exports_external.string().min(1).max(512),
+  declarationDigest: exports_external.string().regex(/^[a-f0-9]{64}$/),
+  anchors: exports_external.array(exports_external.object({
+    command: exports_external.string().min(1).max(400),
+    expect: exports_external.string().max(4096).optional(),
+    expect_prefix: exports_external.string().min(1).max(4096).optional(),
+    matched: exports_external.boolean(),
+    exit_code: exports_external.number().int(),
+    stdout: exports_external.string().max(4096)
+  })).min(1).max(16).superRefine((anchors, ctx) => {
+    anchors.forEach((anchor, index) => {
+      if (anchor.expect === undefined && anchor.expect_prefix === undefined) {
+        ctx.addIssue({
+          code: exports_external.ZodIssueCode.custom,
+          message: `anchor ${index} must carry expect and/or a non-empty expect_prefix`,
+          path: [index]
+        });
+      }
+    });
+  }),
+  attestedAt: exports_external.string().min(1)
+});
+var TaskWorkflowMetadataSchema = exports_external.object({
+  schema: exports_external.literal(TASK_WORKFLOW_SCHEMA_MARKER),
+  generation: exports_external.number().int().min(0),
+  state: exports_external.enum(TASK_WORKFLOW_STATES),
+  retryCount: exports_external.number().int().min(0).default(0),
+  retryHistory: exports_external.array(exports_external.enum(TASK_WORKFLOW_OUTCOMES)).max(3).default([]),
+  retryEpoch: exports_external.number().int().min(0).default(0),
+  lastOutcome: exports_external.enum(TASK_WORKFLOW_OUTCOMES).default("none"),
+  lastTransitionId: exports_external.string().min(1).nullable().optional().default(null),
+  updatedAt: exports_external.string(),
+  forcedCompletion: exports_external.boolean().optional(),
+  supervisedRecovery: exports_external.boolean().optional(),
+  settlementRecovery: exports_external.boolean().optional(),
+  noMutationSettlement: exports_external.object({
+    generation: exports_external.literal(0),
+    transitionId: exports_external.string().min(1).max(512),
+    declaredFiles: exports_external.array(exports_external.string()).length(0)
+  }).optional(),
+  externalEvidence: ExternalEvidenceBundleSchema.optional()
+});
+var TaskEvidenceSchema = exports_external.object({
+  taskId: exports_external.string(),
+  required_gates: exports_external.array(exports_external.string()).default([]),
+  gates: exports_external.record(exports_external.string(), GateEvidenceSchema),
+  turbo: exports_external.boolean().optional(),
+  requirements_state: exports_external.enum(["known", "unknown"]).optional(),
+  test_engineer_exempt: exports_external.boolean().optional(),
+  planId: exports_external.string().optional(),
+  planIdentityHash: exports_external.string().regex(/^[a-f0-9]{64}$/).optional(),
+  workflow: TaskWorkflowMetadataSchema.optional(),
+  repair_provenance: exports_external.object({
+    source_sha256: exports_external.string().regex(/^[a-f0-9]{64}$/).nullable(),
+    source_generation: exports_external.number().int().min(0).nullable(),
+    requirements_receipt_hash: exports_external.string().regex(/^[a-f0-9]{64}$/).nullable()
+  }).optional(),
+  todo_scan: exports_external.object({
+    priority: exports_external.string(),
+    count: exports_external.number().int().min(0),
+    details: exports_external.array(exports_external.string()).max(200).optional(),
+    recorded_at: exports_external.string().optional()
+  }).optional()
+});
+function parseTaskEvidence(raw, expectedTaskId) {
+  const parsed = TaskEvidenceSchema.parse(JSON.parse(raw));
+  if (parsed.taskId !== expectedTaskId) {
+    throw new Error(`TASK_EVIDENCE_IDENTITY_MISMATCH: expected ${expectedTaskId}, found ${parsed.taskId}`);
+  }
+  return parsed;
+}
+function resolveCurrentPlanIdentitySync(directory) {
+  if (!directory)
+    return null;
+  try {
+    const planPath = path2.join(directory, ".swarm", "plan.json");
+    const raw = readFileSync2(planPath, "utf8");
+    const plan = JSON.parse(raw);
+    if (typeof plan.swarm !== "string" || typeof plan.title !== "string")
+      return null;
+    return {
+      planId: derivePlanId(plan),
+      planIdentityHash: derivePlanIdentityHash(plan)
+    };
+  } catch {
+    return null;
+  }
+}
+function evidenceStampedForDifferentPlan(evidence, currentPlanIdentityHash) {
+  if (evidence == null || currentPlanIdentityHash == null)
+    return false;
+  return typeof evidence.planIdentityHash === "string" && evidence.planIdentityHash !== currentPlanIdentityHash;
+}
+function planStampForPersist(nextEvidence, previous, planIdentity, campaignRestart) {
+  if (nextEvidence.planIdentityHash !== undefined)
+    return {};
+  const carriesGates = Object.keys(nextEvidence.gates ?? {}).length > 0;
+  if (carriesGates && previous != null && !campaignRestart) {
+    return previous.planIdentityHash !== undefined ? {
+      ...previous.planId !== undefined ? { planId: previous.planId } : {},
+      planIdentityHash: previous.planIdentityHash
+    } : {};
+  }
+  return planIdentity ? {
+    planId: planIdentity.planId,
+    planIdentityHash: planIdentity.planIdentityHash
+  } : {};
+}
+var DEFAULT_REQUIRED_GATES = ["reviewer", "test_engineer"];
+var DEFAULT_WORKFLOW_STATE = "idle";
+var WORKFLOW_STATE_RANK = {
+  idle: 0,
+  coder_delegated: 1,
+  pre_check_passed: 2,
+  reviewer_run: 3,
+  tests_run: 4,
+  rework_required: 5,
+  blocked: 6,
+  closed: 7,
+  complete: 8
+};
+function isValidTaskId(taskId) {
+  return isStrictTaskId(taskId);
+}
+function assertValidTaskId(taskId) {
+  assertStrictTaskId(taskId);
+}
+function createDefaultWorkflowMetadata(nowIso) {
+  return {
+    schema: TASK_WORKFLOW_SCHEMA_MARKER,
+    generation: 0,
+    state: DEFAULT_WORKFLOW_STATE,
+    retryCount: 0,
+    retryHistory: [],
+    retryEpoch: 0,
+    lastOutcome: "none",
+    lastTransitionId: null,
+    updatedAt: nowIso
+  };
+}
+function getEventOutcome(event) {
+  switch (event.type) {
+    case "dispatch_attempted":
+      return "dispatch_attempted";
+    case "dispatch_no_mutation":
+      return "dispatch_no_mutation";
+    case "accepted_mutation":
+      return event.context?.settlementFailed === true ? "accepted_mutation_failed" : "accepted_mutation";
+    case "stage_a_passed":
+      return "stage_a_passed";
+    case "stage_a_failed":
+      return "stage_a_failed";
+    case "stage_b_completed":
+      return "stage_b_completed";
+    case "stage_b_failed":
+      return "stage_b_failed";
+    case "gate_recorded":
+      return "gate_recorded";
+    case "task_completed":
+      return "task_completed";
+    case "task_blocked":
+      return "task_blocked";
+    case "task_closed":
+      return "task_closed";
+    case "repair_idle":
+      return "repair_idle";
+    case "external_evidence_attested":
+      return "external_evidence_attested";
+    case "external_evidence_revoked":
+      return "external_evidence_revoked";
+  }
+}
+function isAuthoritativeWorkflowMetadata(workflow) {
+  return workflow?.schema === TASK_WORKFLOW_SCHEMA_MARKER;
+}
+function getTaskWorkflowSnapshot(evidence) {
+  if (isAuthoritativeWorkflowMetadata(evidence?.workflow)) {
+    return { ...evidence.workflow, authoritative: true };
+  }
+  return {
+    ...createDefaultWorkflowMetadata(""),
+    authoritative: false
+  };
+}
+function maybeExpandRequiredGates(existing, event) {
+  if (event.type === "accepted_mutation") {
+    const agentType = event.agentType;
+    if (typeof agentType === "string" && agentType.trim() !== "") {
+      return existing ? expandRequiredGates(existing.required_gates.filter((gate) => gate !== TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL), agentType, event.context ?? {}) : deriveRequiredGates(agentType, event.context ?? {});
+    }
+  }
+  if (event.type === "stage_b_completed" && event.ensureDefaultStageB === true) {
+    return expandRequiredGates(existing?.required_gates ?? [], "coder", {
+      testEngineerExempt: false
+    });
+  }
+  if (event.type === "stage_b_completed" || event.type === "gate_recorded") {
+    return existing ? expandRequiredGates(existing.required_gates, event.gate) : deriveRequiredGates(event.gate);
+  }
+  return existing?.required_gates ?? [];
+}
+function hasAllRequiredGatesPassed(requiredGates, gates) {
+  return requiredGates.length > 0 && requiredGates.every((gate) => gates[gate] != null);
+}
+function shouldTreatGateAsStageB(gate) {
+  return gate === "reviewer" || gate === "test_engineer";
+}
+function clearWorkflowGateProof(gates) {
+  const retained = { ...gates };
+  delete retained.pre_check;
+  delete retained.reviewer;
+  delete retained.test_engineer;
+  delete retained.council;
+  delete retained.critic;
+  delete retained.critic_sounding_board;
+  return retained;
+}
+function assertExpectedGeneration(snapshot, event) {
+  if (typeof event.expectedGeneration === "number" && event.expectedGeneration !== snapshot.generation) {
+    throw new Error(`TASK_WORKFLOW_GENERATION_MISMATCH: expected ${event.expectedGeneration}, current ${snapshot.generation}`);
+  }
+}
+function isDuplicateTransition(snapshot, event) {
+  if (event.type === "dispatch_no_mutation" && event.context?.declaredFiles?.length === 0 && event.context.settlementTransitionId === event.transitionId && !snapshot.noMutationSettlement) {
+    return false;
+  }
+  return snapshot.authoritative && typeof event.transitionId === "string" && event.transitionId.length > 0 && snapshot.lastTransitionId === event.transitionId && snapshot.lastOutcome === getEventOutcome(event);
+}
+function isNoMutationSettlementMetadata(workflow) {
+  const settlement = workflow.noMutationSettlement;
+  if (!workflow.authoritative || workflow.generation !== 0 || settlement?.generation !== 0 || typeof settlement.transitionId !== "string" || settlement.transitionId.length === 0 || !Array.isArray(settlement.declaredFiles) || settlement.declaredFiles.length !== 0)
+    return false;
+  return workflow.state === "idle" || workflow.state === "complete";
+}
+function deriveApplicableGateSet(evidence, options) {
+  if (!evidence) {
+    return {
+      requiredGates: ["pre_check"],
+      satisfiedGates: [],
+      missingGates: ["pre_check"],
+      readOnlyNoMutation: false
+    };
+  }
+  const workflow = getTaskWorkflowSnapshot(evidence);
+  const readOnlyNoMutation = isNoMutationSettlementMetadata(workflow) && (options?.currentDeclaredFiles === undefined ? true : options.currentDeclaredFiles !== null && options.currentDeclaredFiles.length === 0);
+  const externalEvidenceMatched = workflow.lastOutcome === "external_evidence_attested" && (workflow.externalEvidence?.anchors.length ?? 0) > 0 && workflow.externalEvidence.anchors.every((anchor) => anchor.matched);
+  const requiredGates = [...new Set(evidence.required_gates ?? [])];
+  if (!readOnlyNoMutation && !externalEvidenceMatched && !requiredGates.includes("pre_check")) {
+    requiredGates.unshift("pre_check");
+  }
+  const satisfiedGates = requiredGates.filter((gate) => evidence.gates?.[gate] != null);
+  return {
+    requiredGates,
+    satisfiedGates,
+    missingGates: requiredGates.filter((gate) => evidence.gates?.[gate] == null),
+    readOnlyNoMutation
+  };
+}
+function isReadOnlyNoMutationEligible(evidence, options) {
+  return deriveApplicableGateSet(evidence, options).readOnlyNoMutation;
+}
+function computeExternalDeclarationDigest(input) {
+  const canonical = {
+    taskId: input.taskId,
+    evidence_class: input.evidence_class,
+    evidence_anchors: input.evidence_anchors.map((anchor) => ({
+      command: anchor.command,
+      expect: anchor.expect,
+      expect_prefix: anchor.expect_prefix
+    })),
+    plan_title: input.plan_title,
+    plan_swarm: input.plan_swarm,
+    generation: input.generation
+  };
+  return createHash2("sha256").update(JSON.stringify(canonical)).digest("hex");
+}
+function externalProofCurrent(plan, planTask, evidence) {
+  if (planTask.evidence_class !== "external_git")
+    return false;
+  const workflow = evidence?.workflow;
+  if (!workflow)
+    return false;
+  const bundle = workflow.externalEvidence;
+  if (!bundle || bundle.anchors.length === 0)
+    return false;
+  if (!bundle.anchors.every((anchor) => anchor.matched))
+    return false;
+  return bundle.declarationDigest === computeExternalDeclarationDigest({
+    taskId: planTask.id,
+    evidence_class: "external_git",
+    evidence_anchors: planTask.evidence_anchors ?? [],
+    plan_title: plan.title,
+    plan_swarm: plan.swarm,
+    generation: workflow.generation
+  });
+}
+function isExternalEvidenceInitialCompletionEligible(plan, planTask, evidence) {
+  if (!externalProofCurrent(plan, planTask, evidence))
+    return false;
+  const snapshot = getTaskWorkflowSnapshot(evidence);
+  return snapshot.authoritative && snapshot.state === "idle";
+}
+function reduceTaskWorkflowSnapshot(current, event, context) {
+  if ((current.state === "complete" || current.state === "blocked" || current.state === "closed") && event.type !== "repair_idle" && !(current.state === "complete" && event.type === "task_completed" || current.state === "blocked" && event.type === "task_blocked" || current.state === "blocked" && event.type === "task_closed" || current.state === "blocked" && event.type === "stage_a_passed" && event.settlementRecovery === true)) {
+    throw new Error(`TASK_WORKFLOW_TERMINAL: cannot apply ${event.type} from ${current.state}`);
+  }
+  const outcome = getEventOutcome(event);
+  const base = {
+    schema: TASK_WORKFLOW_SCHEMA_MARKER,
+    generation: current.generation,
+    state: current.state,
+    retryCount: current.retryCount,
+    retryHistory: current.retryHistory,
+    retryEpoch: current.retryEpoch,
+    lastOutcome: outcome,
+    lastTransitionId: event.transitionId ?? current.lastTransitionId,
+    updatedAt: context.nowIso,
+    ...current.forcedCompletion === true ? { forcedCompletion: true } : {},
+    ...current.supervisedRecovery === true ? { supervisedRecovery: true } : {},
+    ...current.settlementRecovery === true ? { settlementRecovery: true } : {},
+    ...current.noMutationSettlement ? { noMutationSettlement: current.noMutationSettlement } : {},
+    ...current.externalEvidence ? { externalEvidence: current.externalEvidence } : {}
+  };
+  switch (event.type) {
+    case "dispatch_attempted": {
+      const {
+        noMutationSettlement: _clearedSettlement,
+        externalEvidence: _clearedExternalEvidence,
+        ...withoutSettlement
+      } = base;
+      return withoutSettlement;
+    }
+    case "dispatch_no_mutation": {
+      const {
+        noMutationSettlement: _clearedSettlement,
+        externalEvidence: _clearedExternalEvidence,
+        ...withoutSettlement
+      } = base;
+      return {
+        ...withoutSettlement,
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1,
+        ...current.generation === 0 && event.transitionId && Array.isArray(event.context?.declaredFiles) && event.context.declaredFiles.length === 0 && event.context.settlementTransitionId === event.transitionId ? {
+          noMutationSettlement: {
+            generation: 0,
+            transitionId: event.transitionId,
+            declaredFiles: []
+          }
+        } : {}
+      };
+    }
+    case "stage_b_failed":
+      if (current.state !== "pre_check_passed" && current.state !== "reviewer_run" && current.state !== "tests_run" && current.state !== "rework_required") {
+        throw new Error(`TASK_WORKFLOW_STAGE_A_REQUIRED: cannot reject ${event.gate} from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "rework_required",
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1
+      };
+    case "accepted_mutation": {
+      const {
+        noMutationSettlement: _clearedSettlement,
+        externalEvidence: _clearedExternalEvidence,
+        ...withoutSettlement
+      } = base;
+      if (event.context?.settlementFailed === true) {
+        return {
+          ...withoutSettlement,
+          generation: current.generation + 1,
+          state: "rework_required",
+          retryCount: Math.min(current.retryCount + 1, 3),
+          retryHistory: [...current.retryHistory, outcome].slice(-3),
+          retryEpoch: current.retryEpoch || current.generation + 1,
+          supervisedRecovery: undefined,
+          settlementRecovery: undefined
+        };
+      }
+      return {
+        ...withoutSettlement,
+        generation: current.generation + 1,
+        state: "coder_delegated",
+        supervisedRecovery: undefined,
+        settlementRecovery: undefined
+      };
+    }
+    case "stage_a_passed":
+      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed" && !(current.state === "rework_required" && event.supervisedRecovery === true) && !(event.settlementRecovery === true && (current.state === "idle" || current.state === "blocked"))) {
+        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot pass Stage A from ${current.state}`);
+      }
+      return {
+        ...base,
+        ...event.supervisedRecovery === true ? { supervisedRecovery: true } : {},
+        ...event.settlementRecovery === true ? { settlementRecovery: true } : {},
+        state: "pre_check_passed"
+      };
+    case "stage_a_failed":
+      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed" && current.state !== "rework_required") {
+        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot fail Stage A from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "rework_required",
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1
+      };
+    case "stage_b_completed":
+      if (current.state !== "pre_check_passed" && current.state !== "reviewer_run" && current.state !== "tests_run") {
+        throw new Error(`TASK_WORKFLOW_STAGE_A_REQUIRED: cannot record ${event.gate} from ${current.state}`);
+      }
+      if (event.routeComplete === false) {
+        return {
+          ...base,
+          state: event.gate === "reviewer" || current.state === "reviewer_run" ? "reviewer_run" : current.state
+        };
+      }
+      if (event.routeComplete === true) {
+        return { ...base, state: "tests_run" };
+      }
+      return {
+        ...base,
+        state: hasAllRequiredGatesPassed(context.requiredGates, context.gates) ? "tests_run" : "reviewer_run"
+      };
+    case "gate_recorded":
+      return {
+        ...base,
+        state: current.state
+      };
+    case "external_evidence_attested": {
+      if (current.state !== "idle") {
+        throw new Error(`TASK_WORKFLOW_EXTERNAL_ATTEST_STATE: external evidence can only be attested from idle (task never entered the coder QA lifecycle), not ${current.state}`);
+      }
+      if (current.externalEvidence?.transitionId === event.bundle.transitionId) {
+        return { ...base };
+      }
+      return { ...base, externalEvidence: event.bundle };
+    }
+    case "external_evidence_revoked": {
+      const {
+        externalEvidence: _revokedExternalEvidence,
+        ...withoutExternalEvidence
+      } = base;
+      return withoutExternalEvidence;
+    }
+    case "task_completed": {
+      const readOnlyNoMutation = event.readOnlyNoMutation === true && current.state === "idle" && current.generation === 0 && isNoMutationSettlementMetadata(current) && context.requiredGates.every((gate) => context.gates[gate] != null);
+      const externalAdmitted = event.externalEvidence === true && current.externalEvidence !== undefined && current.externalEvidence.anchors.length > 0 && current.externalEvidence.anchors.every((anchor) => anchor.matched) && (current.state === "idle" || current.state === "complete");
+      if (event.qaExempt !== true && current.state !== "tests_run" && current.state !== "complete" && !(current.state === "pre_check_passed" && context.gates.council != null) && !readOnlyNoMutation && !externalAdmitted) {
+        throw new Error(`TASK_WORKFLOW_QA_REQUIRED: cannot complete from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "complete",
+        ...event.qaExempt === true ? { forcedCompletion: true } : {}
+      };
+    }
+    case "task_blocked":
+      return {
+        ...base,
+        state: "blocked"
+      };
+    case "task_closed":
+      return {
+        ...base,
+        state: "closed"
+      };
+    case "repair_idle": {
+      const {
+        forcedCompletion: _cleared,
+        supervisedRecovery: _clearedMarker,
+        settlementRecovery: _clearedSettlementMarker,
+        noMutationSettlement: _clearedSettlement,
+        externalEvidence: _clearedExternalEvidence,
+        ...withoutForced
+      } = base;
+      return {
+        ...withoutForced,
+        generation: current.generation + 1,
+        state: "idle",
+        retryCount: 0,
+        retryHistory: [],
+        retryEpoch: 0
+      };
+    }
+  }
+}
+function getEvidenceDir(directory) {
+  const swarmDir = path2.resolve(directory, ".swarm");
+  const evidenceDir = path2.join(swarmDir, "evidence");
+  mkdirSync2(evidenceDir, { recursive: true });
+  let resolvedSwarmDir;
+  let resolvedEvidenceDir;
+  try {
+    resolvedSwarmDir = path2.normalize(realpathSync2(swarmDir));
+    resolvedEvidenceDir = path2.normalize(realpathSync2(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 bindTrustedNoMutationSettlement(directory, taskId, event) {
+  if (event.type !== "dispatch_no_mutation")
+    return event;
+  const context = event.context;
+  if (!context || event.transitionId === undefined) {
+    return { ...event, context: undefined };
+  }
+  try {
+    const wal = readWorkflowWalFileSync("coder-settlement", validateSwarmPath(directory, `coder-settlements/${taskId}.json`), taskId);
+    const declaredFiles = wal?.context?.declaredFiles;
+    const trusted = wal !== null && (wal.state === "PREPARED" || wal.state === "COMMITTED") && wal.accepted === false && wal.transitionId === event.transitionId && Array.isArray(declaredFiles) && declaredFiles.length === 0 && Array.isArray(context.declaredFiles) && context.declaredFiles.length === 0;
+    return {
+      ...event,
+      context: trusted ? {
+        ...context,
+        declaredFiles,
+        settlementTransitionId: wal.transitionId
+      } : { ...context, settlementTransitionId: undefined }
+    };
+  } catch {
+    return {
+      ...event,
+      context: { ...context, settlementTransitionId: undefined }
+    };
+  }
+}
+function readExisting(evidencePath, taskId) {
+  try {
+    const raw = 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,
+    requirements_state: existing?.requirements_state,
+    ...existing?.repair_provenance ? { repair_provenance: existing.repair_provenance } : {},
+    ...existing?.todo_scan ? { todo_scan: existing.todo_scan } : {}
+  };
+}
+async function transitionTaskWorkflowEvidence(directory, taskId, event) {
+  const { evidence } = await transitionTaskWorkflowEvidenceWithStatus(directory, taskId, event);
+  return evidence;
+}
+async function transitionTaskWorkflowEvidenceWithStatus(directory, taskId, event) {
+  assertValidTaskId(taskId);
+  let updatedEvidence = null;
+  let duplicated = false;
+  await withTaskEvidenceTransaction(directory, taskId, event.type, async (transaction) => {
+    if (transaction.transitionWithStatus) {
+      const result = await transaction.transitionWithStatus(event);
+      updatedEvidence = result.evidence;
+      duplicated = result.duplicated;
+      return;
+    }
+    updatedEvidence = await transaction.transition(event);
+  });
+  return {
+    evidence: updatedEvidence ?? {
+      taskId,
+      required_gates: [],
+      gates: {},
+      workflow: createDefaultWorkflowMetadata(new Date().toISOString())
+    },
+    duplicated
+  };
+}
+async function withTaskEvidenceTransaction(directory, taskId, agent, callback) {
+  assertValidTaskId(taskId);
+  return withTaskEvidenceLock(directory, taskId, agent, async () => {
+    const resolvedEvidenceDir = getEvidenceDir(directory);
+    const evidencePath = 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, event) => {
+      const planIdentity = resolveCurrentPlanIdentitySync(directory);
+      const validated = TaskEvidenceSchema.parse({
+        ...nextEvidence,
+        taskId,
+        ...planStampForPersist(nextEvidence, current, planIdentity, event?.type === "accepted_mutation" && event.agentType === "coder" && nextEvidence !== current)
+      });
+      await atomicWriteFile(evidencePath, JSON.stringify(validated, null, 2));
+      if (event) {
+        await _internals.appendTaskGateRequirementsReceiptIfNeeded(directory, taskId, current, validated, event);
+      }
+      current = validated;
+      return validated;
+    };
+    const transitionWithStatusImpl = async (event) => {
+      const boundEvent = bindTrustedNoMutationSettlement(directory, taskId, event);
+      assertTaskEvidenceWriteAllowed(directory, taskId, boundEvent);
+      const nextEvidence = updateEvidenceForTransition(current, boundEvent);
+      const duplicated = nextEvidence === current;
+      nextEvidence.taskId = taskId;
+      const evidence = await persist(nextEvidence, boundEvent);
+      return { evidence, duplicated };
+    };
+    const saveImpl = async (nextEvidence) => {
+      assertTaskEvidenceWriteAllowed(directory, taskId, undefined);
+      nextEvidence.taskId = taskId;
+      return persist(nextEvidence);
+    };
+    return callback({
+      taskId,
+      read: () => current,
+      transition: async (event) => {
+        const { evidence } = await transitionWithStatusImpl(event);
+        return evidence;
+      },
+      transitionWithStatus: transitionWithStatusImpl,
+      save: saveImpl
+    });
+  });
+}
+async function ensureTaskGateRequirementsReceiptForSettledTransition(directory, taskId, evidence, event) {
+  assertValidTaskId(taskId);
+  const validated = TaskEvidenceSchema.parse({ ...evidence, taskId });
+  await _internals.appendTaskGateRequirementsReceiptIfNeeded(directory, taskId, null, validated, event);
+}
+async function recordGateEvidence(directory, taskId, gate, sessionId, turbo, options = {}) {
+  assertValidTaskId(taskId);
+  if (shouldTreatGateAsStageB(gate) && typeof options.expectedGeneration !== "number") {
+    throw new Error(`TASK_WORKFLOW_GENERATION_REQUIRED: ${gate} for task ${taskId} must be bound at dispatch`);
+  }
+  await transitionTaskWorkflowEvidence(directory, taskId, shouldTreatGateAsStageB(gate) ? {
+    type: "stage_b_completed",
+    gate,
+    sessionId,
+    routeBinding: options.routeBinding,
+    routeComplete: options.routeComplete,
+    turbo,
+    ensureDefaultStageB: options.ensureDefaultStageB,
+    expectedGeneration: options.expectedGeneration,
+    transitionId: options.transitionId
+  } : {
+    type: "gate_recorded",
+    gate,
+    sessionId,
+    turbo,
+    expectedGeneration: options.expectedGeneration,
+    transitionId: options.transitionId
+  });
+  telemetry.gatePassed(sessionId, gate, taskId);
+}
+async function recordTodoScanEvidence(directory, taskId, scan) {
+  assertValidTaskId(taskId);
+  await withTaskEvidenceTransaction(directory, taskId, "todo_scan_recorded", async (transaction) => {
+    const existing = transaction.read();
+    const base = existing ?? {
+      taskId,
+      required_gates: [],
+      gates: {},
+      workflow: createDefaultWorkflowMetadata(new Date().toISOString())
+    };
+    if (!transaction.save) {
+      throw new Error(`TASK_EVIDENCE_SAVE_UNAVAILABLE: transaction for task ${taskId} does not support supplementary writes`);
+    }
+    await transaction.save({ ...base, todo_scan: scan });
+  });
+}
+async function recordAgentDispatch(directory, taskId, agentType, turbo, context = {}) {
+  assertValidTaskId(taskId);
+  const expectedGeneration = getTaskWorkflowSnapshot(await readTaskEvidence(directory, taskId)).generation;
+  await transitionTaskWorkflowEvidence(directory, taskId, agentType === "coder" ? {
+    type: "accepted_mutation",
+    agentType,
+    turbo,
+    context,
+    expectedGeneration
+  } : {
+    type: "dispatch_attempted",
+    agentType,
+    turbo,
+    context,
+    expectedGeneration
+  });
+}
+async function readTaskEvidence(directory, taskId) {
+  const state = await readTaskEvidenceState(directory, taskId);
+  return state.kind === "ok" ? state.evidence : null;
+}
+async function readTaskEvidenceState(directory, taskId) {
+  try {
+    assertValidTaskId(taskId);
+  } catch {
+    return { kind: "missing" };
+  }
+  try {
+    const evidencePath = getEvidencePath(directory, taskId);
+    const raw = readFileSync2(evidencePath, "utf-8");
+    const evidence = parseTaskEvidence(raw, taskId);
+    return { kind: "ok", evidence };
+  } catch (error) {
+    const evidencePath = getEvidencePathSafe(directory, taskId);
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENAMETOOLONG") {
+      return { kind: "missing" };
+    }
+    telemetry.gateParseError(taskId, error);
+    return { kind: "unparseable", evidencePath, error };
+  }
+}
+function getEvidencePathSafe(directory, taskId) {
+  try {
+    return getEvidencePath(directory, taskId);
+  } catch {
+    return `${directory}/.swarm/evidence/${taskId}.json`;
+  }
+}
+function readTaskEvidenceRaw(directory, taskId) {
+  assertValidTaskId(taskId);
+  const evidencePath = getEvidencePath(directory, taskId);
+  try {
+    const raw = 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, currentDeclaredFiles) {
+  const evidence = await readTaskEvidence(directory, taskId);
+  if (!evidence)
+    return false;
+  if (!Array.isArray(evidence.required_gates))
+    return false;
+  if (currentDeclaredFiles === undefined) {
+    if (deriveApplicableGateSet(evidence).readOnlyNoMutation)
+      return false;
+    return hasAllRequiredGatesPassed(evidence.required_gates, evidence.gates);
+  }
+  return deriveApplicableGateSet(evidence, { currentDeclaredFiles }).missingGates.length === 0;
+}
+function compareTaskWorkflowStateRank(left, right) {
+  return WORKFLOW_STATE_RANK[left] - WORKFLOW_STATE_RANK[right];
+}
+
+export { readTaskGateRequirementsReceiptsSync, routeEvidenceFromTaskGateRequirements, isLegacyTaskGateRequirementsChain, isStrictTaskId, sanitizeTaskId, validateTaskIdFormat, _internals, TASK_WORKFLOW_SCHEMA_MARKER, readCurrentTaskDeclaredFiles, TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL, assertTaskEvidenceWriteAllowed, ExternalEvidenceBundleSchema, parseTaskEvidence, resolveCurrentPlanIdentitySync, evidenceStampedForDifferentPlan, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, deriveApplicableGateSet, isReadOnlyNoMutationEligible, computeExternalDeclarationDigest, externalProofCurrent, isExternalEvidenceInitialCompletionEligible, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, transitionTaskWorkflowEvidenceWithStatus, withTaskEvidenceTransaction, ensureTaskGateRequirementsReceiptForSettledTransition, recordGateEvidence, recordTodoScanEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceState, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };