opencode-swarm 7.163.1 → 7.164.1

package/dist/cli/{index-2v06a1yh.js → index-6ay5zp1v.js}

@@ -6,12 +6,12 @@ import {
   resolveSwarmKnowledgePath,
   transactKnowledge,
   wordBigrams
-} from "./index-f923njwh.js";
+} from "./index-jczbtx2x.js";
 import {
   queryHistoricalOutcomes,
   readKnowledgeEvents,
   recordKnowledgeEvent
-} from "./index-4p0wyz5p.js";
+} from "./index-1af3rb5n.js";
 import {
   init_knowledge_types,
   isActiveStatus
@@ -224,11 +224,11 @@ async function maybeQuarantineOnContradiction(directory, entryId, threshold, win
         alreadyInactive: true
       };
     }
-    const { quarantineEntry } = await import("./knowledge-validator-0tt0pe6b.js");
+    const { quarantineEntry } = await import("./knowledge-validator-q1z4fmeg.js");
     let policyConfig;
     try {
-      const { KnowledgeConfigSchema } = await import("./schema-c554j5c8.js");
-      const { loadPluginConfigWithMeta } = await import("./index-swgy9xvk.js");
+      const { KnowledgeConfigSchema } = await import("./schema-skf0ckh4.js");
+      const { loadPluginConfigWithMeta } = await import("./index-vrxx0ea4.js");
       const { config: loadedConfig } = loadPluginConfigWithMeta(directory);
       policyConfig = KnowledgeConfigSchema.parse(loadedConfig.knowledge ?? {});
     } catch {

package/dist/cli/{index-n2mhyect.js → index-6kd3jnaf.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   atomicWriteFile
-} from "./index-n67vx5zw.js";
+} from "./index-6t35714n.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-n67vx5zw.js → index-6t35714n.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   withEvidenceLock
-} from "./index-9crtmnqg.js";
+} from "./index-36nt17m8.js";
 import {
   atomicWriteFileAnyRoot
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 
 // src/evidence/task-file.ts
 import * as path from "path";

package/dist/cli/{index-tnpf9wwv.js → index-862c0xhc.js}

@@ -6,7 +6,7 @@ import {
   PluginConfigSchema,
   init_schema,
   resolveExternalSkillsConfig
-} from "./index-x2f1f011.js";
+} from "./index-2s40e3b0.js";
 import {
   GIT_BINARY_ENV_VAR,
   init_git_executable

package/dist/cli/{index-2n1ym7jb.js → index-b98r3pyv.js}

@@ -2,23 +2,23 @@
 import {
   computePlanStructureHash,
   derivePlanId
-} from "./index-kvra3nv1.js";
+} from "./index-vdgw2k4c.js";
 import {
   appendCoreEventSync
-} from "./index-8ada7ag7.js";
+} from "./index-dhzsvmx6.js";
 import {
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
   PlanSchema
-} from "./index-tnpf9wwv.js";
+} from "./index-862c0xhc.js";
 import {
   assertProjectRoot
-} from "./index-9crtmnqg.js";
+} from "./index-36nt17m8.js";
 import {
   atomicWriteSwarmFile,
   atomicWriteSwarmFileSync
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";

package/dist/cli/{index-8ada7ag7.js → index-dhzsvmx6.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   observeStoreHealth
-} from "./index-cqgpvx2d.js";
+} from "./index-j0ajeary.js";
 import {
   telemetry
-} from "./index-2zgjcmmc.js";
+} from "./index-1b1h770t.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-n985274d.js → index-e630pvvw.js}

@@ -2,7 +2,7 @@
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-08y8pccg.js";
+} from "./index-wnf1ej2q.js";
 import {
   withTimeoutSignal
 } from "./index-q7sjgr1y.js";
@@ -12,11 +12,11 @@ import {
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-f923njwh.js";
+} from "./index-jczbtx2x.js";
 import {
   effectiveRetrievalOutcomes,
   readAuthoritativeKnowledgeCounterRollups
-} from "./index-4p0wyz5p.js";
+} from "./index-1af3rb5n.js";
 import {
   advisoryWarn,
   init_warning_buffer
@@ -28,7 +28,7 @@ import {
 import {
   atomicWriteFileAnyRoot,
   atomicWriteSwarmFile
-} from "./index-3b762978.js";
+} from "./index-f9nfknjg.js";
 import {
   init_logger,
   log,

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-m1fvbah1.js → index-fwfhbs27.js}

@@ -14,14 +14,14 @@ import {
   detectWindowsWrites,
   getSharedClassifierGuardrailBlock,
   resolveWriteTargets
-} from "./index-0tervb1m.js";
+} from "./index-2ee2g27m.js";
 import {
   checkFileAuthority,
   classifyFile,
   isInDeclaredScope,
   redactPath,
   redactShellCommand
-} from "./index-qynqyfgj.js";
+} from "./index-wv4b01ex.js";
 
 // src/services/guardrail-explain-service.ts
 import path from "path";

package/dist/cli/{index-t34daffb.js → index-h2f21caa.js}

@@ -2,14 +2,14 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-f923njwh.js";
+} from "./index-jczbtx2x.js";
 import {
   init_git_executable,
   resolveGitExecutableAsync
 } from "./index-9e6fdz2h.js";
 import {
   resolveKnowledgeStoreDir
-} from "./index-n2mhyect.js";
+} from "./index-6kd3jnaf.js";
 import {
   init_knowledge_types,
   isActiveStatus