opencode-swarm 7.164.0 → 7.164.2

package/dist/cli/{index-4afh2cz7.js → index-92q98ry8.js}

@@ -5,7 +5,7 @@ import {
 } from "./index-3f7hqtgg.js";
 import {
   removeWorktreeProvisioningOwner
-} from "./index-fckfgptr.js";
+} from "./index-qbr05tbw.js";
 import {
   SOURCE_WORKTREE_GONE_STAGE,
   getTaskWorkflowSnapshot,
@@ -13,19 +13,19 @@ import {
   reconcileLandedMerge,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-7r9vpkwa.js";
+} from "./index-h9wnkr2e.js";
 import {
   canonicalRootKeyFresh
 } from "./index-ddszzne4.js";
 import {
   appendCoreEventSync
-} from "./index-93sepnc9.js";
+} from "./index-0145kpjr.js";
 import {
   isPathWithinDeclaredScope
 } from "./index-556ja8an.js";
 import {
   validateSwarmPath
-} from "./index-dtn0pne5.js";
+} from "./index-v56mhyhs.js";
 import {
   init_git_executable,
   resolveGitExecutable
@@ -36,7 +36,7 @@ import {
 } from "./index-4rhhvd1a.js";
 import {
   tryAcquireLock
-} from "./index-36nt17m8.js";
+} from "./index-yep24wn4.js";
 import {
   criticalWarn,
   init_logger
@@ -478,7 +478,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-67fs6rz9.js");
+  } = await import("./worktree-isolation-tje6p4zt.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -602,7 +602,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-67fs6rz9.js");
+        } = await import("./worktree-isolation-tje6p4zt.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,

package/dist/cli/{index-wdtckfnf.js → index-ac39znep.js}

@@ -1,12 +1,12 @@
 // @bun
 import {
   atomicWriteSwarmFile
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 import {
   pseudonymousRef,
   resolveLineageSalt,
   telemetry
-} from "./index-1b1h770t.js";
+} from "./index-bzd67m2j.js";
 
 // src/health/learning-health.ts
 import { promises as fs } from "fs";

package/dist/cli/{index-4jersar8.js → index-axtnc0xf.js}

@@ -2,23 +2,23 @@
 import {
   computePlanStructureHash,
   derivePlanId
-} from "./index-1z4jzwja.js";
+} from "./index-w8qt2612.js";
 import {
   appendCoreEventSync
-} from "./index-93sepnc9.js";
+} from "./index-0145kpjr.js";
 import {
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
   PlanSchema
-} from "./index-nhxaa9j5.js";
+} from "./index-xm6c1tnf.js";
 import {
   assertProjectRoot
-} from "./index-36nt17m8.js";
+} from "./index-yep24wn4.js";
 import {
   atomicWriteSwarmFile,
   atomicWriteSwarmFileSync
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";

package/dist/cli/{index-e3hwzcjv.js → index-b85jnfp4.js}

@@ -2,14 +2,14 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-bm73pych.js";
+} from "./index-br7q79t2.js";
 import {
   init_git_executable,
   resolveGitExecutableAsync
 } from "./index-9e6fdz2h.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-ynqp3jb6.js";
+} from "./index-5d7bzpfn.js";
 import {
   init_knowledge_types,
   isActiveStatus

package/dist/cli/{index-bm73pych.js → index-br7q79t2.js}

@@ -6,17 +6,17 @@ import {
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-ynqp3jb6.js";
+} from "./index-5d7bzpfn.js";
 import {
   atomicWriteFile
-} from "./index-70bfj3v1.js";
+} from "./index-zs1jrsta.js";
 import {
   init_knowledge_types,
   isActiveStatus
 } from "./index-bk5tah7q.js";
 import {
   readCachedParsedFile
-} from "./index-ed5ykebp.js";
+} from "./index-f9nfknjg.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -713,7 +713,7 @@ async function applyConfidenceFloorAction(directory, touched, options) {
   const {
     readAuthoritativeKnowledgeCounterRollups,
     effectiveRetrievalOutcomes
-  } = await import("./knowledge-events-4h88stj7.js");
+  } = await import("./knowledge-events-wz3h98kk.js");
   const rollups = await readAuthoritativeKnowledgeCounterRollups(directory);
   const flagIds = new Set;
   for (const e of atFloor) {
@@ -780,11 +780,11 @@ async function applyConfidenceFloorAction(directory, touched, options) {
     });
   }
   if (action === "quarantine" && toQuarantine.length > 0) {
-    const { quarantineEntry } = await import("./knowledge-validator-edbg761g.js");
-    const { KnowledgeConfigSchema } = await import("./schema-9xkt5hvd.js");
+    const { quarantineEntry } = await import("./knowledge-validator-bk2qfqe2.js");
+    const { KnowledgeConfigSchema } = await import("./schema-674qw3aj.js");
     let config;
     try {
-      const { loadPluginConfigWithMeta } = await import("./index-v3a9rmyh.js");
+      const { loadPluginConfigWithMeta } = await import("./index-1r6p1wpa.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       config = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-1b1h770t.js → index-bzd67m2j.js}

@@ -217,7 +217,7 @@ var CATALOG_SOURCE = [
       category: "delegation",
       severity: "info",
       privacyClass: "pseudonymous",
-      producer: "src/index.ts:638",
+      producer: "src/index.ts:642",
       consumers: CONSUMER_COST_CORRECTION,
       retentionOwnerIssue: ISSUE_COST_RETENTION,
       requiredWorkflowIds: REQUIRE_SESSION_AND_TASK,
@@ -230,7 +230,7 @@ var CATALOG_SOURCE = [
       category: "delegation",
       severity: "info",
       privacyClass: "pseudonymous",
-      producer: "src/index.ts:1563",
+      producer: "src/index.ts:1567",
       consumers: NO_CONSUMERS,
       futureOwnerIssue: ISSUE_SINK,
       retentionOwnerIssue: ISSUE_COST_RETENTION,
@@ -244,7 +244,7 @@ var CATALOG_SOURCE = [
       category: "delegation",
       severity: "notice",
       privacyClass: "pseudonymous",
-      producer: "src/index.ts:1583",
+      producer: "src/index.ts:1587",
       consumers: CONSUMER_COST_JOIN,
       retentionOwnerIssue: ISSUE_COST_RETENTION,
       requiredWorkflowIds: REQUIRE_SESSION,

package/dist/cli/{index-ma8w6pfp.js → index-c8k4cs94.js}

@@ -1,19 +1,19 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-dtn0pne5.js";
+} from "./index-v56mhyhs.js";
 import {
   observeStoreHealth
-} from "./index-wdtckfnf.js";
+} from "./index-ac39znep.js";
 import {
   withEvidenceLock
-} from "./index-36nt17m8.js";
+} from "./index-yep24wn4.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 import {
   telemetry
-} from "./index-1b1h770t.js";
+} from "./index-bzd67m2j.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-t90gjc0k.js → index-cm4r8gh2.js}

@@ -4,7 +4,7 @@ import {
   readShellAuditTail,
   redactPath,
   redactShellCommand
-} from "./index-9sy65e94.js";
+} from "./index-qmeewt3g.js";
 
 // src/services/guardrail-log-service.ts
 var BLOCK_TYPES = new Set([

package/dist/cli/{index-3b762978.js → index-f9nfknjg.js}

@@ -1,12 +1,157 @@
 // @bun
-import {
-  invalidateCachedArtifact
-} from "./index-ed5ykebp.js";
+// src/utils/swarm-artifact-cache.ts
+import * as fsSync from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+var MAX_CACHE_ENTRIES = 128;
+var textCache = new Map;
+var parsedCache = new Map;
+var stats = {
+  textReadCount: 0,
+  textCacheHitCount: 0,
+  textCacheMissCount: 0,
+  parsedReadCount: 0,
+  parseCount: 0,
+  parsedCacheHitCount: 0,
+  parsedCacheMissCount: 0,
+  statFailureCount: 0,
+  evictionCount: 0,
+  textEvictionCount: 0,
+  parsedEvictionCount: 0,
+  cloneFallbackCount: 0,
+  textEntryCount: 0,
+  parsedEntryCount: 0
+};
+function sameStamp(a, b) {
+  return a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs && a.size === b.size;
+}
+var _internals = {
+  stat: fs.stat,
+  statSync: fsSync.statSync
+};
+async function getStamp(filePath) {
+  try {
+    const stat2 = await _internals.stat(filePath);
+    if (!stat2.isFile())
+      return null;
+    return { mtimeMs: stat2.mtimeMs, ctimeMs: stat2.ctimeMs, size: stat2.size };
+  } catch {
+    stats.statFailureCount++;
+    return null;
+  }
+}
+function canStoreRead(before, after) {
+  return after !== null && sameStamp(before, after);
+}
+function setBounded(cache, key, value, cacheKind) {
+  cache.set(key, value);
+  while (cache.size > MAX_CACHE_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+    stats.evictionCount++;
+    if (cacheKind === "text") {
+      stats.textEvictionCount++;
+    } else {
+      stats.parsedEvictionCount++;
+    }
+  }
+  stats.textEntryCount = textCache.size;
+  stats.parsedEntryCount = parsedCache.size;
+}
+function cloneCachedValue(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  stats.cloneFallbackCount++;
+  return JSON.parse(JSON.stringify(value));
+}
+async function readCachedTextFile(filePath, directRead) {
+  const cacheKey = path.resolve(filePath);
+  const stamp = await getStamp(cacheKey);
+  if (!stamp) {
+    stats.textReadCount++;
+    return directRead();
+  }
+  const cached = textCache.get(cacheKey);
+  if (cached && sameStamp(cached, stamp)) {
+    stats.textCacheHitCount++;
+    return cached.value;
+  }
+  stats.textCacheMissCount++;
+  stats.textReadCount++;
+  const value = await directRead();
+  const afterReadStamp = await getStamp(cacheKey);
+  if (value !== null && canStoreRead(stamp, afterReadStamp)) {
+    setBounded(textCache, cacheKey, { ...afterReadStamp, value }, "text");
+  }
+  return value;
+}
+async function readCachedParsedFile(filePath, namespace, readText, parse) {
+  const resolvedPath = path.resolve(filePath);
+  const cacheKey = `${resolvedPath}\x00${namespace}`;
+  const stamp = await getStamp(resolvedPath);
+  if (!stamp) {
+    stats.parsedReadCount++;
+    const content2 = await readText();
+    if (content2 === null)
+      return null;
+    stats.parseCount++;
+    return parse(content2);
+  }
+  const cached = parsedCache.get(cacheKey);
+  if (cached && sameStamp(cached, stamp)) {
+    stats.parsedCacheHitCount++;
+    return cloneCachedValue(cached.value);
+  }
+  stats.parsedCacheMissCount++;
+  stats.parsedReadCount++;
+  const content = await readText();
+  if (content === null)
+    return null;
+  stats.parseCount++;
+  const value = parse(content);
+  const afterReadStamp = await getStamp(resolvedPath);
+  if (canStoreRead(stamp, afterReadStamp)) {
+    setBounded(parsedCache, cacheKey, { ...afterReadStamp, value }, "parsed");
+  }
+  return cloneCachedValue(value);
+}
+function invalidateCachedArtifact(filePath) {
+  const resolvedPath = path.resolve(filePath);
+  textCache.delete(resolvedPath);
+  const prefix = `${resolvedPath}\x00`;
+  for (const key of parsedCache.keys()) {
+    if (key.startsWith(prefix))
+      parsedCache.delete(key);
+  }
+}
+function resetSwarmArtifactCache() {
+  textCache.clear();
+  parsedCache.clear();
+  stats.textReadCount = 0;
+  stats.textCacheHitCount = 0;
+  stats.textCacheMissCount = 0;
+  stats.parsedReadCount = 0;
+  stats.parseCount = 0;
+  stats.parsedCacheHitCount = 0;
+  stats.parsedCacheMissCount = 0;
+  stats.statFailureCount = 0;
+  stats.evictionCount = 0;
+  stats.textEvictionCount = 0;
+  stats.parsedEvictionCount = 0;
+  stats.cloneFallbackCount = 0;
+  stats.textEntryCount = 0;
+  stats.parsedEntryCount = 0;
+}
 
 // src/utils/atomic-write.ts
 import { randomBytes } from "crypto";
-import * as fs from "fs";
-import * as path from "path";
+import * as fs2 from "fs";
+import * as path2 from "path";
 var UUID_RE = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
 var SWARM_TEMP_GRAMMARS = [
   {
@@ -364,7 +509,7 @@ var WRITER_CLASSIFICATION = Object.freeze({
   "src/worktree/core.ts": "reader-only"
 });
 function assertWellFormedTargetPath(targetPath) {
-  if (!path.isAbsolute(targetPath)) {
+  if (!path2.isAbsolute(targetPath)) {
     throw new Error(`atomic-write target must be absolute: ${targetPath}`);
   }
   if (/[\0-\x1f\x7f]/.test(targetPath)) {
@@ -381,15 +526,15 @@ function assertWellFormedTargetPath(targetPath) {
   }
 }
 function lstatNotSymlink(p, what) {
-  const st = fs.lstatSync(p);
+  const st = fs2.lstatSync(p);
   if (st.isSymbolicLink()) {
     throw new Error(`${what} is a symlink/reparse point: ${p}`);
   }
 }
 function assertSwarmContainedTarget(targetPath) {
   assertWellFormedTargetPath(targetPath);
-  const resolved = path.normalize(path.resolve(targetPath));
-  const segments = resolved.split(path.sep);
+  const resolved = path2.normalize(path2.resolve(targetPath));
+  const segments = resolved.split(path2.sep);
   let swarmIdx = -1;
   for (let i = segments.length - 2;i >= 1; i--) {
     if (segments[i] === ".swarm") {
@@ -400,9 +545,9 @@ function assertSwarmContainedTarget(targetPath) {
   if (swarmIdx === -1) {
     throw new Error(`atomic-write target is not under a project .swarm root: ${targetPath}`);
   }
-  const swarmRoot = segments.slice(0, swarmIdx + 1).join(path.sep);
+  const swarmRoot = segments.slice(0, swarmIdx + 1).join(path2.sep);
   try {
-    const st = fs.lstatSync(swarmRoot);
+    const st = fs2.lstatSync(swarmRoot);
     if (!st.isDirectory() || st.isSymbolicLink()) {
       throw new Error(`.swarm root is not a real directory (symlink/reparse or non-dir): ${swarmRoot}`);
     }
@@ -410,28 +555,28 @@ function assertSwarmContainedTarget(targetPath) {
     if (err?.code !== "ENOENT")
       throw err;
   }
-  const rel = path.relative(swarmRoot, resolved);
-  if (!rel || rel.startsWith("..") || path.isAbsolute(rel)) {
+  const rel = path2.relative(swarmRoot, resolved);
+  if (!rel || rel.startsWith("..") || path2.isAbsolute(rel)) {
     throw new Error(`atomic-write target escapes .swarm root: ${targetPath}`);
   }
   let probe = swarmRoot;
-  for (const seg of rel.split(path.sep)) {
-    probe = path.join(probe, seg);
-    if (!fs.existsSync(probe))
+  for (const seg of rel.split(path2.sep)) {
+    probe = path2.join(probe, seg);
+    if (!fs2.existsSync(probe))
       break;
     lstatNotSymlink(probe, "path segment under .swarm");
   }
-  return { projectRoot: path.dirname(swarmRoot), swarmRoot };
+  return { projectRoot: path2.dirname(swarmRoot), swarmRoot };
 }
 var MAX_ATOMIC_WRITE_BYTES = 256 * 1024 * 1024;
 var RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200];
 var RETRYABLE_RENAME_CODES = new Set(["EPERM", "EBUSY", "EACCES", "EEXIST"]);
-var _internals = {
+var _internals2 = {
   randomSuffix: () => randomBytes(16).toString("hex"),
-  writeSync: (fd, buffer, offset, length) => fs.writeSync(fd, buffer, offset, length),
-  renameSync: (from, to) => fs.renameSync(from, to),
-  unlinkSync: (p) => fs.unlinkSync(p),
-  fsyncSync: (fd) => fs.fsyncSync(fd)
+  writeSync: (fd, buffer, offset, length) => fs2.writeSync(fd, buffer, offset, length),
+  renameSync: (from, to) => fs2.renameSync(from, to),
+  unlinkSync: (p) => fs2.unlinkSync(p),
+  fsyncSync: (fd) => fs2.fsyncSync(fd)
 };
 function toBuffer(content) {
   if (typeof content === "string")
@@ -450,7 +595,7 @@ function renameWithRetry(tempPath, targetPath) {
   let lastError;
   for (let attempt = 0;attempt <= RENAME_RETRY_DELAYS_MS.length; attempt++) {
     try {
-      _internals.renameSync(tempPath, targetPath);
+      _internals2.renameSync(tempPath, targetPath);
       return;
     } catch (err) {
       lastError = err;
@@ -470,55 +615,55 @@ function writeAtomicSync(targetPath, content, options) {
   } else {
     assertWellFormedTargetPath(targetPath);
   }
-  const resolvedTarget = path.resolve(targetPath);
+  const resolvedTarget = path2.resolve(targetPath);
   const buffer = toBuffer(content);
   const maxBytes = options?.maxBytes ?? MAX_ATOMIC_WRITE_BYTES;
   if (buffer.byteLength > maxBytes) {
     throw new Error(`atomic write exceeds ${maxBytes} byte bound: ${buffer.byteLength}`);
   }
-  const tempPath = `${resolvedTarget}.${_internals.randomSuffix()}.tmp`;
-  fs.mkdirSync(path.dirname(tempPath), { recursive: true });
+  const tempPath = `${resolvedTarget}.${_internals2.randomSuffix()}.tmp`;
+  fs2.mkdirSync(path2.dirname(tempPath), { recursive: true });
   try {
-    const fd = fs.openSync(tempPath, "wx", options?.mode);
+    const fd = fs2.openSync(tempPath, "wx", options?.mode);
     try {
       let written = 0;
       while (written < buffer.byteLength) {
-        written += _internals.writeSync(fd, buffer, written, buffer.byteLength - written);
+        written += _internals2.writeSync(fd, buffer, written, buffer.byteLength - written);
       }
       if (options?.skipFsync !== true) {
         try {
-          _internals.fsyncSync(fd);
+          _internals2.fsyncSync(fd);
         } catch {}
       }
     } finally {
-      fs.closeSync(fd);
+      fs2.closeSync(fd);
     }
     renameWithRetry(tempPath, resolvedTarget);
   } finally {
     try {
-      _internals.unlinkSync(tempPath);
+      _internals2.unlinkSync(tempPath);
     } catch {}
   }
   try {
-    const dirFd = fs.openSync(path.dirname(resolvedTarget), "r");
+    const dirFd = fs2.openSync(path2.dirname(resolvedTarget), "r");
     try {
-      fs.fsyncSync(dirFd);
+      fs2.fsyncSync(dirFd);
     } finally {
-      fs.closeSync(dirFd);
+      fs2.closeSync(dirFd);
     }
   } catch {}
   invalidateCachedArtifact(resolvedTarget);
 }
 async function atomicWriteSwarmFile(targetPath, content, options) {
-  await new Promise((resolve2) => setImmediate(resolve2));
+  await new Promise((resolve3) => setImmediate(resolve3));
   writeAtomicSync(targetPath, content, options);
 }
 function atomicWriteSwarmFileSync(targetPath, content, options) {
   writeAtomicSync(targetPath, content, options);
 }
 async function atomicWriteFileAnyRoot(targetPath, content, options) {
-  await new Promise((resolve2) => setImmediate(resolve2));
+  await new Promise((resolve3) => setImmediate(resolve3));
   writeAtomicSync(targetPath, content, { ...options, contained: false });
 }
 
-export { matchTempGrammar, parseTargetBasename, atomicWriteSwarmFile, atomicWriteSwarmFileSync, atomicWriteFileAnyRoot };
+export { readCachedTextFile, readCachedParsedFile, invalidateCachedArtifact, resetSwarmArtifactCache, matchTempGrammar, parseTargetBasename, atomicWriteSwarmFile, atomicWriteSwarmFileSync, atomicWriteFileAnyRoot };

package/dist/cli/{index-t9rhtvy9.js → index-fyt5byhd.js}

@@ -2,14 +2,14 @@
 import {
   init_loader,
   loadPluginConfigWithMeta
-} from "./index-nhxaa9j5.js";
+} from "./index-xm6c1tnf.js";
 import {
   init_schema
-} from "./index-td6n935w.js";
+} from "./index-3704v4e6.js";
 import {
   DEFAULT_WORKTREE_ISOLATION_CONFIG,
   init_constants
-} from "./index-9xd073d4.js";
+} from "./index-m1nrd3yd.js";
 
 // src/config/index.ts
 init_constants();

package/dist/cli/{index-zbpcpsk0.js → index-gz5rn6w6.js}

@@ -1,32 +1,32 @@
 // @bun
 import {
   validateSwarmPath
-} from "./index-dtn0pne5.js";
+} from "./index-v56mhyhs.js";
 import {
   loadPluginConfigWithMeta
-} from "./index-nhxaa9j5.js";
+} from "./index-xm6c1tnf.js";
 import {
   KnowledgeConfigSchema,
   init_schema
-} from "./index-td6n935w.js";
+} from "./index-3704v4e6.js";
 import {
   observeReceiptTransition
-} from "./index-wdtckfnf.js";
+} from "./index-ac39znep.js";
 import {
   resolveHiveEventsPath
 } from "./index-ae75rja9.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-ynqp3jb6.js";
+} from "./index-5d7bzpfn.js";
 import {
   atomicWriteFile
-} from "./index-70bfj3v1.js";
+} from "./index-zs1jrsta.js";
 import {
   assertProjectRoot
-} from "./index-36nt17m8.js";
+} from "./index-yep24wn4.js";
 import {
   emit
-} from "./index-1b1h770t.js";
+} from "./index-bzd67m2j.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
@@ -2810,7 +2810,7 @@ async function applyKnowledgeVerdictFeedback(directory, options) {
     }
     let bumps = 0;
     if (deltas.length > 0) {
-      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-j832fxpx.js");
+      const { bumpKnowledgeConfidenceBatch } = await import("./knowledge-store-y1cwe80n.js");
       bumps = await bumpKnowledgeConfidenceBatch(directory, deltas, options?.floorOptions);
     }
     return {

package/dist/cli/{index-7r9vpkwa.js → index-h9wnkr2e.js}

@@ -2,14 +2,14 @@
 import {
   autoCommitDirty,
   cleanUntrackedFiles
-} from "./index-nzrhw31r.js";
+} from "./index-zgeqwbhw.js";
 import {
   isPathWithinDeclaredScope,
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
   validateSwarmPath
-} from "./index-dtn0pne5.js";
+} from "./index-v56mhyhs.js";
 import {
   bunSpawn,
   classifySpawnFailure
@@ -26,13 +26,13 @@ import {
   atomicWriteFile,
   taskEvidencePath,
   withTaskEvidenceLock
-} from "./index-70bfj3v1.js";
+} from "./index-zs1jrsta.js";
 import {
   assertProjectRoot
-} from "./index-36nt17m8.js";
+} from "./index-yep24wn4.js";
 import {
   telemetry
-} from "./index-1b1h770t.js";
+} from "./index-bzd67m2j.js";
 import {
   exports_external,
   init_zod

package/dist/cli/{index-1hpjwz3s.js → index-hcn69kp0.js}

@@ -11,7 +11,7 @@ import {
 } from "./index-4rhhvd1a.js";
 import {
   atomicWriteSwarmFileSync
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 
 // src/sdd/effective-spec.ts
 import { createHash } from "crypto";