opencode-swarm 7.140.3 → 7.140.5

package/dist/cli/index-tjqzr3jc.js

@@ -0,0 +1,623 @@
+// @bun
+import {
+  validateSwarmPath
+} from "./index-k46me75h.js";
+import {
+  atomicWriteFile,
+  taskEvidencePath,
+  withTaskEvidenceLock
+} from "./index-p8kk34am.js";
+import {
+  telemetry
+} from "./index-epvhf50h.js";
+import {
+  exports_external,
+  init_zod
+} from "./index-bpmtbmy9.js";
+
+// src/gate-evidence.ts
+init_zod();
+import { mkdirSync, readFileSync, realpathSync } from "fs";
+import * as path from "path";
+
+// src/validation/task-id.ts
+var STRICT_TASK_ID_PATTERN = /^\d+\.\d+(\.\d+)*$/;
+var RETRO_TASK_ID_REGEX = /^retro-\d+$/;
+var INTERNAL_TOOL_ID_REGEX = /^(?:sast_scan|quality_budget|syntax_check|placeholder_scan|sbom_generate|build|secretscan)$/;
+var GENERAL_TASK_ID_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+function checkUnsafeChars(taskId) {
+  if (!taskId || taskId.length === 0) {
+    return "Invalid task ID: empty string";
+  }
+  if (/\0/.test(taskId)) {
+    return "Invalid task ID: contains null bytes";
+  }
+  for (let i = 0;i < taskId.length; i++) {
+    if (taskId.charCodeAt(i) < 32) {
+      return "Invalid task ID: contains control characters";
+    }
+  }
+  if (taskId.includes("..") || taskId.includes("/") || taskId.includes("\\")) {
+    return "Invalid task ID: path traversal detected";
+  }
+  return;
+}
+function isStrictTaskId(taskId) {
+  if (!taskId)
+    return false;
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg)
+    return false;
+  return STRICT_TASK_ID_PATTERN.test(taskId);
+}
+function assertStrictTaskId(taskId) {
+  if (!isStrictTaskId(taskId)) {
+    throw new Error(`Invalid taskId: "${taskId}". Must match N.M or N.M.P (e.g. "1.1", "1.2.3").`);
+  }
+}
+function sanitizeTaskId(taskId) {
+  const unsafeMsg = checkUnsafeChars(taskId);
+  if (unsafeMsg) {
+    throw new Error(unsafeMsg);
+  }
+  if (STRICT_TASK_ID_PATTERN.test(taskId) || RETRO_TASK_ID_REGEX.test(taskId) || INTERNAL_TOOL_ID_REGEX.test(taskId) || GENERAL_TASK_ID_REGEX.test(taskId)) {
+    return taskId;
+  }
+  throw new Error(`Invalid task ID: must be alphanumeric (ASCII) with optional hyphens, underscores, or dots, got "${taskId}"`);
+}
+
+// src/gate-evidence.ts
+var TASK_WORKFLOW_SCHEMA_MARKER = "exact-task-v1";
+var TASK_WORKFLOW_STATES = [
+  "idle",
+  "coder_delegated",
+  "pre_check_passed",
+  "reviewer_run",
+  "tests_run",
+  "rework_required",
+  "complete",
+  "blocked"
+];
+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",
+  "repair_idle"
+];
+function assertTaskEvidenceWriteAllowed(directory, taskId, event) {
+  assertValidTaskId(taskId);
+  const readWal = (kind, corruptCode) => {
+    const walPath = validateSwarmPath(directory, `${kind}/${taskId}.json`);
+    let raw;
+    try {
+      raw = readFileSync(walPath, "utf-8");
+    } catch (error) {
+      if (error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+    try {
+      return JSON.parse(raw);
+    } catch (error) {
+      throw new Error(`${corruptCode}: ${walPath} is not valid JSON (${error instanceof Error ? error.message : String(error)}). Delete this file to allow the task to be repaired again.`);
+    }
+  };
+  const coderWal = readWal("coder-settlements", "CODER_SETTLEMENT_WAL_CORRUPT");
+  if ((coderWal?.state === "DISPATCHED" || coderWal?.state === "PREPARED") && !(event != null && event.transitionId === coderWal.transitionId && (event.type === "dispatch_attempted" || event.type === "dispatch_no_mutation" || event.type === "accepted_mutation"))) {
+    throw new Error(`CODER_SETTLEMENT_IN_PROGRESS: transition ${String(coderWal.transitionId)} owns evidence for task ${taskId}`);
+  }
+  const terminalWal = readWal("task-terminals", "TASK_TERMINAL_WAL_CORRUPT");
+  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");
+    if (!matchingTerminalEvent) {
+      throw new Error(`TASK_TERMINAL_PREPARED: transition ${String(terminalWal.transitionId)} owns evidence for task ${taskId}`);
+    }
+  }
+  const repairWal = readWal("task-repairs", "TASK_REPAIR_WAL_CORRUPT");
+  if (repairWal?.state === "PREPARED" && !(event?.type === "repair_idle" && event.transitionId === repairWal.transitionId)) {
+    throw new Error(`TASK_REPAIR_PREPARED: transition ${String(repairWal.transitionId)} owns evidence for task ${taskId}`);
+  }
+}
+var GateEvidenceSchema = exports_external.object({
+  sessionId: exports_external.string(),
+  timestamp: exports_external.string(),
+  agent: exports_external.string()
+}).passthrough();
+var TaskWorkflowMetadataSchema = exports_external.object({
+  schema: exports_external.literal(TASK_WORKFLOW_SCHEMA_MARKER),
+  generation: exports_external.number().int().min(0),
+  state: exports_external.enum(TASK_WORKFLOW_STATES),
+  retryCount: exports_external.number().int().min(0).default(0),
+  retryHistory: exports_external.array(exports_external.enum(TASK_WORKFLOW_OUTCOMES)).max(3).default([]),
+  retryEpoch: exports_external.number().int().min(0).default(0),
+  lastOutcome: exports_external.enum(TASK_WORKFLOW_OUTCOMES).default("none"),
+  lastTransitionId: exports_external.string().min(1).nullable().optional().default(null),
+  updatedAt: exports_external.string()
+});
+var TaskEvidenceSchema = exports_external.object({
+  taskId: exports_external.string(),
+  required_gates: exports_external.array(exports_external.string()).default([]),
+  gates: exports_external.record(exports_external.string(), GateEvidenceSchema),
+  turbo: exports_external.boolean().optional(),
+  test_engineer_exempt: exports_external.boolean().optional(),
+  workflow: TaskWorkflowMetadataSchema.optional()
+});
+function parseTaskEvidence(raw, expectedTaskId) {
+  const parsed = TaskEvidenceSchema.parse(JSON.parse(raw));
+  if (parsed.taskId !== expectedTaskId) {
+    throw new Error(`TASK_EVIDENCE_IDENTITY_MISMATCH: expected ${expectedTaskId}, found ${parsed.taskId}`);
+  }
+  return parsed;
+}
+var DEFAULT_REQUIRED_GATES = ["reviewer", "test_engineer"];
+var DEFAULT_WORKFLOW_STATE = "idle";
+var WORKFLOW_STATE_RANK = {
+  idle: 0,
+  coder_delegated: 1,
+  pre_check_passed: 2,
+  reviewer_run: 3,
+  tests_run: 4,
+  rework_required: 5,
+  blocked: 6,
+  complete: 7
+};
+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 "repair_idle":
+      return "repair_idle";
+  }
+}
+function isAuthoritativeWorkflowMetadata(workflow) {
+  return workflow?.schema === TASK_WORKFLOW_SCHEMA_MARKER;
+}
+function getTaskWorkflowSnapshot(evidence) {
+  if (isAuthoritativeWorkflowMetadata(evidence?.workflow)) {
+    return { ...evidence.workflow, authoritative: true };
+  }
+  return {
+    ...createDefaultWorkflowMetadata(""),
+    authoritative: false
+  };
+}
+function maybeExpandRequiredGates(existing, event) {
+  if (event.type === "accepted_mutation") {
+    const agentType = event.agentType;
+    if (typeof agentType === "string" && agentType.trim() !== "") {
+      return existing ? expandRequiredGates(existing.required_gates, agentType, event.context ?? {}) : deriveRequiredGates(agentType, event.context ?? {});
+    }
+  }
+  if (event.type === "stage_b_completed" && event.ensureDefaultStageB === true) {
+    return expandRequiredGates(existing?.required_gates ?? [], "coder", {
+      testEngineerExempt: false
+    });
+  }
+  if (event.type === "stage_b_completed" || event.type === "gate_recorded") {
+    return existing ? expandRequiredGates(existing.required_gates, event.gate) : deriveRequiredGates(event.gate);
+  }
+  return existing?.required_gates ?? [];
+}
+function hasAllRequiredGatesPassed(requiredGates, gates) {
+  return requiredGates.length > 0 && requiredGates.every((gate) => gates[gate] != null);
+}
+function shouldTreatGateAsStageB(gate) {
+  return gate === "reviewer" || gate === "test_engineer";
+}
+function clearWorkflowGateProof(gates) {
+  const retained = { ...gates };
+  delete retained.pre_check;
+  delete retained.reviewer;
+  delete retained.test_engineer;
+  delete retained.council;
+  delete retained.critic;
+  delete retained.critic_sounding_board;
+  return retained;
+}
+function assertExpectedGeneration(snapshot, event) {
+  if (typeof event.expectedGeneration === "number" && event.expectedGeneration !== snapshot.generation) {
+    throw new Error(`TASK_WORKFLOW_GENERATION_MISMATCH: expected ${event.expectedGeneration}, current ${snapshot.generation}`);
+  }
+}
+function isDuplicateTransition(snapshot, event) {
+  return snapshot.authoritative && typeof event.transitionId === "string" && event.transitionId.length > 0 && snapshot.lastTransitionId === event.transitionId && snapshot.lastOutcome === getEventOutcome(event);
+}
+function reduceTaskWorkflowSnapshot(current, event, context) {
+  if ((current.state === "complete" || current.state === "blocked") && event.type !== "repair_idle" && !(current.state === "complete" && event.type === "task_completed" || current.state === "blocked" && event.type === "task_blocked")) {
+    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
+  };
+  switch (event.type) {
+    case "dispatch_attempted":
+      return base;
+    case "dispatch_no_mutation":
+      return {
+        ...base,
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1
+      };
+    case "stage_b_failed":
+      if (current.state !== "pre_check_passed" && current.state !== "reviewer_run" && current.state !== "tests_run" && current.state !== "rework_required") {
+        throw new Error(`TASK_WORKFLOW_STAGE_A_REQUIRED: cannot reject ${event.gate} from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "rework_required",
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1
+      };
+    case "accepted_mutation":
+      if (event.context?.settlementFailed === true) {
+        return {
+          ...base,
+          generation: current.generation + 1,
+          state: "rework_required",
+          retryCount: Math.min(current.retryCount + 1, 3),
+          retryHistory: [...current.retryHistory, outcome].slice(-3),
+          retryEpoch: current.retryEpoch || current.generation + 1
+        };
+      }
+      return {
+        ...base,
+        generation: current.generation + 1,
+        state: "coder_delegated"
+      };
+    case "stage_a_passed":
+      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed") {
+        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot pass Stage A from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "pre_check_passed"
+      };
+    case "stage_a_failed":
+      if (current.state !== "coder_delegated" && current.state !== "pre_check_passed" && current.state !== "rework_required") {
+        throw new Error(`TASK_WORKFLOW_CODER_MUTATION_REQUIRED: cannot fail Stage A from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "rework_required",
+        retryCount: Math.min(current.retryCount + 1, 3),
+        retryHistory: [...current.retryHistory, outcome].slice(-3),
+        retryEpoch: current.retryEpoch || current.generation + 1
+      };
+    case "stage_b_completed":
+      if (current.state !== "pre_check_passed" && current.state !== "reviewer_run" && current.state !== "tests_run") {
+        throw new Error(`TASK_WORKFLOW_STAGE_A_REQUIRED: cannot record ${event.gate} from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: hasAllRequiredGatesPassed(context.requiredGates, context.gates) ? "tests_run" : "reviewer_run"
+      };
+    case "gate_recorded":
+      return {
+        ...base,
+        state: current.state
+      };
+    case "task_completed":
+      if (event.qaExempt !== true && current.state !== "tests_run" && current.state !== "complete" && !(current.state === "pre_check_passed" && context.gates.council != null)) {
+        throw new Error(`TASK_WORKFLOW_QA_REQUIRED: cannot complete from ${current.state}`);
+      }
+      return {
+        ...base,
+        state: "complete"
+      };
+    case "task_blocked":
+      return {
+        ...base,
+        state: "blocked"
+      };
+    case "repair_idle":
+      return {
+        ...base,
+        generation: current.generation + 1,
+        state: "idle",
+        retryCount: 0,
+        retryHistory: [],
+        retryEpoch: 0
+      };
+  }
+}
+function getEvidenceDir(directory) {
+  const swarmDir = path.resolve(directory, ".swarm");
+  const evidenceDir = path.join(swarmDir, "evidence");
+  mkdirSync(evidenceDir, { recursive: true });
+  let resolvedSwarmDir;
+  let resolvedEvidenceDir;
+  try {
+    resolvedSwarmDir = path.normalize(realpathSync(swarmDir));
+    resolvedEvidenceDir = path.normalize(realpathSync(evidenceDir));
+  } catch (error) {
+    throw new Error(`Unable to resolve evidence directory: ${error.message}`);
+  }
+  const swarmPrefix = `${resolvedSwarmDir}${path.sep}`;
+  const withinSwarmBoundary = process.platform === "win32" ? resolvedEvidenceDir.toLowerCase().startsWith(swarmPrefix.toLowerCase()) : resolvedEvidenceDir.startsWith(swarmPrefix);
+  if (!withinSwarmBoundary) {
+    throw new Error(`Evidence path escapes .swarm boundary: ${resolvedEvidenceDir}`);
+  }
+  return resolvedEvidenceDir;
+}
+function getEvidencePath(directory, taskId) {
+  assertValidTaskId(taskId);
+  return taskEvidencePath(directory, taskId);
+}
+function readExisting(evidencePath, taskId) {
+  try {
+    const raw = readFileSync(evidencePath, "utf-8");
+    return parseTaskEvidence(raw, taskId);
+  } catch (error) {
+    if (error.code === "ENOENT")
+      return null;
+    telemetry.gateParseError(taskId, error);
+    throw error;
+  }
+}
+function deriveRequiredGates(agentType, context = {}) {
+  switch (agentType) {
+    case "coder":
+      return context.testEngineerExempt === true ? ["reviewer"] : ["reviewer", "test_engineer"];
+    case "docs":
+      return ["docs"];
+    case "designer":
+      return ["designer", "reviewer", "test_engineer"];
+    case "explorer":
+      return ["explorer"];
+    case "sme":
+      return ["sme"];
+    case "reviewer":
+      return ["reviewer"];
+    case "test_engineer":
+      return ["test_engineer"];
+    case "critic":
+      return ["critic"];
+    case "critic_sounding_board":
+      return ["critic_sounding_board"];
+    case "critic_drift_verifier":
+      return ["critic_drift_verifier"];
+    case "critic_hallucination_verifier":
+      return ["critic_hallucination_verifier"];
+    case "critic_architecture_supervisor":
+      return ["critic_architecture_supervisor"];
+    default:
+      return ["reviewer", "test_engineer"];
+  }
+}
+function expandRequiredGates(existingGates, newAgentType, context = {}) {
+  const newGates = deriveRequiredGates(newAgentType, context);
+  const combined = [...new Set([...existingGates ?? [], ...newGates])];
+  return combined.sort();
+}
+function updateEvidenceForTransition(existing, event) {
+  const nowIso = new Date().toISOString();
+  const requiredGates = maybeExpandRequiredGates(existing, event);
+  let gates = {
+    ...existing?.gates ?? {}
+  };
+  if (event.type === "accepted_mutation" || event.type === "repair_idle") {
+    gates = clearWorkflowGateProof(gates);
+  }
+  if (event.type === "stage_a_passed") {
+    gates = {
+      ...gates,
+      pre_check: {
+        sessionId: "system",
+        timestamp: nowIso,
+        agent: "pre_check"
+      }
+    };
+  }
+  if (event.type === "stage_a_failed") {
+    delete gates.pre_check;
+  }
+  if (event.type === "stage_b_failed") {
+    delete gates.reviewer;
+    delete gates.test_engineer;
+  }
+  if (event.type === "stage_b_completed" || event.type === "gate_recorded") {
+    gates = {
+      ...gates,
+      [event.gate]: {
+        sessionId: event.sessionId,
+        timestamp: nowIso,
+        agent: event.gate
+      }
+    };
+  }
+  const snapshot = getTaskWorkflowSnapshot(existing);
+  assertExpectedGeneration(snapshot, event);
+  if (isDuplicateTransition(snapshot, event) && existing) {
+    return existing;
+  }
+  const workflow = reduceTaskWorkflowSnapshot(snapshot, event, {
+    requiredGates,
+    gates,
+    nowIso
+  });
+  return {
+    taskId: existing?.taskId ?? "",
+    required_gates: requiredGates,
+    gates,
+    turbo: "turbo" in event && event.turbo === true ? true : ("turbo" in event) && event.turbo === false ? existing?.turbo : existing?.turbo,
+    test_engineer_exempt: (event.type === "dispatch_attempted" || event.type === "dispatch_no_mutation" || event.type === "accepted_mutation") && event.agentType === "coder" ? event.context?.testEngineerExempt === true && !requiredGates.includes("test_engineer") : existing?.test_engineer_exempt,
+    workflow
+  };
+}
+async function transitionTaskWorkflowEvidence(directory, taskId, event) {
+  assertValidTaskId(taskId);
+  let updatedEvidence = null;
+  await withTaskEvidenceTransaction(directory, taskId, event.type, async (transaction) => {
+    updatedEvidence = await transaction.transition(event);
+  });
+  return updatedEvidence ?? {
+    taskId,
+    required_gates: [],
+    gates: {},
+    workflow: createDefaultWorkflowMetadata(new Date().toISOString())
+  };
+}
+async function withTaskEvidenceTransaction(directory, taskId, agent, callback) {
+  assertValidTaskId(taskId);
+  return withTaskEvidenceLock(directory, taskId, agent, async () => {
+    const resolvedEvidenceDir = getEvidenceDir(directory);
+    const evidencePath = path.join(resolvedEvidenceDir, `${taskId}.json`);
+    let current = null;
+    try {
+      current = readExisting(evidencePath, taskId);
+    } catch (error) {
+      telemetry.gateParseError(taskId, error);
+      throw error;
+    }
+    const persist = async (nextEvidence) => {
+      const validated = TaskEvidenceSchema.parse({
+        ...nextEvidence,
+        taskId
+      });
+      await atomicWriteFile(evidencePath, JSON.stringify(validated, null, 2));
+      current = validated;
+      return validated;
+    };
+    return callback({
+      taskId,
+      read: () => current,
+      transition: async (event) => {
+        assertTaskEvidenceWriteAllowed(directory, taskId, event);
+        const nextEvidence = updateEvidenceForTransition(current, event);
+        nextEvidence.taskId = taskId;
+        return persist(nextEvidence);
+      }
+    });
+  });
+}
+async function recordGateEvidence(directory, taskId, gate, sessionId, turbo, options = {}) {
+  assertValidTaskId(taskId);
+  if (shouldTreatGateAsStageB(gate) && typeof options.expectedGeneration !== "number") {
+    throw new Error(`TASK_WORKFLOW_GENERATION_REQUIRED: ${gate} for task ${taskId} must be bound at dispatch`);
+  }
+  await transitionTaskWorkflowEvidence(directory, taskId, shouldTreatGateAsStageB(gate) ? {
+    type: "stage_b_completed",
+    gate,
+    sessionId,
+    turbo,
+    ensureDefaultStageB: options.ensureDefaultStageB,
+    expectedGeneration: options.expectedGeneration,
+    transitionId: options.transitionId
+  } : {
+    type: "gate_recorded",
+    gate,
+    sessionId,
+    turbo,
+    expectedGeneration: options.expectedGeneration,
+    transitionId: options.transitionId
+  });
+  telemetry.gatePassed(sessionId, gate, taskId);
+}
+async function recordAgentDispatch(directory, taskId, agentType, turbo, context = {}) {
+  assertValidTaskId(taskId);
+  const expectedGeneration = getTaskWorkflowSnapshot(await readTaskEvidence(directory, taskId)).generation;
+  await transitionTaskWorkflowEvidence(directory, taskId, agentType === "coder" ? {
+    type: "accepted_mutation",
+    agentType,
+    turbo,
+    context,
+    expectedGeneration
+  } : {
+    type: "dispatch_attempted",
+    agentType,
+    turbo,
+    context,
+    expectedGeneration
+  });
+}
+async function readTaskEvidence(directory, taskId) {
+  try {
+    assertValidTaskId(taskId);
+    return readExisting(getEvidencePath(directory, taskId), taskId);
+  } catch {
+    return null;
+  }
+}
+function readTaskEvidenceRaw(directory, taskId) {
+  assertValidTaskId(taskId);
+  const evidencePath = getEvidencePath(directory, taskId);
+  try {
+    const raw = readFileSync(evidencePath, "utf-8");
+    return parseTaskEvidence(raw, taskId);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENAMETOOLONG")
+      return null;
+    throw error;
+  }
+}
+async function hasPassedAllGates(directory, taskId) {
+  const evidence = await readTaskEvidence(directory, taskId);
+  if (!evidence)
+    return false;
+  if (!Array.isArray(evidence.required_gates) || evidence.required_gates.length === 0)
+    return false;
+  return evidence.required_gates.every((gate) => evidence.gates[gate] != null);
+}
+function compareTaskWorkflowStateRank(left, right) {
+  return WORKFLOW_STATE_RANK[left] - WORKFLOW_STATE_RANK[right];
+}
+
+export { sanitizeTaskId, TASK_WORKFLOW_SCHEMA_MARKER, assertTaskEvidenceWriteAllowed, parseTaskEvidence, DEFAULT_REQUIRED_GATES, isValidTaskId, getTaskWorkflowSnapshot, reduceTaskWorkflowSnapshot, deriveRequiredGates, expandRequiredGates, transitionTaskWorkflowEvidence, withTaskEvidenceTransaction, recordGateEvidence, recordAgentDispatch, readTaskEvidence, readTaskEvidenceRaw, hasPassedAllGates, compareTaskWorkflowStateRank };

package/dist/cli/{index-rs1f1bh0.js → index-vh05t3w5.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   atomicWriteFile
-} from "./index-h2waehqq.js";
+} from "./index-p8kk34am.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-adyxbmt5.js → index-wkt9fj06.js}

@@ -5,10 +5,10 @@ import {
 import {
   computePlanStructureHash,
   derivePlanId
-} from "./index-kbfsp07d.js";
+} from "./index-wrb0gykj.js";
 import {
   assertProjectRoot
-} from "./index-hfvxhk4z.js";
+} from "./index-912qz4y0.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -17,7 +17,7 @@ import {
 } from "./index-4nt52yr9.js";
 import {
   PlanSchema
-} from "./index-d181x9zr.js";
+} from "./index-nwrwy8eb.js";
 import {
   __toESM
 } from "./index-a76rekgs.js";
@@ -773,12 +773,12 @@ function isDispatchCorrelated(binding) {
   return binding.activation === "active" && typeof binding.dispatchCallId === "string" && binding.dispatchCallId.length > 0 && binding.ownerMessageId === binding.dispatchCallId && typeof binding.parentOwnerSessionId === "string" && binding.parentOwnerSessionId.length > 0 && binding.ownerSessionId !== binding.parentOwnerSessionId && binding.parentCallId === binding.dispatchCallId;
 }
 function clearScopeBindingFromDisk(input) {
+  const localRetirement = installScopeBindingRetirementIntent(input.binding);
   try {
     assertProjectRoot(input.directory);
   } catch (error) {
     return persistenceFailure(`Scope retirement project-root validation failed: ${error instanceof Error ? error.message : "unknown validation error"}`);
   }
-  const localRetirement = installScopeBindingRetirementIntent(input.binding);
   let release;
   try {
     const resolvedWorkspace = fs2.realpathSync(input.directory);