opencode-swarm 7.178.0 → 7.178.1

package/dist/cli/{index-jzxeymr0.js → index-h0kyy9rd.js}

@@ -3,7 +3,7 @@ import {
   EvaluationRunV1Schema,
   GateAuditResultV1Schema,
   getProtectedEvaluationRunIds
-} from "./index-mpcp6rmj.js";
+} from "./index-7n4dtzk4.js";
 import {
   readEffectiveSpecSync
 } from "./index-n1tcj1q7.js";
@@ -23,13 +23,13 @@ import {
   readTaskEvidence,
   readTaskEvidenceRaw,
   sanitizeTaskId
-} from "./index-kfk403mc.js";
+} from "./index-1hgqs8j8.js";
 import {
   estimateCharsForTokens,
   estimateTokens,
   readSwarmFileAsync,
   validateSwarmPath
-} from "./index-zmb8fjp5.js";
+} from "./index-s4bkey0q.js";
 import {
   bunHash,
   bunWrite,
@@ -58,10 +58,10 @@ import {
   replayFromLedgerWithStatus,
   takeSnapshotEvent,
   takeSnapshotWithRetry
-} from "./index-ke3m026z.js";
+} from "./index-ksq6cqg0.js";
 import {
   appendCoreEventSync
-} from "./index-j1v54ahd.js";
+} from "./index-w1b5qqnp.js";
 import {
   derivePlanId,
   derivePlanIdentityHash,
@@ -69,32 +69,34 @@ import {
   importCoordinationOnce,
   listCoordinationStates,
   transitionCoordinationState
-} from "./index-w4yjy3vp.js";
+} from "./index-whjrhatw.js";
 import {
   DURABILITY_CLASSES,
   getProjectDb,
   projectDbExists,
   withDurabilityClass
-} from "./index-tnjmn0dn.js";
+} from "./index-nzekzzs2.js";
 import {
   assertProjectRoot,
   tryAcquireLock,
   withEvidenceLock
-} from "./index-j3rkh9mp.js";
+} from "./index-kz9pcqn9.js";
 import {
   emit
-} from "./index-wfbh1bx8.js";
+} from "./index-pk97v7b8.js";
 import {
   atomicWriteSwarmFileSync,
   invalidateCachedArtifact,
   readCachedParsedFile
-} from "./index-zsp9de3k.js";
+} from "./index-ne9zamcs.js";
 import {
   canonicalRootKeyFresh
 } from "./index-1xnse449.js";
 import {
-  PlanSchema
-} from "./index-18hjycr1.js";
+  PlanSchema,
+  normalizeCurrentPhaseInPlace,
+  resolveActivePhaseId
+} from "./index-qbs49vge.js";
 import {
   GIT_BINARY_ENV_VAR,
   describeGitResolution,
@@ -116,6 +118,9 @@ import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
 
 // src/plan/manager.ts
 import {
@@ -128,7 +133,7 @@ import {
   writeFileSync
 } from "fs";
 import * as fsPromises from "fs/promises";
-import * as path4 from "path";
+import * as path3 from "path";
 
 // src/db/task-checkpoint-receipt.ts
 import { createHash } from "crypto";
@@ -1545,156 +1550,10 @@ var _internals3 = {
   }
 };
 
-// src/turbo/lean/conflicts.ts
-import * as fs3 from "fs";
-import * as path3 from "path";
-
-// src/utils/path.ts
-function normalizePath(p) {
-  if (!p)
-    return "";
-  let result = p.replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^\.\//, "").replace(/(?:^|\/)\.\//g, "/");
-  result = result.replace(/\/$/, "");
-  result = result.replace(/\/\.$/, "");
-  if (process.platform === "win32")
-    result = result.toLowerCase();
-  if (!result) {
-    const norm = p.replace(/\\/g, "/");
-    if (norm === "." || norm === "./")
-      return ".";
-    return "";
-  }
-  return result;
-}
-
-// src/turbo/lean/conflicts.ts
-var DEFAULT_GLOBAL_FILES = [
-  "package.json",
-  "package-lock.json",
-  "bun.lock",
-  "bun.lockb",
-  "pnpm-lock.yaml",
-  "yarn.lock",
-  "Cargo.lock",
-  "Gemfile.lock",
-  "composer.lock",
-  "poetry.lock",
-  "go.mod",
-  "go.sum",
-  "tsconfig.json",
-  "bunfig.toml",
-  "CHANGELOG.md",
-  ".release-please-manifest.json",
-  "src/index.ts",
-  "src/tools/index.ts",
-  "src/agents/index.ts",
-  "src/config/index.ts",
-  "src/hooks/index.ts",
-  "turbo.json",
-  "nx.json",
-  "packageManager",
-  ".npmrc",
-  ".nvmrc",
-  ".node-version"
-];
-var DEFAULT_PROTECTED_PATTERNS = [
-  "guardrail",
-  "delegation",
-  "authority",
-  "permission",
-  "crypto",
-  "secret",
-  "security",
-  "auth",
-  "/auth/",
-  "/auth.",
-  "auth.",
-  ".env",
-  "credentials",
-  "secrets",
-  "private",
-  "/security/",
-  "/security.",
-  "/protect/",
-  "/protect."
-];
-var BARREL_FILE_PATTERNS = [
-  /\/index\.ts$/,
-  /\/index\.tsx$/,
-  /\/index\.js$/,
-  /\/index\.mjs$/,
-  /\/exports\.ts$/,
-  /\/types\.ts$/
-];
-function pathsConflict(path1, path22) {
-  if (process.platform === "win32") {
-    path1 = path1.toLowerCase();
-    path22 = path22.toLowerCase();
-  }
-  if (path1 === path22) {
-    return true;
-  }
-  const [shorter, longer] = path1.length <= path22.length ? [path1, path22] : [path22, path1];
-  if (longer.startsWith(`${shorter}/`)) {
-    return true;
-  }
-  return false;
-}
-function isGlobalFile(normalizedPath) {
-  if (DEFAULT_GLOBAL_FILES.some((gf) => normalizedPath.endsWith(gf))) {
-    return true;
-  }
-  for (const pattern of BARREL_FILE_PATTERNS) {
-    if (pattern.test(normalizedPath)) {
-      return true;
-    }
-  }
-  return false;
-}
-function isProtectedPath(normalizedPath) {
-  const lowerPath = normalizedPath.toLowerCase();
-  for (const pattern of DEFAULT_PROTECTED_PATTERNS) {
-    if (lowerPath.includes(pattern.toLowerCase())) {
-      if (pattern === "auth" || pattern === "/auth/") {
-        if (lowerPath === "auth" || lowerPath.endsWith("/auth") || lowerPath.includes("/auth/")) {
-          return true;
-        }
-      } else if (pattern === "auth.") {
-        const idx = lowerPath.indexOf("auth.");
-        if (idx !== -1) {
-          const before = idx === 0 || lowerPath[idx - 1] === "/";
-          if (before) {
-            return true;
-          }
-        }
-      } else {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-function readTaskScopes(directory, taskId) {
-  const scopePath = path3.join(directory, ".swarm", "scopes", `scope-${taskId}.json`);
-  try {
-    if (!fs3.existsSync(scopePath)) {
-      return null;
-    }
-    const raw = fs3.readFileSync(scopePath, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || !Array.isArray(parsed.files)) {
-      return null;
-    }
-    return parsed.files;
-  } catch {
-    return null;
-  }
-}
-
 // src/utils/spec-hash.ts
 import { createHash as createHash4 } from "crypto";
 import * as fsSync2 from "fs";
-import { join as join3 } from "path";
+import { join as join2 } from "path";
 async function computeSpecHash(directory) {
   const spec = _internals4.readEffectiveSpecSync(directory);
   if (!spec)
@@ -1723,7 +1582,7 @@ async function isSpecStale(directory, plan) {
   return { stale: false };
 }
 function isObligationPreserving(directory) {
-  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join2(directory, ".swarm", "spec-snapshot.md");
   try {
     let recordedContent;
     try {
@@ -1769,7 +1628,7 @@ var _internals4 = {
   readEffectiveSpecSync
 };
 function computeSpecDiff(directory) {
-  const snapshotPath = join3(directory, ".swarm", "spec-snapshot.md");
+  const snapshotPath = join2(directory, ".swarm", "spec-snapshot.md");
   let recordedContent;
   try {
     const snapshotSize = fsSync2.statSync(snapshotPath).size;
@@ -1888,7 +1747,6 @@ var _internals5 = {
   regeneratePlanMarkdown,
   isGitRepo,
   isEpicModeActiveForProject,
-  readTaskScopes,
   commitTaskCompletion,
   getWorktreeMergeFailure,
   recordTaskAttempt
@@ -2042,7 +1900,7 @@ async function surfaceLedgerStaleIfPersisted(directory, plan) {
   return plan;
 }
 async function parsePlanJsonCached(directory) {
-  const planJsonPath = path4.resolve(directory, ".swarm", "plan.json");
+  const planJsonPath = path3.resolve(directory, ".swarm", "plan.json");
   return readCachedParsedFile(planJsonPath, PLAN_JSON_CACHE_NAMESPACE, () => _internals5.readPlanJsonUtf8(directory), (planJsonContent) => {
     if (planJsonContent.includes("\x00")) {
       throw new Error("Plan rejected: .swarm/plan.json contains null bytes");
@@ -2110,13 +1968,13 @@ async function isPlanMdInSync(directory, plan, cache) {
 }
 async function regeneratePlanMarkdown(directory, plan) {
   assertProjectRoot(directory);
-  const swarmDir = path4.resolve(directory, ".swarm");
+  const swarmDir = path3.resolve(directory, ".swarm");
   const contentHash = computePlanContentHash(plan);
   const markdown = derivePlanMarkdown(plan);
   const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-  const mdPath = path4.join(swarmDir, "plan.md");
-  const mdTempPath = path4.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const mdPath = path3.join(swarmDir, "plan.md");
+  const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(mdTempPath, markdownWithHash);
     renameSync2(mdTempPath, mdPath);
@@ -2229,7 +2087,7 @@ async function loadPlan(directory, cache) {
                 try {
                   assertProjectRoot(directory);
                   const diffInfo = computeSpecDiff(directory);
-                  const specStalenessPath = path4.join(directory, ".swarm", "spec-staleness.json");
+                  const specStalenessPath = path3.join(directory, ".swarm", "spec-staleness.json");
                   await fsPromises.writeFile(specStalenessPath, JSON.stringify({
                     type: "spec_stale_detected",
                     timestamp: new Date().toISOString(),
@@ -2553,6 +2411,7 @@ async function savePlan(directory, plan, options) {
     } catch {}
   }
   derivePhaseStatusesInPlace(validated);
+  normalizeCurrentPhaseInPlace(validated);
   const currentPlan = await _internals5.loadPlanJsonOnly(directory);
   const planId = derivePlanId(validated);
   const planHashForInit = computePlanLedgerHash(validated);
@@ -2750,9 +2609,9 @@ async function savePlan(directory, plan, options) {
       source: "savePlan_manager"
     });
   }
-  const swarmDir = path4.resolve(directory, ".swarm");
-  const planPath = path4.join(swarmDir, "plan.json");
-  const tempPath = path4.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path3.resolve(directory, ".swarm");
+  const planPath = path3.join(swarmDir, "plan.json");
+  const tempPath = path3.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await bunWrite(tempPath, JSON.stringify(projectedPlan, null, 2));
     options?.preCommitCheck?.();
@@ -2765,7 +2624,7 @@ async function savePlan(directory, plan, options) {
   invalidateCachedArtifact(planPath);
   await _internals5.verifyWrittenPlanJson(directory, projectedPlan);
   try {
-    const markerPath = path4.join(swarmDir, ".plan-write-marker");
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -2781,8 +2640,8 @@ async function savePlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(projectedPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdPath = path4.join(swarmDir, "plan.md");
-    const mdTempPath = path4.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdPath = path3.join(swarmDir, "plan.md");
+    const mdTempPath = path3.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     try {
       await bunWrite(mdTempPath, markdownWithHash);
       renameSync2(mdTempPath, mdPath);
@@ -2805,7 +2664,7 @@ ${markdown}`;
     } catch {}
   }
   try {
-    const markerPath = path4.join(swarmDir, ".plan-write-marker");
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
     const tasksCount = projectedPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
     const marker = JSON.stringify({
       source: "plan_manager",
@@ -2861,11 +2720,11 @@ async function rebuildPlan(directory, plan, options) {
   const targetPlan = plan ?? await replayFromLedger(directory);
   if (!targetPlan)
     return null;
-  const swarmDir = path4.join(directory, ".swarm");
-  const planPath = path4.join(swarmDir, "plan.json");
-  const mdPath = path4.join(swarmDir, "plan.md");
+  const swarmDir = path3.join(directory, ".swarm");
+  const planPath = path3.join(swarmDir, "plan.json");
+  const mdPath = path3.join(swarmDir, "plan.md");
   mkdirSync2(swarmDir, { recursive: true });
-  const tempPlanPath = path4.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const tempPlanPath = path3.join(swarmDir, `plan.json.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   {
     const fd = openSync(tempPlanPath, "w");
     try {
@@ -2878,7 +2737,7 @@ async function rebuildPlan(directory, plan, options) {
   renameSync2(tempPlanPath, planPath);
   invalidateCachedArtifact(planPath);
   try {
-    const markerPath = path4.join(swarmDir, ".plan-write-marker");
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager",
       timestamp: new Date().toISOString(),
@@ -2893,13 +2752,13 @@ async function rebuildPlan(directory, plan, options) {
     const markdown = derivePlanMarkdown(targetPlan);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const tempMdPath = path4.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const tempMdPath = path3.join(swarmDir, `plan.md.rebuild.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(tempMdPath, markdownWithHash);
     renameSync2(tempMdPath, mdPath);
     invalidateCachedArtifact(mdPath);
   } finally {
     try {
-      const markerPath = path4.join(swarmDir, ".plan-write-marker");
+      const markerPath = path3.join(swarmDir, ".plan-write-marker");
       const tasksCount = targetPlan.phases.reduce((sum, phase) => sum + phase.tasks.length, 0);
       const marker = JSON.stringify({
         source: "plan_manager",
@@ -2931,6 +2790,7 @@ async function closePlanTerminalState(directory, plan, options) {
   assertProjectRoot(directory);
   const planId = derivePlanId(plan);
   const validated = PlanSchema.parse(plan);
+  normalizeCurrentPhaseInPlace(validated);
   const hashAfter = computePlanLedgerHash(validated);
   for (const taskId of options.closedTaskIds) {
     let taskPhaseId;
@@ -2963,14 +2823,14 @@ async function closePlanTerminalState(directory, plan, options) {
     planHashAfter: hashAfter,
     source: "close_terminal"
   });
-  const swarmDir = path4.join(directory, ".swarm");
-  const planPath = path4.join(swarmDir, "plan.json");
-  const tempPlanPath = path4.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+  const swarmDir = path3.join(directory, ".swarm");
+  const planPath = path3.join(swarmDir, "plan.json");
+  const tempPlanPath = path3.join(swarmDir, `plan.json.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   await bunWrite(tempPlanPath, JSON.stringify(validated, null, 2));
   renameSync2(tempPlanPath, planPath);
   invalidateCachedArtifact(planPath);
   try {
-    const markerPath = path4.join(swarmDir, ".plan-write-marker");
+    const markerPath = path3.join(swarmDir, ".plan-write-marker");
     const inProgressMarker = JSON.stringify({
       source: "plan_manager_close",
       timestamp: new Date().toISOString(),
@@ -2981,18 +2841,18 @@ async function closePlanTerminalState(directory, plan, options) {
     await bunWrite(markerPath, inProgressMarker);
   } catch {}
   try {
-    const mdPath = path4.join(swarmDir, "plan.md");
+    const mdPath = path3.join(swarmDir, "plan.md");
     const contentHash = computePlanContentHash(validated);
     const markdown = derivePlanMarkdown(validated);
     const markdownWithHash = `<!-- PLAN_HASH: ${contentHash} -->
 ${markdown}`;
-    const mdTempPath = path4.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
+    const mdTempPath = path3.join(swarmDir, `plan.md.close.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
     await bunWrite(mdTempPath, markdownWithHash);
     renameSync2(mdTempPath, mdPath);
     invalidateCachedArtifact(mdPath);
   } finally {
     try {
-      const markerPath = path4.join(swarmDir, ".plan-write-marker");
+      const markerPath = path3.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",
@@ -3090,7 +2950,12 @@ async function updateTaskStatus(directory, taskId, status, options) {
               break;
             }
           }
-          const canonicalScope = _internals5.readTaskScopes(directory, taskId);
+          const { readDeclaredScopeFilesFromBindings } = await import("./scope-persistence-8z1hwdr2.js");
+          const canonicalScope = readDeclaredScopeFilesFromBindings({
+            directory,
+            taskId,
+            plan: updatedPlan
+          });
           await _internals5.commitTaskCompletion(directory, taskId, taskDescription, canonicalScope ?? undefined);
         } catch (commitErr) {
           criticalWarn(`[plan/manager] Rule 2 auto-commit for ${taskId} threw (non-fatal): ${commitErr instanceof Error ? commitErr.message : String(commitErr)}`);
@@ -3116,8 +2981,9 @@ function derivePlanMarkdown(plan) {
     closed: "CLOSED"
   };
   const now = new Date().toISOString();
-  const currentPhase = plan.current_phase ?? 1;
-  const phaseStatus = statusMap[plan.phases[currentPhase - 1]?.status] || "PENDING";
+  const currentPhase = resolveActivePhaseId(plan);
+  const currentPhaseObject = plan.phases.find((phase) => phase.id === currentPhase);
+  const phaseStatus = statusMap[currentPhaseObject?.status ?? "pending"] || "PENDING";
   let markdown = `# ${plan.title}
 Swarm: ${plan.swarm}
 Phase: ${currentPhase} [${phaseStatus}] | Updated: ${now}
@@ -3174,7 +3040,7 @@ Phase: ${currentPhase} [${phaseStatus}] | Updated: ${now}
         const sortedFiles = [...task.files_touched].sort();
         suffix += ` (files_touched: ${JSON.stringify(sortedFiles)})`;
       }
-      if (phase.id === plan.current_phase && task.status === "in_progress" && !currentTaskMarked) {
+      if (phase.id === currentPhase && task.status === "in_progress" && !currentTaskMarked) {
         suffix += " \u2190 CURRENT";
         currentTaskMarked = true;
       }
@@ -3411,12 +3277,12 @@ import {
   rmSync,
   statSync as statSync2
 } from "fs";
-import * as fs6 from "fs/promises";
-import * as path6 from "path";
+import * as fs5 from "fs/promises";
+import * as path5 from "path";
 
 // src/evaluation/retention.ts
-import * as fs4 from "fs/promises";
-import * as path5 from "path";
+import * as fs3 from "fs/promises";
+import * as path4 from "path";
 function artifactKey(artifact) {
   return `${artifact.namespace}/${artifact.id}`;
 }
@@ -3424,10 +3290,10 @@ function validId(value) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(value);
 }
 async function evaluationRunCandidates(directory) {
-  const root = path5.join(directory, ".swarm", "evolution", "runs");
+  const root = path4.join(directory, ".swarm", "evolution", "runs");
   let entries = [];
   try {
-    entries = await fs4.readdir(root, { withFileTypes: true });
+    entries = await fs3.readdir(root, { withFileTypes: true });
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return { candidates: [], corrupt: [] };
@@ -3443,9 +3309,9 @@ async function evaluationRunCandidates(directory) {
     if (!validId(id))
       continue;
     const artifact = { namespace: "evaluation-run", id };
-    const target = path5.join(root, entry.name);
+    const target = path4.join(root, entry.name);
     try {
-      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs4.readFile(target, "utf8")));
+      const run = EvaluationRunV1Schema.parse(JSON.parse(await fs3.readFile(target, "utf8")));
       if (run.runId !== id)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -3461,10 +3327,10 @@ async function evaluationRunCandidates(directory) {
   return { candidates, corrupt };
 }
 async function gateAuditCandidates(directory) {
-  const root = path5.join(directory, ".swarm", "evidence", "gate-audit");
+  const root = path4.join(directory, ".swarm", "evidence", "gate-audit");
   let entries = [];
   try {
-    entries = await fs4.readdir(root, { withFileTypes: true });
+    entries = await fs3.readdir(root, { withFileTypes: true });
   } catch (error2) {
     if (error2.code === "ENOENT") {
       return { candidates: [], corrupt: [] };
@@ -3477,9 +3343,9 @@ async function gateAuditCandidates(directory) {
     if (!entry.isDirectory() || !validId(entry.name))
       continue;
     const artifact = { namespace: "gate-audit", id: entry.name };
-    const target = path5.join(root, entry.name);
+    const target = path4.join(root, entry.name);
     try {
-      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs4.readFile(path5.join(target, "results.json"), "utf8")));
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs3.readFile(path4.join(target, "results.json"), "utf8")));
       if (result.runId !== entry.name)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -3510,10 +3376,10 @@ async function protectedArtifacts(directory) {
 }
 async function removeCandidate(candidate) {
   if (candidate.kind === "directory") {
-    await fs4.rm(candidate.target, { recursive: true, force: true });
+    await fs3.rm(candidate.target, { recursive: true, force: true });
     return;
   }
-  await fs4.unlink(candidate.target);
+  await fs3.unlink(candidate.target);
 }
 var _retentionInternals = {
   protectedArtifacts,
@@ -3521,7 +3387,7 @@ var _retentionInternals = {
 };
 async function archiveEvaluationArtifacts(args) {
   assertProjectRoot(args.directory);
-  return withEvidenceLock(args.directory, path5.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
+  return withEvidenceLock(args.directory, path4.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);
@@ -3570,7 +3436,7 @@ async function archiveEvaluationArtifacts(args) {
 }
 
 // src/evidence/documents-retention.ts
-import * as fs5 from "fs";
+import * as fs4 from "fs";
 import * as fsp from "fs/promises";
 import * as readline from "readline";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
@@ -3580,11 +3446,11 @@ var RENAME_BACKOFF_MS = 10;
 var RENAME_RETRY_CODES = new Set(["EPERM", "EBUSY", "ENOTEMPTY", "EACCES"]);
 var _internals6 = {
   stat: (p) => fsp.stat(p),
-  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),
+  createReadStream: (p, options) => fs4.createReadStream(p, options),
+  openSync: (p, flags) => fs4.openSync(p, flags),
+  writeSync: (fd, data, position) => fs4.writeSync(fd, data, position),
+  fsyncSync: (fd) => fs4.fsyncSync(fd),
+  closeSync: (fd) => fs4.closeSync(fd),
   renameWithRetry: atomicRenameWithRetry,
   unlink: (p) => fsp.unlink(p)
 };
@@ -3839,13 +3705,13 @@ async function saveEvidence(directory, taskId, evidence, abortSignal) {
   abortSignal?.throwIfAborted();
   _internals7.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path6.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path5.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
   _internals7.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     abortSignal?.throwIfAborted();
     const evidencePath = validateSwarmPath(directory, relativePath);
-    const evidenceDir = path6.dirname(evidencePath);
+    const evidenceDir = path5.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     abortSignal?.throwIfAborted();
@@ -3889,7 +3755,7 @@ async function saveEvidence(directory, taskId, evidence, abortSignal) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
     mkdirSync3(evidenceDir, { recursive: true });
-    const tempPath = path6.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    const tempPath = path5.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
       abortSignal?.throwIfAborted();
@@ -3935,7 +3801,7 @@ function wrapFlatRetrospective(flatEntry, taskId) {
 }
 async function loadEvidence(directory, taskId, options) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path6.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path5.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -3960,12 +3826,12 @@ async function loadEvidence(directory, taskId, options) {
       try {
         validateProjectRoot(directory);
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path6.dirname(evidencePath);
+          const evidenceDir = path5.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path6.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path5.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs6.rename(tempPath, evidencePath);
+            await fs5.rename(tempPath, evidencePath);
             invalidateCachedArtifact(evidencePath);
           } catch (writeError) {
             try {
@@ -4008,7 +3874,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path6.join(evidenceBasePath, entry);
+    const entryPath = path5.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -4031,7 +3897,7 @@ async function deleteEvidence(directory, taskId) {
   } catch {
     return false;
   }
-  const relativePath = path6.join("evidence", sanitizedTaskId);
+  const relativePath = path5.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -4047,10 +3913,10 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path6.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path6.resolve(directory, ".swarm", relativePath);
+  const relativePath = path5.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path5.resolve(directory, ".swarm", relativePath);
   try {
-    await fs6.access(absolutePath);
+    await fs5.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
@@ -4276,4 +4142,4 @@ function mergeDurableGateEntriesFromEvidence(taskId, entries, evidence) {
   return merged;
 }
 
-export { normalizePath, buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, pathsConflict, isGlobalFile, isProtectedPath, readTaskScopes, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, isValidEvidenceType, isSecretscanEvidence, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, _internals7 as _internals, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };
+export { buildTaskCompletionDescriptor, ensureTaskCheckpointReceipt, updateTaskCheckpointReceipt, MAX_TRANSIENT_RETRIES, isTransientSpawnError, transientBackoff, readLaneEnvFileFromDiskSync, getGitRepositoryStatus, isGitRepo, getDefaultBaseBranch, detectDefaultRemoteBranch, resetToRemoteBranch, resetToMainAfterMerge, isStateUnreadable, loadEpicSessionState, isEpicModeActive, enableEpicMode, disableEpicMode, loadPlanJsonOnly, loadPlan, withPlanLifecycleLock, savePlan, closePlanTerminalState, updateTaskStatus, derivePlanMarkdown, isValidEvidenceType, isSecretscanEvidence, sanitizeTaskId2 as sanitizeTaskId, validateProjectRoot, saveEvidence, loadEvidence, listEvidenceTaskIds, checkRequirementCoverage, archiveEvidence, _internals7 as _internals, readDurableGateEvidence, getDurableGateEvidenceStatus, getDurableGateEvidenceStatusForTask, mergeDurableGateEntriesFromEvidence };