opencode-swarm 7.124.0 → 7.125.1

package/dist/cli/{index-4rzzzjtg.js → index-fs02c7tz.js}

@@ -458,7 +458,7 @@ function detectPowerShellEscape(command) {
 var init_edge_cases = () => {};
 
 // src/sandbox/win32/restricted-environment-executor.ts
-import { Buffer } from "buffer";
+import { Buffer as Buffer2 } from "buffer";
 import { spawnSync as spawnSync3 } from "child_process";
 import * as os2 from "os";
 import * as path2 from "path";
@@ -618,7 +618,7 @@ class WindowsSandboxExecutor {
     }
     const safePath = getSafeWindowsPath();
     const { cmdExe, powerShellExe } = getWindowsExecutablePaths();
-    const commandBase64 = Buffer.from(command, "utf8").toString("base64");
+    const commandBase64 = Buffer2.from(command, "utf8").toString("base64");
     const escapedTemp = psSingleQuoteEscape(temp);
     const escapedPath = psSingleQuoteEscape(safePath);
     const escapedCmdExe = psSingleQuoteEscape(cmdExe);
@@ -698,7 +698,7 @@ try {
   [Console]::Error.WriteLine($_.Exception.Message);
   exit 1;
 }`;
-    const encodedScript = Buffer.from(psScript, "utf16le").toString("base64");
+    const encodedScript = Buffer2.from(psScript, "utf16le").toString("base64");
     const escapedPowerShellExe = psSingleQuoteEscape(powerShellExe);
     return `& '${escapedPowerShellExe}' -NoLogo -NoProfile -NonInteractive -ExecutionPolicy Bypass -WindowStyle Hidden -EncodedCommand ${encodedScript}; exit $LASTEXITCODE`;
   }
@@ -3430,7 +3430,7 @@ import {
   rmSync,
   statSync as statSync2
 } from "fs";
-import * as fs6 from "fs/promises";
+import * as fs7 from "fs/promises";
 import * as os4 from "os";
 import * as path12 from "path";
 
@@ -4510,6 +4510,242 @@ async function archiveEvaluationArtifacts(args) {
   });
 }
 
+// src/evidence/documents-retention.ts
+import * as fs6 from "fs";
+import * as fsp from "fs/promises";
+import * as readline from "readline";
+var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
+var MAX_READ_BYTES = 100 * 1024 * 1024;
+var RENAME_MAX_ATTEMPTS = 5;
+var RENAME_BACKOFF_MS = 10;
+var RENAME_RETRY_CODES = new Set(["EPERM", "EBUSY", "ENOTEMPTY", "EACCES"]);
+var _internals10 = {
+  stat: (p) => fsp.stat(p),
+  createReadStream: (p, options) => fs6.createReadStream(p, options),
+  openSync: (p, flags) => fs6.openSync(p, flags),
+  writeSync: (fd, data, position) => fs6.writeSync(fd, data, position),
+  fsyncSync: (fd) => fs6.fsyncSync(fd),
+  closeSync: (fd) => fs6.closeSync(fd),
+  renameWithRetry: atomicRenameWithRetry,
+  unlink: (p) => fsp.unlink(p)
+};
+async function atomicRenameWithRetry(src, dst, renameFn = fsp.rename) {
+  let lastErr;
+  for (let attempt = 0;attempt < RENAME_MAX_ATTEMPTS; attempt++) {
+    try {
+      await renameFn(src, dst);
+      return;
+    } catch (err) {
+      lastErr = err;
+      const code = err?.code;
+      if (!code || !RENAME_RETRY_CODES.has(code)) {
+        throw err;
+      }
+      if (attempt < RENAME_MAX_ATTEMPTS - 1) {
+        await new Promise((resolve3) => setTimeout(resolve3, RENAME_BACKOFF_MS));
+      }
+    }
+  }
+  throw lastErr;
+}
+function emptyResult(dryRun) {
+  return {
+    inventory: 0,
+    selected: 0,
+    archived: 0,
+    corrupt: 0,
+    bytesBefore: 0,
+    bytesAfter: 0,
+    dryRun,
+    aborted: false
+  };
+}
+async function readCacheRows(filePath) {
+  const stat2 = await _internals10.stat(filePath);
+  const bytesBefore = stat2.size;
+  const stream = _internals10.createReadStream(filePath, {
+    encoding: "utf8",
+    highWaterMark: 64 * 1024
+  });
+  const rl = readline.createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  const rows = [];
+  let corrupt = 0;
+  let bytesRead = 0;
+  let aborted = false;
+  try {
+    for await (const line of rl) {
+      const lineBytes = Buffer.byteLength(line, "utf8") + 1;
+      bytesRead += lineBytes;
+      if (bytesRead > MAX_READ_BYTES) {
+        aborted = true;
+        break;
+      }
+      if (line.length === 0)
+        continue;
+      let record = null;
+      try {
+        const parsed = JSON.parse(line);
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+          record = parsed;
+        } else {
+          corrupt++;
+          continue;
+        }
+      } catch {
+        corrupt++;
+        continue;
+      }
+      rows.push({ raw: line, bytes: lineBytes, record });
+    }
+  } finally {
+    rl.close();
+    stream.destroy();
+  }
+  return { rows, corrupt, aborted, bytesBefore };
+}
+function oldestFirst(a, b) {
+  const at = typeof a.record?.capturedAt === "string" ? a.record.capturedAt : "";
+  const bt = typeof b.record?.capturedAt === "string" ? b.record.capturedAt : "";
+  if (at === bt)
+    return a.raw.localeCompare(b.raw);
+  return at.localeCompare(bt);
+}
+function selectSurvivors(rows, maxRecords, maxBytes) {
+  const ordered = [...rows].sort(oldestFirst);
+  let keepFrom = 0;
+  if (typeof maxRecords === "number" && ordered.length > maxRecords) {
+    keepFrom = ordered.length - maxRecords;
+  }
+  if (typeof maxBytes === "number" && maxBytes > 0) {
+    let total = 0;
+    for (let i = keepFrom;i < ordered.length; i++) {
+      total += ordered[i].bytes;
+    }
+    while (keepFrom < ordered.length && total > maxBytes) {
+      total -= ordered[keepFrom].bytes;
+      keepFrom++;
+    }
+  }
+  const survivors = ordered.slice(keepFrom);
+  const selected = rows.length - survivors.length;
+  return { survivors, selected };
+}
+async function rewriteAtomic(filePath, survivors) {
+  const tmpPath = `${filePath}.tmp.${Date.now()}.${process.pid}`;
+  const payload = survivors.length > 0 ? `${survivors.map((row) => row.raw).join(`
+`)}
+` : "";
+  let succeeded = false;
+  const fd = _internals10.openSync(tmpPath, "w");
+  try {
+    _internals10.writeSync(fd, payload, 0);
+    _internals10.fsyncSync(fd);
+    _internals10.closeSync(fd);
+    await _internals10.renameWithRetry(tmpPath, filePath);
+    succeeded = true;
+  } catch (err) {
+    try {
+      _internals10.closeSync(fd);
+    } catch {}
+    const msg = err instanceof Error ? err.message : String(err);
+    throw new Error(`documents-cache rewrite failed: ${msg}`);
+  } finally {
+    if (!succeeded) {
+      try {
+        await _internals10.unlink(tmpPath);
+      } catch {}
+    }
+  }
+  return Buffer.byteLength(payload, "utf8");
+}
+async function pruneEvidenceDocuments(args) {
+  const dryRun = args.dryRun === true;
+  const capsUnset = (typeof args.maxBytes !== "number" || args.maxBytes <= 0) && (typeof args.maxRecords !== "number" || args.maxRecords <= 0);
+  const filePath = validateSwarmPath(args.directory, EVIDENCE_CACHE_FILE);
+  let stat2;
+  try {
+    stat2 = await _internals10.stat(filePath);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT")
+      return emptyResult(dryRun);
+    throw err;
+  }
+  if (capsUnset) {
+    return {
+      inventory: 0,
+      selected: 0,
+      archived: 0,
+      corrupt: 0,
+      bytesBefore: stat2.size,
+      bytesAfter: stat2.size,
+      dryRun,
+      aborted: false
+    };
+  }
+  let readResult;
+  try {
+    readResult = await readCacheRows(filePath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    warn(`documents-cache prune: read failed: ${msg}`);
+    throw err;
+  }
+  if (readResult.aborted) {
+    warn(`documents-cache prune: aborted, file exceeds ${MAX_READ_BYTES} bytes; left untouched`);
+    return {
+      inventory: readResult.rows.length,
+      selected: 0,
+      archived: 0,
+      corrupt: readResult.corrupt,
+      bytesBefore: readResult.bytesBefore,
+      bytesAfter: readResult.bytesBefore,
+      dryRun,
+      aborted: true
+    };
+  }
+  const { survivors, selected } = selectSurvivors(readResult.rows, args.maxRecords, args.maxBytes);
+  if (dryRun) {
+    const bytesAfter2 = survivors.reduce((sum, row) => sum + row.bytes, 0);
+    return {
+      inventory: readResult.rows.length,
+      selected,
+      archived: 0,
+      corrupt: readResult.corrupt,
+      bytesBefore: readResult.bytesBefore,
+      bytesAfter: bytesAfter2,
+      dryRun: true,
+      aborted: false
+    };
+  }
+  if (selected === 0 && readResult.corrupt === 0) {
+    return {
+      inventory: readResult.rows.length,
+      selected: 0,
+      archived: 0,
+      corrupt: 0,
+      bytesBefore: readResult.bytesBefore,
+      bytesAfter: readResult.bytesBefore,
+      dryRun: false,
+      aborted: false
+    };
+  }
+  const bytesAfter = await rewriteAtomic(filePath, survivors);
+  return {
+    inventory: readResult.rows.length,
+    selected,
+    archived: selected,
+    corrupt: readResult.corrupt,
+    bytesBefore: readResult.bytesBefore,
+    bytesAfter,
+    dryRun: false,
+    aborted: false
+  };
+}
+
 // src/evidence/manager.ts
 var VALID_EVIDENCE_TYPES = [
   "review",
@@ -4608,11 +4844,11 @@ function validateProjectRoot(directory) {
   }
 }
 async function saveEvidence(directory, taskId, evidence) {
-  _internals10.validateProjectRoot(directory);
+  _internals11.validateProjectRoot(directory);
   const sanitizedTaskId = sanitizeTaskId2(taskId);
   const relativePath = path12.join("evidence", sanitizedTaskId, "evidence.json");
   validateSwarmPath(directory, relativePath);
-  _internals10.validateEvidence(evidence);
+  _internals11.validateEvidence(evidence);
   return withEvidenceLock(directory, relativePath, "evidence-manager", sanitizedTaskId, async () => {
     const evidencePath = validateSwarmPath(directory, relativePath);
     const evidenceDir = path12.dirname(evidencePath);
@@ -4661,7 +4897,7 @@ async function saveEvidence(directory, taskId, evidence) {
     const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
-      await fs6.rename(tempPath, evidencePath);
+      await fs7.rename(tempPath, evidencePath);
     } catch (error2) {
       try {
         rmSync(tempPath, { force: true });
@@ -4718,7 +4954,7 @@ async function loadEvidence(directory, taskId) {
     return { status: "invalid_schema", errors: ["Invalid JSON"] };
   }
   if (isFlatRetrospective(parsed)) {
-    const wrappedBundle = _internals10.wrapFlatRetrospective(parsed, sanitizedTaskId);
+    const wrappedBundle = _internals11.wrapFlatRetrospective(parsed, sanitizedTaskId);
     try {
       const validated = EvidenceBundleSchema.parse(wrappedBundle);
       try {
@@ -4728,7 +4964,7 @@ async function loadEvidence(directory, taskId) {
           const tempPath = path12.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
           try {
             await bunWrite(tempPath, bundleJson);
-            await fs6.rename(tempPath, evidencePath);
+            await fs7.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
               rmSync(tempPath, { force: true });
@@ -4807,15 +5043,15 @@ async function checkRequirementCoverage(phase, directory) {
   const relativePath = path12.join("evidence", `req-coverage-phase-${phase}.json`);
   const absolutePath = path12.resolve(directory, ".swarm", relativePath);
   try {
-    await fs6.access(absolutePath);
+    await fs7.access(absolutePath);
     return { exists: true, path: absolutePath };
   } catch {
     return { exists: false, path: absolutePath };
   }
 }
 async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
-  const taskIds = await _internals10.listEvidenceTaskIds(directory);
-  const cutoffDate = options?.now ? new Date(options.now) : _internals10.now();
+  const taskIds = await _internals11.listEvidenceTaskIds(directory);
+  const cutoffDate = options?.now ? new Date(options.now) : _internals11.now();
   cutoffDate.setDate(cutoffDate.getDate() - maxAgeDays);
   const cutoffIso = cutoffDate.toISOString();
   const selected = new Set;
@@ -4827,7 +5063,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
   for (const taskId of taskIds) {
     let result;
     try {
-      result = await _internals10.loadEvidence(directory, taskId);
+      result = await _internals11.loadEvidence(directory, taskId);
     } catch {
       warn("archive: skipping corrupt or unreadable evidence for task", taskId);
       continue;
@@ -4855,7 +5091,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
   }
   if (!options?.dryRun) {
     for (const taskId of [...selected].sort()) {
-      const deleted = await _internals10.deleteEvidence(directory, taskId);
+      const deleted = await _internals11.deleteEvidence(directory, taskId);
       if (deleted)
         archived.push(taskId);
       else
@@ -4869,6 +5105,29 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
     dryRun: options?.dryRun,
     now: options?.now
   });
+  let documentsCache = {
+    inventory: 0,
+    selected: 0,
+    archived: 0,
+    corrupt: 0,
+    bytesBefore: 0,
+    bytesAfter: 0,
+    dryRun: options?.dryRun === true,
+    aborted: false
+  };
+  if (typeof options?.cacheMaxBytes === "number" && options.cacheMaxBytes > 0 || typeof options?.cacheMaxRecords === "number" && options.cacheMaxRecords > 0) {
+    try {
+      documentsCache = await _internals11.pruneEvidenceDocuments({
+        directory,
+        maxBytes: options?.cacheMaxBytes,
+        maxRecords: options?.cacheMaxRecords,
+        dryRun: options?.dryRun
+      });
+    } catch (error2) {
+      const msg = error2 instanceof Error ? error2.message : String(error2);
+      warn(`archiveEvidence: documents-cache prune failed (fail-open): ${msg}`);
+    }
+  }
   if (options?.report) {
     return {
       inventoryEvidence: [...taskIds].sort(),
@@ -4877,7 +5136,8 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
       selectedEvidenceByCount: [...selectedByCount].sort(),
       archivedEvidence: archived.sort(),
       failedEvidence: failed.sort(),
-      evaluation
+      evaluation,
+      documentsCache
     };
   }
   return archived.sort();
@@ -4885,7 +5145,7 @@ async function archiveEvidence(directory, maxAgeDays, maxBundles, options) {
 function validateEvidence(evidence) {
   return EvidenceSchema.parse(evidence);
 }
-var _internals10 = {
+var _internals11 = {
   wrapFlatRetrospective,
   loadEvidence,
   listEvidenceTaskIds,
@@ -4893,6 +5153,7 @@ var _internals10 = {
   validateEvidence,
   saveEvidence,
   deleteEvidence,
+  pruneEvidenceDocuments,
   now: () => new Date
 };
 

package/dist/cli/{index-zjedv2bd.js → index-ghteqdy1.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   authorizeCuration
-} from "./index-13d2g7k9.js";
+} from "./index-kvrk3h8p.js";
 import {
   findNearDuplicate,
   inferTags,
@@ -9,7 +9,7 @@ import {
   resolveSwarmKnowledgePath,
   resolveSwarmRejectedPath,
   transactKnowledge
-} from "./index-2x4maxte.js";
+} from "./index-mwdcvh0e.js";
 import {
   resolveKnowledgeStoreDir
 } from "./index-q27bajqb.js";

package/dist/cli/{index-13d2g7k9.js → index-kvrk3h8p.js}

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

package/dist/cli/{index-eeg04r0x.js → index-kws8zn6y.js}

@@ -2,7 +2,7 @@
 import {
   readKnowledge,
   transactKnowledge
-} from "./index-2x4maxte.js";
+} from "./index-mwdcvh0e.js";
 import {
   resolveKnowledgeStoreDir
 } from "./index-q27bajqb.js";