opencode-swarm 7.142.0 → 7.143.0

package/dist/cli/index-h2vpk15y.js

@@ -1,623 +0,0 @@
-// @bun
-import {
-  validateSwarmPath
-} from "./index-k46me75h.js";
-import {
-  atomicWriteFile,
-  taskEvidencePath,
-  withTaskEvidenceLock
-} from "./index-em1kfnss.js";
-import {
-  telemetry
-} from "./index-338zfvff.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 };