opencode-swarm 7.130.2 → 7.131.0

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

@@ -3432,11 +3432,11 @@ import {
 } from "fs";
 import * as fs7 from "fs/promises";
 import * as os4 from "os";
-import * as path12 from "path";
+import * as path13 from "path";
 
 // src/evaluation/retention.ts
 import * as fs5 from "fs/promises";
-import * as path11 from "path";
+import * as path12 from "path";
 
 // src/evaluation/contracts.ts
 init_zod();
@@ -3811,14 +3811,55 @@ var TaskSetSnapshotV1Schema = exports_external.object({
 }).strict();
 
 // src/evaluation/store.ts
-import { mkdir, readdir, readFile as readFile2 } from "fs/promises";
-import * as path10 from "path";
+import { mkdir as mkdir2, readdir, readFile as readFile3 } from "fs/promises";
+import * as path11 from "path";
+
+// src/evidence/immutable-store.ts
+import { mkdir, readFile } from "fs/promises";
+import * as path9 from "path";
+async function readOptionalFile(filePath) {
+  try {
+    return await readFile(filePath, "utf8");
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return;
+    throw error2;
+  }
+}
+async function writeImmutableArtifact(options) {
+  await mkdir(path9.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);
+    if (existing !== undefined) {
+      let parsed;
+      try {
+        parsed = options.parse(JSON.parse(existing));
+      } catch (error2) {
+        throw options.conflictError({
+          kind: "corrupt",
+          filePath: options.filePath,
+          cause: error2
+        });
+      }
+      if (options.serialize(parsed) === desired || options.isEquivalent?.(parsed, options.value)) {
+        return parsed;
+      }
+      throw options.conflictError({
+        kind: "divergent",
+        filePath: options.filePath
+      });
+    }
+    await atomicWriteFile(options.filePath, desired);
+    return options.value;
+  });
+}
 
 // src/evaluation/hashing.ts
 import { createHash as createHash2 } from "crypto";
 import { lstatSync, realpathSync } from "fs";
-import { lstat, opendir, readFile, realpath } from "fs/promises";
-import * as path9 from "path";
+import { lstat, opendir, readFile as readFile2, realpath } from "fs/promises";
+import * as path10 from "path";
 function canonicalize(value, ancestors) {
   if (value === null || typeof value === "string" || typeof value === "boolean") {
     return value;
@@ -3909,7 +3950,7 @@ async function hashTree(projectRoot, relativePath, budget) {
     }
     if (!entryAlreadyCharged)
       chargeHashEntry(budget);
-    const relative2 = path9.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
+    const relative2 = path10.relative(canonicalRoot, absolutePath).replace(/\\/g, "/");
     if (stat.isDirectory()) {
       entries.push({ path: relative2, type: "directory" });
       const children = [];
@@ -3926,7 +3967,7 @@ async function hashTree(projectRoot, relativePath, budget) {
         await closeDirectory(directory);
       }
       for (const child of children.sort()) {
-        await visit(path9.join(absolutePath, child), true);
+        await visit(path10.join(absolutePath, child), true);
       }
       return;
     }
@@ -3969,10 +4010,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 = path9.relative(canonicalRoot, target).replace(/\\/g, "/");
+    const targetRelative = path10.relative(canonicalRoot, target).replace(/\\/g, "/");
     return (await hashTree(projectRoot, relativePath, budget)).map((entry) => ({
       ...entry,
-      path: path9.posix.relative(targetRelative, entry.path) || "."
+      path: path10.posix.relative(targetRelative, entry.path) || "."
     }));
   };
   const scorerArgv = [...task.scorer.argv];
@@ -4001,11 +4042,11 @@ function computeManifestContentHash(manifest) {
   return contentHashWithout(manifest, ["contentHash"]);
 }
 function isWithin(root, candidate) {
-  const relative2 = path9.relative(root, candidate);
-  return relative2 === "" || !relative2.startsWith("..") && !path9.isAbsolute(relative2);
+  const relative2 = path10.relative(root, candidate);
+  return relative2 === "" || !relative2.startsWith("..") && !path10.isAbsolute(relative2);
 }
 function resolveContainedExistingPath(root, relativePath) {
-  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+  if (path10.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);
@@ -4017,7 +4058,7 @@ function resolveContainedExistingPath(root, relativePath) {
   for (const segment of segments) {
     if (segment === ".")
       continue;
-    cursor = path9.join(cursor, segment);
+    cursor = path10.join(cursor, segment);
     const stat = lstatSync(cursor);
     if (stat.isSymbolicLink()) {
       throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
@@ -4030,7 +4071,7 @@ function resolveContainedExistingPath(root, relativePath) {
   return canonicalCandidate;
 }
 async function resolveContainedExistingPathAsync(root, relativePath) {
-  if (path9.isAbsolute(relativePath) || /^(?:[A-Za-z]:[\\/]|[\\/]{1,2})/.test(relativePath) || relativePath.includes("\x00")) {
+  if (path10.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);
@@ -4042,7 +4083,7 @@ async function resolveContainedExistingPathAsync(root, relativePath) {
   for (const segment of segments) {
     if (segment === ".")
       continue;
-    cursor = path9.join(cursor, segment);
+    cursor = path10.join(cursor, segment);
     const stat = await _internals9.lstat(cursor);
     if (stat.isSymbolicLink()) {
       throw new Error(`evaluation path contains a symlink or reparse point: ${relativePath}`);
@@ -4057,14 +4098,14 @@ async function resolveContainedExistingPathAsync(root, relativePath) {
 var _internals9 = {
   lstat,
   opendir,
-  readFile,
+  readFile: readFile2,
   realpath
 };
 
 // src/evaluation/store.ts
 var AGENT = "evaluation-store";
-var TEST_LEDGER_RELATIVE = path10.join("evolution", "test-consumption.jsonl");
-var TASK_SPLIT_REGISTRY_RELATIVE = path10.join("evolution", "tasks", "split-registry.json");
+var TEST_LEDGER_RELATIVE = path11.join("evolution", "test-consumption.jsonl");
+var TASK_SPLIT_REGISTRY_RELATIVE = path11.join("evolution", "tasks", "split-registry.json");
 
 class EvaluationConflictError extends Error {
   constructor(message) {
@@ -4073,7 +4114,7 @@ class EvaluationConflictError extends Error {
   }
 }
 function swarmPath(directory, ...segments) {
-  return path10.join(directory, ".swarm", ...segments);
+  return path11.join(directory, ".swarm", ...segments);
 }
 function serialized(value) {
   return `${canonicalJson(value)}
@@ -4112,34 +4153,15 @@ function parseTaskSplitRegistry(content) {
   });
   return { v: 1, entries };
 }
-async function readOptional(filePath) {
-  try {
-    return await readFile2(filePath, "utf8");
-  } catch (error2) {
-    if (error2.code === "ENOENT")
-      return;
-    throw error2;
-  }
+function evaluationConflictError(conflict) {
+  return conflict.kind === "corrupt" ? new EvaluationConflictError(`existing evaluation artifact is corrupt: ${conflict.filePath}: ${String(conflict.cause)}`) : new EvaluationConflictError(`immutable evaluation artifact conflicts with existing content: ${conflict.filePath}`);
 }
-async function writeImmutable(options) {
-  await mkdir(path10.dirname(options.filePath), { recursive: true });
-  return withEvidenceLock(options.directory, options.relativeLockPath, AGENT, options.taskId, async () => {
-    const desired = serialized(options.value);
-    const existing = await readOptional(options.filePath);
-    if (existing !== undefined) {
-      let parsed;
-      try {
-        parsed = options.parse(JSON.parse(existing));
-      } catch (error2) {
-        throw new EvaluationConflictError(`existing evaluation artifact is corrupt: ${options.filePath}: ${String(error2)}`);
-      }
-      if (serialized(parsed) === desired || options.isEquivalent?.(parsed, options.value)) {
-        return parsed;
-      }
-      throw new EvaluationConflictError(`immutable evaluation artifact conflicts with existing content: ${options.filePath}`);
-    }
-    await atomicWriteFile(options.filePath, desired);
-    return options.value;
+function writeImmutable(options) {
+  return writeImmutableArtifact({
+    ...options,
+    agent: AGENT,
+    serialize: serialized,
+    conflictError: evaluationConflictError
   });
 }
 function validateTaskInputs(directory, task) {
@@ -4150,8 +4172,8 @@ function validateTaskInputs(directory, task) {
     if (!executable)
       throw new Error("project scorer requires an executable");
     const scorerPath = resolveContainedExistingPath(directory, executable);
-    const relative3 = path10.relative(environmentRoot, scorerPath);
-    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path10.sep}`) || path10.isAbsolute(relative3)) {
+    const relative3 = path11.relative(environmentRoot, scorerPath);
+    if (!relative3 || relative3 === ".." || relative3.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative3)) {
       throw new Error("project scorer executable must be inside the admitted task environment");
     }
   }
@@ -4163,13 +4185,13 @@ async function admitEvaluationTask(directory, input, inputRoot = directory) {
   }
   validateTaskInputs(inputRoot, task);
   const lineageInputHash = await computeTaskLineageInputHash(inputRoot, task);
-  const relative3 = path10.join("evolution", "tasks", task.split, `${task.id}.json`);
+  const relative3 = path11.join("evolution", "tasks", task.split, `${task.id}.json`);
   const admissionLock = TASK_SPLIT_REGISTRY_RELATIVE;
   const filePath = swarmPath(directory, relative3);
-  await mkdir(path10.dirname(filePath), { recursive: true });
+  await mkdir2(path11.dirname(filePath), { recursive: true });
   return withEvidenceLock(directory, admissionLock, AGENT, task.id, async () => {
     const registryPath = swarmPath(directory, TASK_SPLIT_REGISTRY_RELATIVE);
-    const registry = parseTaskSplitRegistry(await readOptional(registryPath));
+    const registry = parseTaskSplitRegistry(await readOptionalFile(registryPath));
     const existingTaskEntry = registry.entries.find((entry) => entry.taskIds.includes(task.id));
     if (existingTaskEntry && existingTaskEntry.split !== task.split) {
       throw new EvaluationConflictError(`task ${task.id} is already admitted to a different split`);
@@ -4185,12 +4207,12 @@ async function admitEvaluationTask(directory, input, inputRoot = directory) {
     for (const split of ["train", "validation", "test"]) {
       if (split === task.split)
         continue;
-      if (await readOptional(swarmPath(directory, "evolution", "tasks", split, `${task.id}.json`))) {
+      if (await readOptionalFile(swarmPath(directory, "evolution", "tasks", split, `${task.id}.json`))) {
         throw new EvaluationConflictError(`task ${task.id} is already admitted to a different split`);
       }
     }
     const desired = serialized(task);
-    const existing = await readOptional(filePath);
+    const existing = await readOptionalFile(filePath);
     if (existing !== undefined) {
       const parsed = EvaluationTaskV1Schema.parse(JSON.parse(existing));
       if (serialized(parsed) === desired) {
@@ -4254,7 +4276,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 = path10.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
+  const relative3 = path11.join("evolution", "task-sets", `${snapshot.contentHash}.json`);
   return writeImmutable({
     directory,
     relativeLockPath: relative3,
@@ -4267,7 +4289,7 @@ async function saveTaskSetSnapshot(directory, input, inputRoot = directory) {
 }
 async function saveGateAuditResult(directory, input) {
   const result = GateAuditResultV1Schema.parse(input);
-  const relative3 = path10.join("evidence", "gate-audit", result.runId, "results.json");
+  const relative3 = path11.join("evidence", "gate-audit", result.runId, "results.json");
   return writeImmutable({
     directory,
     relativeLockPath: relative3,
@@ -4279,7 +4301,7 @@ async function saveGateAuditResult(directory, input) {
 }
 async function saveGateAuditManifest(directory, input) {
   const manifest = GateAuditManifestV1Schema.parse(input);
-  const relative3 = path10.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
+  const relative3 = path11.join("evolution", "gate-audit-manifests", `${manifest.id}.json`);
   return writeImmutable({
     directory,
     relativeLockPath: relative3,
@@ -4290,11 +4312,11 @@ async function saveGateAuditManifest(directory, input) {
   });
 }
 async function readGateAuditManifest(directory, runId) {
-  const content = await readOptional(swarmPath(directory, "evolution", "gate-audit-manifests", `${runId}.json`));
+  const content = await readOptionalFile(swarmPath(directory, "evolution", "gate-audit-manifests", `${runId}.json`));
   return content === undefined ? undefined : GateAuditManifestV1Schema.parse(JSON.parse(content));
 }
 async function readGateAuditResult(directory, runId) {
-  const content = await readOptional(swarmPath(directory, "evidence", "gate-audit", runId, "results.json"));
+  const content = await readOptionalFile(swarmPath(directory, "evidence", "gate-audit", runId, "results.json"));
   return content === undefined ? undefined : GateAuditResultV1Schema.parse(JSON.parse(content));
 }
 async function listGateAuditResults(directory) {
@@ -4315,7 +4337,7 @@ async function listGateAuditResults(directory) {
       continue;
     }
     try {
-      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile2(path10.join(root, entry.name, "results.json"), "utf8")));
+      const parsed = GateAuditResultV1Schema.parse(JSON.parse(await readFile3(path11.join(root, entry.name, "results.json"), "utf8")));
       if (parsed.runId !== entry.name)
         throw new Error("run id/path mismatch");
       results.push(parsed);
@@ -4336,7 +4358,7 @@ function parseTestLedger(content) {
 }
 async function getProtectedEvaluationRunIds(directory) {
   const protectedIds = new Set;
-  const ledger = await readOptional(swarmPath(directory, TEST_LEDGER_RELATIVE));
+  const ledger = await readOptionalFile(swarmPath(directory, TEST_LEDGER_RELATIVE));
   for (const claim of parseTestLedger(ledger ?? ""))
     protectedIds.add(claim.runId);
   const decisionsDirectory = swarmPath(directory, "evolution", "decisions");
@@ -4348,7 +4370,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 readFile2(path10.join(decisionsDirectory, filename), "utf8")));
+    const decision = PromotionDecisionV1Schema.parse(JSON.parse(await readFile3(path11.join(decisionsDirectory, filename), "utf8")));
     protectedIds.add(decision.runId);
     protectedIds.add(decision.lineage.baselineRunId);
     if (decision.lineage.historicalBestRunId !== "unavailable") {
@@ -4366,7 +4388,7 @@ function validId(value) {
   return /^[A-Za-z0-9][A-Za-z0-9._-]{0,159}$/.test(value);
 }
 async function evaluationRunCandidates(directory) {
-  const root = path11.join(directory, ".swarm", "evolution", "runs");
+  const root = path12.join(directory, ".swarm", "evolution", "runs");
   let entries = [];
   try {
     entries = await fs5.readdir(root, { withFileTypes: true });
@@ -4385,7 +4407,7 @@ async function evaluationRunCandidates(directory) {
     if (!validId(id))
       continue;
     const artifact = { namespace: "evaluation-run", id };
-    const target = path11.join(root, entry.name);
+    const target = path12.join(root, entry.name);
     try {
       const run = EvaluationRunV1Schema.parse(JSON.parse(await fs5.readFile(target, "utf8")));
       if (run.runId !== id)
@@ -4403,7 +4425,7 @@ async function evaluationRunCandidates(directory) {
   return { candidates, corrupt };
 }
 async function gateAuditCandidates(directory) {
-  const root = path11.join(directory, ".swarm", "evidence", "gate-audit");
+  const root = path12.join(directory, ".swarm", "evidence", "gate-audit");
   let entries = [];
   try {
     entries = await fs5.readdir(root, { withFileTypes: true });
@@ -4419,9 +4441,9 @@ async function gateAuditCandidates(directory) {
     if (!entry.isDirectory() || !validId(entry.name))
       continue;
     const artifact = { namespace: "gate-audit", id: entry.name };
-    const target = path11.join(root, entry.name);
+    const target = path12.join(root, entry.name);
     try {
-      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs5.readFile(path11.join(target, "results.json"), "utf8")));
+      const result = GateAuditResultV1Schema.parse(JSON.parse(await fs5.readFile(path12.join(target, "results.json"), "utf8")));
       if (result.runId !== entry.name)
         throw new Error("run id/path mismatch");
       candidates.push({
@@ -4462,7 +4484,7 @@ var _retentionInternals = {
   removeCandidate
 };
 async function archiveEvaluationArtifacts(args) {
-  return withEvidenceLock(args.directory, path11.join("evolution", "retention-index"), "evaluation-retention", "archive", async () => {
+  return withEvidenceLock(args.directory, path12.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);
@@ -4785,8 +4807,8 @@ function isWeakConfigContainerRoot(directory) {
     const resolved = realpathSync2(directory);
     return resolved === realpathSync2(os4.tmpdir()) || resolved === realpathSync2(os4.homedir());
   } catch {
-    const resolved = path12.resolve(directory);
-    return resolved === path12.resolve(os4.tmpdir()) || resolved === path12.resolve(os4.homedir());
+    const resolved = path13.resolve(directory);
+    return resolved === path13.resolve(os4.tmpdir()) || resolved === path13.resolve(os4.homedir());
   }
 }
 function hasAccessibleProjectIndicator(directory, options = {}) {
@@ -4796,7 +4818,7 @@ function hasAccessibleProjectIndicator(directory, options = {}) {
       continue;
     }
     try {
-      const indicatorStat = statSync2(path12.join(directory, indicator));
+      const indicatorStat = statSync2(path13.join(directory, indicator));
       if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
         return true;
       }
@@ -4818,14 +4840,14 @@ function validateProjectRoot(directory) {
     if (depth >= MAX_DEPTH)
       break;
     depth++;
-    const parent = path12.dirname(current);
+    const parent = path13.dirname(current);
     if (parent === current)
       break;
-    if (path12.dirname(parent) === parent) {
+    if (path13.dirname(parent) === parent) {
       current = parent;
       continue;
     }
-    const parentSwarm = path12.join(parent, ".swarm");
+    const parentSwarm = path13.join(parent, ".swarm");
     try {
       if (statSync2(parentSwarm).isDirectory()) {
         if (hasAccessibleProjectIndicator(parent, {
@@ -4846,12 +4868,12 @@ function validateProjectRoot(directory) {
 async function saveEvidence(directory, taskId, evidence) {
   _internals11.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path13.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 = path12.dirname(evidencePath);
+    const evidenceDir = path13.dirname(evidencePath);
     let bundle;
     const existingContent = await readSwarmFileAsync(directory, relativePath);
     if (existingContent !== null) {
@@ -4894,7 +4916,7 @@ async function saveEvidence(directory, taskId, evidence) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
     mkdirSync5(evidenceDir, { recursive: true });
-    const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+    const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
       await fs7.rename(tempPath, evidencePath);
@@ -4936,9 +4958,9 @@ function wrapFlatRetrospective(flatEntry, taskId) {
     entries: [remappedEntry]
   };
 }
-async function loadEvidence(directory, taskId) {
+async function loadEvidence(directory, taskId, options) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
+  const relativePath = path13.join("evidence", sanitizedTaskId, "evidence.json");
   if (relativePath.length > 4096) {
     return { status: "not_found" };
   }
@@ -4957,11 +4979,14 @@ async function loadEvidence(directory, taskId) {
     const wrappedBundle = _internals11.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
+      if (options?.migrate === false) {
+        return { status: "found", bundle: validated };
+      }
       try {
         await withEvidenceLock(directory, relativePath, "evidence-loader", sanitizedTaskId, async () => {
-          const evidenceDir = path12.dirname(evidencePath);
+          const evidenceDir = path13.dirname(evidencePath);
           const bundleJson = JSON.stringify(validated);
-          const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
+          const tempPath = path13.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
             await fs7.rename(tempPath, evidencePath);
@@ -5006,7 +5031,7 @@ async function listEvidenceTaskIds(directory) {
   }
   const taskIds = [];
   for (const entry of entries) {
-    const entryPath = path12.join(evidenceBasePath, entry);
+    const entryPath = path13.join(evidenceBasePath, entry);
     try {
       const stats = statSync2(entryPath);
       if (!stats.isDirectory()) {
@@ -5024,7 +5049,7 @@ async function listEvidenceTaskIds(directory) {
 }
 async function deleteEvidence(directory, taskId) {
   const sanitizedTaskId = sanitizeTaskId2(taskId);
-  const relativePath = path12.join("evidence", sanitizedTaskId);
+  const relativePath = path13.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
     statSync2(evidenceDir);
@@ -5040,8 +5065,8 @@ async function deleteEvidence(directory, taskId) {
   }
 }
 async function checkRequirementCoverage(phase, directory) {
-  const relativePath = path12.join("evidence", `req-coverage-phase-${phase}.json`);
-  const absolutePath = path12.resolve(directory, ".swarm", relativePath);
+  const relativePath = path13.join("evidence", `req-coverage-phase-${phase}.json`);
+  const absolutePath = path13.resolve(directory, ".swarm", relativePath);
   try {
     await fs7.access(absolutePath);
     return { exists: true, path: absolutePath };

package/dist/cli/{index-xa29259t.js → index-1atz85c8.js}

@@ -4,7 +4,7 @@ import {
 } from "./index-rtry5xyf.js";
 import {
   readKnowledgeEvents
-} from "./index-jxha73tm.js";
+} from "./index-fepakwhp.js";
 import {
   isLinked,
   readLinkPointer,

package/dist/cli/{index-6fqj8fcp.js → index-6vg0qczz.js}

@@ -12,14 +12,14 @@ import {
   detectPosixWrites,
   detectWindowsWrites,
   resolveWriteTargets
-} from "./index-etdgtk3m.js";
+} from "./index-d2tgc580.js";
 import {
   checkFileAuthority,
   classifyFile,
   isInDeclaredScope,
   redactPath,
   redactShellCommand
-} from "./index-hjar4crm.js";
+} from "./index-cq22pnd2.js";
 
 // src/services/guardrail-explain-service.ts
 import path from "path";

package/dist/cli/{index-zft4hp35.js → index-cnwh164k.js}

@@ -2,7 +2,7 @@
 import {
   redactPath,
   redactShellCommand
-} from "./index-hjar4crm.js";
+} from "./index-cq22pnd2.js";
 
 // src/services/guardrail-log-service.ts
 import * as fs from "fs/promises";

package/dist/cli/{index-hjar4crm.js → index-cq22pnd2.js}

@@ -3,7 +3,7 @@ import {
   init_constants,
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-5xxgeksy.js";
+} from "./index-hynbzh7s.js";
 import {
   init_logger,
   warn