opencode-swarm 7.139.3 → 7.139.5

package/dist/cli/{index-xeyr62x0.js → index-jtg7gtky.js}

@@ -6,13 +6,13 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-z6qe8wft.js";
+} from "./index-9rbwfydj.js";
 import {
   countEntryContradictionsInWindow,
   countEntryViolationsInWindow,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-hwnpd4tw.js";
+} from "./index-px7z3r1c.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -190,11 +190,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-rqj7kech.js");
+    const { quarantineEntry } = await import("./knowledge-validator-rwptbkpz.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-g7rs20c6.js");
-      const { loadPluginConfigWithMeta } = await import("./index-v7g8dnyh.js");
+      const { KnowledgeConfigSchema } = await import("./schema-9v8wgmxf.js");
+      const { loadPluginConfigWithMeta } = await import("./index-hhgbbceq.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-k87hs2ff.js → index-k46me75h.js}

@@ -1,10 +1,10 @@
 // @bun
+import {
+  SwarmError
+} from "./index-ee3x66a5.js";
 import {
   readCachedTextFile
 } from "./index-ed5ykebp.js";
-import {
-  SwarmError
-} from "./index-z6xqpmqg.js";
 import {
   bunFile
 } from "./index-4nt52yr9.js";

package/dist/cli/{index-5hyq2mw6.js → index-ngfw3sd4.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   handleGuardrailExplain
-} from "./index-mzck763x.js";
+} from "./index-9xczz1yh.js";
 import {
   handleGuardrailLog
-} from "./index-bcwx1335.js";
+} from "./index-9jr92bff.js";
 import {
   COMMAND_REGISTRY,
   SWARM_COMMAND_TOOL_ALLOWLIST,
@@ -84,67 +84,67 @@ import {
   handleWriteRetroCommand,
   normalizeSwarmCommandInput,
   resolveCommand
-} from "./index-tkg6rapy.js";
-import"./index-xsxrhakg.js";
-import"./index-ajwmn8gp.js";
-import"./index-0mzz46we.js";
-import"./index-1yd38ajy.js";
-import"./index-4fr94329.js";
-import"./index-hckq2r5m.js";
+} from "./index-2ga0zt4s.js";
+import"./index-41hkt36g.js";
+import"./index-sd657fkp.js";
+import"./index-w9tezcdd.js";
+import"./index-h2zm446q.js";
+import"./index-6nzmp937.js";
+import"./index-nrx08gcr.js";
 import"./index-y8552snf.js";
 import"./index-4905hd2m.js";
 import"./index-134d35c1.js";
-import"./index-6axm8q3s.js";
-import"./index-xeyr62x0.js";
-import"./index-ba5e5e3n.js";
+import"./index-r2bggfra.js";
+import"./index-jtg7gtky.js";
+import"./index-gee0y2d8.js";
 import"./index-6mjf4vr1.js";
 import"./index-c8s9a3zh.js";
 import"./index-9ss2m4rs.js";
+import"./index-0xkjhgrf.js";
+import"./index-xmhhhjjw.js";
+import"./index-556ja8an.js";
+import"./index-6rxgb5r9.js";
+import"./index-1kyex7z2.js";
+import"./index-b8zgtz81.js";
+import"./index-6z0a940s.js";
+import"./index-j77frjq8.js";
+import"./index-k46me75h.js";
+import"./index-ee3x66a5.js";
 import"./index-74hpm6sh.js";
-import"./index-xzzcfwwm.js";
-import"./index-1jbj7vzv.js";
-import"./index-jqn332jx.js";
+import"./index-5z2xps64.js";
+import"./index-8fwhhayc.js";
+import"./index-q1exe2b3.js";
+import"./index-wqk50bv0.js";
+import"./index-0cyqmr36.js";
 import"./index-rtry5xyf.js";
-import"./index-z6qe8wft.js";
-import"./index-hwnpd4tw.js";
+import"./index-9rbwfydj.js";
+import"./index-px7z3r1c.js";
 import"./index-ae75rja9.js";
-import"./index-6mvbjqbt.js";
-import"./index-2eet124q.js";
-import"./index-yawwwhmc.js";
+import"./index-33skgk1a.js";
+import"./index-6r522srn.js";
+import"./index-ed5ykebp.js";
+import"./index-s0qc4gj6.js";
+import"./index-7g4c7s5r.js";
+import"./index-4nt52yr9.js";
+import"./index-fb11cwqr.js";
 import"./index-gprxjmm7.js";
 import"./index-n832052r.js";
+import"./index-1kz6da87.js";
+import"./index-4rhhvd1a.js";
+import"./index-zgwm4ryv.js";
 import {
   init_schema,
   stripKnownSwarmPrefix
-} from "./index-kyz7259r.js";
-import"./index-bk5tah7q.js";
-import"./index-8fwhhayc.js";
-import"./index-q1exe2b3.js";
-import"./index-5syvwd8g.js";
-import"./index-05mms0va.js";
-import"./index-556ja8an.js";
-import"./index-4xbyy6aw.js";
-import"./index-1kz6da87.js";
-import"./index-yh0q21nj.js";
-import"./index-b8zgtz81.js";
-import"./index-gen82t10.js";
-import"./index-4rhhvd1a.js";
+} from "./index-z0tt5j2s.js";
 import {
   AGENT_TOOL_MAP,
   ORCHESTRATOR_NAME,
   init_constants
 } from "./index-4wjk296r.js";
-import"./index-mv0czd9c.js";
-import"./index-k87hs2ff.js";
-import"./index-ed5ykebp.js";
-import"./index-5j6chvj8.js";
-import"./index-7g4c7s5r.js";
-import"./index-a5eba0t8.js";
-import"./index-bpmtbmy9.js";
-import"./index-z6xqpmqg.js";
 import"./index-zjygnfay.js";
-import"./index-4nt52yr9.js";
-import"./index-zgwm4ryv.js";
+import"./index-bk5tah7q.js";
+import"./index-rsrx77fg.js";
+import"./index-bpmtbmy9.js";
 import"./index-a76rekgs.js";
 
 // src/commands/index.ts

package/dist/cli/{index-hckq2r5m.js → index-nrx08gcr.js}

@@ -9,10 +9,11 @@ import {
 } from "./index-y8552snf.js";
 import {
   atomicWriteFile
-} from "./index-2eet124q.js";
+} from "./index-6r522srn.js";
 import {
+  assertProjectRoot,
   withEvidenceLock
-} from "./index-5j6chvj8.js";
+} from "./index-s0qc4gj6.js";
 import {
   exports_external,
   init_zod
@@ -407,6 +408,7 @@ async function readOptionalFile(filePath) {
   }
 }
 async function writeImmutableArtifact(options) {
+  assertProjectRoot(options.directory);
   await mkdir(path.dirname(options.filePath), { recursive: true });
   return withEvidenceLock(options.directory, options.relativeLockPath, options.agent, options.taskId, async () => {
     const desired = options.serialize(options.value);
@@ -530,6 +532,7 @@ async function admitEvaluationTask(directory, input, inputRoot = directory) {
   const relative2 = path2.join("evolution", "tasks", task.split, `${task.id}.json`);
   const admissionLock = TASK_SPLIT_REGISTRY_RELATIVE;
   const filePath = swarmPath(directory, relative2);
+  assertProjectRoot(directory);
   await mkdir2(path2.dirname(filePath), { recursive: true });
   return withEvidenceLock(directory, admissionLock, AGENT, task.id, async () => {
     const registryPath = swarmPath(directory, TASK_SPLIT_REGISTRY_RELATIVE);
@@ -737,6 +740,7 @@ function parseTestLedger(content) {
 async function claimHeldOutTest(directory, input) {
   const claim = TestConsumptionClaimV1Schema.parse(input);
   const filePath = swarmPath(directory, TEST_LEDGER_RELATIVE);
+  assertProjectRoot(directory);
   await mkdir2(path2.dirname(filePath), { recursive: true });
   return withEvidenceLock(directory, TEST_LEDGER_RELATIVE, AGENT, claim.runId, async () => {
     const content = await readOptionalFile(filePath) ?? "";

package/dist/cli/{index-hwnpd4tw.js → index-px7z3r1c.js}

@@ -4,10 +4,10 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-6mvbjqbt.js";
+} from "./index-33skgk1a.js";
 import {
   atomicWriteFile
-} from "./index-2eet124q.js";
+} from "./index-6r522srn.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -628,7 +628,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
       deltas.push({ id, delta });
     }
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-m7vnz62z.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-qe7geq48.js");
       await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-6axm8q3s.js → index-r2bggfra.js}

@@ -2,22 +2,18 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-1jbj7vzv.js";
+} from "./index-wqk50bv0.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-z6qe8wft.js";
+} from "./index-9rbwfydj.js";
 import {
   effectiveRetrievalOutcomes,
   readKnowledgeCounterRollups
-} from "./index-hwnpd4tw.js";
-import {
-  init_knowledge_types,
-  isActiveStatus
-} from "./index-bk5tah7q.js";
+} from "./index-px7z3r1c.js";
 import {
   advisoryWarn,
   init_warning_buffer
@@ -27,6 +23,10 @@ import {
   log,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  init_knowledge_types,
+  isActiveStatus
+} from "./index-bk5tah7q.js";
 import {
   __require
 } from "./index-a76rekgs.js";

package/dist/cli/{index-a5eba0t8.js → index-rsrx77fg.js}

@@ -490,7 +490,7 @@ var CATALOG_SOURCE = [
       category: "evidence",
       severity: "info",
       privacyClass: "sensitive",
-      producer: "src/evidence/lock.ts:94",
+      producer: "src/evidence/lock.ts:99",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
@@ -504,7 +504,7 @@ var CATALOG_SOURCE = [
       category: "evidence",
       severity: "notice",
       privacyClass: "sensitive",
-      producer: "src/evidence/lock.ts:129",
+      producer: "src/evidence/lock.ts:134",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
@@ -518,7 +518,7 @@ var CATALOG_SOURCE = [
       category: "evidence",
       severity: "notice",
       privacyClass: "sensitive",
-      producer: "src/evidence/lock.ts:86",
+      producer: "src/evidence/lock.ts:91",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
@@ -532,7 +532,7 @@ var CATALOG_SOURCE = [
       category: "plan",
       severity: "notice",
       privacyClass: "operational",
-      producer: "src/plan/manager.ts:335",
+      producer: "src/plan/manager.ts:336",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
@@ -545,7 +545,7 @@ var CATALOG_SOURCE = [
       category: "plan",
       severity: "warning",
       privacyClass: "sensitive",
-      producer: "src/plan/manager.ts:1724",
+      producer: "src/plan/manager.ts:1732",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,
@@ -558,7 +558,7 @@ var CATALOG_SOURCE = [
       category: "plan",
       severity: "error",
       privacyClass: "sensitive",
-      producer: "src/plan/ledger.ts:681",
+      producer: "src/plan/ledger.ts:684",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_PLAN_EVIDENCE_RETENTION,

package/dist/cli/index-s0qc4gj6.js

@@ -0,0 +1,298 @@
+// @bun
+import {
+  require_proper_lockfile
+} from "./index-7g4c7s5r.js";
+import {
+  init_logger,
+  warn
+} from "./index-zgwm4ryv.js";
+import {
+  emit
+} from "./index-rsrx77fg.js";
+import {
+  __toESM
+} from "./index-a76rekgs.js";
+
+// src/utils/project-boundary.ts
+init_logger();
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+var MAX_PROJECT_ROOT_DEPTH = 20;
+var PROJECT_ROOT_INDICATORS = [
+  "package.json",
+  ".git",
+  ".opencode",
+  "Cargo.toml",
+  "go.mod",
+  "pyproject.toml",
+  "Gemfile",
+  "composer.json",
+  "pom.xml",
+  "build.gradle",
+  "CMakeLists.txt"
+];
+var PROJECT_BOUNDARY_MARKERS = [
+  {
+    name: ".git",
+    accepts: (stat) => stat.isFile() || stat.isDirectory()
+  },
+  { name: ".opencode", accepts: (stat) => stat.isDirectory() }
+];
+function isAbsoluteDirectoryInput(value) {
+  return typeof value === "string" && value.trim().length > 0 && path.isAbsolute(value);
+}
+function hasExplicitProjectBoundary(directory) {
+  if (!isAbsoluteDirectoryInput(directory))
+    return false;
+  for (const marker of PROJECT_BOUNDARY_MARKERS) {
+    try {
+      const stat = _internals.lstatSync(path.join(directory, marker.name));
+      if (!stat.isSymbolicLink() && marker.accepts(stat))
+        return true;
+    } catch {}
+  }
+  return false;
+}
+function isStrictPathDescendant(candidate, root) {
+  if (!isAbsoluteDirectoryInput(candidate) || !isAbsoluteDirectoryInput(root)) {
+    return false;
+  }
+  const relative2 = path.relative(root, candidate);
+  return relative2 !== "" && relative2 !== ".." && !relative2.startsWith(`..${path.sep}`) && !path.isAbsolute(relative2);
+}
+function isMissingPathError(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ENOTDIR";
+}
+function isWeakConfigContainerRoot(directory, dependencies) {
+  try {
+    const resolved = dependencies.realpathSync(directory);
+    return resolved === dependencies.realpathSync(os.tmpdir()) || resolved === dependencies.realpathSync(os.homedir());
+  } catch {
+    const resolved = path.resolve(directory);
+    return resolved === path.resolve(os.tmpdir()) || resolved === path.resolve(os.homedir());
+  }
+}
+function projectIndicatorState(directory, dependencies, options = {}) {
+  const allowConfigOnly = options.allowConfigOnly ?? true;
+  for (const indicator of PROJECT_ROOT_INDICATORS) {
+    if (!allowConfigOnly && indicator === ".opencode")
+      continue;
+    try {
+      const indicatorStat = dependencies.statSync(path.join(directory, indicator));
+      if (indicatorStat.isFile() || indicatorStat.isDirectory())
+        return "present";
+    } catch (error) {
+      if (!isMissingPathError(error))
+        return "inaccessible";
+    }
+  }
+  return "absent";
+}
+function assertProjectRoot(directory, dependencies = fs, artifactLabel = "runtime state") {
+  let resolved;
+  try {
+    resolved = dependencies.realpathSync(directory);
+  } catch {
+    warn(`[project-boundary] Cannot canonicalize directory "${directory}" \u2014 failing closed`);
+    throw new Error(`Cannot verify project root for "${directory}" \u2014 directory may not exist or is inaccessible`);
+  }
+  if (hasExplicitProjectBoundary(resolved))
+    return;
+  let current = resolved;
+  let depth = 0;
+  while (true) {
+    if (depth >= MAX_PROJECT_ROOT_DEPTH) {
+      warn(`[project-boundary] Ancestor search exceeded ${MAX_PROJECT_ROOT_DEPTH} levels for "${resolved}" \u2014 failing closed`);
+      throw new Error(`Cannot verify project root for "${resolved}" \u2014 ancestor search exceeded ${MAX_PROJECT_ROOT_DEPTH} levels`);
+    }
+    depth++;
+    const parent = path.dirname(current);
+    if (parent === current)
+      break;
+    if (path.dirname(parent) === parent) {
+      current = parent;
+      continue;
+    }
+    const parentSwarm = path.join(parent, ".swarm");
+    let parentSwarmStat;
+    try {
+      parentSwarmStat = dependencies.statSync(parentSwarm);
+    } catch (error) {
+      if (isMissingPathError(error)) {
+        current = parent;
+        continue;
+      }
+      warn(`[project-boundary] Cannot inspect ancestor state "${parentSwarm}" \u2014 failing closed`);
+      throw new Error(`Cannot verify project root for "${resolved}" \u2014 ancestor state "${parentSwarm}" is inaccessible`);
+    }
+    if (parentSwarmStat.isDirectory()) {
+      const indicatorState = projectIndicatorState(parent, dependencies, {
+        allowConfigOnly: !isWeakConfigContainerRoot(parent, dependencies)
+      });
+      if (indicatorState === "inaccessible") {
+        warn(`[project-boundary] Cannot inspect project indicators in ancestor "${parent}" \u2014 failing closed`);
+        throw new Error(`Cannot verify project root for "${resolved}" \u2014 project indicators in ancestor "${parent}" are inaccessible`);
+      }
+      if (indicatorState === "present") {
+        warn(`[project-boundary] Rejecting write to subdirectory "${resolved}" \u2014 parent "${parent}" already contains .swarm/`);
+        throw new Error(`Cannot write ${artifactLabel} in "${resolved}" \u2014 parent directory "${parent}" already contains a .swarm/ folder. Runtime state must be written to the project root.`);
+      }
+    }
+    current = parent;
+  }
+}
+var _internals = {
+  lstatSync: fs.lstatSync
+};
+
+// src/parallel/file-locks.ts
+var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
+import * as crypto from "crypto";
+import * as fs2 from "fs";
+import * as path2 from "path";
+var LOCKS_DIR = ".swarm/locks";
+var LOCK_TIMEOUT_MS = 5 * 60 * 1000;
+var _internals2 = {
+  tryAcquireLock,
+  writeFile: fs2.promises.writeFile
+};
+function getLockFilePath(directory, filePath) {
+  const normalized = path2.resolve(directory, filePath);
+  const baseDir = path2.resolve(directory) + path2.sep;
+  const pathOk = process.platform === "win32" ? normalized.toLowerCase().startsWith(baseDir.toLowerCase()) : normalized.startsWith(baseDir);
+  if (!pathOk) {
+    throw new Error("Invalid file path: path traversal not allowed");
+  }
+  const pathForHash = process.platform === "win32" ? normalized.toLowerCase() : normalized;
+  const hash = crypto.createHash("sha256").update(pathForHash).digest("hex");
+  const lockPath = path2.join(directory, LOCKS_DIR, `${hash}.lock`);
+  const legacyPaths = [pathForHash];
+  if (process.platform === "win32" && normalized !== pathForHash) {
+    legacyPaths.push(normalized);
+  }
+  for (const legacyPath of legacyPaths) {
+    const oldHash = Buffer.from(legacyPath).toString("base64").replace(/[/+=]/g, "_");
+    const oldLockPath = path2.join(directory, LOCKS_DIR, `${oldHash}.lock`);
+    if (fs2.existsSync(oldLockPath)) {
+      return oldLockPath;
+    }
+  }
+  return lockPath;
+}
+async function tryAcquireLock(directory, filePath, agent, taskId) {
+  const lockPath = getLockFilePath(directory, filePath);
+  const locksDir = path2.dirname(lockPath);
+  if (!fs2.existsSync(locksDir)) {
+    fs2.mkdirSync(locksDir, { recursive: true });
+  }
+  if (!fs2.existsSync(lockPath)) {
+    fs2.writeFileSync(lockPath, "", "utf-8");
+  }
+  let release;
+  try {
+    release = await import_proper_lockfile.default.lock(lockPath, {
+      stale: LOCK_TIMEOUT_MS,
+      retries: {
+        retries: 5,
+        minTimeout: 10,
+        maxTimeout: 500,
+        factor: 2
+      },
+      realpath: false
+    });
+  } catch (err) {
+    const code = err.code;
+    if (code === "ELOCKED" || code === "EEXIST") {
+      return { acquired: false };
+    }
+    throw err;
+  }
+  const lock = {
+    filePath,
+    agent,
+    taskId,
+    timestamp: new Date().toISOString(),
+    expiresAt: Date.now() + LOCK_TIMEOUT_MS,
+    _release: release
+  };
+  return { acquired: true, lock };
+}
+
+// src/evidence/lock.ts
+class EvidenceLockTimeoutError extends Error {
+  directory;
+  evidencePath;
+  agent;
+  taskId;
+  constructor(directory, evidencePath, agent, taskId, timeoutMs) {
+    super(`Evidence lock timeout after ${timeoutMs}ms for ${evidencePath} (agent=${agent}, task=${taskId})`);
+    this.name = "EvidenceLockTimeoutError";
+    this.directory = directory;
+    this.evidencePath = evidencePath;
+    this.agent = agent;
+    this.taskId = taskId;
+  }
+}
+var BACKOFF_START_MS = 50;
+var BACKOFF_MAX_MS = 2000;
+var BACKOFF_JITTER_RATIO = 0.25;
+function backoffMs(attempt) {
+  const base = Math.min(BACKOFF_START_MS * 2 ** attempt, BACKOFF_MAX_MS);
+  const jitter = base * BACKOFF_JITTER_RATIO * (Math.random() * 2 - 1);
+  return Math.max(1, Math.round(base + jitter));
+}
+async function withEvidenceLock(directory, evidencePath, agent, taskId, fn, timeoutMs = 60000) {
+  assertProjectRoot(directory);
+  const deadline = Date.now() + timeoutMs;
+  let attempt = 0;
+  while (true) {
+    const result = await tryAcquireLock(directory, evidencePath, agent, taskId);
+    if (result.acquired) {
+      const lock = result.lock;
+      if (attempt > 0) {
+        emit("evidence_lock_stale_recovered", {
+          directory,
+          evidencePath,
+          agent,
+          taskId,
+          attempt
+        });
+      }
+      emit("evidence_lock_acquired", {
+        directory,
+        evidencePath,
+        agent,
+        taskId,
+        attempt
+      });
+      try {
+        return await fn();
+      } finally {
+        if (lock._release) {
+          try {
+            await lock._release();
+          } catch {}
+        }
+      }
+    }
+    if (Date.now() >= deadline) {
+      throw new EvidenceLockTimeoutError(directory, evidencePath, agent, taskId, timeoutMs);
+    }
+    emit("evidence_lock_contended", {
+      directory,
+      evidencePath,
+      agent,
+      taskId,
+      attempt
+    });
+    const delay = Math.min(backoffMs(attempt), deadline - Date.now());
+    if (delay > 0) {
+      await new Promise((resolve3) => setTimeout(resolve3, delay));
+    }
+    attempt++;
+  }
+}
+
+export { tryAcquireLock, hasExplicitProjectBoundary, isStrictPathDescendant, assertProjectRoot, withEvidenceLock };

package/dist/cli/{index-ajwmn8gp.js → index-sd657fkp.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-hckq2r5m.js";
+} from "./index-nrx08gcr.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,
@@ -18,13 +18,13 @@ import {
   computeTaskSetContentHash,
   resolveContainedExistingPath
 } from "./index-y8552snf.js";
+import {
+  bunSpawn
+} from "./index-4nt52yr9.js";
 import {
   exports_external,
   init_zod
 } from "./index-bpmtbmy9.js";
-import {
-  bunSpawn
-} from "./index-4nt52yr9.js";
 
 // src/evaluation/runner.ts
 import * as fs3 from "fs";

package/dist/cli/{index-0mzz46we.js → index-w9tezcdd.js}

@@ -1,8 +1,4 @@
 // @bun
-import {
-  init_schema,
-  stripKnownSwarmPrefix
-} from "./index-kyz7259r.js";
 import {
   getPathFlavor,
   isOnDifferentPathRoot,
@@ -12,13 +8,17 @@ import {
   sanitizeDiagnosticText,
   unsafePathTextReason
 } from "./index-556ja8an.js";
-import {
-  init_constants
-} from "./index-4wjk296r.js";
 import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  init_schema,
+  stripKnownSwarmPrefix
+} from "./index-z0tt5j2s.js";
+import {
+  init_constants
+} from "./index-4wjk296r.js";
 import {
   __commonJS,
   __toESM