opencode-swarm 7.166.1 → 7.166.3

package/dist/cli/{index-gy0nyfbw.js → index-m21x1bkx.js}

@@ -6,6 +6,21 @@ import * as path from "path";
 var MAX_CACHE_ENTRIES = 128;
 var textCache = new Map;
 var parsedCache = new Map;
+var MAX_KNOWN_TO_EXIST_PATHS = 512;
+var knownToExist = new Set;
+function noteKnownToExist(resolvedPath) {
+  if (knownToExist.has(resolvedPath))
+    return;
+  knownToExist.add(resolvedPath);
+  if (knownToExist.size > MAX_KNOWN_TO_EXIST_PATHS) {
+    const oldest = knownToExist.values().next().value;
+    if (oldest !== undefined)
+      knownToExist.delete(oldest);
+  }
+}
+function wasObservedToExist(filePath) {
+  return knownToExist.has(path.resolve(filePath));
+}
 var stats = {
   textReadCount: 0,
   textCacheHitCount: 0,
@@ -76,6 +91,7 @@ async function readCachedTextFile(filePath, directRead) {
     stats.textReadCount++;
     return directRead();
   }
+  noteKnownToExist(cacheKey);
   const cached = textCache.get(cacheKey);
   if (cached && sameStamp(cached, stamp)) {
     stats.textCacheHitCount++;
@@ -218,15 +234,15 @@ var SWARM_TEMP_GRAMMARS = [
       "src/plan/manager.ts:1832",
       "src/review/evidence.ts:175",
       "src/turbo/lean/evidence.ts:182",
-      "src/summaries/manager.ts:122",
+      "src/summaries/manager.ts:123",
       "src/evidence/manager.ts:288",
       "src/evidence/manager.ts:456",
       "src/tools/sast-baseline.ts:199",
       "src/tools/repo-graph/storage.ts:524",
       "src/memory/reflection-service.ts (pre-#2035; migrated-to=src/memory/reflection-service.ts:atomicWrite)",
-      "src/hooks/review-receipt.ts:608",
-      "src/hooks/review-receipt.ts:674",
-      "src/hooks/review-receipt.ts:812",
+      "src/hooks/review-receipt.ts:609",
+      "src/hooks/review-receipt.ts:675",
+      "src/hooks/review-receipt.ts:894",
       "src/knowledge/identity.ts:209",
       "src/evidence/phase-participation.ts (pre-#2035; migrated-to=src/evidence/phase-participation.ts:atomicWriteBytes)",
       "src/turbo/lean/integration.ts:428",
@@ -235,7 +251,7 @@ var SWARM_TEMP_GRAMMARS = [
       "src/services/synonym-map.ts:389",
       "src/services/skill-optimizer/store.ts:340",
       "src/services/skill-optimizer/store.ts:503",
-      "src/turbo/epic/calibration.ts:202",
+      "src/turbo/epic/calibration.ts:234",
       "src/commands/archive-sqlite.ts:318",
       "src/memory/jsonl-migration.ts:161"
     ],
@@ -272,7 +288,10 @@ var SWARM_TEMP_GRAMMARS = [
       "src/background/pending-delegations.ts:1443",
       "src/background/delegation-health.ts:391",
       "src/tools/submit-phase-council-verdicts.ts:458",
-      "src/summaries/store.ts (pre-#2035; migrated-to=src/summaries/store.ts:writeRawSidecar)"
+      "src/summaries/store.ts (pre-#2035; migrated-to=src/summaries/store.ts:writeRawSidecar)",
+      "src/retention/jsonl-cap.ts:213",
+      "src/services/skill-changelog.ts:58",
+      "src/turbo/epic/divergence-recorder.ts:108"
     ],
     note: "background lane/delegation stores keep bounded-retry rename semantics wired into their callers (#2034/#2276 delivery contracts); migration candidates for a follow-up but grammars registered"
   },
@@ -397,9 +416,11 @@ var SWARM_TEMP_GRAMMARS = [
       "src/tools/checkpoint.ts:195",
       "src/full-auto/state.ts:460",
       "src/context-map/persistence.ts:119",
-      "src/context-map/capsule-persistence.ts:109",
-      "src/test-impact/history-store.ts:225",
-      "src/test-impact/history-store.ts:353",
+      "src/context-map/capsule-persistence.ts:111",
+      "src/test-impact/history-store.ts:297",
+      "src/test-impact/history-store.ts:302",
+      "src/test-impact/history-store.ts:429",
+      "src/test-impact/history-store.ts:435",
       "src/hooks/promotion-evidence-store.ts:112",
       "src/hooks/skill-usage-log.ts:1165",
       "src/hooks/skill-usage-log.ts:1675",
@@ -440,6 +461,9 @@ var WRITER_CLASSIFICATION = Object.freeze({
   "src/services/skill-improver.ts": "migrated",
   "src/summaries/store.ts": "migrated",
   "src/prm/trajectory-store.ts": "migrated",
+  "src/retention/jsonl-cap.ts": "registered-bespoke",
+  "src/services/skill-changelog.ts": "registered-bespoke",
+  "src/turbo/epic/divergence-recorder.ts": "registered-bespoke",
   "src/background/delegation-health.ts": "registered-bespoke",
   "src/background/lane-output-store.ts": "registered-bespoke",
   "src/background/pending-delegations.ts": "registered-bespoke",
@@ -574,6 +598,28 @@ function assertSwarmContainedTarget(targetPath) {
 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 MAX_RECENT_WRITE_TRACKED_PATHS = 256;
+var RECENT_WRITE_WINDOW_MS = 500;
+var recentWriteActivity = new Map;
+function noteRecentWriteActivity(resolvedTarget) {
+  recentWriteActivity.delete(resolvedTarget);
+  recentWriteActivity.set(resolvedTarget, Date.now());
+  while (recentWriteActivity.size > MAX_RECENT_WRITE_TRACKED_PATHS) {
+    const oldest = recentWriteActivity.keys().next().value;
+    if (oldest === undefined)
+      break;
+    recentWriteActivity.delete(oldest);
+  }
+}
+function clearRecentWriteActivity(targetPath) {
+  return recentWriteActivity.delete(path2.resolve(targetPath));
+}
+function wasRecentlyWrittenByThisProcess(targetPath, withinMs = RECENT_WRITE_WINDOW_MS) {
+  const last = recentWriteActivity.get(path2.resolve(targetPath));
+  if (last === undefined)
+    return false;
+  return Date.now() - last <= withinMs;
+}
 var _internals2 = {
   randomSuffix: () => randomBytes(16).toString("hex"),
   writeSync: (fd, buffer, offset, length) => fs2.writeSync(fd, buffer, offset, length),
@@ -619,6 +665,7 @@ function writeAtomicSync(targetPath, content, options) {
     assertWellFormedTargetPath(targetPath);
   }
   const resolvedTarget = path2.resolve(targetPath);
+  noteRecentWriteActivity(resolvedTarget);
   const buffer = toBuffer(content);
   const maxBytes = options?.maxBytes ?? MAX_ATOMIC_WRITE_BYTES;
   if (buffer.byteLength > maxBytes) {
@@ -627,25 +674,30 @@ function writeAtomicSync(targetPath, content, options) {
   const tempPath = `${resolvedTarget}.${_internals2.randomSuffix()}.tmp`;
   fs2.mkdirSync(path2.dirname(tempPath), { recursive: true });
   try {
-    const fd = fs2.openSync(tempPath, "wx", options?.mode);
     try {
-      let written = 0;
-      while (written < buffer.byteLength) {
-        written += _internals2.writeSync(fd, buffer, written, buffer.byteLength - written);
-      }
-      if (options?.skipFsync !== true) {
-        try {
-          _internals2.fsyncSync(fd);
-        } catch {}
+      const fd = fs2.openSync(tempPath, "wx", options?.mode);
+      try {
+        let written = 0;
+        while (written < buffer.byteLength) {
+          written += _internals2.writeSync(fd, buffer, written, buffer.byteLength - written);
+        }
+        if (options?.skipFsync !== true) {
+          try {
+            _internals2.fsyncSync(fd);
+          } catch {}
+        }
+      } finally {
+        fs2.closeSync(fd);
       }
+      renameWithRetry(tempPath, resolvedTarget);
     } finally {
-      fs2.closeSync(fd);
+      try {
+        _internals2.unlinkSync(tempPath);
+      } catch {}
     }
-    renameWithRetry(tempPath, resolvedTarget);
-  } finally {
-    try {
-      _internals2.unlinkSync(tempPath);
-    } catch {}
+  } catch (error) {
+    clearRecentWriteActivity(resolvedTarget);
+    throw error;
   }
   try {
     const dirFd = fs2.openSync(path2.dirname(resolvedTarget), "r");
@@ -656,6 +708,7 @@ function writeAtomicSync(targetPath, content, options) {
     }
   } catch {}
   invalidateCachedArtifact(resolvedTarget);
+  noteRecentWriteActivity(resolvedTarget);
 }
 async function atomicWriteSwarmFile(targetPath, content, options) {
   await new Promise((resolve3) => setImmediate(resolve3));
@@ -669,4 +722,4 @@ async function atomicWriteFileAnyRoot(targetPath, content, options) {
   writeAtomicSync(targetPath, content, { ...options, contained: false });
 }
 
-export { readCachedTextFile, readCachedParsedFile, invalidateCachedArtifact, resetSwarmArtifactCache, matchTempGrammar, parseTargetBasename, atomicWriteSwarmFile, atomicWriteSwarmFileSync, atomicWriteFileAnyRoot };
+export { wasObservedToExist, readCachedTextFile, readCachedParsedFile, invalidateCachedArtifact, resetSwarmArtifactCache, matchTempGrammar, parseTargetBasename, RECENT_WRITE_WINDOW_MS, wasRecentlyWrittenByThisProcess, atomicWriteSwarmFile, atomicWriteSwarmFileSync, atomicWriteFileAnyRoot };

package/dist/cli/{index-hvk3zs62.js → index-m3tx1q9v.js}

@@ -9,7 +9,7 @@ import {
   readEvaluationRun,
   saveEvaluationRun,
   saveTaskSetSnapshot
-} from "./index-17yszqs5.js";
+} from "./index-5bd84nxc.js";
 import {
   canonicalHash,
   computeCandidateInputContentHash,

package/dist/cli/{index-xwkn5hse.js → index-ms16gaa4.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   computePlanStructureHash
-} from "./index-2y4kargd.js";
+} from "./index-3f1tr4ha.js";
 import {
   appendCoreEventSync
-} from "./index-2v17wb75.js";
+} from "./index-qd619x3r.js";
 import {
   deleteCoordinationState,
   derivePlanId,
@@ -13,27 +13,27 @@ import {
   transitionCoordinationState,
   transitionCoordinationStateWithinTransaction,
   withCoordinationTransaction
-} from "./index-jx9f4ke1.js";
+} from "./index-6d4dc99f.js";
 import {
   getProjectDb
-} from "./index-aftapk6j.js";
+} from "./index-rk10x4zr.js";
 import {
   canonicalExistingFilesystemPath,
   legacyCanonicalExistingFilesystemPath
 } from "./index-ry16d01s.js";
 import {
   assertProjectRoot
-} from "./index-edm41q4j.js";
+} from "./index-2w0beg3s.js";
 import {
   atomicWriteSwarmFile,
   atomicWriteSwarmFileSync
-} from "./index-gy0nyfbw.js";
+} from "./index-m21x1bkx.js";
 import {
   require_proper_lockfile
 } from "./index-7g4c7s5r.js";
 import {
   PlanSchema
-} from "./index-52xdezsh.js";
+} from "./index-0jpv5z94.js";
 import {
   init_path_identity,
   unsafePathTextReason

package/dist/cli/{index-066xxa4q.js → index-qa7t42e7.js}

@@ -5,25 +5,29 @@ import {
 import {
   effectiveRetrievalOutcomes,
   readAuthoritativeKnowledgeCounterRollups
-} from "./index-zha9bdj9.js";
+} from "./index-tzq6t9wc.js";
 import {
   ALLOWED_SKILL_PATH_PREFIXES,
   validateSkillPath
-} from "./index-6rff2h8x.js";
+} from "./index-bwvbj3fp.js";
 import {
   computeOutcomeSignal,
   readKnowledge,
   resolveHiveKnowledgePath,
   resolveSwarmKnowledgePath,
   transactKnowledge
-} from "./index-bkd3450m.js";
+} from "./index-8cky7ksv.js";
 import {
-  canonicalRootKeyFresh
-} from "./index-7qefgq4j.js";
+  appendCappedJsonl,
+  resolveRetentionCap
+} from "./index-vzm6zre7.js";
 import {
   atomicWriteFileAnyRoot,
   atomicWriteSwarmFile
-} from "./index-gy0nyfbw.js";
+} from "./index-m21x1bkx.js";
+import {
+  canonicalRootKeyFresh
+} from "./index-7qefgq4j.js";
 import {
   advisoryWarn,
   init_warning_buffer
@@ -43,7 +47,7 @@ import {
 
 // src/services/skill-generator.ts
 import { existsSync as existsSync2, unlinkSync } from "fs";
-import { mkdir as mkdir4, readFile as readFile4, unlink, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir3, readFile as readFile4, unlink as unlink2, writeFile as writeFile3 } from "fs/promises";
 import * as path4 from "path";
 
 // src/config/bundled-skills.ts
@@ -406,34 +410,95 @@ init_knowledge_types();
 init_logger();
 
 // src/services/skill-changelog.ts
-init_logger();
-import { appendFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile2, rename as rename2, unlink, writeFile as writeFile2 } from "fs/promises";
 import * as path2 from "path";
-var MAX_CHANGELOG_ENTRIES_PER_SKILL = 200;
+init_logger();
+var MAX_SKILL_CHANGELOG_ENTRIES_PER_SKILL = 200;
+var MAX_SKILL_CHANGELOG_GLOBAL_ENTRIES = 1e4;
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
     throw new Error(`Invalid skill slug: ${slug} \u2014 must not contain "..", "/" or "\\"`);
   }
   return path2.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
 }
-async function appendSkillChangelog(directory, slug, entry) {
-  const filePath = resolveSkillChangelogPath(directory, slug);
-  const dirPath = path2.dirname(filePath);
-  await mkdir2(dirPath, { recursive: true });
-  await appendFile(filePath, `${JSON.stringify(entry)}
+async function rewriteLinesAtomically(filePath, lines) {
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Math.random().toString(36).slice(2, 8)}`;
+  await writeFile2(tmpPath, `${lines.join(`
+`)}
 `, "utf-8");
   try {
-    const content = await readFile2(filePath, "utf-8");
+    await rename2(tmpPath, filePath);
+  } catch (err) {
+    await unlink(tmpPath).catch(() => {});
+    throw err;
+  }
+}
+async function enforceGlobalEntryCap(dirPath) {
+  const cap = resolveRetentionCap("MAX_SKILL_CHANGELOG_GLOBAL_ENTRIES", MAX_SKILL_CHANGELOG_GLOBAL_ENTRIES);
+  let files;
+  try {
+    files = (await readdir2(dirPath)).filter((name) => name.endsWith(".jsonl"));
+  } catch {
+    return;
+  }
+  const linesByFile = new Map;
+  const stamped = [];
+  for (const file of files) {
+    let content;
+    try {
+      content = await readFile2(path2.join(dirPath, file), "utf-8");
+    } catch {
+      continue;
+    }
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
-    if (lines.length > MAX_CHANGELOG_ENTRIES_PER_SKILL) {
-      const trimmed = lines.slice(lines.length - MAX_CHANGELOG_ENTRIES_PER_SKILL);
-      await writeFile2(filePath, `${trimmed.join(`
-`)}
-`, "utf-8");
+    linesByFile.set(file, lines);
+    for (let i = 0;i < lines.length; i++) {
+      let timestamp = "";
+      try {
+        const parsed = JSON.parse(lines[i]);
+        if (typeof parsed.timestamp === "string")
+          timestamp = parsed.timestamp;
+      } catch {}
+      stamped.push({ file, index: i, timestamp });
+    }
+  }
+  if (stamped.length <= cap)
+    return;
+  stamped.sort((a, b) => {
+    if (a.timestamp !== b.timestamp) {
+      return a.timestamp < b.timestamp ? -1 : 1;
     }
+    if (a.file !== b.file)
+      return a.file < b.file ? -1 : 1;
+    return a.index - b.index;
+  });
+  const drop = new Set;
+  for (let i = 0;i < stamped.length - cap; i++) {
+    const item = stamped[i];
+    drop.add(`${item.file}\x00${item.index}`);
+  }
+  for (const [file, lines] of linesByFile) {
+    const kept = lines.filter((_, index) => !drop.has(`${file}\x00${index}`));
+    if (kept.length === lines.length)
+      continue;
+    const filePath = path2.join(dirPath, file);
+    if (kept.length === 0) {
+      await unlink(filePath).catch(() => {});
+      continue;
+    }
+    await rewriteLinesAtomically(filePath, kept);
+  }
+}
+async function appendSkillChangelog(directory, slug, entry) {
+  const filePath = resolveSkillChangelogPath(directory, slug);
+  await appendCappedJsonl(filePath, JSON.stringify(entry), {
+    maxEntries: resolveRetentionCap("MAX_SKILL_CHANGELOG_ENTRIES_PER_SKILL", MAX_SKILL_CHANGELOG_ENTRIES_PER_SKILL)
+  });
+  try {
+    await enforceGlobalEntryCap(path2.dirname(filePath));
   } catch (err) {
-    warn(`[skill-changelog] FIFO trim failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    warn(`[skill-changelog] global ceiling enforcement failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
@@ -442,8 +507,8 @@ import { createHash } from "crypto";
 import { existsSync } from "fs";
 import {
   lstat as lstat2,
-  mkdir as mkdir3,
-  readdir as readdir2,
+  mkdir as mkdir2,
+  readdir as readdir3,
   readFile as readFile3,
   realpath,
   stat as stat2
@@ -559,7 +624,7 @@ async function loadEvalSet(directory, slug) {
   }
   let entries;
   try {
-    entries = await readdir2(root);
+    entries = await readdir3(root);
   } catch (err) {
     return {
       status: "invalid",
@@ -760,7 +825,7 @@ async function evaluateSkillChange(req) {
   };
 }
 async function atomicWrite(filePath, content) {
-  await mkdir3(path3.dirname(filePath), { recursive: true });
+  await mkdir2(path3.dirname(filePath), { recursive: true });
   await atomicWriteSwarmFile(filePath, content);
 }
 async function appendRejectedSkillEdit(req, evaluation) {
@@ -871,7 +936,7 @@ async function writeEvalStub(directory, slug, cases) {
     return { written: false, path: stubPath, reason: "no directive fields" };
   }
   try {
-    await mkdir4(path4.dirname(stubPath), { recursive: true });
+    await mkdir3(path4.dirname(stubPath), { recursive: true });
     await atomicWrite2(stubPath, `${JSON.stringify({ cases })}
 `);
     return { written: true, path: stubPath };
@@ -1106,7 +1171,7 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite2(p, content) {
-  await mkdir4(path4.dirname(p), { recursive: true });
+  await mkdir3(path4.dirname(p), { recursive: true });
   await atomicWriteFileAnyRoot(p, content);
 }
 async function generateSkills(req) {
@@ -1864,7 +1929,7 @@ async function retireSkill(directory, slug, reason) {
     retiredAt: new Date().toISOString(),
     reason: reason ?? "manual_retire"
   });
-  await mkdir4(markerDir, { recursive: true });
+  await mkdir3(markerDir, { recursive: true });
   await writeFile3(markerPath, markerContent, "utf-8");
   let clearedLinks = [];
   try {
@@ -1954,13 +2019,13 @@ async function clearSkillLinks(directory, skillFilePath, slug, mode) {
   return cleared;
 }
 async function markSkillStale(skillDir, reason) {
-  await mkdir4(skillDir, { recursive: true });
+  await mkdir3(skillDir, { recursive: true });
   await writeFile3(path4.join(skillDir, "stale.marker"), reason, "utf-8");
 }
 async function clearSkillStale(skillDir) {
   const markerPath = path4.join(skillDir, "stale.marker");
   try {
-    await unlink(markerPath);
+    await unlink2(markerPath);
   } catch (err) {
     if (err instanceof Error && "code" in err && err.code === "ENOENT") {
       return;

package/dist/cli/{index-2v17wb75.js → index-qd619x3r.js}

@@ -1,10 +1,10 @@
 // @bun
 import {
   observeStoreHealth
-} from "./index-axf65x87.js";
+} from "./index-qd726agw.js";
 import {
   telemetry
-} from "./index-hwj25q9r.js";
+} from "./index-f6zgz02s.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-axf65x87.js → index-qd726agw.js}

@@ -1,15 +1,15 @@
 // @bun
-import {
-  canonicalRootKeyFresh
-} from "./index-7qefgq4j.js";
 import {
   atomicWriteSwarmFile
-} from "./index-gy0nyfbw.js";
+} from "./index-m21x1bkx.js";
 import {
   pseudonymousRef,
   resolveLineageSalt,
   telemetry
-} from "./index-hwj25q9r.js";
+} from "./index-f6zgz02s.js";
+import {
+  canonicalRootKeyFresh
+} from "./index-7qefgq4j.js";
 
 // src/health/learning-health.ts
 import { promises as fs } from "fs";

package/dist/cli/{index-c20gf089.js → index-qww0h314.js}

@@ -2,15 +2,19 @@
 import {
   cohortConfigFingerprint
 } from "./index-rtry5xyf.js";
+import {
+  appendCappedJsonl,
+  resolveRetentionCap
+} from "./index-vzm6zre7.js";
 import {
   isLinked,
   readLinkPointer,
   resolveKnowledgeStoreDir,
   resolveLinkDir
-} from "./index-a7rw4g4s.js";
+} from "./index-t8tw1bhs.js";
 
 // src/knowledge/curation-policy.ts
-import { appendFile, mkdir as mkdir2, readFile as readFile2 } from "fs/promises";
+import { readFile as readFile2 } from "fs/promises";
 import * as path2 from "path";
 
 // src/knowledge/worktree-identity.ts
@@ -85,6 +89,7 @@ async function resolveWorktreeId(directory) {
 
 // src/knowledge/curation-policy.ts
 var DEFAULT_QUORUM = { minCohortEvidence: 3 };
+var MAX_CURATION_PROPOSALS = 200;
 async function authorizeCuration(input, context, quorum = DEFAULT_QUORUM) {
   const { directory, action, entryId } = input;
   const proposal = {
@@ -99,9 +104,9 @@ async function authorizeCuration(input, context, quorum = DEFAULT_QUORUM) {
     queueMicrotask(async () => {
       try {
         const storeDir = _internals2.resolveKnowledgeStoreDir(directory);
-        await mkdir2(storeDir, { recursive: true });
-        await appendFile(path2.join(storeDir, "curation-proposals.jsonl"), `${JSON.stringify(p)}
-`, "utf-8");
+        await appendCappedJsonl(path2.join(storeDir, "curation-proposals.jsonl"), JSON.stringify(p), {
+          maxEntries: resolveRetentionCap("MAX_CURATION_PROPOSALS", MAX_CURATION_PROPOSALS)
+        });
       } catch {}
     });
   };
@@ -241,4 +246,4 @@ var _internals2 = {
   resolveKnowledgeStoreDir
 };
 
-export { authorizeCuration, buildConfigFingerprintInput, readCohortConfigFingerprint, _internals2 as _internals };
+export { MAX_CURATION_PROPOSALS, authorizeCuration, buildConfigFingerprintInput, readCohortConfigFingerprint, _internals2 as _internals };

package/dist/cli/{index-aftapk6j.js → index-rk10x4zr.js}

@@ -5,13 +5,13 @@ import {
 import {
   loadDatabaseCtor
 } from "./index-n4fzmqz8.js";
+import {
+  atomicWriteSwarmFileSync
+} from "./index-m21x1bkx.js";
 import {
   canonicalRootKeyFresh,
   lexicalRootAliasKey
 } from "./index-7qefgq4j.js";
-import {
-  atomicWriteSwarmFileSync
-} from "./index-gy0nyfbw.js";
 
 // src/db/project-db.ts
 import { existsSync, mkdirSync, unlinkSync } from "fs";

package/dist/cli/{index-bfr392e7.js → index-sahf5yz3.js}

@@ -1,13 +1,16 @@
 // @bun
-import {
-  SwarmError
-} from "./index-ee6ydtfe.js";
 import {
   bunFile
 } from "./index-p612v1mv.js";
 import {
-  readCachedTextFile
-} from "./index-gy0nyfbw.js";
+  RECENT_WRITE_WINDOW_MS,
+  readCachedTextFile,
+  wasObservedToExist,
+  wasRecentlyWrittenByThisProcess
+} from "./index-m21x1bkx.js";
+import {
+  SwarmError
+} from "./index-ee6ydtfe.js";
 import {
   warn
 } from "./index-zgwm4ryv.js";
@@ -144,8 +147,9 @@ async function readSwarmFileAsync(directory, filename, cache) {
   const ENOENT_RETRY_DELAY_MS = 10;
   const maxAttempts = 6;
   for (let attempt = 0;attempt < maxAttempts; attempt++) {
+    let resolvedPath = "";
     try {
-      const resolvedPath = _internals.validateSwarmPath(directory, filename);
+      resolvedPath = _internals.validateSwarmPath(directory, filename);
       return await _internals.readCachedTextFile(resolvedPath, async () => {
         const file = bunFile(resolvedPath);
         return await file.text();
@@ -153,6 +157,9 @@ async function readSwarmFileAsync(directory, filename, cache) {
     } catch (err) {
       const code = err?.code;
       if (code === "ENOENT") {
+        const retryWorthy = resolvedPath !== "" && (wasRecentlyWrittenByThisProcess(resolvedPath, RECENT_WRITE_WINDOW_MS) || wasObservedToExist(resolvedPath));
+        if (!retryWorthy)
+          return null;
         if (attempt >= ENOENT_MAX_ATTEMPTS - 1)
           return null;
         await new Promise((resolve2) => setTimeout(resolve2, ENOENT_RETRY_DELAY_MS));

package/dist/cli/{index-a7rw4g4s.js → index-t8tw1bhs.js}

@@ -1,10 +1,10 @@
 // @bun
+import {
+  atomicWriteFile
+} from "./index-2w0beg3s.js";
 import {
   canonicalRootKeyFresh
 } from "./index-7qefgq4j.js";
-import {
-  atomicWriteFile
-} from "./index-edm41q4j.js";
 import {
   init_logger,
   warn