@wrongstack/core 0.267.0 → 0.269.0

package/dist/storage/index.js

@@ -5,15 +5,7 @@ import * as os from 'os';
 import { hostname } from 'os';
 import 'fs';
 
-// src/utils/expect-defined.ts
-function expectDefined(value, label) {
-  if (value === null || value === void 0) {
-    const err = new Error("Expected value to be defined");
-    err.name = "ExpectDefinedError";
-    throw err;
-  }
-  return value;
-}
+// src/storage/session-store.ts
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path2.dirname(targetPath);
   await fsp.mkdir(dir, { recursive: true });
@@ -127,6 +119,16 @@ async function renameWithRetry(from, to) {
   throw lastErr;
 }
 
+// src/utils/expect-defined.ts
+function expectDefined(value, label) {
+  if (value === null || value === void 0) {
+    const err = new Error("Expected value to be defined");
+    err.name = "ExpectDefinedError";
+    throw err;
+  }
+  return value;
+}
+
 // src/utils/message-invariants.ts
 function repairToolUseAdjacency(messages) {
   const removedToolUses = [];
@@ -189,7 +191,7 @@ function hasToolResult(msg) {
 }
 function toolUseIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "assistant") return ids;
+  if (msg?.role !== "assistant") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_use") ids.add(block.id);
   }
@@ -197,7 +199,7 @@ function toolUseIds(msg) {
 }
 function toolResultIds(msg) {
   const ids = /* @__PURE__ */ new Set();
-  if (!msg || msg.role !== "user") return ids;
+  if (msg?.role !== "user") return ids;
   for (const block of contentBlocks(msg)) {
     if (block.type === "tool_result") ids.add(block.tool_use_id);
   }
@@ -237,7 +239,7 @@ function envFlag(value) {
   return !/^(0|false|no|off)$/i.test(value.trim());
 }
 var COLOR = isColorTty();
-var wrap = (open6, close) => (s) => COLOR ? `\x1B[${open6}m${s}\x1B[${close}m` : s;
+var wrap = (open7, close) => (s) => COLOR ? `\x1B[${open7}m${s}\x1B[${close}m` : s;
 var color = {
   reset: wrap("0", "0"),
   bold: wrap("1", "22"),
@@ -455,6 +457,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * processes. When the limit is reached, the oldest entry is evicted.
    */
   _loadCache = /* @__PURE__ */ new Map();
+  _indexCache = null;
   static LOAD_CACHE_MAX_ENTRIES = 50;
   constructor(opts) {
     this.dir = opts.dir;
@@ -616,16 +619,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
     let errorMsg;
     let cacheHit = false;
     try {
-      let stat7;
-      try {
-        const s = await fsp.stat(file);
-        stat7 = { mtimeMs: s.mtimeMs, size: s.size };
-      } catch (err) {
-        throw err;
-      }
+      const s = await fsp.stat(file);
+      const stat7 = { mtimeMs: s.mtimeMs, size: s.size };
       const cached = this._loadCache.get(id);
       if (cached && cached.mtimeMs === stat7.mtimeMs && cached.size === stat7.size) {
         cacheHit = true;
+        this._loadCache.delete(id);
+        this._loadCache.set(id, cached);
         return cached.data;
       }
       const raw = await fsp.readFile(file, "utf8");
@@ -711,6 +711,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       const line = JSON.stringify(summary) + "\n";
       await fsp.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
       this.indexAppendCount++;
       if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
         await this.compactIndex();
@@ -725,6 +726,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       await ensureDir(this.dir);
       const line = JSON.stringify({ action: "delete", id }) + "\n";
       await fsp.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
       this.indexAppendCount++;
     } catch {
     }
@@ -744,6 +746,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
       await fsp.writeFile(tmp, lines, "utf8");
       await fsp.rename(tmp, this.indexFile);
+      this._indexCache = null;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
@@ -757,10 +760,22 @@ var DefaultSessionStore = class _DefaultSessionStore {
    * Returns empty array when the index doesn't exist or is corrupt.
    */
   async readIndex() {
+    let stat7;
+    try {
+      const s = await fsp.stat(this.indexFile);
+      stat7 = { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      this._indexCache = null;
+      return [];
+    }
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat7.mtimeMs && this._indexCache.size === stat7.size) {
+      return [...this._indexCache.summaries];
+    }
     let raw;
     try {
       raw = await fsp.readFile(this.indexFile, "utf8");
     } catch {
+      this._indexCache = null;
       return [];
     }
     const deleted = /* @__PURE__ */ new Set();
@@ -780,7 +795,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
       } catch {
       }
     }
-    return Array.from(seen.values());
+    const summaries = Array.from(seen.values());
+    this._indexCache = { ...stat7, summaries };
+    return [...summaries];
   }
   /**
    * Rebuild the index from disk by scanning all sessions and writing a
@@ -794,6 +811,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
     await fsp.writeFile(tmp, lines, "utf8");
     await fsp.rename(tmp, this.indexFile);
+    this._indexCache = null;
     return valid.length;
   }
   /** Recursively collect session IDs from date-shard subdirectories.
@@ -1493,6 +1511,12 @@ var FileSessionWriter = class _FileSessionWriter {
       files
     });
   }
+  /**
+   * Truncate the session file to the checkpoint with the given promptIndex,
+   * removing all events that follow it. Uses a single-pass byte-offset scan
+   * so post-checkpoint content is never read or parsed — O(1) memory instead
+   * of O(N) JSON.parse calls over the full file.
+   */
   async truncateToCheckpoint(targetPromptIndex) {
     if (!this.filePath) return 0;
     if (this.flushTimer) {
@@ -1501,51 +1525,118 @@ var FileSessionWriter = class _FileSessionWriter {
     }
     await this.flushBuffer();
     await this.writeChain;
-    const raw = await fsp.readFile(this.filePath, "utf8");
-    const lines = raw.split("\n");
-    const kept = [];
+    const CHUNK_SIZE = 65536;
+    let fd;
+    let fileOffset = 0;
+    let lineStartOffset = 0;
+    let checkpointByteOffset = -1;
     let removedCount = 0;
-    let targetCheckpointLine = -1;
-    let afterTarget = false;
-    for (let i = 0; i < lines.length; i++) {
-      const line = expectDefined(lines[i]);
-      if (!line.trim()) continue;
-      let event;
-      try {
-        event = JSON.parse(line);
-      } catch {
-        kept.push(line);
-        continue;
-      }
-      if (event.type === "checkpoint") {
-        if (event.promptIndex === targetPromptIndex) {
-          targetCheckpointLine = kept.length;
-          afterTarget = true;
-        } else if (event.promptIndex > targetPromptIndex) {
-          afterTarget = true;
+    let targetCheckpointSeen = false;
+    try {
+      fd = await fsp.open(this.filePath, "r", 384);
+      while (true) {
+        const buf = Buffer.alloc(CHUNK_SIZE);
+        const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
+        if (bytesRead === 0) break;
+        let chunkPos = 0;
+        while (chunkPos < bytesRead) {
+          const idx = buf.indexOf("\n", chunkPos);
+          if (idx === -1) {
+            lineStartOffset = fileOffset + chunkPos;
+            break;
+          }
+          if (checkpointByteOffset !== -1) {
+            removedCount++;
+          } else {
+            const lineBytes = buf.subarray(chunkPos, idx);
+            const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
+            if (line.trim()) {
+              try {
+                const event = JSON.parse(line);
+                if (event.type === "checkpoint") {
+                  if (event.promptIndex === targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                    targetCheckpointSeen = true;
+                  } else if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                  }
+                } else if (targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                } else if (targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                }
+              } catch {
+              }
+            }
+          }
+          chunkPos = idx + 1;
+          lineStartOffset = fileOffset + chunkPos;
         }
-      }
-      if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
-        removedCount++;
-      } else if (event.promptIndex === void 0) {
-        if (!afterTarget || targetCheckpointLine === -1) {
-          kept.push(line);
-        } else {
-          removedCount++;
+        fileOffset += bytesRead;
+        if (chunkPos >= bytesRead) {
+          lineStartOffset = fileOffset;
         }
-      } else {
-        kept.push(line);
       }
+    } finally {
+      await fd?.close();
     }
-    const truncated = kept.join("\n");
+    if (checkpointByteOffset === -1) return 0;
+    await this.writeChain;
+    await this.handle.close();
     const tmpPath = `${this.filePath}.rewind.tmp`;
-    await fsp.writeFile(tmpPath, truncated + "\n", "utf8");
+    const src = await fsp.open(this.filePath, "r", 384);
     try {
-      await this.handle.close();
+      const statResult = await src.stat();
+      const totalSize = statResult.size;
+      const prefixBytes = checkpointByteOffset;
+      let newlineAfterCheckpoint = prefixBytes;
+      if (prefixBytes < totalSize) {
+        const probeBuf = Buffer.alloc(Math.min(CHUNK_SIZE, totalSize - prefixBytes));
+        const { bytesRead: probeRead } = await src.read(probeBuf, 0, probeBuf.length, prefixBytes);
+        if (probeRead > 0) {
+          const nl = probeBuf.indexOf("\n");
+          newlineAfterCheckpoint = nl !== -1 ? prefixBytes + nl + 1 : totalSize;
+        }
+      } else {
+        newlineAfterCheckpoint = totalSize;
+      }
+      const writeFd = await fsp.open(tmpPath, "w", 384);
+      try {
+        let copied = 0;
+        let readOffset = 0;
+        while (readOffset < newlineAfterCheckpoint) {
+          const toCopy = Math.min(CHUNK_SIZE, newlineAfterCheckpoint - readOffset);
+          const copyBuf = Buffer.alloc(toCopy);
+          const { bytesRead: r } = await src.read(copyBuf, 0, toCopy, readOffset);
+          if (r === 0) break;
+          await writeFd.write(copyBuf, 0, r);
+          readOffset += r;
+          copied += r;
+        }
+        const raw = await fsp.readFile(this.filePath);
+        const tail = raw.subarray(newlineAfterCheckpoint).toString("utf8");
+        for (const line of tail.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            JSON.parse(line);
+          } catch {
+            await writeFd.write(`${line}
+`, void 0, "utf8");
+          }
+        }
+      } finally {
+        await writeFd.close();
+      }
+      await src.close();
       await fsp.rename(tmpPath, this.filePath);
       this.handle = await fsp.open(this.filePath, "a", 384);
     } catch (err) {
       await fsp.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp.open(this.filePath, "a", 384).catch(() => this.handle);
       throw err;
     }
     await this.append({
@@ -1938,6 +2029,7 @@ var MEMORY_TYPE_LABELS = {
 // src/storage/memory-backend.ts
 var TYPE_PRIORITY_RE = /^\[(\w+)\|(\w+)\]\s+/;
 var TAG_RE = /#([\w-]+)/g;
+var MAX_MEMORY_CONSOLIDATE_BACKUPS = 5;
 function formatMetadata(entry) {
   const parts = [];
   if (entry.type && entry.priority) {
@@ -2130,6 +2222,7 @@ ${line}`;
     const backup = `${file}.bak.${Date.now()}`;
     try {
       await fsp.copyFile(file, backup);
+      await pruneConsolidateBackups(file);
     } catch {
     }
     try {
@@ -2140,6 +2233,20 @@ ${line}`;
     return removed;
   }
 };
+async function pruneConsolidateBackups(file) {
+  const dir = path2.dirname(file);
+  const base = path2.basename(file);
+  const prefix = `${base}.bak.`;
+  const backups = (await fsp.readdir(dir)).filter((name) => name.startsWith(prefix)).sort().reverse();
+  await Promise.all(
+    backups.slice(MAX_MEMORY_CONSOLIDATE_BACKUPS).map(async (name) => {
+      try {
+        await fsp.unlink(path2.join(dir, name));
+      } catch {
+      }
+    })
+  );
+}
 function parseEntries(raw, scope = "project-memory") {
   const entries = [];
   for (const line of raw.split("\n")) {
@@ -2750,27 +2857,25 @@ var GraphMemoryBackend = class {
     enriched.sort((a, b) => b.ts.localeCompare(a.ts));
     return limit ? enriched.slice(0, limit) : enriched;
   }
-  async search(scope, query, filePath, limit) {
+  async search(scope, query, _filePath, limit) {
     await this.loadGraph(scope);
     const needle = query.toLowerCase().split(/\s+/);
-    const all = await this.list(scope, filePath);
-    const scored = all.map((entry) => {
-      const words = entry.text.toLowerCase().split(/\s+/);
+    const scored = [];
+    for (const node of this.nodes.values()) {
+      if (node.entry.scope !== scope) continue;
+      const words = node.entry.text.toLowerCase().split(/\s+/);
       let score = 0;
       for (const n of needle) {
         if (words.some((w) => w.includes(n))) score += 1;
-        if (entry.tags?.some((t) => t.toLowerCase().includes(n))) score += 2;
-      }
-      const node = this.nodes.get(this.nodeId(entry));
-      if (node) {
-        if (node.priority === "critical") score += 3;
-        else if (node.priority === "high") score += 2;
-        score += node.count * 0.5;
+        if (node.entry.tags?.some((t) => t.toLowerCase().includes(n))) score += 2;
       }
-      return { entry, score };
-    });
+      if (node.priority === "critical") score += 3;
+      else if (node.priority === "high") score += 2;
+      score += node.count * 0.5;
+      if (score > 0) scored.push({ entry: node.entry, score });
+    }
     scored.sort((a, b) => b.score - a.score);
-    const matched = scored.filter((s) => s.score > 0).map((s) => s.entry);
+    const matched = scored.map((s) => s.entry);
     return limit ? matched.slice(0, limit) : matched;
   }
   async clear(scope, filePath) {
@@ -2954,7 +3059,7 @@ var SessionMemoryConsolidator = class {
     if (!result.finalText || result.finalText.trim().length < 20) return;
     if (result.iterations < this.minIterations) return;
     const provider = this.provider ?? ctx.provider;
-    if (!provider || !provider.complete) return;
+    if (!provider?.complete) return;
     try {
       const existingEntries = await this.memoryStore.list("project-memory", this.maxExistingEntries);
       const prompt = buildConsolidationPrompt(
@@ -2997,7 +3102,7 @@ var SessionMemoryConsolidator = class {
             break;
           }
           case "edit": {
-            if (op.query && op.text && op.text.trim()) {
+            if (op.query && op.text?.trim()) {
               await this.memoryStore.forget(op.query);
               await this.memoryStore.remember(op.text.trim(), void 0, {
                 type: op.type,
@@ -3298,6 +3403,9 @@ var DEFAULT_CONTEXT_CONFIG = Object.freeze({
   preserveK: 10,
   eliseThreshold: 2e3
 });
+var DEFAULT_AUTONOMY_CONFIG = Object.freeze({
+  autoProceedDelayMs: 45e3
+});
 var DEFAULT_SESSION_LOGGING_CONFIG = Object.freeze({
   auditLevel: "standard",
   sampling: {
@@ -3341,15 +3449,19 @@ var BEHAVIOR_DEFAULTS = {
     plugins: true,
     memory: true,
     modelsRegistry: true,
-    skills: true
+    skills: true,
+    tokenSavingMode: "off",
+    allowOutsideProjectRoot: true
   },
+  mcpServers: {},
   indexing: {
     onSessionStart: true,
     onEdit: true,
     watchExternal: true,
     debounceMs: 400
   },
-  session: { ...DEFAULT_SESSION_LOGGING_CONFIG }
+  session: { ...DEFAULT_SESSION_LOGGING_CONFIG },
+  autonomy: { autoProceedDelayMs: DEFAULT_AUTONOMY_CONFIG.autoProceedDelayMs }
 };
 function envBool(v) {
   return !/^(0|false|no|off)$/i.test(v.trim());
@@ -4676,11 +4788,11 @@ var ReplayLogStore = class {
         if (!entry.isFile() || !entry.name.endsWith(".replay.jsonl")) continue;
         const base = entry.name.slice(0, -".replay.jsonl".length);
         const sessionId = prefix ? `${prefix}/${base}` : base;
-        const all = await this.load(sessionId);
+        const fp = path2.join(dir, entry.name);
         out.push({
           sessionId,
-          entryCount: all.length,
-          path: path2.join(dir, entry.name)
+          entryCount: await this.countEntries(fp),
+          path: fp
         });
       }
     };
@@ -4691,6 +4803,33 @@ var ReplayLogStore = class {
   filePath(sessionId) {
     return sessionScopedPath(this.dir, sessionId, ".replay.jsonl");
   }
+  async countEntries(filePath) {
+    const handle = await fsp.open(filePath, "r");
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    let count = 0;
+    let hasNonWhitespace = false;
+    try {
+      while (true) {
+        const { bytesRead } = await handle.read(buffer, 0, buffer.length, null);
+        if (bytesRead === 0) break;
+        for (let i = 0; i < bytesRead; i++) {
+          const ch = buffer[i];
+          if (ch === 10) {
+            if (hasNonWhitespace) count++;
+            hasNonWhitespace = false;
+            continue;
+          }
+          if (ch !== 13 && ch !== 32 && ch !== 9) {
+            hasNonWhitespace = true;
+          }
+        }
+      }
+    } finally {
+      await handle.close();
+    }
+    if (hasNonWhitespace) count++;
+    return count;
+  }
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
@@ -5342,6 +5481,8 @@ var HEARTBEAT_INTERVAL_MS = 5e3;
 var STALE_TIMEOUT_MS = 3e4;
 var CLOSING_GRACE_MS = 15e3;
 var STALE_LOCK_MS = 1e4;
+var STALE_TMP_MS = 6e4;
+var MAX_STALE_TMP_FILES = 20;
 function pidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -5494,25 +5635,24 @@ var SessionRegistry = class {
   async heartbeat() {
     if (!this.currentSessionId) return;
     try {
-      const raw = await fsp.readFile(this.filePath, "utf8").catch(() => "{}");
-      const registry = JSON.parse(raw);
-      const entry = registry[this.currentSessionId];
-      if (entry) {
-        entry.lastHeartbeatAt = (/* @__PURE__ */ new Date()).toISOString();
-        if (entry.status !== "closing") {
-          const hasRunning = (entry.agents ?? []).some(
-            (a) => a.status === "running" || a.status === "streaming"
-          );
-          entry.status = hasRunning ? "active" : "idle";
-        }
-        await this.writeAtomic(registry);
-      } else if (this.lastEntry) {
-        await this.atomicUpdate((reg) => {
-          if (!reg[this.currentSessionId] && this.lastEntry) {
-            reg[this.currentSessionId] = { ...this.lastEntry, lastHeartbeatAt: (/* @__PURE__ */ new Date()).toISOString() };
+      const sessionId = this.currentSessionId;
+      const nowIso = (/* @__PURE__ */ new Date()).toISOString();
+      await this.atomicUpdate((registry) => {
+        const entry = registry[sessionId];
+        if (entry) {
+          entry.lastHeartbeatAt = nowIso;
+          if (entry.status !== "closing") {
+            const hasRunning = (entry.agents ?? []).some(
+              (a) => a.status === "running" || a.status === "streaming"
+            );
+            entry.status = hasRunning ? "active" : "idle";
           }
-        });
-      }
+          return;
+        }
+        if (this.lastEntry) {
+          registry[sessionId] = { ...this.lastEntry, lastHeartbeatAt: nowIso };
+        }
+      });
     } catch {
     }
   }
@@ -5605,15 +5745,48 @@ var SessionRegistry = class {
     }
   }
   async writeAtomicLocked(registry) {
-    const tmp = `${this.filePath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
-    await fsp.rename(tmp, this.filePath);
+    await this.pruneStaleTempFiles();
+    await this.writeAtomicFile(registry);
   }
   /** Legacy write without lock — used by heartbeat for performance. */
   async writeAtomic(registry) {
-    const tmp = `${this.filePath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
-    await fsp.rename(tmp, this.filePath);
+    await this.pruneStaleTempFiles();
+    await this.writeAtomicFile(registry);
+  }
+  async writeAtomicFile(registry) {
+    const tmp = path2.join(
+      path2.dirname(this.filePath),
+      `.${path2.basename(this.filePath)}.${randomUUID().slice(0, 8)}.tmp`
+    );
+    try {
+      await fsp.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
+      await fsp.rename(tmp, this.filePath);
+    } catch (err) {
+      await fsp.unlink(tmp).catch(() => void 0);
+      throw err;
+    }
+  }
+  async pruneStaleTempFiles() {
+    try {
+      const dir = path2.dirname(this.filePath);
+      const base = path2.basename(this.filePath);
+      const now = Date.now();
+      const stale = [];
+      for (const name of await fsp.readdir(dir)) {
+        const isTemp = (name.startsWith(`${base}.`) || name.startsWith(`.${base}.`)) && name.endsWith(".tmp");
+        if (!isTemp) continue;
+        const stat7 = await fsp.stat(path2.join(dir, name)).catch(() => null);
+        if (!stat7) continue;
+        if (now - stat7.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat7.mtimeMs });
+      }
+      stale.sort((a, b) => b.mtimeMs - a.mtimeMs);
+      await Promise.all(
+        stale.slice(MAX_STALE_TMP_FILES).map(async ({ name }) => {
+          await fsp.unlink(path2.join(dir, name)).catch(() => void 0);
+        })
+      );
+    } catch {
+    }
   }
 };
 var _instance = null;
@@ -7620,7 +7793,7 @@ function createSessionEventBridge(writer, level = "standard", options = {}) {
       if (!shouldSample(event)) return;
       try {
         await target.append(event);
-      } catch (err) {
+      } catch (_err) {
       }
     },
     async appendBatch(events) {