opencode-swarm 7.132.2 → 7.134.0

package/dist/cli/{index-03zyn94g.js → index-k742ecbm.js}

@@ -2,6 +2,15 @@
 import {
   readEffectiveSpecSync
 } from "./index-9ss2m4rs.js";
+import {
+  isValidTaskId,
+  readTaskEvidence,
+  readTaskEvidenceRaw,
+  sanitizeTaskId
+} from "./index-wk1h5ec2.js";
+import {
+  atomicWriteFile
+} from "./index-dd7ttx8x.js";
 import {
   EVIDENCE_MAX_JSON_BYTES,
   EvidenceBundleSchema,
@@ -29,35 +38,23 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-2tn5h2zp.js";
+} from "./index-4p02dp92.js";
 import {
   PlanSchema
 } from "./index-1kz6da87.js";
+import {
+  getWorktreeMergeFailure
+} from "./index-b8zgtz81.js";
 import {
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-s80bsjkj.js";
-import {
-  criticalWarn,
-  error,
-  init_logger,
-  warn
-} from "./index-zgwm4ryv.js";
-import {
-  isValidTaskId,
-  readTaskEvidence,
-  readTaskEvidenceRaw,
-  sanitizeTaskId
-} from "./index-3x761jqv.js";
-import {
-  atomicWriteFile
-} from "./index-7mkpsw6g.js";
+} from "./index-2ghkk9ve.js";
 import {
   readCachedParsedFile
 } from "./index-fsrp8wp3.js";
 import {
   withEvidenceLock
-} from "./index-76kvm9z5.js";
+} from "./index-5nybajn9.js";
 import {
   emit
 } from "./index-q2rrv0cy.js";
@@ -71,6 +68,12 @@ import {
   bunWrite,
   mergeEnvForChild
 } from "./index-qe3v54nb.js";
+import {
+  criticalWarn,
+  error,
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
 import {
   __esm,
   __export,
@@ -966,17 +969,17 @@ var init_executor = __esm(() => {
 import {
   closeSync,
   copyFileSync,
-  existsSync as existsSync4,
+  existsSync as existsSync3,
   fsyncSync,
-  mkdirSync as mkdirSync4,
+  mkdirSync as mkdirSync3,
   openSync,
   readdirSync,
-  renameSync as renameSync3,
-  unlinkSync as unlinkSync3,
-  writeFileSync as writeFileSync5
+  renameSync as renameSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync4
 } from "fs";
 import * as fsPromises from "fs/promises";
-import * as path8 from "path";
+import * as path7 from "path";
 
 // src/git/branch.ts
 init_executor();
@@ -1582,65 +1585,18 @@ var _internals5 = {
   readLaneEnvFileFromDiskSync
 };
 
-// src/hooks/delegation-gate/worktree-merge-status.ts
-import * as fs2 from "fs";
-import * as path5 from "path";
-var failuresByTask = new Map;
-var durableStatusPath;
-var hasLoaded = false;
-function loadDurableStatus(statusPath) {
-  try {
-    hasLoaded = true;
-    if (!fs2.existsSync(statusPath)) {
-      failuresByTask.clear();
-      return;
-    }
-    const data = JSON.parse(fs2.readFileSync(statusPath, "utf-8"));
-    if (data && typeof data === "object") {
-      failuresByTask.clear();
-      for (const [taskId, failure] of Object.entries(data)) {
-        failuresByTask.set(taskId, failure);
-      }
-    }
-  } catch {
-    failuresByTask.clear();
-  }
-}
-function initDurableStatusPath(projectDir) {
-  if (typeof projectDir !== "string" || projectDir.length === 0)
-    return;
-  const nextPath = path5.join(projectDir, ".swarm", "worktree-merge-status.json");
-  if (durableStatusPath === nextPath && hasLoaded)
-    return;
-  durableStatusPath = nextPath;
-  hasLoaded = false;
-  loadDurableStatus(durableStatusPath);
-}
-function getWorktreeMergeFailure(taskId) {
-  if (!hasLoaded && durableStatusPath) {
-    loadDurableStatus(durableStatusPath);
-  }
-  return failuresByTask.get(taskId);
-}
-function getAllWorktreeMergeFailures() {
-  if (!hasLoaded && durableStatusPath) {
-    loadDurableStatus(durableStatusPath);
-  }
-  return failuresByTask.entries();
-}
-
 // src/turbo/epic/state.ts
 init_logger();
-import * as fs3 from "fs";
-import * as path6 from "path";
+import * as fs2 from "fs";
+import * as path5 from "path";
 var STATE_FILE = "epic-state.json";
 function nowISO() {
   return new Date().toISOString();
 }
 function ensureSwarmDir(directory) {
-  const swarmDir = path6.resolve(directory, ".swarm");
-  if (!fs3.existsSync(swarmDir)) {
-    fs3.mkdirSync(swarmDir, { recursive: true });
+  const swarmDir = path5.resolve(directory, ".swarm");
+  if (!fs2.existsSync(swarmDir)) {
+    fs2.mkdirSync(swarmDir, { recursive: true });
   }
   return swarmDir;
 }
@@ -1660,17 +1616,17 @@ function markStateUnreadable(directory, reason) {
 }
 function readPersisted(directory) {
   try {
-    const filePath = path6.join(directory, ".swarm", STATE_FILE);
-    if (!fs3.existsSync(filePath)) {
+    const filePath = path5.join(directory, ".swarm", STATE_FILE);
+    if (!fs2.existsSync(filePath)) {
       const seed = emptyPersisted();
       try {
         ensureSwarmDir(directory);
-        fs3.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
+        fs2.writeFileSync(filePath, `${JSON.stringify(seed, null, 2)}
 `, "utf-8");
       } catch {}
       return seed;
     }
-    const raw = fs3.readFileSync(filePath, "utf-8");
+    const raw = fs2.readFileSync(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || parsed.version !== 1 || !parsed.sessions || typeof parsed.sessions !== "object" || Array.isArray(parsed.sessions)) {
       markStateUnreadable(directory, `malformed shape (version=${parsed?.version}, sessions type=${Array.isArray(parsed?.sessions) ? "array" : typeof parsed?.sessions})`);
@@ -1696,7 +1652,7 @@ function writePersisted(directory, persisted) {
   let payload;
   try {
     ensureSwarmDir(directory);
-    filePath = path6.join(directory, ".swarm", STATE_FILE);
+    filePath = path5.join(directory, ".swarm", STATE_FILE);
     tmpPath = `${filePath}.tmp.${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
     persisted.updatedAt = nowISO();
     payload = `${JSON.stringify(persisted, null, 2)}
@@ -1707,14 +1663,14 @@ function writePersisted(directory, persisted) {
     throw new Error(`Epic state persistence prepare failed: ${msg}`);
   }
   try {
-    fs3.writeFileSync(tmpPath, payload, "utf-8");
-    fs3.renameSync(tmpPath, filePath);
+    fs2.writeFileSync(tmpPath, payload, "utf-8");
+    fs2.renameSync(tmpPath, filePath);
   } catch (error2) {
     const msg = error2 instanceof Error ? error2.message : String(error2);
     error(`[turbo/epic/state] Failed to persist ${STATE_FILE} atomically: ${msg}`);
     try {
-      if (fs3.existsSync(tmpPath))
-        fs3.unlinkSync(tmpPath);
+      if (fs2.existsSync(tmpPath))
+        fs2.unlinkSync(tmpPath);
     } catch {}
     throw new Error(`Epic state persistence failed: ${msg}`);
   }
@@ -1745,7 +1701,7 @@ function isEpicModeActive(directory, sessionID) {
 function isEpicModeActiveForProject(directory) {
   if (stateUnreadableMap.get(directory))
     return false;
-  if (!fs3.existsSync(path6.join(directory, ".swarm", STATE_FILE))) {
+  if (!fs2.existsSync(path5.join(directory, ".swarm", STATE_FILE))) {
     return false;
   }
   const persisted = readPersisted(directory);
@@ -1871,8 +1827,8 @@ var _internals6 = {
 };
 
 // src/turbo/lean/conflicts.ts
-import * as fs4 from "fs";
-import * as path7 from "path";
+import * as fs3 from "fs";
+import * as path6 from "path";
 
 // src/utils/path.ts
 function normalizePath(p) {
@@ -2000,12 +1956,12 @@ function isProtectedPath(normalizedPath) {
   return false;
 }
 function readTaskScopes(directory, taskId) {
-  const scopePath = path7.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
+  const scopePath = path6.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
   try {
-    if (!fs4.existsSync(scopePath)) {
+    if (!fs3.existsSync(scopePath)) {
       return null;
     }
-    const raw = fs4.readFileSync(scopePath, "utf-8");
+    const raw = fs3.readFileSync(scopePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.files)) {
       return null;
@@ -2019,7 +1975,7 @@ function readTaskScopes(directory, taskId) {
 // src/utils/spec-hash.ts
 import { createHash } from "crypto";
 import * as fsSync2 from "fs";
-import { join as join6 } from "path";
+import { join as join5 } from "path";
 async function computeSpecHash(directory) {
   const spec = _internals7.readEffectiveSpecSync(directory);
   if (!spec)
@@ -2048,7 +2004,7 @@ async function isSpecStale(directory, plan) {
   return { stale: false };
 }
 function isObligationPreserving(directory) {
-  const snapshotPath = join6(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join5(directory, ".swarm", "spec-snapshot.md");
   try {
     let recordedContent;
     try {
@@ -2094,7 +2050,7 @@ var _internals7 = {
   readEffectiveSpecSync
 };
 function computeSpecDiff(directory) {
-  const snapshotPath = join6(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join5(directory, ".swarm", "spec-snapshot.md");
   let recordedContent;
   try {
     const snapshotSize = fsSync2.statSync(snapshotPath).size;
@@ -2340,7 +2296,7 @@ async function getLatestLedgerHash(directory) {
   }
 }
 async function surfaceLedgerStaleIfPersisted(directory, plan) {
-  const resolvedWorkspace = path8.resolve(directory);
+  const resolvedWorkspace = path7.resolve(directory);
   if (!ledgerStaleWorkspaces.has(resolvedWorkspace)) {
     return plan;
   }
@@ -2359,7 +2315,7 @@ async function surfaceLedgerStaleIfPersisted(directory, plan) {
   return plan;
 }
 async function parsePlanJsonCached(directory) {
-  const planJsonPath = path8.resolve(directory, ".swarm", "plan.json");
+  const planJsonPath = path7.resolve(directory, ".swarm", "plan.json");
   return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => readSwarmFileAsync(directory, "plan.json"), (planJsonContent) => {
     if (planJsonContent.includes("\x00") || planJsonContent.includes("\uFFFD")) {
       throw new Error("Plan rejected: .swarm/plan.json contains null bytes or invalid encoding");
@@ -2419,19 +2375,19 @@ async function isPlanMdInSync(directory, plan, cache) {
   return false;
 }
 async function regeneratePlanMarkdown(directory, plan) {
-  const swarmDir = path8.resolve(directory, ".swarm");
+  const swarmDir = path7.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
   const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-  const mdPath = path8.join(swarmDir, "plan.md");
-  const mdTempPath = path8.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const mdPath = path7.join(swarmDir, "plan.md");
+  const mdTempPath = path7.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync3(mdTempPath, mdPath);
+    renameSync2(mdTempPath, mdPath);
   } finally {
     try {
-      unlinkSync3(mdTempPath);
+      unlinkSync2(mdTempPath);
     } catch {}
   }
 }
@@ -2457,7 +2413,7 @@ async function loadPlan(directory, cache) {
           if (await ledgerExists(directory)) {
             const planHash = computePlanHash(validated);
             const ledgerHash = await getLatestLedgerHash(directory);
-            const resolvedWorkspace = path8.resolve(directory);
+            const resolvedWorkspace = path7.resolve(directory);
             if (!startupLedgerCheckedWorkspaces.has(resolvedWorkspace)) {
               startupLedgerCheckedWorkspaces.add(resolvedWorkspace);
               if (ledgerHash !== "" && planHash !== ledgerHash) {
@@ -2531,7 +2487,7 @@ async function loadPlan(directory, cache) {
               if (!preserving) {
                 try {
                   const diffInfo = computeSpecDiff(directory);
-                  const specStalenessPath = path8.join(directory, ".swarm", "spec-staleness.json");
+                  const specStalenessPath = path7.join(directory, ".swarm", "spec-staleness.json");
                   await fsPromises.writeFile(specStalenessPath, JSON.stringify({
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2545,7 +2501,7 @@ async function loadPlan(directory, cache) {
                   }, null, 2), "utf-8");
                 } catch {}
                 try {
-                  const eventsPath = path8.join(directory, ".swarm", "events.jsonl");
+                  const eventsPath = path7.join(directory, ".swarm", "events.jsonl");
                   const event = {
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2611,7 +2567,7 @@ async function loadPlan(directory, cache) {
     return migrated;
   }
   if (await ledgerExists(directory)) {
-    const resolvedDir = path8.resolve(directory);
+    const resolvedDir = path7.resolve(directory);
     const existingMutex = recoveryMutexes.get(resolvedDir);
     if (existingMutex) {
       await existingMutex;
@@ -2740,13 +2696,13 @@ async function savePlan(directory, plan, options) {
   } else {
     const existingEvents = await readLedgerEvents(directory);
     if (existingEvents.length > 0 && existingEvents[0].plan_id !== planId) {
-      const swarmDir2 = path8.resolve(directory, ".swarm");
-      const oldLedgerPath = path8.join(swarmDir2, "plan-ledger.jsonl");
-      const oldLedgerBackupPath = path8.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+      const swarmDir2 = path7.resolve(directory, ".swarm");
+      const oldLedgerPath = path7.join(swarmDir2, "plan-ledger.jsonl");
+      const oldLedgerBackupPath = path7.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync4(oldLedgerPath)) {
+      if (existsSync3(oldLedgerPath)) {
         try {
-          renameSync3(oldLedgerPath, oldLedgerBackupPath);
+          renameSync2(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
         } catch (renameErr) {
           throw new Error(`[savePlan] Cannot reinitialize ledger: could not move old ledger aside (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). The existing ledger has plan_id="${existingEvents[0].plan_id}" which does not match the current plan="${planId}". To proceed, close any programs that may have the ledger file open, or run /swarm reset-session to clear the ledger.`);
@@ -2761,17 +2717,17 @@ async function savePlan(directory, plan, options) {
           const errorMessage2 = String(initErr);
           if (errorMessage2.includes("already initialized")) {
             try {
-              if (existsSync4(oldLedgerBackupPath))
-                unlinkSync3(oldLedgerBackupPath);
+              if (existsSync3(oldLedgerBackupPath))
+                unlinkSync2(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync4(oldLedgerBackupPath)) {
+            if (existsSync3(oldLedgerBackupPath)) {
               try {
-                renameSync3(oldLedgerBackupPath, oldLedgerPath);
+                renameSync2(oldLedgerBackupPath, oldLedgerPath);
               } catch {
                 copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
-                  unlinkSync3(oldLedgerBackupPath);
+                  unlinkSync2(oldLedgerBackupPath);
                 } catch {}
               }
             }
@@ -2780,21 +2736,21 @@ async function savePlan(directory, plan, options) {
         }
       }
       if (initSucceeded && backupExists) {
-        const archivePath = path8.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
+        const archivePath = path7.join(swarmDir2, `plan-ledger.archived-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
         try {
-          renameSync3(oldLedgerBackupPath, archivePath);
+          renameSync2(oldLedgerBackupPath, archivePath);
           warn(`[savePlan] Ledger identity mismatch (was "${existingEvents[0].plan_id}", now "${planId}") \u2014 archived old ledger to ${archivePath} and reinitializing.`);
         } catch (renameErr) {
           warn(`[savePlan] Could not archive old ledger (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). Old ledger may still exist at ${oldLedgerBackupPath}.`);
           try {
-            if (existsSync4(oldLedgerBackupPath))
-              unlinkSync3(oldLedgerBackupPath);
+            if (existsSync3(oldLedgerBackupPath))
+              unlinkSync2(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync4(oldLedgerBackupPath))
-            unlinkSync3(oldLedgerBackupPath);
+          if (existsSync3(oldLedgerBackupPath))
+            unlinkSync2(oldLedgerBackupPath);
         } catch {}
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
@@ -2805,7 +2761,7 @@ async function savePlan(directory, plan, options) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
           for (const file of toRemove) {
             try {
-              unlinkSync3(path8.join(swarmDir2, file));
+              unlinkSync2(path7.join(swarmDir2, file));
             } catch {}
           }
         }
@@ -2948,19 +2904,19 @@ async function savePlan(directory, plan, options) {
       source: "savePlan_manager"
     });
   }
-  const swarmDir = path8.resolve(directory, ".swarm");
-  const planPath = path8.join(swarmDir, "plan.json");
-  const tempPath = path8.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path7.resolve(directory, ".swarm");
+  const planPath = path7.join(swarmDir, "plan.json");
+  const tempPath = path7.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(tempPath, JSON.stringify(projectedPlan, null, 2));
-    renameSync3(tempPath, planPath);
+    renameSync2(tempPath, planPath);
   } finally {
     try {
-      unlinkSync3(tempPath);
+      unlinkSync2(tempPath);
     } catch {}
   }
   try {
-    const markerPath = path8.join(swarmDir, ".plan-write-marker");
+    const markerPath = path7.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -2975,14 +2931,14 @@ async function savePlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(projectedPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdPath = path8.join(swarmDir, "plan.md");
-    const mdTempPath = path8.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdPath = path7.join(swarmDir, "plan.md");
+    const mdTempPath = path7.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
-      renameSync3(mdTempPath, mdPath);
+      renameSync2(mdTempPath, mdPath);
     } finally {
       try {
-        unlinkSync3(mdTempPath);
+        unlinkSync2(mdTempPath);
       } catch {}
     }
   } catch (mdError) {
@@ -2997,7 +2953,7 @@ ${markdown}`;
     } catch {}
   }
   try {
-    const markerPath = path8.join(swarmDir, ".plan-write-marker");
+    const markerPath = path7.join(swarmDir, ".plan-write-marker");
     const tasksCount = projectedPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
     const marker = JSON.stringify({
       source: "plan_manager",
@@ -3013,23 +2969,23 @@ async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
-  const swarmDir = path8.join(directory, ".swarm");
-  const planPath = path8.join(swarmDir, "plan.json");
-  const mdPath = path8.join(swarmDir, "plan.md");
-  mkdirSync4(swarmDir, { recursive: true });
-  const tempPlanPath = path8.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path7.join(directory, ".swarm");
+  const planPath = path7.join(swarmDir, "plan.json");
+  const mdPath = path7.join(swarmDir, "plan.md");
+  mkdirSync3(swarmDir, { recursive: true });
+  const tempPlanPath = path7.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   {
     const fd = openSync(tempPlanPath, "w");
     try {
-      writeFileSync5(fd, JSON.stringify(targetPlan, null, 2), "utf8");
+      writeFileSync4(fd, JSON.stringify(targetPlan, null, 2), "utf8");
       fsyncSync(fd);
     } finally {
       closeSync(fd);
     }
   }
-  renameSync3(tempPlanPath, planPath);
+  renameSync2(tempPlanPath, planPath);
   try {
-    const markerPath = path8.join(swarmDir, ".plan-write-marker");
+    const markerPath = path7.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -3044,12 +3000,12 @@ async function rebuildPlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const tempMdPath = path8.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const tempMdPath = path7.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(tempMdPath, markdownWithHash);
-    renameSync3(tempMdPath, mdPath);
+    renameSync2(tempMdPath, mdPath);
   } finally {
     try {
-      const markerPath = path8.join(swarmDir, ".plan-write-marker");
+      const markerPath = path7.join(swarmDir, ".plan-write-marker");
       const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager",
@@ -3112,13 +3068,13 @@ async function closePlanTerminalState(directory, plan, options) {
     planHashAfter: hashAfter,
     source: "close_terminal"
   });
-  const swarmDir = path8.join(directory, ".swarm");
-  const planPath = path8.join(swarmDir, "plan.json");
-  const tempPlanPath = path8.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path7.join(directory, ".swarm");
+  const planPath = path7.join(swarmDir, "plan.json");
+  const tempPlanPath = path7.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
-  renameSync3(tempPlanPath, planPath);
+  renameSync2(tempPlanPath, planPath);
   try {
-    const markerPath = path8.join(swarmDir, ".plan-write-marker");
+    const markerPath = path7.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager_close",
       timestamp: new Date().toISOString(),
@@ -3129,17 +3085,17 @@ async function closePlanTerminalState(directory, plan, options) {
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const mdPath = path8.join(swarmDir, "plan.md");
+    const mdPath = path7.join(swarmDir, "plan.md");
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdTempPath = path8.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdTempPath = path7.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
-    renameSync3(mdTempPath, mdPath);
+    renameSync2(mdTempPath, mdPath);
   } finally {
     try {
-      const markerPath = path8.join(swarmDir, ".plan-write-marker");
+      const markerPath = path7.join(swarmDir, ".plan-write-marker");
       const tasksCount = validated.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager_close",
@@ -3424,19 +3380,19 @@ function migrateLegacyPlan(planContent, swarmId) {
 // src/evidence/manager.ts
 init_zod();
 import {
-  mkdirSync as mkdirSync5,
+  mkdirSync as mkdirSync4,
   readdirSync as readdirSync2,
   realpathSync as realpathSync2,
   rmSync,
   statSync as statSync2
 } from "fs";
-import * as fs7 from "fs/promises";
+import * as fs6 from "fs/promises";
 import * as os4 from "os";
-import * as path13 from "path";
+import * as path12 from "path";
 
 // src/evaluation/retention.ts
-import * as fs5 from "fs/promises";
-import * as path12 from "path";
+import * as fs4 from "fs/promises";
+import * as path11 from "path";
 
 // src/evaluation/contracts.ts
 init_zod();
@@ -3812,11 +3768,11 @@ var TaskSetSnapshotV1Schema = exports_external.object({
 
 // src/evaluation/store.ts
 import { mkdir as mkdir2, readdir, readFile as readFile3 } from "fs/promises";
-import * as path11 from "path";
+import * as path10 from "path";
 
 // src/evidence/immutable-store.ts
 import { mkdir, readFile } from "fs/promises";
-import * as path9 from "path";
+import * as path8 from "path";
 async function readOptionalFile(filePath) {
   try {
     return await readFile(filePath, "utf8");
@@ -3827,7 +3783,7 @@ async function readOptionalFile(filePath) {
   }
 }
 async function writeImmutableArtifact(options) {
-  await mkdir(path9.dirname(options.filePath), { recursive: true });
+  await mkdir(path8.dirname(options.filePath), { recursive: true });
   return withEvidenceLock(options.directory, options.relativeLockPath, options.agent, options.taskId, async () => {
     const desired = options.serialize(options.value);
     const existing = await readOptionalFile(options.filePath);
@@ -3859,7 +3815,7 @@ async function writeImmutableArtifact(options) {
 import { createHash as createHash2 } from "crypto";
 import { lstatSync, realpathSync } from "fs";
 import { lstat, opendir, readFile as readFile2, realpath } from "fs/promises";
-import * as path10 from "path";
+import * as path9 from "path";
 function canonicalize(value, ancestors) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
@@ -3950,7 +3906,7 @@ async function hashTree(projectRoot, relativePath, budget) {
     }
     if (!entryAlreadyCharged)
       chargeHashEntry(budget);
-    const relative2 = path10.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
+    const relative2 = path9.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
     if (stat.isDirectory()) {
       entries.push({ path: relative2, type: "directory" });
       const children = [];
@@ -3967,7 +3923,7 @@ async function hashTree(projectRoot, relativePath, budget) {
         await closeDirectory(directory);
       }
       for (const child of children.sort()) {
-        await visit(path10.join(absolutePath, child), true);
+        await visit(path9.join(absolutePath, child), true);
       }
       return;
     }
@@ -4010,10 +3966,10 @@ async function computeTaskLineageInputHash(projectRoot, task, limits = {}) {
   const normalizedTree = async (relativePath) => {
     const canonicalRoot = await _internals9.realpath(projectRoot);
     const target = await resolveContainedExistingPathAsync(projectRoot, relativePath);
-    const targetRelative = path10.relative(canonicalRoot, target).replace(/\\/g, "/");
+    const targetRelative = path9.relative(canonicalRoot, target).replace(/\\/g, "/");
     return (await hashTree(projectRoot, relativePath, budget)).map((entry) => ({
       ...entry,
-      path: path10.posix.relative(targetRelative, entry.path) || "."
+      path: path9.posix.relative(targetRelative, entry.path) || "."
     }));
   };
   const scorerArgv = [...task.scorer.argv];
@@ -4042,11 +3998,11 @@ function computeManifestContentHash(manifest) {
   return contentHashWithout(manifest, ["contentHash"]);
 }
 function isWithin(root, candidate) {
-  const relative2 = path10.relative(root, candidate);
-  return relative2 === "" || !relative2.startsWith("..") && !path10.isAbsolute(relative2);
+  const relative2 = path9.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path9.isAbsolute(relative2);
 }
 function resolveContainedExistingPath(root, relativePath) {
-  if (path10.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
     throw new Error("evaluation path must be a non-NUL relative path");
   }
   const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
@@ -4058,7 +4014,7 @@ function resolveContainedExistingPath(root, relativePath) {
   for (const segment of segments) {
     if (segment === ".")
       continue;
-    cursor = path10.join(cursor, segment);
+    cursor = path9.join(cursor, segment);
     const stat = lstatSync(cursor);
     if (stat.isSymbolicLink()) {
       throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
@@ -4071,7 +4027,7 @@ function resolveContainedExistingPath(root, relativePath) {
   return canonicalCandidate;
 }
 async function resolveContainedExistingPathAsync(root, relativePath) {
-  if (path10.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
     throw new Error("evaluation path must be a non-NUL relative path");
   }
   const segments = relativePath.replace(/\\/g, "/").split("/").filter(Boolean);
@@ -4083,7 +4039,7 @@ async function resolveContainedExistingPathAsync(root, relativePath) {
   for (const segment of segments) {
     if (segment === ".")
       continue;
-    cursor = path10.join(cursor, segment);
+    cursor = path9.join(cursor, segment);
     const stat = await _internals9.lstat(cursor);
     if (stat.isSymbolicLink()) {
       throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
@@ -4104,8 +4060,8 @@ var _internals9 = {
 
 // src/evaluation/store.ts
 var AGENT = "evaluation-store";
-var TEST_LEDGER_RELATIVE = path11.join("evolution", "test-consumption.jsonl");
-var TASK_SPLIT_REGISTRY_RELATIVE = path11.join("evolution", "tasks", "split-registry.json");
+var TEST_LEDGER_RELATIVE = path10.join("evolution", "test-consumption.jsonl");
+var TASK_SPLIT_REGISTRY_RELATIVE = path10.join("evolution", "tasks", "split-registry.json");
 
 class EvaluationConflictError extends Error {
   constructor(message) {
@@ -4114,7 +4070,7 @@ class EvaluationConflictError extends Error {
   }
 }
 function swarmPath(directory, ...segments) {
-  return path11.join(directory, ".swarm", ...segments);
+  return path10.join(directory, ".swarm", ...segments);
 }
 function serialized(value) {
   return `${canonicalJson(value)}
@@ -4172,8 +4128,8 @@ function validateTaskInputs(directory, task) {
     if (!executable)
       throw new Error("project scorer requires an executable");
     const scorerPath = resolveContainedExistingPath(directory, executable);
-    const relative3 = path11.relative(environmentRoot, scorerPath);
-    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative3)) {
+    const relative3 = path10.relative(environmentRoot, scorerPath);
+    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative3)) {
       throw new Error("project scorer executable must be inside the admitted task environment");
     }
   }
@@ -4185,10 +4141,10 @@ async function admitEvaluationTask(directory, input, inputRoot = directory) {
   }
   validateTaskInputs(inputRoot, task);
   const lineageInputHash = await computeTaskLineageInputHash(inputRoot, task);
-  const relative3 = path11.join("evolution", "tasks", task.split, `${task.id}.json`);
+  const relative3 = path10.join("evolution", "tasks", task.split, `${task.id}.json`);
   const admissionLock = TASK_SPLIT_REGISTRY_RELATIVE;
   const filePath = swarmPath(directory, relative3);
-  await mkdir2(path11.dirname(filePath), { recursive: true });
+  await mkdir2(path10.dirname(filePath), { recursive: true });
   return withEvidenceLock(directory, admissionLock, AGENT, task.id, async () => {
     const registryPath = swarmPath(directory, TASK_SPLIT_REGISTRY_RELATIVE);
     const registry = parseTaskSplitRegistry(await readOptionalFile(registryPath));
@@ -4276,7 +4232,7 @@ async function saveTaskSetSnapshot(directory, input, inputRoot = directory) {
   if (computeTaskSetContentHash(snapshot) !== snapshot.contentHash) {
     throw new Error("task-set content hash does not match its canonical inputs");
   }
-  const relative3 = path11.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
+  const relative3 = path10.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
   return writeImmutable({
     directory,
     relativeLockPath: relative3,
@@ -4289,7 +4245,7 @@ async function saveTaskSetSnapshot(directory, input, inputRoot = directory) {
 }
 async function saveGateAuditResult(directory, input) {
   const result = GateAuditResultV1Schema.parse(input);
-  const relative3 = path11.join("evidence", "gate-audit", result.runId, "results.json");
+  const relative3 = path10.join("evidence", "gate-audit", result.runId, "results.json");
   return writeImmutable({
     directory,
     relativeLockPath: relative3,
@@ -4301,7 +4257,7 @@ async function saveGateAuditResult(directory, input) {
 }
 async function saveGateAuditManifest(directory, input) {
   const manifest = GateAuditManifestV1Schema.parse(input);
-  const relative3 = path11.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
+  const relative3 = path10.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
   return writeImmutable({
     directory,
     relativeLockPath: relative3,
@@ -4337,7 +4293,7 @@ async function listGateAuditResults(directory) {
       continue;
     }
     try {
-      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile3(path11.join(root, entry.name, "results.json"), "utf8")));
+      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile3(path10.join(root, entry.name, "results.json"), "utf8")));
       if (parsed.runId !== entry.name)
         throw new Error("run id/path mismatch");
       results.push(parsed);
@@ -4370,7 +4326,7 @@ async function getProtectedEvaluationRunIds(directory) {
       throw error2;
   }
   for (const filename of files.filter((value) => value.endsWith(".json")).sort()) {
-    const decision = PromotionDecisionV1Schema.parse(JSON.parse(await readFile3(path11.join(decisionsDirectory, filename), "utf8")));
+    const decision = PromotionDecisionV1Schema.parse(JSON.parse(await readFile3(path10.join(decisionsDirectory, filename), "utf8")));
     protectedIds.add(decision.runId);
     protectedIds.add(decision.lineage.baselineRunId);
     if (decision.lineage.historicalBestRunId !== "unavailable") {
@@ -4388,10 +4344,10 @@ function validId(value) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(value);
 }
 async function evaluationRunCandidates(directory) {
-  const root = path12.join(directory, ".swarm", "evolution", "runs");
+  const root = path11.join(directory, ".swarm", "evolution", "runs");
   let entries = [];
   try {
-    entries = await fs5.readdir(root, { withFileTypes: true });
+    entries = await fs4.readdir(root, { withFileTypes: true });
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return { candidates: [], corrupt: [] };
@@ -4407,9 +4363,9 @@ async function evaluationRunCandidates(directory) {
     if (!validId(id))
       continue;
     const artifact = { namespace: "evaluation-run", id };
-    const target = path12.join(root, entry.name);
+    const target = path11.join(root, entry.name);
     try {
-      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs5.readFile(target, "utf8")));
+      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs4.readFile(target, "utf8")));
       if (run.runId !== id)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -4425,10 +4381,10 @@ async function evaluationRunCandidates(directory) {
   return { candidates, corrupt };
 }
 async function gateAuditCandidates(directory) {
-  const root = path12.join(directory, ".swarm", "evidence", "gate-audit");
+  const root = path11.join(directory, ".swarm", "evidence", "gate-audit");
   let entries = [];
   try {
-    entries = await fs5.readdir(root, { withFileTypes: true });
+    entries = await fs4.readdir(root, { withFileTypes: true });
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return { candidates: [], corrupt: [] };
@@ -4441,9 +4397,9 @@ async function gateAuditCandidates(directory) {
     if (!entry.isDirectory() || !validId(entry.name))
       continue;
     const artifact = { namespace: "gate-audit", id: entry.name };
-    const target = path12.join(root, entry.name);
+    const target = path11.join(root, entry.name);
     try {
-      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs5.readFile(path12.join(target, "results.json"), "utf8")));
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs4.readFile(path11.join(target, "results.json"), "utf8")));
       if (result.runId !== entry.name)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -4474,17 +4430,17 @@ async function protectedArtifacts(directory) {
 }
 async function removeCandidate(candidate) {
   if (candidate.kind === "directory") {
-    await fs5.rm(candidate.target, { recursive: true, force: true });
+    await fs4.rm(candidate.target, { recursive: true, force: true });
     return;
   }
-  await fs5.unlink(candidate.target);
+  await fs4.unlink(candidate.target);
 }
 var _retentionInternals = {
   protectedArtifacts,
   removeCandidate
 };
 async function archiveEvaluationArtifacts(args) {
-  return withEvidenceLock(args.directory, path12.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
+  return withEvidenceLock(args.directory, path11.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
     const inventory = await retentionCandidates(args.directory);
     let protectedKeys = await _retentionInternals.protectedArtifacts(args.directory);
     const protectedRefs = inventory.candidates.filter((candidate) => protectedKeys.has(artifactKey(candidate.artifact))).map((candidate) => candidate.artifact);
@@ -4533,7 +4489,7 @@ async function archiveEvaluationArtifacts(args) {
 }
 
 // src/evidence/documents-retention.ts
-import * as fs6 from "fs";
+import * as fs5 from "fs";
 import * as fsp from "fs/promises";
 import * as readline from "readline";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
@@ -4543,11 +4499,11 @@ var RENAME_BACKOFF_MS = 10;
 var RENAME_RETRY_CODES = new Set(["EPERM", "EBUSY", "ENOTEMPTY", "EACCES"]);
 var _internals10 = {
   stat: (p) => fsp.stat(p),
-  createReadStream: (p, options) => fs6.createReadStream(p, options),
-  openSync: (p, flags) => fs6.openSync(p, flags),
-  writeSync: (fd, data, position) => fs6.writeSync(fd, data, position),
-  fsyncSync: (fd) => fs6.fsyncSync(fd),
-  closeSync: (fd) => fs6.closeSync(fd),
+  createReadStream: (p, options) => fs5.createReadStream(p, options),
+  openSync: (p, flags) => fs5.openSync(p, flags),
+  writeSync: (fd, data, position) => fs5.writeSync(fd, data, position),
+  fsyncSync: (fd) => fs5.fsyncSync(fd),
+  closeSync: (fd) => fs5.closeSync(fd),
   renameWithRetry: atomicRenameWithRetry,
   unlink: (p) => fsp.unlink(p)
 };
@@ -4807,8 +4763,8 @@ function isWeakConfigContainerRoot(directory) {
     const resolved = realpathSync2(directory);
     return resolved === realpathSync2(os4.tmpdir()) || resolved === realpathSync2(os4.homedir());
   } catch {
-    const resolved = path13.resolve(directory);
-    return resolved === path13.resolve(os4.tmpdir()) || resolved === path13.resolve(os4.homedir());
+    const resolved = path12.resolve(directory);
+    return resolved === path12.resolve(os4.tmpdir()) || resolved === path12.resolve(os4.homedir());
   }
 }
 function hasAccessibleProjectIndicator(directory, options = {}) {
@@ -4818,7 +4774,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
       continue;
     }
     try {
-      const indicatorStat = statSync2(path13.join(directory, indicator));
+      const indicatorStat = statSync2(path12.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
         return true;
       }
@@ -4840,14 +4796,14 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path13.dirname(current);
+    const parent = path12.dirname(current);
     if (parent === current)
       break;
-    if (path13.dirname(parent) === parent) {
+    if (path12.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path13.join(parent, ".swarm");
+    const parentSwarm = path12.join(parent, ".swarm");
     try {
       if (statSync2(parentSwarm).isDirectory()) {
         if (hasAccessibleProjectIndicator(parent, {
@@ -4868,12 +4824,12 @@ function validateProjectRoot(directory) {
 async function saveEvidence(directory, taskId, evidence) {
   _internals11.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
   _internals11.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path13.dirname(evidencePath);
+    const evidenceDir = path12.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -4915,11 +4871,11 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync5(evidenceDir, { recursive: true });
-    const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    mkdirSync4(evidenceDir, { recursive: true });
+    const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs7.rename(tempPath, evidencePath);
+      await fs6.rename(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -4960,7 +4916,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId, options) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -4984,12 +4940,12 @@ async function loadEvidence(directory, taskId, options) {
       }
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path13.dirname(evidencePath);
+          const evidenceDir = path12.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs7.rename(tempPath, evidencePath);
+            await fs6.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -5031,7 +4987,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path13.join(evidenceBasePath, entry);
+    const entryPath = path12.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -5049,7 +5005,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path13.join("evidence", sanitizedTaskId);
+  const relativePath = path12.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -5065,10 +5021,10 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path13.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path13.resolve(directory, ".swarm", relativePath);
+  const relativePath = path12.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path12.resolve(directory, ".swarm", relativePath);
   try {
-    await fs7.access(absolutePath);
+    await fs6.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
@@ -5292,4 +5248,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, initDurableStatusPath, getAllWorktreeMergeFailures, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, IdentifierSchema, EvaluationTaskV1Schema, GateNameSchema, GateAuditManifestV1Schema, GateAuditResultV1Schema, canonicalJson, canonicalHash, computeTaskInputContentHash, computeTaskSetContentHash, computeManifestContentHash, resolveContainedExistingPath, admitEvaluationTask, saveTaskSetSnapshot, saveGateAuditResult, saveGateAuditManifest, readGateAuditManifest, readGateAuditResult, listGateAuditResults, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { getExecutor, init_executor, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, normalizePath, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, computeSpecHash, loadPlanJsonOnly, loadPlan, savePlan, closePlanTerminalState, derivePlanMarkdown, IdentifierSchema, EvaluationTaskV1Schema, GateNameSchema, GateAuditManifestV1Schema, GateAuditResultV1Schema, canonicalJson, canonicalHash, computeTaskInputContentHash, computeTaskSetContentHash, computeManifestContentHash, resolveContainedExistingPath, admitEvaluationTask, saveTaskSetSnapshot, saveGateAuditResult, saveGateAuditManifest, readGateAuditManifest, readGateAuditResult, listGateAuditResults, isValidEvidenceType, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };