opencode-swarm 7.199.5 → 7.200.0

package/dist/cli/attest-task-8ekwny8v.js

@@ -0,0 +1,2209 @@
+// @bun
+import {
+  advanceTaskState,
+  applySessionWorkflowView,
+  commitTaskTerminalUnderPlanLock,
+  enforcePersistedReviewRouteReceipt,
+  ensureAgentSession,
+  getAgentSession,
+  getModifiedFilesForTask,
+  getStageBRouteEvidence,
+  getTaskState,
+  hasActiveLeanTurbo,
+  hasActiveTurboMode,
+  hasBothStageBCompletions,
+  hasModifiedFilesForTask,
+  isStageBRouteRequired,
+  matchesTier3,
+  normalizePath,
+  readReviewRouteReceiptSync,
+  recordStageBCompletion,
+  recoverPreparedTaskRepair,
+  recoverPreparedTaskRepairUnderPlanLock,
+  recoverPreparedTaskTerminal,
+  recoverPreparedTaskTerminalUnderPlanLock,
+  repairTaskWorkflowUnderPlanLock,
+  startAgentSession,
+  swarmState,
+  updateTaskWorkflowCache
+} from "./index-hg4qa0aq.js";
+import"./index-nq3zcrhm.js";
+import"./index-8rrs1nc0.js";
+import"./index-md2180vx.js";
+import"./index-yss701b3.js";
+import"./index-0wg5q595.js";
+import"./index-axqyjreb.js";
+import"./index-txdagbh7.js";
+import"./index-qnabg1wp.js";
+import"./index-vqtca3xv.js";
+import"./index-rdec0y3z.js";
+import"./index-qnst0jwc.js";
+import {
+  recoverCoderSettlement
+} from "./index-71bqn1nn.js";
+import"./index-e8m8bb1r.js";
+import"./index-bp476gwc.js";
+import"./index-8a3aasag.js";
+import"./index-x5jwegqw.js";
+import"./index-r02aqt0a.js";
+import"./index-rfvnq6wd.js";
+import"./index-8mrentmw.js";
+import"./index-pt7h91zc.js";
+import"./index-q7sjgr1y.js";
+import {
+  createSwarmTool,
+  resolveWorkingDirectory
+} from "./index-22atsy06.js";
+import {
+  loadPlan,
+  recordTaskAttempt,
+  updateTaskStatus
+} from "./index-35tf03js.js";
+import"./index-6b295cas.js";
+import"./index-9nyqt3kb.js";
+import"./index-9nmrw7ek.js";
+import"./index-v3bmwmqw.js";
+import"./index-sk1rva12.js";
+import {
+  TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL,
+  computeExternalDeclarationDigest,
+  deriveApplicableGateSet,
+  externalProofCurrent,
+  getTaskWorkflowSnapshot,
+  isExternalEvidenceInitialCompletionEligible,
+  isLegacyTaskGateRequirementsChain,
+  isReadOnlyNoMutationEligible,
+  readCurrentTaskDeclaredFiles,
+  readTaskEvidenceRaw,
+  readTaskGateRequirementsReceiptsSync,
+  readWorkflowWalFile,
+  routeEvidenceFromTaskGateRequirements,
+  transitionTaskWorkflowEvidence,
+  validateTaskIdFormat
+} from "./index-58cr1xg0.js";
+import"./index-m9j9varx.js";
+import"./index-spggmr30.js";
+import"./index-1rfgzsaw.js";
+import"./index-x25rhkmk.js";
+import"./index-m9zzj4ee.js";
+import {
+  validateSwarmPath
+} from "./index-x1z5d5kj.js";
+import"./index-p5m71yph.js";
+import"./index-jy0mgzjq.js";
+import"./index-rtry5xyf.js";
+import"./index-hxp5jgd8.js";
+import"./index-g22dps7x.js";
+import"./index-0725jpp7.js";
+import"./index-pyv8vzkx.js";
+import {
+  formatLegacyQaBindingRecovery,
+  getProfileLookupForIdentity
+} from "./index-99zt998b.js";
+import"./index-7v74n9a1.js";
+import"./index-vmevv6my.js";
+import"./index-d083d1q7.js";
+import"./index-ry16d01s.js";
+import"./index-rdm3px0g.js";
+import"./index-wr0n2w3z.js";
+import"./index-7pmbnjvj.js";
+import"./index-9rwhas09.js";
+import"./index-1tpz99db.js";
+import"./index-n5k81wym.js";
+import"./index-vzm6zre7.js";
+import"./index-ae75rja9.js";
+import"./index-dng8z8me.js";
+import"./index-ac8vdmgv.js";
+import"./index-q8vfw61p.js";
+import {
+  assertProjectRoot,
+  hasExplicitProjectBoundary,
+  isStrictPathDescendant
+} from "./index-t7hmqgjy.js";
+import {
+  telemetry
+} from "./index-c2k7q723.js";
+import"./index-te9hq2f4.js";
+import {
+  listActiveLocks,
+  tryAcquireLock
+} from "./index-ejhxgyvm.js";
+import"./index-7g4c7s5r.js";
+import"./index-q1x73nnd.js";
+import {
+  PlanSchema
+} from "./index-3t46mez1.js";
+import {
+  init_loader,
+  loadPluginConfig
+} from "./index-gwc7jahh.js";
+import {
+  init_git_executable,
+  init_warning_buffer,
+  resolveGitExecutable
+} from "./index-sp2cxpaq.js";
+import {
+  bunSpawn,
+  init_bun_compat
+} from "./index-qbxk2rn6.js";
+import {
+  criticalWarn,
+  init_logger,
+  log
+} from "./index-zgwm4ryv.js";
+import {
+  init_schema,
+  stripKnownSwarmPrefix
+} from "./index-yvv0my1a.js";
+import"./index-xfzkq1k4.js";
+import"./index-bk5tah7q.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-gknz3bv1.js";
+import"./index-zpsr8rpc.js";
+import"./index-a76rekgs.js";
+
+// src/tools/attest-task.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+init_bun_compat();
+init_git_executable();
+
+// src/tools/update-task-status.ts
+init_zod();
+init_loader();
+init_schema();
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/hooks/diff-scope.ts
+init_bun_compat();
+init_git_executable();
+import * as fs from "fs";
+import * as path from "path";
+
+// src/utils/gitignore-warning.ts
+init_warning_buffer();
+init_bun_compat();
+init_git_executable();
+var ENSURE_SWARM_GIT_EXCLUDED_PER_CALL_TIMEOUT_MS = 1500;
+
+// src/hooks/diff-scope.ts
+var _internals = { bunSpawn, resolveGitExecutable };
+function getDeclaredScope(taskId, directory) {
+  try {
+    const planPath = path.join(directory, ".swarm", "plan.json");
+    if (!fs.existsSync(planPath))
+      return null;
+    const raw = fs.readFileSync(planPath, "utf-8");
+    const plan = JSON.parse(raw);
+    for (const phase of plan.phases ?? []) {
+      for (const task of phase.tasks ?? []) {
+        if (task.id !== taskId)
+          continue;
+        const ft = task.files_touched;
+        if (Array.isArray(ft) && ft.length > 0) {
+          return ft;
+        }
+        if (typeof ft === "string" && ft.length > 0) {
+          return [ft];
+        }
+        return null;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+var GIT_DIFF_SPAWN_OPTIONS = {
+  timeout: ENSURE_SWARM_GIT_EXCLUDED_PER_CALL_TIMEOUT_MS,
+  stdin: "ignore",
+  stdout: "pipe",
+  stderr: "pipe"
+};
+async function getChangedFiles(directory) {
+  try {
+    const gitExecutable = _internals.resolveGitExecutable();
+    const proc = _internals.bunSpawn([gitExecutable, "diff", "--name-only", "HEAD~1"], {
+      cwd: directory,
+      ...GIT_DIFF_SPAWN_OPTIONS
+    });
+    let exitCode;
+    let stdout;
+    try {
+      [exitCode, stdout] = await Promise.all([proc.exited, proc.stdout.text()]);
+    } finally {
+      try {
+        proc.kill();
+      } catch {}
+    }
+    if (exitCode === 0) {
+      return {
+        files: stdout.trim().split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0),
+        basis: "HEAD~1"
+      };
+    }
+    const proc2 = _internals.bunSpawn([gitExecutable, "diff", "--name-only", "HEAD"], {
+      cwd: directory,
+      ...GIT_DIFF_SPAWN_OPTIONS
+    });
+    let exitCode2;
+    let stdout2;
+    try {
+      [exitCode2, stdout2] = await Promise.all([
+        proc2.exited,
+        proc2.stdout.text()
+      ]);
+    } finally {
+      try {
+        proc2.kill();
+      } catch {}
+    }
+    if (exitCode2 === 0) {
+      return {
+        files: stdout2.trim().split(`
+`).map((f) => f.trim()).filter((f) => f.length > 0),
+        basis: "HEAD"
+      };
+    }
+    return { files: null, basis: "HEAD~1" };
+  } catch {
+    return { files: null, basis: "HEAD~1" };
+  }
+}
+async function getLatestCommitShortSha(directory) {
+  try {
+    const gitExecutable = _internals.resolveGitExecutable();
+    const proc = _internals.bunSpawn([gitExecutable, "rev-parse", "--short", "HEAD"], {
+      cwd: directory,
+      ...GIT_DIFF_SPAWN_OPTIONS
+    });
+    let exitCode;
+    let stdout;
+    try {
+      [exitCode, stdout] = await Promise.all([proc.exited, proc.stdout.text()]);
+    } finally {
+      try {
+        proc.kill();
+      } catch {}
+    }
+    if (exitCode === 0) {
+      const sha = stdout.trim();
+      if (sha.length > 0 && !/\s/.test(sha))
+        return sha;
+    }
+    return "";
+  } catch {
+    return "";
+  }
+}
+function hasDeclaredDiffScope(taskId, directory) {
+  try {
+    return getDeclaredScope(taskId, directory) !== null;
+  } catch {
+    return false;
+  }
+}
+async function validateDiffScope(taskId, directory, attribution) {
+  try {
+    const declaredScope = getDeclaredScope(taskId, directory);
+    if (!declaredScope)
+      return null;
+    const normalise = (p) => p.replace(/\\/g, "/").replace(/^\.\//, "");
+    const isSwarmPath = (p) => normalise(p).startsWith(".swarm/");
+    const normScope = new Set(declaredScope.map(normalise));
+    const canonicaliseAttributionEntry = (raw) => {
+      const resolved = path.isAbsolute(raw) ? path.normalize(raw) : path.resolve(directory, raw);
+      const relative2 = path.relative(directory, resolved);
+      if (!relative2)
+        return null;
+      if (relative2.startsWith("..") || path.isAbsolute(relative2)) {
+        return null;
+      }
+      return relative2;
+    };
+    const attributed = attribution?.attributedFiles;
+    let undeclared;
+    let evidence;
+    if (Array.isArray(attributed) && attributed.length > 0) {
+      const normScopeAttribution = new Set(declaredScope.map(normalizePath));
+      undeclared = attributed.filter((f) => typeof f === "string" && f.length > 0).map(canonicaliseAttributionEntry).filter((entry) => entry !== null).map(normalise).filter((f) => !isSwarmPath(f)).filter((f) => !normScopeAttribution.has(normalizePath(f)));
+      evidence = "task attribution record";
+    } else {
+      const { files, basis } = await getChangedFiles(directory);
+      if (!files)
+        return null;
+      undeclared = files.filter((f) => !isSwarmPath(f)).map(normalise).filter((f) => !normScope.has(f));
+      if (undeclared.length === 0)
+        return null;
+      const sha = await getLatestCommitShortSha(directory);
+      const shaSuffix = sha ? ` ${sha}` : "";
+      evidence = basis === "HEAD" ? `repository-wide uncommitted diff vs HEAD${shaSuffix}` : `repository-wide diff vs latest commit${shaSuffix}`;
+    }
+    if (undeclared.length === 0)
+      return null;
+    const scopeStr = declaredScope.join(", ");
+    const undeclaredStr = undeclared.slice(0, 5).join(", ");
+    const extra = undeclared.length > 5 ? ` (+${undeclared.length - 5} more)` : "";
+    return `SCOPE WARNING: Task ${taskId} declared scope [${scopeStr}] but also modified [${undeclaredStr}${extra}] (evidence: ${evidence}). Reviewer should verify these changes are intentional.`;
+  } catch {
+    return null;
+  }
+}
+
+// src/turbo/lean/task-completion.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var _internals2 = {
+  listActiveLocks,
+  verifyLeanTurboTaskCompletion
+};
+function verifyLeanTurboTaskCompletion(directory, taskId, sessionID) {
+  let persisted = null;
+  try {
+    const statePath = path2.join(directory, ".swarm", "turbo-state.json");
+    if (!fs2.existsSync(statePath)) {
+      return {
+        ok: false,
+        reason: "Lean Turbo state file not found"
+      };
+    }
+    const raw = fs2.readFileSync(statePath, "utf-8");
+    persisted = JSON.parse(raw);
+  } catch {
+    return {
+      ok: false,
+      reason: "Lean Turbo state file unreadable or malformed"
+    };
+  }
+  if (typeof persisted !== "object" || persisted === null || typeof persisted.sessions !== "object" || persisted.sessions === null || Array.isArray(persisted.sessions)) {
+    return {
+      ok: false,
+      reason: "Lean Turbo state malformed: missing expected fields"
+    };
+  }
+  let runState = null;
+  for (const sessionState of Object.values(persisted.sessions)) {
+    if (typeof sessionState === "object" && sessionState !== null && sessionState.strategy === "lean" && sessionState.status === "running") {
+      if (sessionID !== undefined && sessionState.sessionID !== sessionID) {
+        continue;
+      }
+      runState = sessionState;
+      break;
+    }
+  }
+  if (!runState) {
+    return {
+      ok: false,
+      reason: "No active Lean Turbo run state found"
+    };
+  }
+  if (!Array.isArray(runState.lanes) || !Array.isArray(runState.degradedTasks)) {
+    return {
+      ok: false,
+      reason: "Lean Turbo state malformed: missing expected fields"
+    };
+  }
+  const lane = runState.lanes.find((l) => typeof l === "object" && l !== null && Array.isArray(l.taskIds) && typeof l.laneId === "string" && l.taskIds.includes(taskId));
+  if (!lane) {
+    return {
+      ok: false,
+      reason: `Task ${taskId} not found in any Lean Turbo lane`,
+      laneFound: false
+    };
+  }
+  const degradedTask = runState.degradedTasks.find((dt) => typeof dt === "object" && dt !== null && dt.taskId === taskId);
+  if (degradedTask) {
+    return {
+      ok: false,
+      reason: `Task ${taskId} is degraded: ${degradedTask.reason}`,
+      laneFound: true
+    };
+  }
+  if (lane.status !== "completed") {
+    return {
+      ok: false,
+      reason: `Lane ${lane.laneId} is not completed (status: ${lane.status})`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  if (lane.laneId.length === 0 || lane.laneId.includes("/") || lane.laneId.includes("\\") || lane.laneId.includes("..")) {
+    return {
+      ok: false,
+      reason: `Lane ID contains invalid characters: ${lane.laneId}`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  const phase = runState.phase ?? 0;
+  const evidencePath = path2.join(directory, ".swarm", "evidence", String(phase), "lean-turbo", `${lane.laneId}.json`);
+  const expectedDir = path2.join(directory, ".swarm", "evidence", String(phase), "lean-turbo");
+  const resolvedPath = path2.resolve(evidencePath);
+  const resolvedDir = path2.resolve(expectedDir);
+  if (!resolvedPath.startsWith(resolvedDir + path2.sep) && resolvedPath !== resolvedDir) {
+    return {
+      ok: false,
+      reason: `Lane ID causes path traversal: ${lane.laneId}`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  if (!fs2.existsSync(evidencePath)) {
+    return {
+      ok: false,
+      reason: `Lane ${lane.laneId} evidence file not found: ${evidencePath}`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  const activeLocks = _internals2.listActiveLocks(directory);
+  const laneLocks = activeLocks.filter((lock) => lock.laneId === lane.laneId);
+  if (laneLocks.length > 0) {
+    return {
+      ok: false,
+      reason: `Active file locks exist for lane ${lane.laneId}: ${laneLocks.map((l) => l.filePath).join(", ")}`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  let filesTouched = [];
+  try {
+    const planPath = path2.join(directory, ".swarm", "plan.json");
+    const planRaw = fs2.readFileSync(planPath, "utf-8");
+    const plan = JSON.parse(planRaw);
+    for (const planPhase of plan.phases ?? []) {
+      for (const task of planPhase.tasks ?? []) {
+        if (task.id === taskId && task.files_touched) {
+          filesTouched = task.files_touched;
+          break;
+        }
+      }
+    }
+  } catch {
+    return {
+      ok: false,
+      reason: `Cannot verify Tier-3 patterns for task ${taskId}: plan.json unreadable`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  if (filesTouched.length > 0 && matchesTier3(filesTouched)) {
+    return {
+      ok: false,
+      reason: `Task ${taskId} touches Tier-3 security-sensitive files and cannot bypass Stage B`,
+      laneFound: true,
+      evidence: {
+        laneId: lane.laneId,
+        laneStatus: lane.status,
+        taskIds: lane.taskIds
+      }
+    };
+  }
+  return {
+    ok: true,
+    reason: `Task ${taskId} in completed lane ${lane.laneId}`,
+    laneFound: true,
+    evidence: {
+      laneId: lane.laneId,
+      laneStatus: lane.status,
+      taskIds: lane.taskIds
+    }
+  };
+}
+
+// src/tools/update-task-status.ts
+init_logger();
+var _internals3 = {
+  tryAcquireLock,
+  updateTaskStatus,
+  resolveWorkingDirectory,
+  loadPlan,
+  readTaskEvidenceRaw,
+  hasActiveLeanTurbo,
+  hasActiveTurboMode,
+  verifyLeanTurboTaskCompletion,
+  hasPassedDurableGateEvidence,
+  emitReviewerGateDecision: telemetry.reviewerGateDecision,
+  recordTaskAttempt
+};
+async function recordRunMemoryOutcome(directory, input) {
+  try {
+    await _internals3.recordTaskAttempt(directory, input);
+  } catch (_error) {}
+}
+function syncCallerWorkflowFromEvidence(sessionId, taskId, evidence) {
+  if (!sessionId)
+    return;
+  const callerSession = ensureAgentSession(sessionId);
+  const workflow = getTaskWorkflowSnapshot(evidence);
+  applySessionWorkflowView(callerSession, taskId, workflow);
+}
+async function hasPreparedWorkflowWal(directory, taskId, kind) {
+  return await readPreparedWorkflowWal(directory, taskId, kind) !== null;
+}
+async function readPreparedWorkflowWal(directory, taskId, kind) {
+  const walPath = validateSwarmPath(directory, kind === "task-repair" ? `task-repairs/${taskId}.json` : `task-terminals/${taskId}.json`);
+  const wal = await readWorkflowWalFile(kind, walPath, taskId);
+  return wal?.state === "PREPARED" ? wal : null;
+}
+function resolveRunMemoryFileTargets(plan, taskId) {
+  return plan?.phases.flatMap((phase) => phase.tasks).find((candidate) => candidate.id === taskId)?.files_touched ?? [];
+}
+var VALID_STATUSES = [
+  "pending",
+  "in_progress",
+  "completed",
+  "blocked"
+];
+function validateStatus(status) {
+  if (!VALID_STATUSES.includes(status)) {
+    return `Invalid status "${status}". Must be one of: ${VALID_STATUSES.join(", ")}`;
+  }
+  return;
+}
+function validateTaskId(taskId) {
+  const result = validateTaskIdFormat(taskId);
+  if (result) {
+    return `Invalid task_id "${taskId}". Must match pattern N.M or N.M.P (e.g., "1.1", "1.2.3")`;
+  }
+  return;
+}
+function getSettledTransitionRejection(taskId, currentStatus, nextStatus, force) {
+  if (currentStatus !== "pending" && currentStatus !== "in_progress" && nextStatus !== currentStatus) {
+    if (nextStatus !== "in_progress" || force !== true) {
+      return {
+        success: false,
+        message: `Task ${taskId} is settled (${currentStatus}); backward transitions require the audited in_progress repair path.`,
+        errors: [
+          `Task ${taskId} is settled (${currentStatus}); use force:true with exact CAS and audit fields to repair it to in_progress.`
+        ]
+      };
+    }
+  }
+  return null;
+}
+function isRepairRetryShape(args) {
+  return args.status === "in_progress" && args.force === true && typeof args.transition_id === "string";
+}
+function reviewerGateDecision(taskId, sessionID, result, reasonCode, evidenceKind) {
+  try {
+    _internals3.emitReviewerGateDecision(sessionID ?? "", taskId, result.blocked, reasonCode, evidenceKind);
+  } catch (_error) {}
+  return result;
+}
+function hasPassedDurableGateEvidence(workingDirectory, taskId) {
+  const evidence = readTaskEvidenceRaw(workingDirectory, taskId);
+  if (!evidence || !Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0) {
+    return false;
+  }
+  return evidence.required_gates.every((gate) => evidence.gates?.[gate] != null);
+}
+function routeGateAllowsTask(directory, taskId, sessionID) {
+  if (!directory)
+    return true;
+  const enforcementEnabled = (() => {
+    try {
+      return loadPluginConfig(directory).review_routing?.enforce_receipts ?? true;
+    } catch {
+      return true;
+    }
+  })();
+  if (!enforcementEnabled)
+    return true;
+  const requirementReceipts = (() => {
+    try {
+      return readTaskGateRequirementsReceiptsSync(directory, taskId);
+    } catch {
+      return null;
+    }
+  })();
+  if (!requirementReceipts)
+    return false;
+  const session = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+  const routeRequired = sessionID ? session ? isStageBRouteRequired(session, taskId) : false : [...swarmState.agentSessions.values()].some((candidate) => isStageBRouteRequired(candidate, taskId));
+  const legacyUnrouted = isLegacyTaskGateRequirementsChain(requirementReceipts) && !routeRequired;
+  if (!routeRequired && requirementReceipts.length === 0)
+    return true;
+  const durableEvidence = routeEvidenceFromTaskGateRequirements(requirementReceipts);
+  const routeAllowsSession = (candidateSessionID, candidateSession) => {
+    try {
+      readReviewRouteReceiptSync({
+        projectRoot: directory,
+        sessionId: candidateSessionID,
+        taskId
+      });
+    } catch {
+      return false;
+    }
+    const liveEvidence = candidateSession ? getStageBRouteEvidence(candidateSession, taskId) : [];
+    return enforcePersistedReviewRouteReceipt({
+      projectRoot: directory,
+      sessionId: candidateSessionID,
+      taskId,
+      receipts: liveEvidence.length > 0 ? liveEvidence : durableEvidence,
+      enforcementEnabled: true,
+      legacyUnrouted: false,
+      requireEvidenceBindings: true
+    }).canAdvance;
+  };
+  if (sessionID)
+    return routeAllowsSession(sessionID, session);
+  if (!routeRequired)
+    return legacyUnrouted;
+  const evidenceSessionIDs = new Set(durableEvidence.map((evidence) => evidence.sessionId).filter((value) => Boolean(value)));
+  for (const [
+    candidateSessionID,
+    candidateSession
+  ] of swarmState.agentSessions) {
+    if (!isStageBRouteRequired(candidateSession, taskId) && !evidenceSessionIDs.has(candidateSessionID))
+      continue;
+    if (routeAllowsSession(candidateSessionID, candidateSession))
+      return true;
+  }
+  return false;
+}
+function checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled = false, sessionID, fallbackDir, currentDeclaredFiles) {
+  try {
+    let skipStandardTurboBypass = false;
+    if (!fallbackDir && !sessionID && _internals3.hasActiveLeanTurbo(sessionID)) {
+      const resolvedDir2 = workingDirectory;
+      try {
+        const leanCheck = _internals3.verifyLeanTurboTaskCompletion(resolvedDir2, taskId, sessionID);
+        if (leanCheck.ok) {
+          return reviewerGateDecision(taskId, sessionID, {
+            blocked: false,
+            reason: `Lean Turbo bypass: ${leanCheck.reason}`
+          }, "lean_turbo_completed_lane", "fallback");
+        }
+        if (leanCheck.laneFound !== false) {
+          skipStandardTurboBypass = true;
+        }
+      } catch {
+        skipStandardTurboBypass = true;
+      }
+    }
+    if (!fallbackDir && !sessionID && !skipStandardTurboBypass && _internals3.hasActiveTurboMode(sessionID)) {
+      const resolvedDir2 = workingDirectory;
+      try {
+        const planPath = path3.join(resolvedDir2, ".swarm", "plan.json");
+        const planRaw = fs3.readFileSync(planPath, "utf-8");
+        const plan = JSON.parse(planRaw);
+        for (const planPhase of plan.phases ?? []) {
+          for (const task of planPhase.tasks ?? []) {
+            if (task.id === taskId && Array.isArray(task.files_touched) && task.files_touched.length > 0) {
+              if (!matchesTier3(task.files_touched)) {
+                return reviewerGateDecision(taskId, sessionID, {
+                  blocked: false,
+                  reason: "Turbo Mode bypass"
+                }, "standard_turbo_non_tier3", "fallback");
+              }
+              break;
+            }
+          }
+        }
+      } catch {}
+    }
+    let authoritativeDir;
+    if (fallbackDir) {
+      const resolved = _internals3.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      authoritativeDir = resolved.success ? resolved.directory : fallbackDir;
+    } else if (workingDirectory) {
+      authoritativeDir = workingDirectory;
+    }
+    if (authoritativeDir) {
+      const legacyDirectCaller = Symbol("legacy-direct-reviewer-gate");
+      try {
+        const evidence = _internals3.readTaskEvidenceRaw(authoritativeDir, taskId);
+        if (!fallbackDir && !sessionID && !evidence?.workflow)
+          throw legacyDirectCaller;
+        try {
+          const planPath = path3.join(authoritativeDir, ".swarm", "plan.json");
+          const planRaw = fs3.readFileSync(planPath, "utf-8");
+          const plan = JSON.parse(planRaw);
+          const declaredTask = (plan.phases ?? []).flatMap((phase) => phase.tasks ?? []).find((task) => task.id === taskId);
+          if (declaredTask && declaredTask.evidence_class === "external_git" && typeof plan.title === "string" && typeof plan.swarm === "string") {
+            const planIdentity = {
+              title: plan.title,
+              swarm: plan.swarm
+            };
+            const workflow2 = getTaskWorkflowSnapshot(evidence);
+            if (isExternalEvidenceInitialCompletionEligible(planIdentity, declaredTask, evidence) || workflow2.state === "complete" && externalProofCurrent(planIdentity, declaredTask, evidence)) {
+              return reviewerGateDecision(taskId, sessionID, {
+                blocked: false,
+                reason: `External evidence attested: task ${taskId} completed via the pinned external_git anchors (issue #3422)`,
+                requiredGates: [],
+                satisfiedGates: [],
+                missingGates: [],
+                source: "external_attest",
+                generation: workflow2.generation
+              }, "durable_evidence_complete", "fallback");
+            }
+            return reviewerGateDecision(taskId, sessionID, {
+              blocked: true,
+              reason: `Task ${taskId} declares external_git evidence but no matched attestation exists yet. Run /swarm attest ${taskId} (or re-plan it as a thin coder dispatch).`,
+              requiredGates: [],
+              satisfiedGates: [],
+              missingGates: ["external_attest"],
+              source: "durable_exact_task",
+              generation: workflow2.generation,
+              nextAction: `Run /swarm attest ${taskId} (or re-plan it as a thin coder dispatch).`
+            }, "required_gates_missing", "block");
+          }
+        } catch {}
+        if (!evidence) {
+          return reviewerGateDecision(taskId, sessionID, {
+            blocked: true,
+            reason: `Task ${taskId} has no exact-task QA evidence. Delegate the required Stage B agents, then retry completion.`,
+            requiredGates: [],
+            satisfiedGates: [],
+            missingGates: ["reviewer", "test_engineer"],
+            source: "durable_exact_task",
+            generation: 0,
+            nextAction: "Delegate reviewer and test_engineer for this exact task generation."
+          }, "required_gates_missing", "block");
+        }
+        if (!evidence.workflow) {
+          const derivedGates2 = deriveApplicableGateSet(evidence);
+          return reviewerGateDecision(taskId, sessionID, {
+            blocked: true,
+            reason: `Task ${taskId} has legacy QA evidence without an authoritative workflow generation. Run a fresh exact-task workflow transition before completion.`,
+            requiredGates: derivedGates2.requiredGates,
+            satisfiedGates: derivedGates2.satisfiedGates,
+            missingGates: derivedGates2.missingGates,
+            source: "durable_exact_task",
+            generation: 0,
+            nextAction: "Re-run the exact-task coder/Stage A/Stage B workflow to migrate evidence."
+          }, "required_gates_missing", "block");
+        }
+        const workflow = getTaskWorkflowSnapshot(evidence);
+        const derivedGates = deriveApplicableGateSet(evidence, {
+          currentDeclaredFiles: currentDeclaredFiles === undefined ? readCurrentTaskDeclaredFiles(authoritativeDir, taskId) : currentDeclaredFiles
+        });
+        const requiredGates = derivedGates.requiredGates;
+        const satisfiedGates = derivedGates.satisfiedGates;
+        const missingGates = derivedGates.missingGates;
+        if (requiredGates.includes(TASK_GATE_REQUIREMENTS_RECONSTRUCTION_SENTINEL)) {
+          const recovery = `Task ${taskId} contains a legacy receipt-less gate-repair marker that no agent can satisfy. ` + `Call repair_gate_evidence for task ${taskId}, then delegate coder for a fresh accepted mutation before rerunning Stage A and Stage B.`;
+          return reviewerGateDecision(taskId, sessionID, {
+            blocked: true,
+            reason: recovery,
+            requiredGates,
+            satisfiedGates,
+            missingGates,
+            source: "durable_exact_task",
+            generation: workflow.generation,
+            nextAction: recovery
+          }, "required_gates_missing", "data_quality");
+        }
+        const contradictorySignals = [];
+        if ((workflow.state === "tests_run" || workflow.state === "complete") && missingGates.length > 0) {
+          contradictorySignals.push(`workflow state ${workflow.state} claims completion readiness while required proof is missing`);
+        }
+        if (workflow.state !== "tests_run" && workflow.state !== "complete" && evidence.gates.pre_check != null && requiredGates.length > 0 && missingGates.length === 0) {
+          contradictorySignals.push(`all required proof exists but workflow state is ${workflow.state}`);
+        }
+        const workflowComplete = workflow.state === "tests_run" || workflow.state === "complete";
+        if (missingGates.length === 0 && contradictorySignals.length === 0 && (workflowComplete || derivedGates.readOnlyNoMutation)) {
+          if (!derivedGates.readOnlyNoMutation && !routeGateAllowsTask(authoritativeDir, taskId, sessionID)) {
+            return reviewerGateDecision(taskId, sessionID, {
+              blocked: true,
+              reason: `Task ${taskId} has not satisfied its exact v1 review route receipt. Missing or mismatched route evidence fails closed.`,
+              requiredGates,
+              satisfiedGates,
+              missingGates: ["review_route_receipt"],
+              source: "durable_exact_task",
+              generation: workflow.generation,
+              nextAction: "Recover the exact route receipt and independent Stage-B bindings before completing this task."
+            }, "required_gates_missing", "block");
+          }
+          return reviewerGateDecision(taskId, sessionID, {
+            blocked: false,
+            reason: "",
+            requiredGates,
+            satisfiedGates,
+            missingGates,
+            contradictorySignals,
+            source: "durable_exact_task",
+            generation: workflow.generation
+          }, "durable_evidence_complete", "genuine");
+        }
+        return reviewerGateDecision(taskId, sessionID, {
+          blocked: true,
+          reason: `Task ${taskId} generation ${workflow.generation} has not passed exact-task QA. State: ${workflow.state}. Missing gates: [${missingGates.join(", ")}]. Contradictions: [${contradictorySignals.join("; ")}].`,
+          requiredGates,
+          satisfiedGates,
+          missingGates,
+          contradictorySignals,
+          source: "durable_exact_task",
+          generation: workflow.generation,
+          nextAction: workflow.state === "rework_required" ? "Delegate the same task to coder for repair, then rerun Stage A and Stage B." : "Complete the missing exact-task Stage A/Stage B transitions."
+        }, "required_gates_missing", "block");
+      } catch (error) {
+        if (error === legacyDirectCaller) {} else {
+          return reviewerGateDecision(taskId, sessionID, {
+            blocked: true,
+            reason: `Evidence file for task ${taskId} is corrupt or unreadable: ${error instanceof Error ? error.message : String(error)}. ` + `Call repair_gate_evidence for task ${taskId}; corrupt evidence fails closed until the repair completes.`,
+            requiredGates: [],
+            satisfiedGates: [],
+            missingGates: ["reviewer", "test_engineer"],
+            source: "durable_exact_task",
+            corrupt: true,
+            nextAction: `Call repair_gate_evidence for task ${taskId}; corrupt evidence fails closed until the repair completes.`
+          }, "corrupt_evidence", "data_quality");
+        }
+      }
+    }
+    let resolvedDir;
+    if (fallbackDir) {
+      const resolveResult = _internals3.resolveWorkingDirectory(workingDirectory, fallbackDir);
+      if (resolveResult.success) {
+        resolvedDir = resolveResult.directory;
+      } else {
+        resolvedDir = fallbackDir;
+      }
+    } else if (workingDirectory) {
+      resolvedDir = workingDirectory;
+    }
+    const routeAllowsStageB = (sessionId, _session) => routeGateAllowsTask(resolvedDir, taskId, sessionId);
+    let evidenceIncompleteReason = null;
+    try {
+      if (!resolvedDir) {} else {
+        const evidence = _internals3.readTaskEvidenceRaw(resolvedDir, taskId);
+        if (evidence === null) {} else if (evidence.required_gates && Array.isArray(evidence.required_gates) && evidence.gates) {
+          if (evidence.required_gates.length > 0 && evidence.required_gates.every((gate) => evidence.gates[gate] != null)) {
+            const routeSession = sessionID ? swarmState.agentSessions.get(sessionID) : undefined;
+            if (!resolvedDir || routeAllowsStageB(sessionID, routeSession)) {
+              return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "durable_evidence_complete", "genuine");
+            }
+          }
+          const missingGates = evidence.required_gates.filter((gate) => evidence.gates[gate] == null);
+          evidenceIncompleteReason = evidence.required_gates.length === 0 ? `Task ${taskId} has an evidence file with no required gates. Delegate reviewer and test_engineer before marking task as completed.` : `Task ${taskId} is missing required gates: [${missingGates.join(", ")}]. ` + `Required: [${evidence.required_gates.join(", ")}]. ` + `Completed: [${Object.keys(evidence.gates).join(", ")}]. ` + `Delegate the missing gate agents before marking task as completed.`;
+        }
+      }
+    } catch (error) {
+      log(`[gate-evidence] Evidence file for task ${taskId} is corrupt or unreadable:`, error instanceof Error ? error.message : String(error));
+      telemetry.gateFailed("", "qa_gate", taskId, `Evidence file corrupt or unreadable`);
+      return reviewerGateDecision(taskId, sessionID, {
+        blocked: true,
+        reason: `Evidence file for task ${taskId} is corrupt or unreadable. ` + `Call repair_gate_evidence for task ${taskId}; corrupt evidence fails closed until the repair completes.`
+      }, "corrupt_evidence", "data_quality");
+    }
+    if (swarmState.agentSessions.size === 0 && !evidenceIncompleteReason) {
+      return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "no_active_sessions", "fallback");
+    }
+    let validSessionCount = 0;
+    for (const [_sessionId, session] of swarmState.agentSessions) {
+      if (!(session.taskWorkflowStates instanceof Map)) {
+        continue;
+      }
+      validSessionCount++;
+      const state = getTaskState(session, taskId);
+      if (state === "tests_run" || state === "complete") {
+        if (resolvedDir && !routeAllowsStageB(_sessionId, session)) {
+          continue;
+        }
+        return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "workflow_state_complete", "genuine");
+      }
+      if (stageBParallelEnabled && hasBothStageBCompletions(session, taskId) && (!resolvedDir || routeAllowsStageB(_sessionId, session))) {
+        return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "stage_b_parallel_complete", "genuine");
+      }
+    }
+    if (validSessionCount === 0 && !evidenceIncompleteReason) {
+      return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "zero_valid_sessions", "data_quality");
+    }
+    const stateEntries = [];
+    for (const [sessionId, session] of swarmState.agentSessions) {
+      if (!(session.taskWorkflowStates instanceof Map))
+        continue;
+      const state = getTaskState(session, taskId);
+      stateEntries.push(`${sessionId}: ${state}`);
+    }
+    if (resolvedDir) {
+      try {
+        const planPath = path3.join(resolvedDir, ".swarm", "plan.json");
+        const planRaw = fs3.readFileSync(planPath, "utf-8");
+        const plan = JSON.parse(planRaw);
+        for (const planPhase of plan.phases ?? []) {
+          for (const task of planPhase.tasks ?? []) {
+            if (task.id === taskId && task.status === "completed" && _internals3.hasPassedDurableGateEvidence(resolvedDir, taskId)) {
+              return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "restart_recovery_complete", "genuine");
+            }
+          }
+        }
+      } catch {}
+    }
+    {
+      let hasReviewer = false;
+      let hasTestEngineer = false;
+      for (const [sessionId, chain] of swarmState.delegationChains) {
+        const session = swarmState.agentSessions.get(sessionId);
+        if (session && (session.currentTaskId === taskId || session.lastCoderDelegationTaskId === taskId)) {
+          for (const delegation of chain) {
+            const target = stripKnownSwarmPrefix(delegation.to);
+            if (target === "reviewer")
+              hasReviewer = true;
+            if (target === "test_engineer")
+              hasTestEngineer = true;
+          }
+        }
+      }
+      if (hasReviewer && hasTestEngineer) {
+        return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "scoped_delegation_complete", "genuine");
+      }
+      if (!evidenceIncompleteReason && (!hasReviewer || !hasTestEngineer)) {
+        for (const [sessionId, chain] of swarmState.delegationChains) {
+          const hasCoder = chain.some((d) => stripKnownSwarmPrefix(d.to) === "coder");
+          if (hasCoder)
+            continue;
+          const chainSession = swarmState.agentSessions.get(sessionId);
+          if (chainSession) {
+            const chainTaskId = chainSession.currentTaskId || chainSession.lastCoderDelegationTaskId;
+            if (chainTaskId && chainTaskId !== taskId)
+              continue;
+          }
+          for (const delegation of chain) {
+            const target = stripKnownSwarmPrefix(delegation.to);
+            if (target === "reviewer")
+              hasReviewer = true;
+            if (target === "test_engineer")
+              hasTestEngineer = true;
+          }
+        }
+        if (hasReviewer && hasTestEngineer) {
+          return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "unscoped_delegation_complete", "genuine");
+        }
+      }
+    }
+    const currentStateStr = stateEntries.length > 0 ? stateEntries.join(", ") : "no active sessions";
+    const chainEntries = [];
+    for (const [sessionId, chain] of swarmState.delegationChains) {
+      const session = swarmState.agentSessions.get(sessionId);
+      if (session && (session.currentTaskId === taskId || session.lastCoderDelegationTaskId === taskId)) {
+        const targets = chain.map((d) => stripKnownSwarmPrefix(d.to));
+        chainEntries.push(`${sessionId}: [${targets.join(", ")}]`);
+      }
+    }
+    const chainSummary = chainEntries.length > 0 ? chainEntries.join("; ") : "no chains for this task";
+    const rehydratedSessionCount = [
+      ...swarmState.agentSessions.values()
+    ].filter((s) => s.sessionRehydratedAt > 0).length;
+    const finalReason = [
+      `Task ${taskId} has not passed QA gates.`,
+      `  Session states: [${currentStateStr}].`,
+      `  Delegation chains: [${chainSummary}].`,
+      `  Evidence: [${evidenceIncompleteReason ?? "no evidence file found"}].`,
+      `  Rehydrated sessions: ${rehydratedSessionCount}.`,
+      `  Missing required state: tests_run or complete.`
+    ].join(`
+`);
+    telemetry.gateFailed("", "qa_gate", taskId, evidenceIncompleteReason ? `Missing gates: evidence incomplete` : `Missing state: tests_run or complete`);
+    return reviewerGateDecision(taskId, sessionID, {
+      blocked: true,
+      reason: finalReason
+    }, "required_gates_missing", "block");
+  } catch {
+    return reviewerGateDecision(taskId, sessionID, { blocked: false, reason: "" }, "inspection_error", "fallback");
+  }
+}
+function hasForeignAttributionRecord(taskId, checkingSessionId) {
+  try {
+    const checker = swarmState.agentSessions.get(checkingSessionId);
+    const checkerProject = checker?.owningProjectKey ?? null;
+    for (const [sessionId, session] of swarmState.agentSessions) {
+      if (sessionId === checkingSessionId)
+        continue;
+      if (!(session.modifiedFilesByTask instanceof Map))
+        continue;
+      if ((session.owningProjectKey ?? null) !== checkerProject)
+        continue;
+      const entry = session.modifiedFilesByTask.get(taskId);
+      if (Array.isArray(entry) && entry.length > 0)
+        return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function checkReviewerGateWithScope(taskId, workingDirectory, sessionID, fallbackDir) {
+  const stageBParallelEnabled = true;
+  const result = checkReviewerGate(taskId, workingDirectory, stageBParallelEnabled, sessionID, fallbackDir);
+  const session = sessionID ? getAgentSession(sessionID) : undefined;
+  const attributedFiles = session ? getModifiedFilesForTask(session, taskId) : [];
+  const scopeAdvisoryLine = !!sessionID && !hasModifiedFilesForTask(session, taskId) && !!workingDirectory && hasDeclaredDiffScope(taskId, workingDirectory) ? hasForeignAttributionRecord(taskId, sessionID) ? `SCOPE ADVISORY: attribution record for task ${taskId} exists under another session \u2014 not used for scope verification` : "SCOPE ADVISORY: no attribution record in this session \u2014 not used for scope verification" : null;
+  const scopeWarning = await validateDiffScope(taskId, workingDirectory, sessionID && attributedFiles.length > 0 ? { attributedFiles } : undefined).catch(() => null);
+  if (!scopeWarning && !scopeAdvisoryLine)
+    return result;
+  return {
+    ...result,
+    reason: [result.reason, scopeWarning, scopeAdvisoryLine].filter((part) => typeof part === "string" && part.length > 0).join(`
+`)
+  };
+}
+function recoverTaskStateFromDelegations(taskId, directory) {
+  let hasReviewer = false;
+  let hasTestEngineer = false;
+  for (const [sessionId, chain] of swarmState.delegationChains) {
+    const session = swarmState.agentSessions.get(sessionId);
+    if (session && (session.currentTaskId === taskId || session.lastCoderDelegationTaskId === taskId)) {
+      for (const delegation of chain) {
+        const target = stripKnownSwarmPrefix(delegation.to);
+        if (target === "reviewer")
+          hasReviewer = true;
+        if (target === "test_engineer")
+          hasTestEngineer = true;
+      }
+    }
+  }
+  let hasDurableIncompleteGates = false;
+  if (directory) {
+    try {
+      const taskEvidence = readTaskEvidenceRaw(directory, taskId);
+      if (taskEvidence?.gates && Array.isArray(taskEvidence.required_gates) && taskEvidence.required_gates.length > 0) {
+        const gates = taskEvidence.gates;
+        hasDurableIncompleteGates = taskEvidence.required_gates.some((g) => gates[g] == null);
+      }
+    } catch {
+      hasDurableIncompleteGates = true;
+    }
+  }
+  if (!hasDurableIncompleteGates && (!hasReviewer || !hasTestEngineer)) {
+    for (const [sessionId, chain] of swarmState.delegationChains) {
+      const hasCoder = chain.some((d) => stripKnownSwarmPrefix(d.to) === "coder");
+      if (hasCoder)
+        continue;
+      const chainSession = swarmState.agentSessions.get(sessionId);
+      if (chainSession) {
+        const chainTaskId = chainSession.currentTaskId || chainSession.lastCoderDelegationTaskId;
+        if (chainTaskId && chainTaskId !== taskId)
+          continue;
+      }
+      for (const delegation of chain) {
+        const target = stripKnownSwarmPrefix(delegation.to);
+        if (target === "reviewer")
+          hasReviewer = true;
+        if (target === "test_engineer")
+          hasTestEngineer = true;
+      }
+    }
+  }
+  if ((!hasReviewer || !hasTestEngineer) && directory) {
+    try {
+      const evidence = readTaskEvidenceRaw(directory, taskId);
+      if (evidence?.gates && Array.isArray(evidence.required_gates)) {
+        if (evidence.gates.reviewer != null)
+          hasReviewer = true;
+        if (evidence.gates.test_engineer != null)
+          hasTestEngineer = true;
+      }
+    } catch {}
+  }
+  if (!hasReviewer && !hasTestEngineer)
+    return;
+  if (swarmState.agentSessions.size === 0) {
+    try {
+      startAgentSession("recovery-session", "architect");
+    } catch {}
+  }
+  const recoveryRouteEnforcementEnabled = directory ? (() => {
+    try {
+      return loadPluginConfig(directory).review_routing?.enforce_receipts ?? true;
+    } catch {
+      return true;
+    }
+  })() : false;
+  for (const [sessionId, session] of swarmState.agentSessions) {
+    if (!(session.taskWorkflowStates instanceof Map))
+      continue;
+    const routeEvidence = (() => {
+      const live = getStageBRouteEvidence(session, taskId);
+      if (live.length > 0)
+        return live;
+      try {
+        return routeEvidenceFromTaskGateRequirements(readTaskGateRequirementsReceiptsSync(directory, taskId));
+      } catch {
+        return [];
+      }
+    })();
+    const routeRequired = isStageBRouteRequired(session, taskId) || routeEvidence.length > 0;
+    if (directory && recoveryRouteEnforcementEnabled && routeRequired && !enforcePersistedReviewRouteReceipt({
+      projectRoot: directory,
+      sessionId,
+      taskId,
+      receipts: routeEvidence,
+      enforcementEnabled: true,
+      legacyUnrouted: (() => {
+        try {
+          return !isStageBRouteRequired(session, taskId) && isLegacyTaskGateRequirementsChain(readTaskGateRequirementsReceiptsSync(directory, taskId));
+        } catch {
+          return false;
+        }
+      })(),
+      requireEvidenceBindings: true
+    }).canAdvance) {
+      continue;
+    }
+    const currentState = getTaskState(session, taskId);
+    if (currentState === "tests_run" || currentState === "complete")
+      continue;
+    if (hasReviewer && currentState === "idle") {
+      try {
+        advanceTaskState(session, taskId, "coder_delegated");
+      } catch {}
+    }
+    if (hasReviewer) {
+      recordStageBCompletion(session, taskId, "reviewer");
+    }
+    if (hasTestEngineer) {
+      recordStageBCompletion(session, taskId, "test_engineer");
+    }
+    if (hasReviewer) {
+      const stateNow = getTaskState(session, taskId);
+      if (stateNow === "coder_delegated" || stateNow === "pre_check_passed") {
+        try {
+          advanceTaskState(session, taskId, "reviewer_run");
+        } catch {}
+      }
+    }
+    if (hasTestEngineer) {
+      const stateNow = getTaskState(session, taskId);
+      if (stateNow === "reviewer_run") {
+        try {
+          advanceTaskState(session, taskId, "tests_run");
+        } catch {}
+      }
+    }
+  }
+}
+function checkCouncilGate(workingDirectory, taskId) {
+  let councilEnabled = false;
+  let effectiveMinimum = 3;
+  try {
+    const config = loadPluginConfig(workingDirectory);
+    councilEnabled = config.council?.enabled === true;
+    effectiveMinimum = config.council?.requireAllMembers ? 5 : config.council?.minimumMembers ?? 3;
+  } catch {
+    return { blocked: false, reason: "", active: false };
+  }
+  if (!councilEnabled) {
+    return { blocked: false, reason: "", active: false };
+  }
+  try {
+    const planPath = path3.join(workingDirectory, ".swarm", "plan.json");
+    const planRaw = fs3.readFileSync(planPath, "utf-8");
+    const planObj = JSON.parse(planRaw);
+    if (planObj.swarm && planObj.title) {
+      const lookup = getProfileLookupForIdentity(workingDirectory, planObj);
+      if (lookup.kind === "bound") {
+        if (!lookup.profile.gates.council_mode) {
+          return { blocked: false, reason: "", active: false };
+        }
+      } else if (lookup.kind === "unbound_legacy") {
+        if (lookup.profile.gates.council_mode) {
+          return {
+            blocked: true,
+            reason: `council gate required but the QA gate profile is not exact-bound to the current raw swarm_id/plan_title. ${formatLegacyQaBindingRecovery({ swarm: planObj.swarm, title: planObj.title }, "retry advancing this task")}`,
+            active: true
+          };
+        }
+        return { blocked: false, reason: "", active: false };
+      } else {
+        return { blocked: false, reason: "", active: false };
+      }
+    }
+  } catch {
+    return { blocked: false, reason: "", active: false };
+  }
+  let evidence;
+  try {
+    evidence = readTaskEvidenceRaw(workingDirectory, taskId);
+  } catch {
+    return {
+      blocked: true,
+      reason: "council gate required but not yet run \u2014 architect must call submit_council_verdicts before advancing this task",
+      active: true
+    };
+  }
+  const councilGate = evidence?.gates?.council;
+  if (!councilGate) {
+    return {
+      blocked: true,
+      reason: "council gate required but not yet run \u2014 architect must call submit_council_verdicts before advancing this task",
+      active: true
+    };
+  }
+  const councilWorkflow = getTaskWorkflowSnapshot(evidence);
+  if (!councilWorkflow.authoritative || councilWorkflow.state !== "pre_check_passed" || councilGate.workflowGeneration !== councilWorkflow.generation) {
+    return {
+      blocked: true,
+      reason: `council gate evidence is stale or unbound: expected pre_check_passed@${councilWorkflow.generation}, recorded generation ${String(councilGate.workflowGeneration)}`,
+      active: true
+    };
+  }
+  if (councilGate.verdict === "REJECT") {
+    return {
+      blocked: true,
+      reason: "council gate blocked advancement \u2014 resolve requiredFixes and re-run submit_council_verdicts",
+      active: true
+    };
+  }
+  const rawQuorumSize = councilGate.quorumSize;
+  const quorumSize = typeof rawQuorumSize === "number" && Number.isFinite(rawQuorumSize) && rawQuorumSize >= 1 ? rawQuorumSize : 1;
+  if (quorumSize < effectiveMinimum) {
+    return {
+      blocked: true,
+      reason: `council gate blocked advancement \u2014 recorded verdict has insufficient quorum (${quorumSize} of ${effectiveMinimum} required members). Re-run submit_council_verdicts with the missing council members.`,
+      active: true
+    };
+  }
+  return { blocked: false, reason: "", active: true };
+}
+async function executeUpdateTaskStatus(args, fallbackDir, ctx) {
+  const statusError = validateStatus(args.status);
+  if (statusError) {
+    return {
+      success: false,
+      message: "Validation failed",
+      errors: [statusError]
+    };
+  }
+  const taskIdError = validateTaskId(args.task_id);
+  if (taskIdError) {
+    return {
+      success: false,
+      message: "Validation failed",
+      errors: [taskIdError]
+    };
+  }
+  let directory;
+  const resolveResult = _internals3.resolveWorkingDirectory(args.working_directory, fallbackDir);
+  if (!resolveResult.success) {
+    return {
+      success: false,
+      message: resolveResult.message,
+      errors: [resolveResult.message]
+    };
+  }
+  directory = resolveResult.directory;
+  try {
+    assertProjectRoot(directory);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message,
+      errors: [message]
+    };
+  }
+  const planPath = path3.join(directory, ".swarm", "plan.json");
+  if (!fs3.existsSync(planPath)) {
+    return {
+      success: false,
+      message: `Invalid working_directory: plan not found in "${directory}"`,
+      errors: [`Invalid working_directory: plan not found in "${directory}"`]
+    };
+  }
+  if (fallbackDir && directory !== fallbackDir) {
+    const canonicalDir = fs3.realpathSync(path3.resolve(directory));
+    const canonicalRoot = fs3.realpathSync(path3.resolve(fallbackDir));
+    if (isStrictPathDescendant(canonicalDir, canonicalRoot) && !hasExplicitProjectBoundary(canonicalDir)) {
+      return {
+        success: false,
+        message: `Invalid working_directory: "${directory}" is a subdirectory of ` + `the project root "${fallbackDir}". Pass the project root path or ` + `omit working_directory entirely.`,
+        errors: [
+          `Subdirectory rejected: use project root "${fallbackDir}" instead`
+        ]
+      };
+    }
+  }
+  let exactRepairRetry = false;
+  if (isRepairRetryShape(args)) {
+    try {
+      const repairWal = await readWorkflowWalFile("task-repair", validateSwarmPath(directory, `task-repairs/${args.task_id}.json`), args.task_id);
+      exactRepairRetry = repairWal?.state === "PREPARED" && repairWal.transitionId === args.transition_id;
+    } catch (error) {
+      return {
+        success: false,
+        message: "Task operation paused while recovering an interrupted task repair",
+        errors: [error instanceof Error ? error.message : String(error)]
+      };
+    }
+  }
+  try {
+    const recoveredCoder = await recoverCoderSettlement(directory, args.task_id);
+    if (recoveredCoder && ctx?.sessionID) {
+      const callerSession = ensureAgentSession(ctx.sessionID);
+      const workflow = getTaskWorkflowSnapshot(recoveredCoder.evidence);
+      callerSession.taskWorkflowStates.set(args.task_id, workflow.state);
+      callerSession.stageBCompletion?.delete(args.task_id);
+      updateTaskWorkflowCache(callerSession, args.task_id, workflow);
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: "Task operation paused while recovering an interrupted coder settlement",
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+  try {
+    const recoveredTerminal = await recoverPreparedTaskTerminal(directory, args.task_id, ctx?.sessionID ?? "update-task-status");
+    if (recoveredTerminal) {
+      syncCallerWorkflowFromEvidence(ctx?.sessionID, args.task_id, recoveredTerminal.evidence);
+    }
+  } catch (error) {
+    return {
+      success: false,
+      message: "Task operation paused while recovering an interrupted terminal status transition",
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+  if (!exactRepairRetry) {
+    try {
+      const recoveredRepair = await recoverPreparedTaskRepair(directory, args.task_id, ctx?.sessionID ?? "update-task-status");
+      if (recoveredRepair) {
+        syncCallerWorkflowFromEvidence(ctx?.sessionID, args.task_id, readTaskEvidenceRaw(directory, args.task_id));
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("TASK_REPAIR_AUDIT_LOCKED")) {
+        criticalWarn(`[update-task-status] task-repair audit recovery deferred for ${args.task_id}: ${error.message}`);
+      } else {
+        return {
+          success: false,
+          message: "Task operation paused while recovering an interrupted task repair",
+          errors: [error instanceof Error ? error.message : String(error)]
+        };
+      }
+    }
+  }
+  let loadedPlan = null;
+  try {
+    loadedPlan = await _internals3.loadPlan(directory);
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to load plan for task validation",
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+  if (!loadedPlan) {
+    return {
+      success: false,
+      message: "Failed to load plan for task validation",
+      errors: ["Plan could not be loaded"]
+    };
+  }
+  if (loadedPlan._ledgerReplayStale === true) {
+    const staleReason = loadedPlan._ledgerReplayStaleReason ?? "plan.json is stale relative to the active plan-ledger authority";
+    return {
+      success: false,
+      message: `Task status update refused: plan.json is stale relative to the ledger (ledger replay failed). ${staleReason}`,
+      errors: [staleReason],
+      recovery_guidance: "Plan state could not be reconciled with the active plan-ledger authority. " + "Retry save_plan with the unchanged loaded plan so it can reconverge the projections and authority metadata, then retry update_task_status."
+    };
+  }
+  const currentTask = loadedPlan.phases.flatMap((phase) => phase.tasks).find((task) => task.id === args.task_id);
+  if (!currentTask) {
+    return {
+      success: false,
+      message: "Failed to update task status",
+      errors: [`Task not found: ${args.task_id}`]
+    };
+  }
+  {
+    const settledRejection = getSettledTransitionRejection(args.task_id, currentTask.status, args.status, args.force);
+    if (settledRejection) {
+      return settledRejection;
+    }
+  }
+  if (args.status === "in_progress" && args.force === true) {
+    const repairFieldsValid = typeof args.expected_state === "string" && args.expected_state.length > 0 && Number.isInteger(args.expected_generation) && (args.expected_generation ?? -1) >= 0 && args.target_state === "idle" && typeof args.reason === "string" && args.reason.trim().length > 0 && args.reason.length <= 2000 && typeof args.transition_id === "string" && args.transition_id.trim().length > 0 && args.transition_id.length <= 200;
+    if (!repairFieldsValid) {
+      return {
+        success: false,
+        message: "TASK_REPAIR_INVALID: force repair requires an exact CAS and audit identity",
+        errors: [
+          'Provide expected_state, expected_generation, target_state="idle", a non-empty reason (max 2000 chars), and a non-empty transition_id (max 200 chars).'
+        ]
+      };
+    }
+    log(`[update-task-status] Force-override: attempting audited repair for task ${args.task_id} (settled task, or in_progress at the retry-escalation rung per issue #3389; admission is verified under the plan lock) to in_progress`);
+  }
+  const agentName = (ctx?.sessionID ? swarmState.activeAgent.get(ctx.sessionID) : undefined) ?? "update-task-status";
+  let scopeAdvisories;
+  if (args.status === "completed") {
+    if (!fallbackDir && !ctx?.sessionID) {
+      recoverTaskStateFromDelegations(args.task_id, directory);
+    }
+    let phaseRequiresReviewer = true;
+    let taskDeclaresExternalEvidence = false;
+    try {
+      const planPath2 = path3.join(directory, ".swarm", "plan.json");
+      const planRaw = fs3.readFileSync(planPath2, "utf-8");
+      const plan = JSON.parse(planRaw);
+      const taskPhase = plan.phases.find((p) => p.tasks.some((t) => t.id === args.task_id));
+      if (taskPhase?.required_agents && !taskPhase.required_agents.includes("reviewer")) {
+        phaseRequiresReviewer = false;
+      }
+      taskDeclaresExternalEvidence = taskPhase?.tasks.find((t) => t.id === args.task_id)?.evidence_class === "external_git";
+    } catch {}
+    const councilCheck = taskDeclaresExternalEvidence ? { blocked: false, active: false } : checkCouncilGate(directory, args.task_id);
+    if (councilCheck.blocked) {
+      await recordRunMemoryOutcome(directory, {
+        taskId: args.task_id,
+        agent: agentName,
+        outcome: "fail",
+        failureReason: `council gate: ${councilCheck.reason}`,
+        fileTargets: resolveRunMemoryFileTargets(loadedPlan, args.task_id)
+      });
+      return {
+        success: false,
+        message: "Gate check failed: council gate not yet satisfied for task " + args.task_id,
+        errors: [councilCheck.reason]
+      };
+    }
+    if (phaseRequiresReviewer && !councilCheck.active && !taskDeclaresExternalEvidence) {
+      const reviewerCheck = await checkReviewerGateWithScope(args.task_id, directory, ctx?.sessionID, ctx?.sessionID ? fallbackDir : undefined);
+      if (reviewerCheck.reason) {
+        const advisoryLines = reviewerCheck.reason.split(`
+`).filter((line) => line.length > 0);
+        if (advisoryLines.length > 0)
+          scopeAdvisories = advisoryLines;
+      }
+      if (reviewerCheck.blocked) {
+        await recordRunMemoryOutcome(directory, {
+          taskId: args.task_id,
+          agent: agentName,
+          outcome: "fail",
+          failureReason: `QA gate: ${reviewerCheck.reason}`,
+          fileTargets: resolveRunMemoryFileTargets(loadedPlan, args.task_id)
+        });
+        return {
+          success: false,
+          message: "Gate check failed: required QA gates not yet satisfied for task " + args.task_id,
+          errors: [reviewerCheck.reason]
+        };
+      }
+    }
+  }
+  const lockTaskId = `update-task-status-${args.task_id}-${Date.now()}`;
+  const planFilePath = "plan.json";
+  let lockResult;
+  try {
+    lockResult = await _internals3.tryAcquireLock(directory, planFilePath, agentName, lockTaskId);
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to acquire lock for task status update",
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  }
+  if (!lockResult.acquired) {
+    return {
+      success: false,
+      message: `Task status write blocked: plan.json is locked by ${lockResult.existing?.agent ?? "another agent"} (task: ${lockResult.existing?.taskId ?? "unknown"})`,
+      errors: [
+        "Concurrent plan write detected \u2014 retry after the current write completes"
+      ],
+      recovery_guidance: "Wait a moment and retry update_task_status. The lock will expire automatically if the holding agent fails."
+    };
+  }
+  try {
+    const lockedPlan = await _internals3.loadPlan(directory);
+    if (lockedPlan?._ledgerReplayStale === true) {
+      return {
+        success: false,
+        message: "Task status update refused: plan became ledger-stale while waiting for the lock",
+        errors: [
+          lockedPlan._ledgerReplayStaleReason ?? "plan.json is stale relative to the authoritative ledger"
+        ],
+        recovery_guidance: "Retry save_plan with the unchanged loaded plan to reconverge the projection/hash, then retry update_task_status."
+      };
+    }
+    if (!lockedPlan) {
+      return {
+        success: false,
+        message: "Failed to update task status",
+        errors: ["No approved plan is available under the plan lock"]
+      };
+    }
+    let authoritativePlan = lockedPlan;
+    const lockedPreparedRepairWal = await readPreparedWorkflowWal(directory, args.task_id, "task-repair");
+    const lockedExactRepairRetry = isRepairRetryShape(args) && lockedPreparedRepairWal?.transitionId === args.transition_id;
+    if (lockedPreparedRepairWal && !lockedExactRepairRetry) {
+      try {
+        const recoveredRepair = await recoverPreparedTaskRepairUnderPlanLock(directory, args.task_id, ctx?.sessionID ?? "update-task-status", authoritativePlan);
+        if (recoveredRepair) {
+          authoritativePlan = recoveredRepair.plan;
+          syncCallerWorkflowFromEvidence(ctx?.sessionID, args.task_id, readTaskEvidenceRaw(directory, args.task_id));
+        }
+      } catch (error) {
+        if (error instanceof Error && error.message.startsWith("TASK_REPAIR_AUDIT_LOCKED")) {
+          criticalWarn(`[update-task-status] task-repair audit recovery deferred for ${args.task_id}: ${error.message}`);
+        } else {
+          return {
+            success: false,
+            message: "Task operation paused while recovering an interrupted task repair",
+            errors: [error instanceof Error ? error.message : String(error)]
+          };
+        }
+      }
+    }
+    if (await hasPreparedWorkflowWal(directory, args.task_id, "task-terminal")) {
+      try {
+        const recoveredTerminal = await recoverPreparedTaskTerminalUnderPlanLock(directory, args.task_id, ctx?.sessionID ?? "update-task-status", authoritativePlan);
+        if (recoveredTerminal) {
+          authoritativePlan = recoveredTerminal.plan;
+          syncCallerWorkflowFromEvidence(ctx?.sessionID, args.task_id, recoveredTerminal.evidence);
+        }
+      } catch (error) {
+        return {
+          success: false,
+          message: "Task operation paused while recovering an interrupted terminal status transition",
+          errors: [error instanceof Error ? error.message : String(error)]
+        };
+      }
+    }
+    const lockedTask = authoritativePlan.phases.flatMap((phase) => phase.tasks).find((task) => task.id === args.task_id);
+    if (!lockedTask) {
+      return {
+        success: false,
+        message: "Failed to update task status",
+        errors: [`Task not found: ${args.task_id}`]
+      };
+    }
+    const lockedSettledRejection = getSettledTransitionRejection(args.task_id, lockedTask.status, args.status, args.force);
+    if (lockedSettledRejection) {
+      return lockedSettledRejection;
+    }
+    const forceRepair = args.status === "in_progress" && args.force === true;
+    const repairResult = forceRepair ? await repairTaskWorkflowUnderPlanLock({
+      directory,
+      taskId: args.task_id,
+      actor: agentName,
+      reason: args.reason,
+      transitionId: args.transition_id,
+      expectedState: args.expected_state,
+      expectedGeneration: args.expected_generation,
+      currentPlanStatus: lockedTask.status,
+      currentPlan: authoritativePlan,
+      updatePlan: () => _internals3.updateTaskStatus(directory, args.task_id, "in_progress", { force: true, planLockAlreadyHeld: true })
+    }) : null;
+    let updatedPlan;
+    let terminalEvidence = null;
+    if (args.status === "completed") {
+      const lockedTaskPhase = authoritativePlan.phases.find((phase) => phase.tasks.some((task) => task.id === args.task_id));
+      const lockedPhaseRequiresReviewer = !lockedTaskPhase?.required_agents || lockedTaskPhase.required_agents.includes("reviewer");
+      const lockedTaskDeclaresExternal = lockedTask.evidence_class === "external_git";
+      const terminalResult = await commitTaskTerminalUnderPlanLock({
+        directory,
+        taskId: args.task_id,
+        actor: agentName,
+        transitionId: `plan-status:${args.task_id}:completed:${Date.now()}`,
+        currentPlanStatus: lockedTask.status,
+        targetStatus: "completed",
+        qaExempt: !lockedPhaseRequiresReviewer && !lockedTaskDeclaresExternal,
+        resolveTerminal: (evidence) => ({
+          targetStatus: "completed",
+          qaExempt: !lockedPhaseRequiresReviewer && !lockedTaskDeclaresExternal,
+          readOnlyNoMutation: !lockedPhaseRequiresReviewer ? false : isReadOnlyNoMutationEligible(evidence, {
+            currentDeclaredFiles: lockedTask.files_touched
+          }),
+          externalEvidence: lockedTaskDeclaresExternal
+        }),
+        currentPlan: authoritativePlan,
+        validateEvidence: async () => {
+          if (lockedTaskDeclaresExternal) {
+            const externalTaskEvidence = _internals3.readTaskEvidenceRaw(directory, args.task_id);
+            const planIdentity = {
+              title: authoritativePlan.title,
+              swarm: authoritativePlan.swarm
+            };
+            const externalWorkflow = getTaskWorkflowSnapshot(externalTaskEvidence);
+            if (!isExternalEvidenceInitialCompletionEligible(planIdentity, lockedTask, externalTaskEvidence) && !(externalWorkflow.state === "complete" && externalProofCurrent(planIdentity, lockedTask, externalTaskEvidence))) {
+              throw new Error(`TASK_COMPLETION_CAS_MISMATCH: Task ${args.task_id} declares external_git evidence but has no current matched attestation; run /swarm attest ${args.task_id} first`);
+            }
+            return;
+          }
+          const lockedGate = checkReviewerGate(args.task_id, directory, false, ctx?.sessionID, fallbackDir ?? directory, lockedTask.files_touched ?? null);
+          const lockedCouncil = checkCouncilGate(directory, args.task_id);
+          if (lockedCouncil.blocked || lockedPhaseRequiresReviewer && !lockedCouncil.active && lockedGate.blocked) {
+            throw new Error(`TASK_COMPLETION_CAS_MISMATCH: ${lockedCouncil.blocked ? lockedCouncil.reason : lockedGate.reason}`);
+          }
+        },
+        updatePlan: async () => {
+          const next = await _internals3.updateTaskStatus(directory, args.task_id, "completed", { force: false, planLockAlreadyHeld: true });
+          const persisted = next.phases.flatMap((phase) => phase.tasks).find((task) => task.id === args.task_id);
+          if (persisted?.status !== "completed") {
+            throw new Error("TASK_STATUS_WRITE_NOT_APPLIED");
+          }
+          return next;
+        }
+      });
+      updatedPlan = terminalResult.plan;
+      terminalEvidence = terminalResult.evidence;
+    } else if (args.status === "blocked") {
+      const terminalResult = await commitTaskTerminalUnderPlanLock({
+        directory,
+        taskId: args.task_id,
+        actor: agentName,
+        transitionId: `plan-status:${args.task_id}:blocked:${Date.now()}`,
+        currentPlanStatus: lockedTask.status,
+        targetStatus: "blocked",
+        qaExempt: false,
+        currentPlan: authoritativePlan,
+        updatePlan: async () => {
+          const next = await _internals3.updateTaskStatus(directory, args.task_id, "blocked", { force: false, planLockAlreadyHeld: true });
+          const persisted = next.phases.flatMap((phase) => phase.tasks).find((task) => task.id === args.task_id);
+          if (persisted?.status !== "blocked") {
+            throw new Error("TASK_STATUS_WRITE_NOT_APPLIED");
+          }
+          return next;
+        }
+      });
+      updatedPlan = terminalResult.plan;
+      terminalEvidence = terminalResult.evidence;
+    } else {
+      updatedPlan = repairResult?.plan ?? await _internals3.updateTaskStatus(directory, args.task_id, args.status, { force: false, planLockAlreadyHeld: true });
+      const persisted = updatedPlan.phases.flatMap((phase) => phase.tasks).find((task) => task.id === args.task_id);
+      if (persisted?.status !== args.status) {
+        throw new Error("TASK_STATUS_WRITE_NOT_APPLIED");
+      }
+    }
+    if (terminalEvidence) {
+      const terminal = getTaskWorkflowSnapshot(terminalEvidence);
+      const callerSession = ctx?.sessionID ? swarmState.agentSessions.get(ctx.sessionID) : undefined;
+      if (callerSession) {
+        const session = callerSession;
+        session.taskWorkflowStates.set(args.task_id, terminal.state);
+        session.stageBCompletion?.delete(args.task_id);
+        updateTaskWorkflowCache(session, args.task_id, terminal);
+      }
+    }
+    if (args.status === "in_progress") {
+      if (ctx?.sessionID)
+        ensureAgentSession(ctx.sessionID).currentTaskId = args.task_id;
+      if (repairResult) {
+        const callerSession = ctx?.sessionID ? swarmState.agentSessions.get(ctx.sessionID) : undefined;
+        if (callerSession) {
+          const session = callerSession;
+          session.taskWorkflowStates.set(args.task_id, "idle");
+          session.stageBCompletion?.delete(args.task_id);
+          session.taskCouncilApproved?.delete(args.task_id);
+          session.taskCouncilWorkflowGeneration?.delete(args.task_id);
+          updateTaskWorkflowCache(session, args.task_id, {
+            generation: repairResult.generation
+          });
+        }
+      }
+    }
+    return {
+      success: true,
+      message: "Task status updated successfully",
+      task_id: args.task_id,
+      new_status: args.status,
+      current_phase: updatedPlan.current_phase,
+      ...scopeAdvisories && scopeAdvisories.length > 0 ? { warnings: scopeAdvisories } : {}
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: "Failed to update task status",
+      errors: [error instanceof Error ? error.message : String(error)]
+    };
+  } finally {
+    if (lockResult?.acquired && lockResult.lock._release) {
+      try {
+        await lockResult.lock._release();
+      } catch (releaseError) {
+        log("[update-task-status] Lock release failed:", releaseError);
+      }
+    }
+  }
+}
+var update_task_status = createSwarmTool({
+  description: "Update the status of a specific task in the implementation plan. " + "Task status can be one of: pending, in_progress, completed, blocked.",
+  args: {
+    task_id: exports_external.string().min(1).regex(/^\d+\.\d+(\.\d+)*$/, "Task ID must be in N.M or N.M.P format").describe('Task ID in N.M format, e.g. "1.1", "1.2.3"'),
+    status: exports_external.enum(["pending", "in_progress", "completed", "blocked"]).describe("New status for the task: pending, in_progress, completed, or blocked"),
+    working_directory: exports_external.string().optional().describe("Working directory where the plan is located"),
+    force: exports_external.boolean().optional().default(false).describe('Enable the audited repair contract: re-open a settled task, or an in_progress task that reached the retry ladder user_escalation rung (issue #3389). Requires expected_state, expected_generation, target_state="idle", reason, and transition_id.'),
+    expected_state: exports_external.string().optional().describe("CAS workflow state expected by a force repair."),
+    expected_generation: exports_external.number().int().min(0).optional().describe("ABA-safe workflow generation expected by a force repair."),
+    target_state: exports_external.literal("idle").optional().describe("Repair target state. The only valid target is idle (re-opens the task for new work)."),
+    reason: exports_external.string().min(1).max(2000).optional().describe("Required human-readable audit reason for a force repair."),
+    transition_id: exports_external.string().min(1).max(200).optional().describe("Caller-generated idempotency key for an audited force repair.")
+  },
+  execute: async (args, _directory, _ctx) => {
+    return JSON.stringify(await executeUpdateTaskStatus(args, _directory, _ctx), null, 2);
+  }
+});
+
+// src/tools/attest-task.ts
+var ANCHOR_STDOUT_MAX_CHARS = 4096;
+var ANCHOR_SPAWN_TIMEOUT_MS = 1e4;
+var ANCHOR_SPAWN_MAX_BUFFER_BYTES = 256 * 1024;
+var ATTEST_TOTAL_DEADLINE_MS = 30000;
+var READ_ONLY_GIT_FLAGS = {
+  "rev-list": { "--count": 0, "--max-count": 1, "--format": 1, "--skip": 1 },
+  log: {
+    "--format": 1,
+    "--max-count": 1,
+    "-n": 1,
+    "--oneline": 0,
+    "--no-patch": 0,
+    "--stat": 0,
+    "--name-only": 0,
+    "-1": 0,
+    "-2": 0,
+    "-3": 0,
+    "-4": 0,
+    "-5": 0,
+    "-9": 0
+  },
+  show: {
+    "--format": 1,
+    "--stat": 0,
+    "--name-only": 0,
+    "--no-patch": 0,
+    "--quiet": 0
+  },
+  diff: { "--stat": 0, "--name-only": 0, "--quiet": 0 },
+  "rev-parse": { "--verify": 0, "--short": 0 }
+};
+var REMOTE_HELPER_PATTERN = /^(ext::|[a-z+.-]+::)/;
+function anchorEnv() {
+  const env = {
+    PATH: process.env.PATH,
+    HOME: process.env.HOME,
+    LANG: process.env.LANG,
+    LC_ALL: process.env.LC_ALL,
+    GIT_CONFIG_NOSYSTEM: "1"
+  };
+  if (process.platform === "win32") {
+    env.SYSTEMROOT = process.env.SYSTEMROOT;
+    env.WINDIR = process.env.WINDIR;
+    env.COMSPEC = process.env.COMSPEC;
+  }
+  const envOverrides = {
+    GIT_EXTERNAL_DIFF: null,
+    GIT_CONFIG_PARAMETERS: null,
+    GIT_CONFIG_COUNT: null,
+    GIT_DIR: null,
+    GIT_WORK_TREE: null,
+    GIT_INDEX_FILE: null,
+    GIT_SSH_COMMAND: null,
+    GIT_ASKPASS: null,
+    GIT_EXEC_PATH: null,
+    GIT_PAGER: null
+  };
+  return { env, envOverrides };
+}
+function buildAnchorArgv(command) {
+  const tokens = command.trim().split(/\s+/).filter(Boolean);
+  if (tokens[0] !== "git" || tokens.length < 2) {
+    return {
+      argv: null,
+      refusal: `anchor command is not an allowed read-only git invocation: "${command}"`
+    };
+  }
+  const subcommand = tokens[1];
+  if (subcommand.startsWith("-")) {
+    return {
+      argv: null,
+      refusal: `anchor command smuggles a git global option ("${subcommand}"); only bare read-only git subcommands are allowed`
+    };
+  }
+  const allowed = READ_ONLY_GIT_FLAGS[subcommand];
+  if (!allowed) {
+    return {
+      argv: null,
+      refusal: `git "${subcommand}" is not in the read-only git subcommand allowlist (rev-list, log, rev-parse, show, diff)`
+    };
+  }
+  const finalTokens = [subcommand];
+  for (let i = 2;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith("-")) {
+      const eq = token.indexOf("=");
+      const flag = eq >= 0 ? token.slice(0, eq) : token;
+      const inlineValue = eq >= 0 ? token.slice(eq + 1) : undefined;
+      const arity = allowed[flag];
+      if (arity === undefined) {
+        return {
+          argv: null,
+          refusal: `flag "${flag}" is not in the read-only git allowlist for git ${subcommand}`
+        };
+      }
+      if (arity === 0) {
+        if (inlineValue !== undefined) {
+          return {
+            argv: null,
+            refusal: `flag "${flag}" takes no value; =-joined forms are not valid for it`
+          };
+        }
+        finalTokens.push(flag);
+      } else {
+        let value = inlineValue;
+        if (value === undefined) {
+          const next = tokens[i + 1];
+          if (next === undefined || next.startsWith("--")) {
+            return {
+              argv: null,
+              refusal: `flag "${flag}" requires a value token`
+            };
+          }
+          value = next;
+          i++;
+        }
+        finalTokens.push(flag.startsWith("--") ? `${flag}=${value}` : `${flag}${value}`);
+      }
+      continue;
+    }
+    const hasControlByte = Array.from(token).some((ch) => ch.charCodeAt(0) < 32 || ch.charCodeAt(0) === 127);
+    if (token.length > 400 || hasControlByte) {
+      return {
+        argv: null,
+        refusal: "anchor argument is too long or contains control bytes"
+      };
+    }
+    if (REMOTE_HELPER_PATTERN.test(token)) {
+      return {
+        argv: null,
+        refusal: `anchor argument "${token.slice(0, 32)}" looks like a remote-helper URL; remote helpers can execute commands and are not read-only git invocations`
+      };
+    }
+    finalTokens.push(token);
+  }
+  if (subcommand === "diff" || subcommand === "show" || subcommand === "log") {
+    finalTokens.push("--no-ext-diff", "--no-textconv");
+  }
+  const git = resolveGitExecutable();
+  const argv = [
+    git,
+    "--no-pager",
+    "-c",
+    "diff.external=",
+    "-c",
+    "core.pager=cat",
+    "-c",
+    "core.fsmonitor=",
+    "-c",
+    "gpg.program=",
+    "-c",
+    "credential.helper=",
+    ...finalTokens
+  ];
+  return { argv, refusal: null };
+}
+async function runAnchor(argv, cwd, timeoutMs) {
+  const { env, envOverrides } = anchorEnv();
+  const proc = bunSpawn(argv, {
+    cwd,
+    env,
+    envOverrides,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    timeout: timeoutMs,
+    maxBuffer: ANCHOR_SPAWN_MAX_BUFFER_BYTES
+  });
+  try {
+    const exited = await proc.exited;
+    let stdout;
+    try {
+      stdout = await proc.stdout.text();
+    } catch {
+      return {
+        exitCode: exited,
+        stdout: "",
+        refusal: `anchor output exceeded the ${Math.floor(ANCHOR_SPAWN_MAX_BUFFER_BYTES / 1024)}KB spawn capture buffer; refusing rather than truncating`
+      };
+    }
+    if (exited !== 0) {
+      const stderr = await proc.stderr.text();
+      const detail = stderr.trim().slice(0, 200);
+      return {
+        exitCode: exited,
+        stdout,
+        refusal: `anchor command exited with code ${exited}${detail ? `: ${detail}` : ""}`
+      };
+    }
+    return { exitCode: exited, stdout, refusal: null };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+var _internals4 = {
+  runAnchor,
+  buildAnchorArgv,
+  loadPlanTask: (directory, taskId) => {
+    const planPath = path4.join(directory, ".swarm", "plan.json");
+    if (!fs4.existsSync(planPath))
+      return null;
+    const plan = PlanSchema.parse(JSON.parse(fs4.readFileSync(planPath, "utf-8")));
+    for (const phase of plan.phases) {
+      for (const task of phase.tasks) {
+        if (task.id === taskId) {
+          return { title: plan.title, swarm: plan.swarm, task };
+        }
+      }
+    }
+    return null;
+  }
+};
+function validateAnchorExpectations(anchors) {
+  for (const anchor of anchors) {
+    if (anchor.expect === undefined && anchor.expect_prefix === undefined) {
+      return `anchor "${anchor.command.slice(0, 60)}" declares neither expect nor expect_prefix`;
+    }
+    if (anchor.expect_prefix !== undefined && anchor.expect_prefix.length === 0) {
+      return `anchor "${anchor.command.slice(0, 60)}" declares an empty expect_prefix, which would match any output`;
+    }
+  }
+  return null;
+}
+async function executeAttestTask(args, fallbackDir) {
+  const resolveResult = _internals3.resolveWorkingDirectory(args.working_directory, fallbackDir);
+  if (!resolveResult.success) {
+    return {
+      success: false,
+      message: resolveResult.message,
+      errors: [resolveResult.message]
+    };
+  }
+  const directory = resolveResult.directory;
+  try {
+    assertProjectRoot(directory);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { success: false, message, errors: [message] };
+  }
+  let found;
+  try {
+    found = _internals4.loadPlanTask(directory, args.task_id);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes("expect_prefix") || message.includes("evidence_anchors")) {
+      const refusal2 = "the plan declares an invalid external-evidence anchor: every anchor must carry expect and/or a non-empty expect_prefix (an empty prefix would match any output)";
+      return {
+        success: false,
+        message: refusal2,
+        errors: [refusal2],
+        task_id: args.task_id
+      };
+    }
+    const refusal = `the plan at ${directory} is invalid or unreadable; fix or re-save the plan before attesting`;
+    return {
+      success: false,
+      message: refusal,
+      errors: [`${refusal} (${message.slice(0, 160)})`],
+      task_id: args.task_id
+    };
+  }
+  if (!found) {
+    const message = `Task ${args.task_id} not found in the plan at ${directory}`;
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  if (found.task.evidence_class !== "external_git") {
+    const message = `Task ${args.task_id} does not declare evidence_class external_git; the attest path is ` + `fail-closed to explicitly declared external-evidence tasks (issue #3422)`;
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  const anchors = found.task.evidence_anchors ?? [];
+  if (anchors.length === 0) {
+    const message = `Task ${args.task_id} declares external_git evidence but pins no evidence_anchors`;
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  const malformed = validateAnchorExpectations(anchors);
+  if (malformed) {
+    return {
+      success: false,
+      message: malformed,
+      errors: [malformed],
+      task_id: args.task_id
+    };
+  }
+  const startedAt = Date.now();
+  const outcomes = [];
+  for (const anchor of anchors) {
+    const { argv, refusal } = _internals4.buildAnchorArgv(anchor.command);
+    if (refusal !== null || argv === null) {
+      const message = `anchor not admitted: ${refusal ?? "not an allowed read-only git invocation"}`;
+      return {
+        success: false,
+        message,
+        errors: [message],
+        task_id: args.task_id
+      };
+    }
+    const remaining = ATTEST_TOTAL_DEADLINE_MS - (Date.now() - startedAt);
+    if (remaining <= 0) {
+      const message = "attest total deadline (30s) exhausted before all anchors ran";
+      return {
+        success: false,
+        message,
+        errors: [message],
+        task_id: args.task_id
+      };
+    }
+    const run = await _internals4.runAnchor(argv, directory, Math.min(ANCHOR_SPAWN_TIMEOUT_MS, remaining));
+    if (run.refusal !== null) {
+      const message = `anchor "${anchor.command.slice(0, 60)}" failed: ${run.refusal}`;
+      return {
+        success: false,
+        message,
+        errors: [message],
+        task_id: args.task_id
+      };
+    }
+    if (run.stdout.length > ANCHOR_STDOUT_MAX_CHARS) {
+      const message = `anchor "${anchor.command.slice(0, 60)}" produced ${run.stdout.length} chars of stdout, ` + `exceeding the ${ANCHOR_STDOUT_MAX_CHARS}-char evidence storage bound; refusing rather than truncating`;
+      return {
+        success: false,
+        message,
+        errors: [message],
+        task_id: args.task_id
+      };
+    }
+    const trimmed = run.stdout.trim();
+    const matched = anchor.expect !== undefined ? trimmed === anchor.expect && (anchor.expect_prefix === undefined || trimmed.startsWith(anchor.expect_prefix)) : trimmed.startsWith(anchor.expect_prefix);
+    outcomes.push({
+      command: anchor.command,
+      expect: anchor.expect,
+      expect_prefix: anchor.expect_prefix,
+      matched,
+      exit_code: run.exitCode,
+      stdout: run.stdout
+    });
+  }
+  if (!outcomes.every((outcome) => outcome.matched)) {
+    const failed = outcomes.find((outcome) => !outcome.matched);
+    const message = `anchor "${failed?.command.slice(0, 60) ?? "?"}" did not match its expectation ` + `(stdout: ${JSON.stringify(failed?.stdout.slice(0, 120) ?? "")})`;
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  let current;
+  try {
+    current = _internals4.loadPlanTask(directory, args.task_id);
+  } catch (error) {
+    const message = "the plan became unreadable while anchors were running; re-run attest against the current declaration";
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  const anchorsUnchanged = JSON.stringify(current?.task.evidence_anchors ?? null) === JSON.stringify(anchors);
+  if (!current || current.task.evidence_class !== "external_git" || current.title !== found.title || current.swarm !== found.swarm || !anchorsUnchanged) {
+    const message = "the plan changed while anchors were running; re-run attest against the current declaration";
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  let existingEvidence = null;
+  try {
+    existingEvidence = readTaskEvidenceRaw(directory, args.task_id);
+  } catch (error) {
+    const message = `the existing evidence file for task ${args.task_id} is unreadable (corrupt): ` + `${error instanceof Error ? error.message.slice(0, 160) : String(error).slice(0, 160)}; ` + "inspect the file before attesting";
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  const generation = existingEvidence?.workflow?.generation ?? 0;
+  const transitionId = `attest:${args.task_id}:${startedAt}:${Math.random().toString(36).slice(2, 10)}`;
+  const bundle = {
+    class: "external_git",
+    transitionId,
+    declarationDigest: computeExternalDeclarationDigest({
+      taskId: args.task_id,
+      evidence_class: "external_git",
+      evidence_anchors: anchors,
+      plan_title: current.title,
+      plan_swarm: current.swarm,
+      generation
+    }),
+    anchors: outcomes,
+    attestedAt: new Date().toISOString()
+  };
+  try {
+    await transitionTaskWorkflowEvidence(directory, args.task_id, {
+      type: "external_evidence_attested",
+      bundle,
+      expectedGeneration: generation,
+      transitionId
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      success: false,
+      message,
+      errors: [message],
+      task_id: args.task_id
+    };
+  }
+  return {
+    success: true,
+    message: `Task ${args.task_id}: ${outcomes.length} external evidence anchor(s) attested and recorded; completion is now admissible for this declared task`,
+    task_id: args.task_id
+  };
+}
+export {
+  executeAttestTask,
+  buildAnchorArgv,
+  _internals4 as _internals
+};