@wrongstack/core 0.273.1 → 0.274.0

package/dist/storage/index.js

@@ -1,5 +1,5 @@
 import { createReadStream } from 'fs';
-import * as fsp from 'fs/promises';
+import * as fsp2 from 'fs/promises';
 import * as path2 from 'path';
 import { createInterface } from 'readline';
 import { randomBytes, randomUUID, createHash } from 'crypto';
@@ -9,16 +9,16 @@ import { hostname } from 'os';
 // src/storage/session-store.ts
 async function atomicWrite(targetPath, content, opts = {}) {
   const dir = path2.dirname(targetPath);
-  await fsp.mkdir(dir, { recursive: true });
+  await fsp2.mkdir(dir, { recursive: true });
   const tmp = path2.join(dir, `.${path2.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fsp.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fsp2.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fsp.writeFile(tmp, content, { flag: "wx" });
+      await fsp2.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fsp.open(tmp, "r+");
+      const fh = await fsp2.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -28,29 +28,29 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat7 = await fsp.stat(targetPath);
-      mode = stat7.mode & 511;
+      const stat10 = await fsp2.stat(targetPath);
+      mode = stat10.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fsp.chmod(tmp, mode);
+      await fsp2.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
   } catch (err) {
     try {
-      await fsp.unlink(tmp);
+      await fsp2.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fsp.mkdir(dir, { recursive: true });
+  await fsp2.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
   const dir = path2.dirname(targetPath);
-  await fsp.mkdir(dir, { recursive: true });
+  await fsp2.mkdir(dir, { recursive: true });
   const lockPath = path2.join(dir, `.${path2.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
@@ -58,20 +58,20 @@ async function withFileLock(targetPath, fn, opts = {}) {
   let handle;
   for (; ; ) {
     try {
-      handle = await fsp.open(lockPath, "wx");
+      handle = await fsp2.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        await fsp.mkdir(dir, { recursive: true });
+        await fsp2.mkdir(dir, { recursive: true });
         continue;
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat7 = await fsp.stat(lockPath);
-        if (Date.now() - stat7.mtimeMs > staleMs) {
-          await fsp.unlink(lockPath);
+        const stat10 = await fsp2.stat(lockPath);
+        if (Date.now() - stat10.mtimeMs > staleMs) {
+          await fsp2.unlink(lockPath);
           continue;
         }
       } catch {
@@ -91,7 +91,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fsp.unlink(lockPath);
+      await fsp2.unlink(lockPath);
     } catch {
     }
   }
@@ -99,14 +99,14 @@ async function withFileLock(targetPath, fn, opts = {}) {
 var TRANSIENT_RENAME_CODES = /* @__PURE__ */ new Set(["EPERM", "EBUSY", "EACCES", "ENOTEMPTY"]);
 async function renameWithRetry(from, to) {
   if (process.platform !== "win32") {
-    await fsp.rename(from, to);
+    await fsp2.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fsp.rename(from, to);
+      await fsp2.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -240,7 +240,7 @@ function envFlag(value) {
   return !/^(0|false|no|off)$/i.test(value.trim());
 }
 var COLOR = isColorTty();
-var wrap = (open7, close) => (s) => COLOR ? `\x1B[${open7}m${s}\x1B[${close}m` : s;
+var wrap = (open8, close) => (s) => COLOR ? `\x1B[${open8}m${s}\x1B[${close}m` : s;
 var color = {
   reset: wrap("0", "0"),
   bold: wrap("1", "22"),
@@ -432,1541 +432,1674 @@ function resolveWstackPaths(opts) {
     projectStatus: (projectHash2) => path2.join(globalRoot, "projects", projectHash2, "status.json")
   };
 }
-function sanitizeModel(model) {
-  return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
-}
-function generateSessionId(startedAt, model) {
-  const date = startedAt.slice(0, 10);
-  const time = startedAt.slice(11, 19).replace(/:/g, "-");
-  const suffix = randomBytes(2).toString("hex");
-  const modelPart = model ? `_${sanitizeModel(model)}` : "";
-  return `${date}/${time}Z${modelPart}_${suffix}`;
+
+// src/storage/session-helpers.ts
+function userInputTitle(content) {
+  const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+  return (text || "(non-text input)").slice(0, 60);
 }
 
-// src/storage/session-store.ts
-var DefaultSessionStore = class _DefaultSessionStore {
-  dir;
+// src/storage/file-session-writer.ts
+var FileSessionWriter = class _FileSessionWriter {
+  constructor(id, handle, startedAt, meta, events, opts = {}, traceId) {
+    this.id = id;
+    this.handle = handle;
+    this.startedAt = startedAt;
+    this.meta = meta;
+    this.events = events;
+    this.resumed = opts.resumed ?? false;
+    this.manifestFile = opts.dir ? path2.join(opts.dir, `${path2.basename(id)}.summary.json`) : "";
+    this.filePath = opts.filePath ?? "";
+    this.secretScrubber = opts.secretScrubber;
+    this.onCloseCb = opts.onClose;
+    this.summary = {
+      id,
+      title: "(empty session)",
+      startedAt,
+      model: meta.model ?? "unknown",
+      provider: meta.provider ?? "unknown",
+      tokenTotal: 0
+    };
+    this.traceId = traceId;
+  }
+  id;
+  handle;
+  startedAt;
+  meta;
   events;
-  secretScrubber;
+  closed = false;
+  closePromise = null;
+  manifestFile;
+  summary;
+  tokenIn = 0;
+  tokenOut = 0;
+  filePath;
+  get transcriptPath() {
+    return this.filePath || void 0;
+  }
   /**
-   * In-memory cache for load() results, keyed by session ID. The cache is
-   * invalidated when the file's mtimeMs or size changes (indicating the
-   * file was written to). This eliminates redundant full-file reads and
-   * JSON parses when the same session is loaded multiple times within the
-   * store's lifetime (e.g., webui session detail views, list() fallbacks).
-   *
-   * Max size is capped to prevent unbounded memory growth in long-running
-   * processes. When the limit is reached, the oldest entry is evicted.
+   * Lazy session_start/session_resumed init, shared by all appenders.
+   * A single promise (not a boolean) so a second append racing the first
+   * can't push its event into the buffer BEFORE the first append's event —
+   * every appender awaits the same init and resumes in FIFO call order.
    */
-  _loadCache = /* @__PURE__ */ new Map();
-  _indexCache = null;
-  static LOAD_CACHE_MAX_ENTRIES = 50;
-  static LIST_SCAN_CONCURRENCY = 32;
-  constructor(opts) {
-    this.dir = opts.dir;
-    this.events = opts.events;
-    this.secretScrubber = opts.secretScrubber;
+  initPromise = null;
+  ensureInit() {
+    if (!this.initPromise) this.initPromise = this.writeSessionStartLazy();
+    return this.initPromise;
+  }
+  resumed;
+  appendFailCount = 0;
+  lastAppendWarnAt = 0;
+  secretScrubber;
+  onCloseCb;
+  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
+  traceId;
+  // ── Write buffer — batches events to reduce per-event disk I/O ──────────────
+  //
+  // Every append() pushes the scrubbed event into an in-memory buffer instead
+  // of calling handle.appendFile() synchronously. The buffer flushes to disk
+  // when it reaches FLUSH_SIZE events OR after FLUSH_INTERVAL_MS of inactivity.
+  // This cuts the number of disk writes by ~95% without changing the on-disk
+  // format — the JSONL is still one JSON object per line.
+  writeBuffer = [];
+  flushTimer = null;
+  static FLUSH_INTERVAL_MS = 500;
+  static FLUSH_SIZE = 50;
+  // ── Write serialization ─────────────────────────────────────────────────────
+  //
+  // All disk writes are funneled through a FIFO promise chain. Without it,
+  // a timer-driven flush racing an explicit flush()/close() issues two
+  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
+  // may complete them out of order (chronology breaks) or, for large
+  // batches, interleave partial writes (torn JSONL lines). The chain keeps
+  // exactly one write in flight; failures don't break the chain.
+  writeChain = Promise.resolve();
+  /** Enqueue a write on the FIFO chain. Resolves/rejects with that write. */
+  enqueueWrite(data) {
+    const write = this.writeChain.then(() => this.handle.appendFile(data, "utf8"));
+    this.writeChain = write.then(
+      () => void 0,
+      () => void 0
+    );
+    return write;
   }
+  // ── Enriched summary tracking ───────────────────────────────────────────────
+  iterationCount = 0;
+  toolCallCount = 0;
+  toolErrorCount = 0;
+  toolBreakdown = {};
+  fileChangeCount = 0;
+  compactionCount = 0;
+  outcome = void 0;
   /**
-   * Clear the load() cache. Useful for testing or when the caller knows
-   * the file has changed externally (e.g., another process wrote to it).
+   * Scrub secrets out of conversation-turn events before they are observed
+   * for the summary, written to the JSONL log, or surfaced on resume. Only
+   * `user_input` / `llm_response` carry free-form user/model text; other event
+   * types either have no secret-bearing content or are already scrubbed
+   * upstream (tool results). Returns the event unchanged when no scrubber is
+   * configured.
    */
-  clearLoadCache(sessionId) {
-    if (sessionId !== void 0) {
-      this._loadCache.delete(sessionId);
-    } else {
-      this._loadCache.clear();
+  scrubEvent(event) {
+    const s = this.secretScrubber;
+    if (!s) return event;
+    if (event.type === "user_input") {
+      return {
+        ...event,
+        content: typeof event.content === "string" ? s.scrub(event.content) : s.scrubObject(event.content)
+      };
+    }
+    if (event.type === "llm_response") {
+      return { ...event, content: s.scrubObject(event.content) };
     }
+    return event;
   }
-  // ── Storage event helpers ───────────────────────────────────────────────────
-  emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
-    this.events?.emit("storage.read", {
-      sessionId,
-      store: "session",
-      filePath,
-      operation,
-      outcome,
-      durationMs,
-      ...error !== void 0 ? { error } : {}
-    });
+  pendingFileSnapshots = [];
+  /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
+  openToolUses = /* @__PURE__ */ new Set();
+  recordFileChange(input) {
+    this.pendingFileSnapshots.push(input);
   }
-  emitWrite(sessionId, filePath, operation, outcome, durationMs, eventCount, error) {
-    this.events?.emit("storage.write", {
-      sessionId,
-      store: "session",
-      filePath,
-      operation,
-      outcome,
-      durationMs,
-      ...eventCount !== void 0 ? { eventCount } : {},
-      ...error !== void 0 ? { error } : {}
-    });
+  get pendingToolUses() {
+    return Array.from(this.openToolUses);
   }
-  emitError(sessionId, filePath, operation, error, recoverable) {
-    this.events?.emit("storage.error", {
-      sessionId,
-      store: "session",
-      filePath,
-      operation,
-      error,
-      recoverable
-    });
+  async writeSessionStartLazy() {
+    const record = `${JSON.stringify({
+      type: this.resumed ? "session_resumed" : "session_start",
+      ts: this.startedAt,
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    try {
+      await this.enqueueWrite(record);
+    } catch {
+    }
   }
-  /** Absolute path to the session index file. */
-  get indexFile() {
-    return path2.join(this.dir, "_index.jsonl");
+  async append(event) {
+    if (this.closed) return;
+    await this.ensureInit();
+    const scrubbed = this.scrubEvent(event);
+    this.observeForSummary(scrubbed);
+    this.writeBuffer.push(scrubbed);
+    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flushBuffer();
+    } else {
+      this.scheduleFlush();
+    }
   }
-  /** Join session ID to its absolute path within the store directory. */
-  sessionPath(id, ext) {
-    return path2.join(this.dir, `${id}${ext}`);
+  async appendBatch(events) {
+    if (this.closed || events.length === 0) return;
+    await this.ensureInit();
+    for (const event of events) {
+      const scrubbed = this.scrubEvent(event);
+      this.observeForSummary(scrubbed);
+      this.writeBuffer.push(scrubbed);
+    }
+    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
+      if (this.flushTimer) {
+        clearTimeout(this.flushTimer);
+        this.flushTimer = null;
+      }
+      await this.flushBuffer();
+    } else {
+      this.scheduleFlush();
+    }
   }
   /**
-   * Ensure the directory implied by the session ID exists. When the ID
-   * contains a date prefix like `2026-06-06/...`, this creates the date
-   * subdirectory so sessions group naturally by day.
+   * Flush buffered events to disk immediately. Critical events
+   * (user_input, llm_response) call this so they survive SIGKILL/crash
+   * instead of sitting in the in-memory buffer for up to 500ms.
+   *
+   * Idempotent — cancels any pending timer and writes whatever has
+   * accumulated in the buffer. Safe to call even when the buffer
+   * is empty (no-op).
    */
-  async ensureShardDir(id) {
-    const dirPath = path2.dirname(path2.join(this.dir, id));
-    await ensureDir(dirPath);
-    return dirPath;
+  async flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushBuffer();
   }
-  async create(meta) {
-    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
-    const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt, meta.model ?? meta.provider);
-    const shardDir = await this.ensureShardDir(id);
-    const file = path2.join(shardDir, `${path2.basename(id)}.jsonl`);
-    const t0 = Date.now();
-    let handle;
-    try {
-      handle = await fsp.open(file, "a", 384);
-    } catch (err) {
-      this.emitError(id, file, "create", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session file: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
-    }
-    try {
-      const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
-        dir: shardDir,
-        filePath: file,
-        secretScrubber: this.secretScrubber,
-        onClose: (s) => this.appendToIndex(s)
+  /** Schedule a deferred flush. No-op if a timer is already pending. */
+  scheduleFlush() {
+    if (this.flushTimer) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flushBuffer().catch(() => {
       });
-      this.emitWrite(id, file, "create", "success", Date.now() - t0);
-      return writer;
-    } catch (err) {
-      await handle.close().catch((e) => console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.handle_close_failed",
-        message: e instanceof Error ? e.message : String(e),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })));
-      this.emitError(id, file, "create", toErrorMessage(err), true);
-      throw err;
-    }
-  }
-  async resume(id) {
-    const file = this.sessionPath(id, ".jsonl");
-    const t0 = Date.now();
-    const data = await this.load(id);
-    let handle;
-    try {
-      handle = await fsp.open(file, "a", 384);
-    } catch (err) {
-      this.emitError(id, file, "resume", toErrorMessage(err), false);
-      throw new Error(
-        `Failed to open session "${id}" for append: ${toErrorMessage(err)}`,
-        { cause: err }
-      );
-    }
-    try {
-      const writer = new FileSessionWriter(
-        id,
-        handle,
-        (/* @__PURE__ */ new Date()).toISOString(),
-        {
-          id,
-          model: data.metadata.model,
-          provider: data.metadata.provider
-        },
-        this.events,
-        {
-          resumed: true,
-          // Shard directory (sessions/<date>/) — must match create() so the
-          // .summary.json sidecar lands next to the JSONL instead of the
-          // sessions root (where summaryFor() would never find it).
-          dir: path2.dirname(file),
-          filePath: file,
-          secretScrubber: this.secretScrubber,
-          onClose: (s) => this.appendToIndex(s)
-        }
-      );
-      this.emitWrite(id, file, "resume", "success", Date.now() - t0);
-      return { writer, data };
-    } catch (err) {
-      await handle.close().catch((e) => console.warn(JSON.stringify({
-        level: "warn",
-        event: "session_store.handle_close_failed",
-        message: e instanceof Error ? e.message : String(e),
-        timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      })));
-      this.emitError(id, file, "resume", toErrorMessage(err), true);
-      throw err;
-    }
+    }, _FileSessionWriter.FLUSH_INTERVAL_MS);
   }
-  async load(id) {
-    const file = this.sessionPath(id, ".jsonl");
+  /**
+   * Flush all buffered events to disk as a single appendFile call.
+   * Errors use the same throttled-warning pattern the old per-event
+   * append path used — one warning every 5s with a suppressed count.
+   * On failure the buffer is cleared (events are best-effort, same as
+   * the old per-event path where a failed write was silently dropped).
+   */
+  async flushBuffer() {
+    if (this.writeBuffer.length === 0) return;
+    const eventCount = this.writeBuffer.length;
+    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    this.writeBuffer = [];
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
-    let cacheHit = false;
     try {
-      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");
-      const lines = raw.split("\n").filter((l) => l.trim());
-      const events = [];
-      let sessionStartEvent;
-      let sessionEndEvent;
-      let sessionModel;
-      let sessionProvider;
-      let sessionPendingToolUses;
-      const messages = [];
-      const openToolUses = /* @__PURE__ */ new Set();
-      let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
-      for (const line of lines) {
-        try {
-          const parsed = JSON.parse(line);
-          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            const ev = parsed;
-            events.push(ev);
-            if (ev.type === "session_start" && !sessionStartEvent) {
-              sessionStartEvent = ev;
-              sessionModel = ev.model;
-              sessionProvider = ev.provider;
-            }
-            if (ev.type === "session_end") {
-              sessionEndEvent = ev;
-              sessionPendingToolUses = ev.pendingToolUses;
-            }
-            if (ev.type === "user_input") {
-              openToolUses.clear();
-              messages.push({ role: "user", content: ev.content, ts: ev.ts });
-            } else if (ev.type === "llm_response") {
-              messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
-              for (const b of ev.content) {
-                if (b.type === "tool_use") openToolUses.add(b.id);
-              }
-              usage = {
-                input: usage.input + (ev.usage.input ?? 0),
-                output: usage.output + (ev.usage.output ?? 0),
-                cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
-                cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
-              };
-            } else if (ev.type === "tool_result") {
-              if (!openToolUses.has(ev.id)) {
-                this.events?.emit("session.damaged", {
-                  sessionId: id,
-                  detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
-                });
-                continue;
-              }
-              openToolUses.delete(ev.id);
-              const resultBlock = {
-                type: "tool_result",
-                tool_use_id: ev.id,
-                content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
-                is_error: ev.isError
-              };
-              const last = messages[messages.length - 1];
-              const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
-              if (lastIsToolResultUser && Array.isArray(last.content)) {
-                last.content.push(resultBlock);
-              } else {
-                messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
-              }
-            }
-          }
-        } catch {
-        }
-      }
-      if (openToolUses.size > 0) {
-        this.events?.emit("session.damaged", {
-          sessionId: id,
-          detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
-        });
-      }
-      const repaired = repairToolUseAdjacency(messages);
-      if (repaired.report.changed) {
-        this.events?.emit("session.damaged", {
-          sessionId: id,
-          detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
-        });
-      }
-      const meta = {
-        id,
-        startedAt: sessionStartEvent?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
-        endedAt: sessionEndEvent?.ts,
-        model: sessionModel,
-        provider: sessionProvider,
-        pendingToolUses: sessionPendingToolUses
-      };
-      const toolCallEnds = extractToolCallEnds(events);
-      const data = { metadata: meta, events, messages: repaired.messages, usage, toolCallEnds };
-      if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
-        const oldest = this._loadCache.keys().next().value;
-        if (oldest !== void 0) {
-          this._loadCache.delete(oldest);
-        }
-      }
-      this._loadCache.set(id, { mtimeMs: stat7.mtimeMs, size: stat7.size, data });
-      return data;
+      await this.enqueueWrite(batch);
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
-      throw err;
-    } finally {
-      this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
-      if (cacheHit) {
-        this.events?.emit("storage.cache_hit", {
-          sessionId: id,
-          store: "session",
-          filePath: file,
-          operation: "load",
-          durationMs: Date.now() - t0
-        });
+      this.appendFailCount += eventCount;
+      const now = Date.now();
+      if (now - this.lastAppendWarnAt > 5e3) {
+        const suppressed = this.appendFailCount - 1;
+        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
+        console.warn(
+          "[session] flush failed:",
+          toErrorMessage(err),
+          tail
+        );
+        this.lastAppendWarnAt = now;
+        this.appendFailCount = 0;
       }
+    } finally {
+      this.events?.emit("storage.write", {
+        sessionId: this.id,
+        store: "session",
+        filePath: this.filePath,
+        operation: "flush",
+        outcome,
+        durationMs: Date.now() - t0,
+        ...errorMsg !== void 0 ? { error: errorMsg } : {},
+        ...eventCount !== void 0 ? { eventCount } : {},
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
     }
   }
-  /**
-   * Streaming search over a session's JSONL. Walks the file once, parses
-   * each event lazily, and yields only the events that match `predicate`.
-   * Stops as soon as `opts.limit` matches are collected.
-   *
-   * Why this exists: `load()` parses the entire file into memory and
-   * rebuilds `messages`/`toolCallEnds` for every caller. `search()` only
-   * needs to know which events contain matching text — a per-line
-   * predicate is enough. The full parse work (and the `_loadCache` poll)
-   * is wasted in that case.
-   *
-   * Memory: O(hits) regardless of file size. Disk: one linear scan,
-   * terminated at `limit` if the caller asked for one.
-   *
-   * Errors: missing file yields []. Corrupt lines are skipped (same
-   * policy as `load()`). Aborting via `signal` rejects with `AbortError`.
-   */
-  async searchEvents(id, predicate, opts) {
-    const file = this.sessionPath(id, ".jsonl");
-    const limit = opts?.limit;
-    const signal = opts?.signal;
-    const out = [];
-    let stat7;
-    try {
-      stat7 = await fsp.stat(file);
-    } catch (err) {
-      if (err.code === "ENOENT") return [];
-      throw err;
-    }
-    if (stat7.size === 0) return [];
-    let fh;
-    try {
-      fh = await fsp.open(file, "r");
-      const CHUNK = 64 * 1024;
-      const buf = Buffer.alloc(CHUNK);
-      let leftover = "";
-      let eventIndex = 0;
-      for (let position = 0; ; position += buf.byteLength) {
-        if (signal?.aborted) {
-          const reason = signal.reason ?? new DOMException("Aborted", "AbortError");
-          throw reason;
-        }
-        const { bytesRead } = await fh.read(buf, 0, CHUNK, position);
-        if (bytesRead === 0) break;
-        const text = leftover + buf.subarray(0, bytesRead).toString("utf8");
-        const parts = text.split("\n");
-        leftover = parts.pop() ?? "";
-        for (const line of parts) {
-          if (!line) continue;
-          let ev;
-          try {
-            const parsed = JSON.parse(line);
-            if (parsed === null || typeof parsed !== "object" || typeof parsed.type !== "string" || typeof parsed.ts !== "string") {
-              continue;
-            }
-            ev = parsed;
-          } catch {
-            continue;
-          }
-          if (predicate(ev, eventIndex, ev.ts)) {
-            out.push({ event: ev, eventIndex, ts: ev.ts });
-            if (limit !== void 0 && out.length >= limit) {
-              return out;
-            }
-          }
-          eventIndex++;
-        }
+  observeForSummary(event) {
+    if (event.type === "llm_response") {
+      for (const block of event.content) {
+        if (block.type === "tool_use") this.openToolUses.add(block.id);
       }
-      if (leftover.trim()) {
-        try {
-          const parsed = JSON.parse(leftover);
-          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            const ev = parsed;
-            if (predicate(ev, eventIndex, ev.ts)) {
-              out.push({ event: ev, eventIndex, ts: ev.ts });
-            }
-          }
-        } catch {
-        }
+    }
+    if (event.type === "tool_use") {
+      this.openToolUses.add(event.id);
+    } else if (event.type === "tool_call_start") {
+      this.toolCallCount++;
+      this.toolBreakdown[event.name] = (this.toolBreakdown[event.name] ?? 0) + 1;
+    } else if (event.type === "tool_result") {
+      this.openToolUses.delete(event.id);
+      if (event.isError) {
+        this.toolErrorCount++;
+        this.outcome = "error";
       }
-      return out;
-    } finally {
-      if (fh) await fh.close().catch(() => void 0);
+    } else if (event.type === "file_snapshot") {
+      this.fileChangeCount += event.files.length;
+    } else if (event.type === "compaction") {
+      this.compactionCount++;
+    }
+    if (event.type === "error" || event.type === "provider_error") {
+      this.outcome = "error";
+    }
+    if (event.type === "user_input" && this.summary.title === "(empty session)") {
+      this.summary = { ...this.summary, title: userInputTitle(event.content) };
+    } else if (event.type === "llm_response") {
+      this.tokenIn += event.usage.input;
+      this.tokenOut += event.usage.output;
+      this.summary = { ...this.summary, tokenTotal: this.tokenIn + this.tokenOut };
+    } else if (event.type === "session_end") {
+      const total = event.usage.input + event.usage.output;
+      if (total > 0) this.summary = { ...this.summary, tokenTotal: total };
+    } else if (event.type === "in_flight_start") {
+      this.iterationCount++;
     }
   }
-  async list(limit = 20) {
-    try {
-      await ensureDir(this.dir);
-      const indexed = await this.readIndex();
-      if (indexed.length > 0) {
-        indexed.sort((a, b) => {
-          if (a.startedAt < b.startedAt) return 1;
-          if (a.startedAt > b.startedAt) return -1;
-          return a.id.localeCompare(b.id);
+  async close() {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.doClose();
+    return this.closePromise;
+  }
+  async doClose() {
+    this.closed = true;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    await this.flushBuffer();
+    await this.writeChain;
+    this.summary = {
+      ...this.summary,
+      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      iterationCount: this.iterationCount,
+      toolCallCount: this.toolCallCount,
+      toolErrorCount: this.toolErrorCount,
+      fileChangeCount: this.fileChangeCount,
+      compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
+      toolBreakdown: { ...this.toolBreakdown },
+      outcome: this.outcome ?? "completed"
+    };
+    if (this.manifestFile) {
+      const t0 = Date.now();
+      let outcome = "success";
+      let errorMsg;
+      try {
+        await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
+      } catch (err) {
+        outcome = "failure";
+        errorMsg = toErrorMessage(err);
+      } finally {
+        this.events?.emit("storage.write", {
+          sessionId: this.id,
+          store: "session",
+          filePath: this.manifestFile,
+          operation: "close",
+          outcome,
+          durationMs: Date.now() - t0,
+          ...errorMsg !== void 0 ? { error: errorMsg } : {},
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
         });
-        return indexed.slice(0, limit);
       }
-      return await this.listFromDirectoryScan(limit);
-    } catch {
-      return [];
     }
-  }
-  // ── Session index (_index.jsonl) ─────────────────────────────────────────
-  //
-  // One JSON line per closed session, appended atomically on close().
-  // When a session is deleted, a tombstone {action:"delete",id:"..."} is
-  // appended. On read, tombstones filter out matching session entries.
-  // This keeps listing O(lines-in-index) instead of O(files-on-disk).
-  //
-  // The index auto-compacts every N appends to prevent unbounded growth
-  // from tombstones and duplicate entries (resume cycles).
-  indexAppendCount = 0;
-  static COMPACT_EVERY = 30;
-  /** Append a session summary to the index. */
-  async appendToIndex(summary) {
+    const idxT0 = Date.now();
+    let idxOutcome = "success";
+    let idxError;
     try {
-      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();
-        this.indexAppendCount = 0;
-      }
-    } catch {
+      await this.onCloseCb?.(this.summary);
+    } catch (err) {
+      idxOutcome = "failure";
+      idxError = toErrorMessage(err);
+    } finally {
+      this.events?.emit("storage.write", {
+        sessionId: this.summary.id,
+        store: "session",
+        filePath: this.filePath,
+        operation: "index_append",
+        outcome: idxOutcome,
+        durationMs: Date.now() - idxT0,
+        ...idxError !== void 0 ? { error: idxError } : {},
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
     }
-  }
-  /** Append a tombstone entry for a deleted session. */
-  async writeTombstone(id) {
     try {
-      await ensureDir(this.dir);
-      const line = JSON.stringify({ action: "delete", id }) + "\n";
-      await fsp.appendFile(this.indexFile, line, "utf8");
-      this._indexCache = null;
-      this.indexAppendCount++;
+      await this.handle.close();
     } catch {
     }
   }
-  /**
-   * Compact the index: read all entries, drop tombstones, deduplicate
-   * (keep latest per session), and rewrite. Atomic via temp+rename.
-   */
-  async compactIndex() {
-    const t0 = Date.now();
-    let outcome = "success";
-    let errorMsg;
-    try {
-      const entries = await this.readIndex();
-      if (entries.length === 0) return;
-      const tmp = `${this.indexFile}.compact.tmp`;
-      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);
-    } finally {
-      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+  async writeCheckpoint(promptIndex, promptPreview) {
+    const fileCount = this.pendingFileSnapshots.length;
+    if (fileCount > 0) {
+      await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
+      this.pendingFileSnapshots = [];
     }
+    await this.append({
+      type: "checkpoint",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      promptIndex,
+      promptPreview
+    });
+    this.events?.emit("checkpoint.written", {
+      promptIndex,
+      promptPreview,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      fileCount
+    });
+  }
+  async writeFileSnapshot(promptIndex, files) {
+    await this.append({
+      type: "file_snapshot",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      promptIndex,
+      files
+    });
   }
   /**
-   * Read the index file and return deduplicated session summaries.
-   * Entries with a matching tombstone are filtered out.
-   * Returns empty array when the index doesn't exist or is corrupt.
+   * 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 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];
+  async truncateToCheckpoint(targetPromptIndex) {
+    if (!this.filePath) return 0;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
     }
-    let raw;
-    try {
-      raw = await fsp.readFile(this.indexFile, "utf8");
-    } catch {
-      this._indexCache = null;
-      return [];
+    await this.flushBuffer();
+    await this.writeChain;
+    const CHUNK_SIZE = 65536;
+    let fd;
+    let fileOffset = 0;
+    let lineStartOffset = 0;
+    let checkpointByteOffset = -1;
+    let removedCount = 0;
+    let targetCheckpointSeen = false;
+    try {
+      fd = await fsp2.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;
+        }
+        fileOffset += bytesRead;
+        if (chunkPos >= bytesRead) {
+          lineStartOffset = fileOffset;
+        }
+      }
+    } finally {
+      await fd?.close();
     }
-    const deleted = /* @__PURE__ */ new Set();
-    const seen = /* @__PURE__ */ new Map();
-    for (const line of raw.split("\n")) {
-      if (!line.trim()) continue;
+    if (checkpointByteOffset === -1) return 0;
+    await this.writeChain;
+    await this.handle.close();
+    const tmpPath = `${this.filePath}.rewind.tmp`;
+    const src = await fsp2.open(this.filePath, "r", 384);
+    try {
+      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 fsp2.open(tmpPath, "w", 384);
       try {
-        const entry = JSON.parse(line);
-        if (entry.action === "delete" && entry.id) {
-          deleted.add(entry.id);
-          seen.delete(entry.id);
-          continue;
+        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;
         }
-        if (entry.id && !deleted.has(entry.id)) {
-          seen.set(entry.id, entry);
+        let tailOffset = newlineAfterCheckpoint;
+        let leftover = "";
+        while (tailOffset < totalSize) {
+          const toRead = Math.min(CHUNK_SIZE, totalSize - tailOffset);
+          const tailBuf = Buffer.alloc(toRead);
+          const { bytesRead: tr } = await src.read(tailBuf, 0, toRead, tailOffset);
+          if (tr === 0) break;
+          const chunk = leftover + tailBuf.subarray(0, tr).toString("utf8");
+          const lastNl = chunk.lastIndexOf("\n");
+          if (lastNl === -1) {
+            leftover = chunk;
+          } else {
+            for (const line of chunk.slice(0, lastNl + 1).split("\n")) {
+              if (!line.trim()) continue;
+              try {
+                JSON.parse(line);
+              } catch {
+                await writeFd.write(`${line}
+`, void 0, "utf8");
+              }
+            }
+            leftover = chunk.slice(lastNl + 1);
+          }
+          tailOffset += tr;
         }
-      } catch {
+        if (leftover.trim()) {
+          try {
+            JSON.parse(leftover);
+          } catch {
+            await writeFd.write(`${leftover}
+`, void 0, "utf8");
+          }
+        }
+      } finally {
+        await writeFd.close();
       }
+      await src.close();
+      await fsp2.rename(tmpPath, this.filePath);
+      this.handle = await fsp2.open(this.filePath, "a", 384);
+    } catch (err) {
+      await fsp2.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp2.open(this.filePath, "a", 384).catch(() => this.handle);
+      throw err;
     }
-    const summaries = Array.from(seen.values());
-    this._indexCache = { ...stat7, summaries };
-    return [...summaries];
+    await this.append({
+      type: "rewound",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      toPromptIndex: targetPromptIndex,
+      revertedFiles: []
+    });
+    this.events?.emit("session.rewound", {
+      toPromptIndex: targetPromptIndex,
+      revertedFiles: [],
+      removedEvents: removedCount
+    });
+    return removedCount;
+  }
+  async clearSession() {
+    if (!this.filePath) return;
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.writeBuffer = [];
+    await this.writeChain;
+    const record = `${JSON.stringify({
+      type: "session_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    await fsp2.writeFile(this.filePath, record, "utf8");
   }
   /**
-   * Rebuild the index from disk by scanning all sessions and writing a
-   * fresh _index.jsonl. Useful after manual cleanup or index corruption.
+   * Write an in-flight marker. The agent loop should call
+   * this at the start of each long-running operation; a matching
+   * `clearInFlightMarker` follows on clean exit. A stale marker
+   * (no end) is what `SessionRecovery.detectStale` looks for.
    */
-  async rebuildIndex() {
-    const ids = await this.collectSessionIds(this.dir);
-    const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
-    const valid = summaries.filter((s) => s !== null);
-    const tmp = `${this.indexFile}.tmp`;
-    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;
+  async writeInFlightMarker(context) {
+    if (!context || context.length > 500) {
+      throw new Error("In-flight context must be 1..500 chars");
+    }
+    await this.append({
+      type: "in_flight_start",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      context
+    });
+    this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
-  async listFromDirectoryScan(limit) {
-    const refs = await this.collectSessionFiles(this.dir);
-    const candidates = await mapWithConcurrency(
-      refs,
-      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
-      async (ref) => {
-        const manifest = await this.readSummaryManifest(ref.id);
-        if (manifest) return { summary: manifest, needsBackfill: false };
-        const summary = await this.summaryHeaderFor(ref);
-        return summary ? { summary, needsBackfill: true } : null;
-      }
-    );
-    const out = candidates.filter((s) => s !== null);
-    out.sort((a, b) => compareSessionSummaries(a.summary, b.summary));
-    const selected = out.slice(0, limit);
-    const summaries = await mapWithConcurrency(
-      selected,
-      Math.min(_DefaultSessionStore.LIST_SCAN_CONCURRENCY, Math.max(1, limit)),
-      async (candidate) => {
-        if (!candidate.needsBackfill) return candidate.summary;
-        return await this.summaryFor(candidate.summary.id).catch(() => candidate.summary);
-      }
-    );
-    return summaries.filter((s) => s !== null);
+  /**
+   * Close the in-flight marker. Idempotent in spirit
+   * (you can call it after a successful iteration even if you
+   * didn't open one this round) — but the session log records
+   * every call so postmortem tooling can see "the agent finished
+   * cleanly X times, then died without finishing Y".
+   */
+  async clearInFlightMarker(reason) {
+    await this.append({
+      type: "in_flight_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      reason
+    });
+    this.events?.emit("in_flight.ended", { reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
-  async collectSessionFiles(dir, prefix = "", depth = 0) {
-    let entries;
-    try {
-      entries = await fsp.readdir(dir, { withFileTypes: true });
-    } catch {
-      return [];
+};
+function sanitizeModel(model) {
+  return model.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").slice(0, 40);
+}
+function generateSessionId(startedAt, model) {
+  const date = startedAt.slice(0, 10);
+  const time = startedAt.slice(11, 19).replace(/:/g, "-");
+  const suffix = randomBytes(2).toString("hex");
+  const modelPart = model ? `_${sanitizeModel(model)}` : "";
+  return `${date}/${time}Z${modelPart}_${suffix}`;
+}
+
+// src/storage/session-store.ts
+var DefaultSessionStore = class _DefaultSessionStore {
+  dir;
+  events;
+  secretScrubber;
+  /**
+   * In-memory cache for load() results, keyed by session ID. The cache is
+   * invalidated when the file's mtimeMs or size changes (indicating the
+   * file was written to). This eliminates redundant full-file reads and
+   * JSON parses when the same session is loaded multiple times within the
+   * store's lifetime (e.g., webui session detail views, list() fallbacks).
+   *
+   * Max size is capped to prevent unbounded memory growth in long-running
+   * processes. When the limit is reached, the oldest entry is evicted.
+   */
+  _loadCache = /* @__PURE__ */ new Map();
+  _indexCache = null;
+  shardManifestCache = /* @__PURE__ */ new Map();
+  static LOAD_CACHE_MAX_ENTRIES = 50;
+  static LIST_SCAN_CONCURRENCY = 32;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.events = opts.events;
+    this.secretScrubber = opts.secretScrubber;
+  }
+  /**
+   * Clear the load() cache. Useful for testing or when the caller knows
+   * the file has changed externally (e.g., another process wrote to it).
+   */
+  clearLoadCache(sessionId) {
+    if (sessionId !== void 0) {
+      this._loadCache.delete(sessionId);
+    } else {
+      this._loadCache.clear();
     }
-    const dirEntries = [];
-    const files = [];
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
-      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
-        continue;
-      if (entry.isDirectory()) {
-        dirEntries.push(entry);
-      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        if (entry.name === "_index.jsonl") continue;
-        const base = entry.name.replace(/\.jsonl$/, "");
-        const id = prefix ? `${prefix}/${base}` : base;
-        files.push({ id, filePath: path2.join(dir, entry.name) });
-      }
-    }
-    const childFileArrays = await Promise.all(
-      dirEntries.map((entry) => {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionFiles(path2.join(dir, entry.name), childPrefix, depth + 1);
-      })
-    );
-    return [...childFileArrays.flat(), ...files];
   }
-  /** Recursively collect session IDs from date-shard subdirectories.
-   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
-   *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
-   *  sub-directories that belong to fleet/subagent sessions. */
-  async collectSessionIds(dir, prefix = "", depth = 0) {
-    let entries;
-    try {
-      entries = await fsp.readdir(dir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    const dirEntries = [];
-    const fileIds = [];
-    for (const entry of entries) {
-      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
-      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
-        continue;
-      if (entry.isDirectory()) {
-        dirEntries.push(entry);
-      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-        if (entry.name === "_index.jsonl") continue;
-        const base = entry.name.replace(/\.jsonl$/, "");
-        fileIds.push(prefix ? `${prefix}/${base}` : base);
-      }
-    }
-    const childIdArrays = await Promise.all(
-      dirEntries.map((entry) => {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionIds(path2.join(dir, entry.name), childPrefix, depth + 1);
-      })
-    );
-    return [...childIdArrays.flat(), ...fileIds];
+  // ── Storage event helpers ───────────────────────────────────────────────────
+  emitRead(sessionId, filePath, operation, outcome, durationMs, error) {
+    this.events?.emit("storage.read", {
+      sessionId,
+      store: "session",
+      filePath,
+      operation,
+      outcome,
+      durationMs,
+      ...error !== void 0 ? { error } : {}
+    });
   }
-  async summaryFor(id) {
-    const manifest = this.sessionPath(id, ".summary.json");
+  emitWrite(sessionId, filePath, operation, outcome, durationMs, eventCount, error) {
+    this.events?.emit("storage.write", {
+      sessionId,
+      store: "session",
+      filePath,
+      operation,
+      outcome,
+      durationMs,
+      ...eventCount !== void 0 ? { eventCount } : {},
+      ...error !== void 0 ? { error } : {}
+    });
+  }
+  emitError(sessionId, filePath, operation, error, recoverable) {
+    this.events?.emit("storage.error", {
+      sessionId,
+      store: "session",
+      filePath,
+      operation,
+      error,
+      recoverable
+    });
+  }
+  /** Absolute path to the session index file. */
+  get indexFile() {
+    return path2.join(this.dir, "_index.jsonl");
+  }
+  /** Join session ID to its absolute path within the store directory. */
+  sessionPath(id, ext) {
+    return path2.join(this.dir, `${id}${ext}`);
+  }
+  shardManifestPath(shardKey) {
+    return shardKey ? path2.join(this.dir, shardKey, "_manifest.json") : path2.join(this.dir, "_manifest.json");
+  }
+  shardKeyForSessionId(id) {
+    const dirName = path2.dirname(id);
+    return dirName === "." ? "" : dirName;
+  }
+  invalidateShardManifestBySessionId(id) {
+    this.shardManifestCache.delete(this.shardKeyForSessionId(id));
+  }
+  /**
+   * Ensure the directory implied by the session ID exists. When the ID
+   * contains a date prefix like `2026-06-06/...`, this creates the date
+   * subdirectory so sessions group naturally by day.
+   */
+  async ensureShardDir(id) {
+    const dirPath = path2.dirname(path2.join(this.dir, id));
+    await ensureDir(dirPath);
+    return dirPath;
+  }
+  async create(meta) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt, meta.model ?? meta.provider);
+    const shardDir = await this.ensureShardDir(id);
+    const file = path2.join(shardDir, `${path2.basename(id)}.jsonl`);
     const t0 = Date.now();
-    let outcome = "success";
-    let errorMsg;
-    const fromManifest = await this.readSummaryManifest(id, t0);
-    if (fromManifest) return fromManifest;
+    let handle;
     try {
-      const full = this.sessionPath(id, ".jsonl");
-      const stat7 = await fsp.stat(full);
-      const summary = await this.summarize(id, stat7.mtime.toISOString());
-      await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
-        const msg = toErrorMessage(err);
-        this.emitError(id, manifest, "summary_fallback", msg, true);
-        console.warn(JSON.stringify({
-          level: "warn",
-          event: "session_store.manifest_write_failed",
-          sessionId: id,
-          message: msg,
-          timestamp: (/* @__PURE__ */ new Date()).toISOString()
-        }));
-      });
-      outcome = "failure";
-      errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
-      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
-      return summary;
+      handle = await fsp2.open(file, "a", 384);
     } catch (err) {
-      outcome = "failure";
-      errorMsg = toErrorMessage(err);
-      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
-      return {
-        id,
-        title: "(damaged)",
-        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
-        model: "unknown",
-        provider: "unknown",
-        tokenTotal: 0
-      };
+      this.emitError(id, file, "create", toErrorMessage(err), false);
+      throw new Error(
+        `Failed to open session file: ${toErrorMessage(err)}`,
+        { cause: err }
+      );
     }
-  }
-  async readSummaryManifest(id, startTime = Date.now()) {
-    const manifest = this.sessionPath(id, ".summary.json");
     try {
-      const raw = await fsp.readFile(manifest, "utf8");
-      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
-      return JSON.parse(raw);
-    } catch {
-      return null;
+      const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
+        dir: shardDir,
+        filePath: file,
+        secretScrubber: this.secretScrubber,
+        onClose: (s) => this.appendToIndex(s)
+      });
+      this.emitWrite(id, file, "create", "success", Date.now() - t0);
+      return writer;
+    } catch (err) {
+      await handle.close().catch((e) => console.warn(JSON.stringify({
+        level: "warn",
+        event: "session_store.handle_close_failed",
+        message: e instanceof Error ? e.message : String(e),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      })));
+      this.emitError(id, file, "create", toErrorMessage(err), true);
+      throw err;
     }
   }
-  async summaryHeaderFor(ref) {
-    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+  async resume(id) {
+    const file = this.sessionPath(id, ".jsonl");
+    const t0 = Date.now();
+    const data = await this.load(id);
+    let handle;
     try {
-      const stat7 = await fsp.stat(ref.filePath);
-      if (!stat7.isFile()) {
-        return {
-          id: ref.id,
-          title: "(damaged)",
-          startedAt: stat7.mtime.toISOString(),
-          model: "unknown",
-          provider: "unknown",
-          tokenTotal: 0
-        };
-      }
-      mtime = stat7.mtime.toISOString();
-    } catch {
-      return null;
+      handle = await fsp2.open(file, "a", 384);
+    } catch (err) {
+      this.emitError(id, file, "resume", toErrorMessage(err), false);
+      throw new Error(
+        `Failed to open session "${id}" for append: ${toErrorMessage(err)}`,
+        { cause: err }
+      );
     }
     try {
-      for await (const event of this.iterSessionEvents(ref.filePath)) {
-        if (event.type === "session_start") {
-          return {
-            id: ref.id,
-            title: "(empty session)",
-            startedAt: event.ts,
-            model: event.model ?? "unknown",
-            provider: event.provider ?? "unknown",
-            tokenTotal: 0
-          };
-        }
-      }
-      return {
-        id: ref.id,
-        title: "(empty session)",
-        startedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
-        model: "unknown",
-        provider: "unknown",
-        tokenTotal: 0
-      };
-    } catch {
-      return {
-        id: ref.id,
-        title: "(damaged)",
-        startedAt: mtime,
-        model: "unknown",
-        provider: "unknown",
-        tokenTotal: 0
-      };
-    }
-  }
-  /**
-   * Delete a session and all associated files: JSONL, summary, plan/todos
-   * sidecars, and the session directory (fleet.json, shared/, subagents/).
-   *
-   * Individual file deletions are best-effort (logged as structured warnings),
-   * but a tombstone is always written so readIndex() filters this session out.
-   * If the session directory itself can't be removed, the error is surfaced
-   * to the caller so prune() can report it.
-   */
-  async deleteSession(id) {
-    const jsonlPath = this.sessionPath(id, ".jsonl");
-    const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path2.dirname(path2.join(this.dir, id));
-    const base = path2.basename(id);
-    const sessDir = path2.join(shardDir, base);
-    const deletions = [
-      fsp.unlink(jsonlPath),
-      fsp.unlink(summaryPath),
-      fsp.unlink(path2.join(shardDir, `${base}.plan.json`)),
-      fsp.unlink(path2.join(shardDir, `${base}.todos.json`))
-    ];
-    const results = await Promise.allSettled(deletions);
-    for (const r of results) {
-      if (r.status === "rejected") {
-        const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
-        if (r.reason?.code !== "ENOENT") {
-          console.warn(JSON.stringify({
-            level: "warn",
-            event: "session_store.delete_failed",
-            sessionId: id,
-            message: msg,
-            timestamp: (/* @__PURE__ */ new Date()).toISOString()
-          }));
+      const writer = new FileSessionWriter(
+        id,
+        handle,
+        (/* @__PURE__ */ new Date()).toISOString(),
+        {
+          id,
+          model: data.metadata.model,
+          provider: data.metadata.provider
+        },
+        this.events,
+        {
+          resumed: true,
+          // Shard directory (sessions/<date>/) — must match create() so the
+          // .summary.json sidecar lands next to the JSONL instead of the
+          // sessions root (where summaryFor() would never find it).
+          dir: path2.dirname(file),
+          filePath: file,
+          secretScrubber: this.secretScrubber,
+          onClose: (s) => this.appendToIndex(s)
         }
-      }
-    }
-    await fsp.rm(sessDir, { recursive: true, force: true }).catch((err) => {
-      console.warn(JSON.stringify({
+      );
+      this.emitWrite(id, file, "resume", "success", Date.now() - t0);
+      return { writer, data };
+    } catch (err) {
+      await handle.close().catch((e) => console.warn(JSON.stringify({
         level: "warn",
-        event: "session_store.rmdir_failed",
-        sessionId: id,
-        message: toErrorMessage(err),
+        event: "session_store.handle_close_failed",
+        message: e instanceof Error ? e.message : String(e),
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
-      }));
-    });
-    await this.writeTombstone(id);
-  }
-  async delete(id) {
-    await this.deleteSession(id);
-  }
-  async prune(maxAgeDays = 30) {
-    const cutoff = Date.now() - maxAgeDays * 864e5;
-    let deleted = 0;
-    let activeSessionId = null;
-    try {
-      const raw = await fsp.readFile(path2.join(this.dir, "active.json"), "utf8");
-      const active = JSON.parse(raw);
-      activeSessionId = active.sessionId ?? null;
-    } catch {
-    }
-    const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
-    const pruneFile = async (dir, name, prefix) => {
-      const jsonlPath = path2.join(dir, name);
-      try {
-        const stat7 = await fsp.stat(jsonlPath);
-        if (stat7.mtimeMs >= cutoff) return;
-      } catch {
-        return;
-      }
-      const base = name.replace(/\.jsonl$/, "");
-      const id = prefix ? `${prefix}/${base}` : base;
-      if (activeSessionId && id === activeSessionId) return;
-      await this.deleteSession(id);
-      deleted++;
-    };
-    const entries = await fsp.readdir(this.dir, { withFileTypes: true }).catch(() => []);
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        if (isPrunableJsonl(entry.name)) await pruneFile(this.dir, entry.name, "");
-        continue;
-      }
-      if (!entry.isDirectory()) continue;
-      const dateDir = path2.join(this.dir, entry.name);
-      const files = await fsp.readdir(dateDir, { withFileTypes: true }).catch(() => []);
-      for (const file of files) {
-        if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
-        await pruneFile(dateDir, file.name, entry.name);
-      }
-    }
-    if (deleted > 0) {
-      await this.compactIndex().catch(() => void 0);
-    }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dateDir = path2.join(this.dir, entry.name);
-      try {
-        const remaining = await fsp.readdir(dateDir);
-        if (remaining.length === 0) {
-          await fsp.rmdir(dateDir).catch(() => void 0);
-        }
-      } catch {
-      }
+      })));
+      this.emitError(id, file, "resume", toErrorMessage(err), true);
+      throw err;
     }
-    return deleted;
   }
-  async clearHistory(id) {
-    await this.ensureShardDir(id);
+  async load(id) {
     const file = this.sessionPath(id, ".jsonl");
-    const meta = this.sessionPath(id, ".summary.json");
-    const record = `${JSON.stringify({
-      type: "session_start",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      id,
-      model: "unknown",
-      provider: "unknown"
-    })}
-`;
-    await fsp.writeFile(file, record, "utf8");
-    await fsp.unlink(meta).catch(() => void 0);
-  }
-  async summarize(id, mtime) {
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    let cacheHit = false;
     try {
-      const file = this.sessionPath(id, ".jsonl");
-      let title = "(empty session)";
-      let startedAt = (/* @__PURE__ */ new Date(0)).toISOString();
-      let endedAt;
-      let model = "unknown";
-      let provider = "unknown";
-      let tokenIn = 0;
-      let tokenOut = 0;
-      let iterationCount = 0;
-      let toolCallCount = 0;
-      let toolErrorCount = 0;
-      let fileChangeCount = 0;
-      const toolBreakdown = {};
-      let outcome;
-      let lastEventType;
-      let hasError = false;
-      let sawStart = false;
-      for await (const e of this.iterSessionEvents(file)) {
-        lastEventType = e.type;
-        if (e.type === "session_start") {
-          if (!sawStart) {
-            sawStart = true;
-            startedAt = e.ts;
-            model = e.model ?? "unknown";
-            provider = e.provider ?? "unknown";
-          }
-        } else if (e.type === "session_end") {
-          endedAt = e.ts;
-        } else if (e.type === "user_input") {
-          if (title === "(empty session)") title = userInputTitle(e.content);
-        } else if (e.type === "llm_response") {
-          tokenIn += e.usage.input ?? 0;
-          tokenOut += e.usage.output ?? 0;
-        } else if (e.type === "in_flight_start") iterationCount++;
-        else if (e.type === "tool_call_start") {
-          toolCallCount++;
-          toolBreakdown[e.name] = (toolBreakdown[e.name] ?? 0) + 1;
-        } else if (e.type === "tool_result" && e.isError) toolErrorCount++;
-        else if (e.type === "file_snapshot") fileChangeCount += e.files.length;
-        else if (e.type === "error" || e.type === "provider_error") hasError = true;
+      const s = await fsp2.stat(file);
+      const stat10 = { mtimeMs: s.mtimeMs, size: s.size };
+      const cached = this._loadCache.get(id);
+      if (cached && cached.mtimeMs === stat10.mtimeMs && cached.size === stat10.size) {
+        cacheHit = true;
+        this._loadCache.delete(id);
+        this._loadCache.set(id, cached);
+        return cached.data;
+      }
+      const raw = await fsp2.readFile(file, "utf8");
+      const lines = raw.split("\n").filter((l) => l.trim());
+      const events = [];
+      let sessionStartEvent;
+      let sessionEndEvent;
+      let sessionModel;
+      let sessionProvider;
+      let sessionPendingToolUses;
+      const messages = [];
+      const openToolUses = /* @__PURE__ */ new Set();
+      let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+            const ev = parsed;
+            events.push(ev);
+            if (ev.type === "session_start" && !sessionStartEvent) {
+              sessionStartEvent = ev;
+              sessionModel = ev.model;
+              sessionProvider = ev.provider;
+            }
+            if (ev.type === "session_end") {
+              sessionEndEvent = ev;
+              sessionPendingToolUses = ev.pendingToolUses;
+            }
+            if (ev.type === "user_input") {
+              openToolUses.clear();
+              messages.push({ role: "user", content: ev.content, ts: ev.ts });
+            } else if (ev.type === "llm_response") {
+              messages.push({ role: "assistant", content: ev.content, ts: ev.ts });
+              for (const b of ev.content) {
+                if (b.type === "tool_use") openToolUses.add(b.id);
+              }
+              usage = {
+                input: usage.input + (ev.usage.input ?? 0),
+                output: usage.output + (ev.usage.output ?? 0),
+                cacheRead: (usage.cacheRead ?? 0) + (ev.usage.cacheRead ?? 0),
+                cacheWrite: (usage.cacheWrite ?? 0) + (ev.usage.cacheWrite ?? 0)
+              };
+            } else if (ev.type === "tool_result") {
+              if (!openToolUses.has(ev.id)) {
+                this.events?.emit("session.damaged", {
+                  sessionId: id,
+                  detail: `Orphan tool_result "${ev.id}" has no matching tool_use`
+                });
+                continue;
+              }
+              openToolUses.delete(ev.id);
+              const resultBlock = {
+                type: "tool_result",
+                tool_use_id: ev.id,
+                content: typeof ev.content === "string" ? ev.content : JSON.stringify(ev.content),
+                is_error: ev.isError
+              };
+              const last = messages[messages.length - 1];
+              const lastIsToolResultUser = last?.role === "user" && Array.isArray(last.content) && last.content.every((b) => b.type === "tool_result");
+              if (lastIsToolResultUser && Array.isArray(last.content)) {
+                last.content.push(resultBlock);
+              } else {
+                messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
+              }
+            }
+          }
+        } catch {
+        }
       }
-      if (lastEventType === "session_end") {
-        outcome = "completed";
-      } else if (lastEventType === "in_flight_start") {
-        outcome = "aborted";
-      } else if (hasError) {
-        outcome = "error";
+      if (openToolUses.size > 0) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
+        });
       }
-      return {
-        id,
-        title,
-        startedAt,
-        endedAt,
-        model,
-        provider,
-        tokenTotal: tokenIn + tokenOut,
-        iterationCount: iterationCount > 0 ? iterationCount : void 0,
-        toolCallCount: toolCallCount > 0 ? toolCallCount : void 0,
-        toolErrorCount: toolErrorCount > 0 ? toolErrorCount : void 0,
-        fileChangeCount: fileChangeCount > 0 ? fileChangeCount : void 0,
-        toolBreakdown: Object.keys(toolBreakdown).length > 0 ? toolBreakdown : {},
-        outcome
-      };
-    } catch {
-      return {
+      const repaired = repairToolUseAdjacency(messages);
+      if (repaired.report.changed) {
+        this.events?.emit("session.damaged", {
+          sessionId: id,
+          detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+        });
+      }
+      const meta = {
         id,
-        title: "(damaged)",
-        startedAt: mtime,
-        model: "unknown",
-        provider: "unknown",
-        tokenTotal: 0
+        startedAt: sessionStartEvent?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+        endedAt: sessionEndEvent?.ts,
+        model: sessionModel,
+        provider: sessionProvider,
+        pendingToolUses: sessionPendingToolUses
       };
+      const toolCallEnds = extractToolCallEnds(events);
+      const data = { metadata: meta, events, messages: repaired.messages, usage, toolCallEnds };
+      if (this._loadCache.size >= _DefaultSessionStore.LOAD_CACHE_MAX_ENTRIES) {
+        const oldest = this._loadCache.keys().next().value;
+        if (oldest !== void 0) {
+          this._loadCache.delete(oldest);
+        }
+      }
+      this._loadCache.set(id, { mtimeMs: stat10.mtimeMs, size: stat10.size, data });
+      return data;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      throw err;
+    } finally {
+      this.emitRead(id, file, "load", outcome, Date.now() - t0, errorMsg);
+      if (cacheHit) {
+        this.events?.emit("storage.cache_hit", {
+          sessionId: id,
+          store: "session",
+          filePath: file,
+          operation: "load",
+          durationMs: Date.now() - t0
+        });
+      }
     }
   }
-  async *iterSessionEvents(file) {
-    const stream = createReadStream(file, { encoding: "utf8" });
-    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  /**
+   * Streaming search over a session's JSONL. Walks the file once, parses
+   * each event lazily, and yields only the events that match `predicate`.
+   * Stops as soon as `opts.limit` matches are collected.
+   *
+   * Why this exists: `load()` parses the entire file into memory and
+   * rebuilds `messages`/`toolCallEnds` for every caller. `search()` only
+   * needs to know which events contain matching text — a per-line
+   * predicate is enough. The full parse work (and the `_loadCache` poll)
+   * is wasted in that case.
+   *
+   * Memory: O(hits) regardless of file size. Disk: one linear scan,
+   * terminated at `limit` if the caller asked for one.
+   *
+   * Errors: missing file yields []. Corrupt lines are skipped (same
+   * policy as `load()`). Aborting via `signal` rejects with `AbortError`.
+   */
+  async searchEvents(id, predicate, opts) {
+    const file = this.sessionPath(id, ".jsonl");
+    const limit = opts?.limit;
+    const signal = opts?.signal;
+    const out = [];
+    let stat10;
     try {
-      for await (const line of lines) {
-        if (!line.trim()) continue;
+      stat10 = await fsp2.stat(file);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    if (stat10.size === 0) return [];
+    let fh;
+    try {
+      fh = await fsp2.open(file, "r");
+      const CHUNK = 64 * 1024;
+      const buf = Buffer.alloc(CHUNK);
+      let leftover = "";
+      let eventIndex = 0;
+      for (let position = 0; ; position += buf.byteLength) {
+        if (signal?.aborted) {
+          const reason = signal.reason ?? new DOMException("Aborted", "AbortError");
+          throw reason;
+        }
+        const { bytesRead } = await fh.read(buf, 0, CHUNK, position);
+        if (bytesRead === 0) break;
+        const text = leftover + buf.subarray(0, bytesRead).toString("utf8");
+        const parts = text.split("\n");
+        leftover = parts.pop() ?? "";
+        for (const line of parts) {
+          if (!line) continue;
+          let ev;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed === null || typeof parsed !== "object" || typeof parsed.type !== "string" || typeof parsed.ts !== "string") {
+              continue;
+            }
+            ev = parsed;
+          } catch {
+            continue;
+          }
+          if (predicate(ev, eventIndex, ev.ts)) {
+            out.push({ event: ev, eventIndex, ts: ev.ts });
+            if (limit !== void 0 && out.length >= limit) {
+              return out;
+            }
+          }
+          eventIndex++;
+        }
+      }
+      if (leftover.trim()) {
         try {
-          const parsed = JSON.parse(line);
+          const parsed = JSON.parse(leftover);
           if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
-            yield parsed;
+            const ev = parsed;
+            if (predicate(ev, eventIndex, ev.ts)) {
+              out.push({ event: ev, eventIndex, ts: ev.ts });
+            }
           }
         } catch {
         }
       }
+      return out;
     } finally {
-      lines.close();
-      stream.destroy();
+      if (fh) await fh.close().catch(() => void 0);
     }
   }
-};
-function extractToolCallEnds(events) {
-  const result = [];
-  for (const e of events) {
-    if (e.type === "tool_call_end") {
-      result.push({
-        name: e.name,
-        id: e.id,
-        durationMs: e.durationMs,
-        ok: e.ok ?? false,
-        outputBytes: e.outputBytes,
-        outputTokens: e.outputTokens,
-        outputLines: e.outputLines
-      });
+  async list(limit = 20) {
+    try {
+      await ensureDir(this.dir);
+      const indexed = await this.readIndex();
+      if (indexed.length > 0) {
+        indexed.sort((a, b) => {
+          if (a.startedAt < b.startedAt) return 1;
+          if (a.startedAt > b.startedAt) return -1;
+          return a.id.localeCompare(b.id);
+        });
+        return indexed.slice(0, limit);
+      }
+      return await this.listFromDirectoryScan(limit);
+    } catch {
+      return [];
     }
   }
-  return result;
-}
-var FileSessionWriter = class _FileSessionWriter {
-  constructor(id, handle, startedAt, meta, events, opts = {}, traceId) {
-    this.id = id;
-    this.handle = handle;
-    this.startedAt = startedAt;
-    this.meta = meta;
-    this.events = events;
-    this.resumed = opts.resumed ?? false;
-    this.manifestFile = opts.dir ? path2.join(opts.dir, `${path2.basename(id)}.summary.json`) : "";
-    this.filePath = opts.filePath ?? "";
-    this.secretScrubber = opts.secretScrubber;
-    this.onCloseCb = opts.onClose;
-    this.summary = {
-      id,
-      title: "(empty session)",
-      startedAt,
-      model: meta.model ?? "unknown",
-      provider: meta.provider ?? "unknown",
-      tokenTotal: 0
-    };
-    this.traceId = traceId;
+  /**
+   * List sessions matching filter criteria, using the cached index.
+   * Filters are applied BEFORE sorting and slicing, so the caller gets
+   * exactly `limit` matching sessions — not a slice of a larger fetch.
+   *
+   * This avoids the DefaultSessionReader pattern of fetching 1000 sessions
+   * then linear-filtering: the index is already in memory (readIndex
+   * caches it), and the filter runs over the cached array without any
+   * additional disk I/O.
+   */
+  async listFiltered(criteria) {
+    const limit = criteria.limit ?? 100;
+    try {
+      await ensureDir(this.dir);
+      const indexed = await this.readIndex();
+      if (indexed.length === 0) {
+        const raw = await this.list(Math.max(limit, 100));
+        return raw.filter((s) => matchesSessionFilter(s, criteria)).slice(0, limit);
+      }
+      const filtered = indexed.filter((s) => matchesSessionFilter(s, criteria));
+      filtered.sort((a, b) => {
+        if (a.startedAt < b.startedAt) return 1;
+        if (a.startedAt > b.startedAt) return -1;
+        return a.id.localeCompare(b.id);
+      });
+      return filtered.slice(0, limit);
+    } catch {
+      return [];
+    }
   }
-  id;
-  handle;
-  startedAt;
-  meta;
-  events;
-  closed = false;
-  closePromise = null;
-  manifestFile;
-  summary;
-  tokenIn = 0;
-  tokenOut = 0;
-  filePath;
-  get transcriptPath() {
-    return this.filePath || void 0;
+  // ── Session index (_index.jsonl) ─────────────────────────────────────────
+  //
+  // One JSON line per closed session, appended atomically on close().
+  // When a session is deleted, a tombstone {action:"delete",id:"..."} is
+  // appended. On read, tombstones filter out matching session entries.
+  // This keeps listing O(lines-in-index) instead of O(files-on-disk).
+  //
+  // The index auto-compacts every N appends to prevent unbounded growth
+  // from tombstones and duplicate entries (resume cycles).
+  indexAppendCount = 0;
+  static COMPACT_EVERY = 30;
+  /** Append a session summary to the index. */
+  async appendToIndex(summary) {
+    try {
+      await ensureDir(this.dir);
+      const line = JSON.stringify(summary) + "\n";
+      await fsp2.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
+      this.invalidateShardManifestBySessionId(summary.id);
+      this.indexAppendCount++;
+      if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
+        await this.compactIndex();
+        this.indexAppendCount = 0;
+      }
+    } catch {
+    }
+  }
+  /** Append a tombstone entry for a deleted session. */
+  async writeTombstone(id) {
+    try {
+      await ensureDir(this.dir);
+      const line = JSON.stringify({ action: "delete", id }) + "\n";
+      await fsp2.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
+      this.invalidateShardManifestBySessionId(id);
+      this.indexAppendCount++;
+    } catch {
+    }
   }
   /**
-   * Lazy session_start/session_resumed init, shared by all appenders.
-   * A single promise (not a boolean) so a second append racing the first
-   * can't push its event into the buffer BEFORE the first append's event —
-   * every appender awaits the same init and resumes in FIFO call order.
+   * Compact the index: read all entries, drop tombstones, deduplicate
+   * (keep latest per session), and rewrite. Atomic via temp+rename.
    */
-  initPromise = null;
-  ensureInit() {
-    if (!this.initPromise) this.initPromise = this.writeSessionStartLazy();
-    return this.initPromise;
-  }
-  resumed;
-  appendFailCount = 0;
-  lastAppendWarnAt = 0;
-  secretScrubber;
-  onCloseCb;
-  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
-  traceId;
-  // ── Write buffer — batches events to reduce per-event disk I/O ─────────
-  //
-  // Every append() pushes the scrubbed event into an in-memory buffer instead
-  // of calling handle.appendFile() synchronously. The buffer flushes to disk
-  // when it reaches FLUSH_SIZE events OR after FLUSH_INTERVAL_MS of inactivity.
-  // This cuts the number of disk writes by ~95% without changing the on-disk
-  // format — the JSONL is still one JSON object per line.
-  writeBuffer = [];
-  flushTimer = null;
-  static FLUSH_INTERVAL_MS = 500;
-  static FLUSH_SIZE = 50;
-  // ── Write serialization ─────────────────────────────────────────────────
-  //
-  // All disk writes are funneled through a FIFO promise chain. Without it,
-  // a timer-driven flush racing an explicit flush()/close() issues two
-  // concurrent appendFile() calls on the shared O_APPEND handle — the kernel
-  // may complete them out of order (chronology breaks) or, for large
-  // batches, interleave partial writes (torn JSONL lines). The chain keeps
-  // exactly one write in flight; failures don't break the chain.
-  writeChain = Promise.resolve();
-  /** Enqueue a write on the FIFO chain. Resolves/rejects with that write. */
-  enqueueWrite(data) {
-    const write = this.writeChain.then(() => this.handle.appendFile(data, "utf8"));
-    this.writeChain = write.then(
-      () => void 0,
-      () => void 0
-    );
-    return write;
+  async compactIndex() {
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    try {
+      const entries = await this.readIndex();
+      if (entries.length === 0) return;
+      const tmp = `${this.indexFile}.compact.tmp`;
+      const lines = entries.map((s) => JSON.stringify(s)).join("\n") + "\n";
+      await fsp2.writeFile(tmp, lines, "utf8");
+      await fsp2.rename(tmp, this.indexFile);
+      this._indexCache = null;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+    } finally {
+      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+    }
   }
-  // ── Enriched summary tracking ──────────────────────────────────────────
-  iterationCount = 0;
-  toolCallCount = 0;
-  toolErrorCount = 0;
-  toolBreakdown = {};
-  fileChangeCount = 0;
-  compactionCount = 0;
-  outcome = void 0;
   /**
-   * Scrub secrets out of conversation-turn events before they are observed
-   * for the summary, written to the JSONL log, or surfaced on resume. Only
-   * `user_input` / `llm_response` carry free-form user/model text; other event
-   * types either have no secret-bearing content or are already scrubbed
-   * upstream (tool results). Returns the event unchanged when no scrubber is
-   * configured.
+   * Read the index file and return deduplicated session summaries.
+   * Entries with a matching tombstone are filtered out.
+   * Returns empty array when the index doesn't exist or is corrupt.
    */
-  scrubEvent(event) {
-    const s = this.secretScrubber;
-    if (!s) return event;
-    if (event.type === "user_input") {
-      return {
-        ...event,
-        content: typeof event.content === "string" ? s.scrub(event.content) : s.scrubObject(event.content)
-      };
+  async readIndex() {
+    let stat10;
+    try {
+      const s = await fsp2.stat(this.indexFile);
+      stat10 = { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      this._indexCache = null;
+      return [];
     }
-    if (event.type === "llm_response") {
-      return { ...event, content: s.scrubObject(event.content) };
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat10.mtimeMs && this._indexCache.size === stat10.size) {
+      return [...this._indexCache.summaries];
     }
-    return event;
+    let raw;
+    try {
+      raw = await fsp2.readFile(this.indexFile, "utf8");
+    } catch {
+      this._indexCache = null;
+      return [];
+    }
+    const deleted = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Map();
+    for (const line of raw.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const entry = JSON.parse(line);
+        if (entry.action === "delete" && entry.id) {
+          deleted.add(entry.id);
+          seen.delete(entry.id);
+          continue;
+        }
+        if (entry.id && !deleted.has(entry.id)) {
+          seen.set(entry.id, entry);
+        }
+      } catch {
+      }
+    }
+    const summaries = Array.from(seen.values());
+    this._indexCache = { ...stat10, summaries };
+    return [...summaries];
   }
-  pendingFileSnapshots = [];
-  /** Tracks open tool_use IDs during the current run to serialize on close for resume. */
-  openToolUses = /* @__PURE__ */ new Set();
-  recordFileChange(input) {
-    this.pendingFileSnapshots.push(input);
+  /**
+   * Rebuild the index from disk by scanning all sessions and writing a
+   * fresh _index.jsonl. Useful after manual cleanup or index corruption.
+   */
+  async rebuildIndex() {
+    const ids = await this.collectSessionIds(this.dir);
+    const summaries = await Promise.all(ids.map((id) => this.summaryFor(id).catch(() => null)));
+    const valid = summaries.filter((s) => s !== null);
+    const tmp = `${this.indexFile}.tmp`;
+    const lines = valid.map((s) => JSON.stringify(s)).join("\n") + "\n";
+    await fsp2.writeFile(tmp, lines, "utf8");
+    await fsp2.rename(tmp, this.indexFile);
+    this._indexCache = null;
+    return valid.length;
   }
-  get pendingToolUses() {
-    return Array.from(this.openToolUses);
+  async listFromDirectoryScan(limit) {
+    const shardKeys = await this.collectShardKeys();
+    const shardEntries = await mapWithConcurrency(
+      shardKeys,
+      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+      async (shardKey) => await this.readOrBuildShardManifest(shardKey)
+    );
+    const out = [];
+    for (const entry of shardEntries) {
+      for (const summary of entry.summaries) {
+        out.push({ summary, needsBackfill: false });
+      }
+    }
+    out.sort((a, b) => compareSessionSummaries(a.summary, b.summary));
+    const selected = out.slice(0, limit);
+    const summaries = await mapWithConcurrency(
+      selected,
+      Math.min(_DefaultSessionStore.LIST_SCAN_CONCURRENCY, Math.max(1, limit)),
+      async (candidate) => candidate.summary
+    );
+    return summaries.filter((s) => s !== null);
   }
-  async writeSessionStartLazy() {
-    const record = `${JSON.stringify({
-      type: this.resumed ? "session_resumed" : "session_start",
-      ts: this.startedAt,
-      id: this.id,
-      model: this.meta.model ?? "unknown",
-      provider: this.meta.provider ?? "unknown"
-    })}
-`;
+  async collectShardKeys() {
+    let entries;
     try {
-      await this.enqueueWrite(record);
+      entries = await fsp2.readdir(this.dir, { withFileTypes: true });
     } catch {
+      return [""];
     }
+    const shardKeys = [""];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments") continue;
+      if (entry.isDirectory()) shardKeys.push(entry.name);
+    }
+    return shardKeys;
   }
-  async append(event) {
-    if (this.closed) return;
-    await this.ensureInit();
-    const scrubbed = this.scrubEvent(event);
-    this.observeForSummary(scrubbed);
-    this.writeBuffer.push(scrubbed);
-    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
-      if (this.flushTimer) {
-        clearTimeout(this.flushTimer);
-        this.flushTimer = null;
-      }
-      await this.flushBuffer();
-    } else {
-      this.scheduleFlush();
+  async readOrBuildShardManifest(shardKey) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (cached) return cached;
+    const manifestPath = this.shardManifestPath(shardKey);
+    try {
+      const raw = await fsp2.readFile(manifestPath, "utf8");
+      const parsed = JSON.parse(raw);
+      const entry2 = {
+        summaries: Array.isArray(parsed.summaries) ? parsed.summaries : [],
+        ids: Array.isArray(parsed.ids) ? parsed.ids : []
+      };
+      this.shardManifestCache.set(shardKey, entry2);
+      return entry2;
+    } catch {
     }
+    const refs = await this.collectSessionFilesInShard(shardKey);
+    const candidates = await mapWithConcurrency(
+      refs,
+      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+      async (ref) => {
+        const manifest = await this.readSummaryManifest(ref.id);
+        if (manifest) return { summary: manifest, needsBackfill: false };
+        const summary = await this.summaryHeaderFor(ref);
+        if (!summary) return null;
+        const hydrated = await this.summaryFor(summary.id).catch(() => summary);
+        return { summary: hydrated, needsBackfill: false };
+      }
+    );
+    const summaries = candidates.filter((candidate) => candidate !== null).map((candidate) => candidate.summary);
+    summaries.sort(compareSessionSummaries);
+    const entry = { summaries, ids: summaries.map((summary) => summary.id) };
+    this.shardManifestCache.set(shardKey, entry);
+    await atomicWrite(manifestPath, JSON.stringify(entry), { mode: 384 }).catch(() => void 0);
+    return entry;
+  }
+  async collectSessionFilesInShard(shardKey) {
+    const dir = shardKey ? path2.join(this.dir, shardKey) : this.dir;
+    const entries = await this.collectSessionFiles(dir, shardKey);
+    return shardKey ? entries.filter((entry) => entry.id.startsWith(`${shardKey}/`)) : entries.filter((entry) => !entry.id.includes("/"));
   }
-  async appendBatch(events) {
-    if (this.closed || events.length === 0) return;
-    await this.ensureInit();
-    for (const event of events) {
-      const scrubbed = this.scrubEvent(event);
-      this.observeForSummary(scrubbed);
-      this.writeBuffer.push(scrubbed);
+  async collectSessionFiles(dir, prefix = "", depth = 0) {
+    let entries;
+    try {
+      entries = await fsp2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
     }
-    if (this.writeBuffer.length >= _FileSessionWriter.FLUSH_SIZE) {
-      if (this.flushTimer) {
-        clearTimeout(this.flushTimer);
-        this.flushTimer = null;
+    const dirEntries = [];
+    const files = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
+      if (entry.isDirectory()) {
+        dirEntries.push(entry);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        if (entry.name === "_index.jsonl") continue;
+        const base = entry.name.replace(/\.jsonl$/, "");
+        const id = prefix ? `${prefix}/${base}` : base;
+        files.push({ id, filePath: path2.join(dir, entry.name) });
       }
-      await this.flushBuffer();
-    } else {
-      this.scheduleFlush();
     }
+    const childFileArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionFiles(path2.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childFileArrays.flat(), ...files];
   }
-  /**
-   * Flush buffered events to disk immediately. Critical events
-   * (user_input, llm_response) call this so they survive SIGKILL/crash
-   * instead of sitting in the in-memory buffer for up to 500ms.
-   *
-   * Idempotent — cancels any pending timer and writes whatever has
-   * accumulated in the buffer. Safe to call even when the buffer
-   * is empty (no-op).
-   */
-  async flush() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+  /** Recursively collect session IDs from date-shard subdirectories.
+   *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
+   *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
+   *  sub-directories that belong to fleet/subagent sessions. */
+  async collectSessionIds(dir, prefix = "", depth = 0) {
+    let entries;
+    try {
+      entries = await fsp2.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
     }
-    await this.flushBuffer();
-  }
-  /** Schedule a deferred flush. No-op if a timer is already pending. */
-  scheduleFlush() {
-    if (this.flushTimer) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = null;
-      this.flushBuffer().catch(() => {
-      });
-    }, _FileSessionWriter.FLUSH_INTERVAL_MS);
+    const dirEntries = [];
+    const fileIds = [];
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") && entry.name !== ".wrongstack") continue;
+      if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+        continue;
+      if (entry.isDirectory()) {
+        dirEntries.push(entry);
+      } else if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+        if (entry.name === "_index.jsonl") continue;
+        const base = entry.name.replace(/\.jsonl$/, "");
+        fileIds.push(prefix ? `${prefix}/${base}` : base);
+      }
+    }
+    const childIdArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionIds(path2.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childIdArrays.flat(), ...fileIds];
   }
-  /**
-   * Flush all buffered events to disk as a single appendFile call.
-   * Errors use the same throttled-warning pattern the old per-event
-   * append path used — one warning every 5s with a suppressed count.
-   * On failure the buffer is cleared (events are best-effort, same as
-   * the old per-event path where a failed write was silently dropped).
-   */
-  async flushBuffer() {
-    if (this.writeBuffer.length === 0) return;
-    const eventCount = this.writeBuffer.length;
-    const batch = this.writeBuffer.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    this.writeBuffer = [];
+  async summaryFor(id) {
+    const manifest = this.sessionPath(id, ".summary.json");
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
+    const fromManifest = await this.readSummaryManifest(id, t0);
+    if (fromManifest) return fromManifest;
     try {
-      await this.enqueueWrite(batch);
+      const full = this.sessionPath(id, ".jsonl");
+      const stat10 = await fsp2.stat(full);
+      const summary = await this.summarize(id, stat10.mtime.toISOString());
+      await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+        const msg = toErrorMessage(err);
+        this.emitError(id, manifest, "summary_fallback", msg, true);
+        console.warn(JSON.stringify({
+          level: "warn",
+          event: "session_store.manifest_write_failed",
+          sessionId: id,
+          message: msg,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        }));
+      });
+      outcome = "failure";
+      errorMsg = "summary fallback \xE2\u20AC\u201D manifest rebuilt";
+      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
+      return summary;
     } catch (err) {
       outcome = "failure";
       errorMsg = toErrorMessage(err);
-      this.appendFailCount += eventCount;
-      const now = Date.now();
-      if (now - this.lastAppendWarnAt > 5e3) {
-        const suppressed = this.appendFailCount - 1;
-        const tail = suppressed > 0 ? ` (+${suppressed} suppressed)` : "";
-        console.warn(
-          "[session] flush failed:",
-          toErrorMessage(err),
-          tail
-        );
-        this.lastAppendWarnAt = now;
-        this.appendFailCount = 0;
-      }
-    } finally {
-      this.events?.emit("storage.write", {
-        sessionId: this.id,
-        store: "session",
-        filePath: this.filePath,
-        operation: "flush",
-        outcome,
-        durationMs: Date.now() - t0,
-        ...errorMsg !== void 0 ? { error: errorMsg } : {},
-        ...eventCount !== void 0 ? { eventCount } : {},
-        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-      });
+      this.emitRead(id, manifest, "summary", outcome, Date.now() - t0, errorMsg);
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
     }
   }
-  observeForSummary(event) {
-    if (event.type === "llm_response") {
-      for (const block of event.content) {
-        if (block.type === "tool_use") this.openToolUses.add(block.id);
-      }
+  async readSummaryManifest(id, startTime = Date.now()) {
+    const manifest = this.sessionPath(id, ".summary.json");
+    try {
+      const raw = await fsp2.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
+      return JSON.parse(raw);
+    } catch {
+      return null;
     }
-    if (event.type === "tool_use") {
-      this.openToolUses.add(event.id);
-    } else if (event.type === "tool_call_start") {
-      this.toolCallCount++;
-      this.toolBreakdown[event.name] = (this.toolBreakdown[event.name] ?? 0) + 1;
-    } else if (event.type === "tool_result") {
-      this.openToolUses.delete(event.id);
-      if (event.isError) {
-        this.toolErrorCount++;
-        this.outcome = "error";
+  }
+  async summaryHeaderFor(ref) {
+    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+    try {
+      const stat10 = await fsp2.stat(ref.filePath);
+      if (!stat10.isFile()) {
+        return {
+          id: ref.id,
+          title: "(damaged)",
+          startedAt: stat10.mtime.toISOString(),
+          model: "unknown",
+          provider: "unknown",
+          tokenTotal: 0
+        };
       }
-    } else if (event.type === "file_snapshot") {
-      this.fileChangeCount += event.files.length;
-    } else if (event.type === "compaction") {
-      this.compactionCount++;
-    }
-    if (event.type === "error" || event.type === "provider_error") {
-      this.outcome = "error";
+      mtime = stat10.mtime.toISOString();
+    } catch {
+      return null;
     }
-    if (event.type === "user_input" && this.summary.title === "(empty session)") {
-      this.summary = { ...this.summary, title: userInputTitle(event.content) };
-    } else if (event.type === "llm_response") {
-      this.tokenIn += event.usage.input;
-      this.tokenOut += event.usage.output;
-      this.summary = { ...this.summary, tokenTotal: this.tokenIn + this.tokenOut };
-    } else if (event.type === "session_end") {
-      const total = event.usage.input + event.usage.output;
-      if (total > 0) this.summary = { ...this.summary, tokenTotal: total };
-    } else if (event.type === "in_flight_start") {
-      this.iterationCount++;
+    try {
+      for await (const event of this.iterSessionEvents(ref.filePath)) {
+        if (event.type === "session_start") {
+          return {
+            id: ref.id,
+            title: "(empty session)",
+            startedAt: event.ts,
+            model: event.model ?? "unknown",
+            provider: event.provider ?? "unknown",
+            tokenTotal: 0
+          };
+        }
+      }
+      return {
+        id: ref.id,
+        title: "(empty session)",
+        startedAt: (/* @__PURE__ */ new Date(0)).toISOString(),
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
+    } catch {
+      return {
+        id: ref.id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
     }
   }
-  async close() {
-    if (this.closePromise) return this.closePromise;
-    this.closePromise = this.doClose();
-    return this.closePromise;
-  }
-  async doClose() {
-    this.closed = true;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    await this.flushBuffer();
-    await this.writeChain;
-    this.summary = {
-      ...this.summary,
-      endedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      iterationCount: this.iterationCount,
-      toolCallCount: this.toolCallCount,
-      toolErrorCount: this.toolErrorCount,
-      fileChangeCount: this.fileChangeCount,
-      compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
-      toolBreakdown: { ...this.toolBreakdown },
-      outcome: this.outcome ?? "completed"
-    };
-    if (this.manifestFile) {
-      const t0 = Date.now();
-      let outcome = "success";
-      let errorMsg;
-      try {
-        await atomicWrite(this.manifestFile, JSON.stringify(this.summary), { mode: 384 });
-      } catch (err) {
-        outcome = "failure";
-        errorMsg = toErrorMessage(err);
-      } finally {
-        this.events?.emit("storage.write", {
-          sessionId: this.id,
-          store: "session",
-          filePath: this.manifestFile,
-          operation: "close",
-          outcome,
-          durationMs: Date.now() - t0,
-          ...errorMsg !== void 0 ? { error: errorMsg } : {},
-          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-        });
+  /**
+   * Delete a session and all associated files: JSONL, summary, plan/todos
+   * sidecars, and the session directory (fleet.json, shared/, subagents/).
+   *
+   * Individual file deletions are best-effort (logged as structured warnings),
+   * but a tombstone is always written so readIndex() filters this session out.
+   * If the session directory itself can't be removed, the error is surfaced
+   * to the caller so prune() can report it.
+   */
+  async deleteSession(id) {
+    const jsonlPath = this.sessionPath(id, ".jsonl");
+    const summaryPath = this.sessionPath(id, ".summary.json");
+    const shardDir = path2.dirname(path2.join(this.dir, id));
+    const base = path2.basename(id);
+    const sessDir = path2.join(shardDir, base);
+    const deletions = [
+      fsp2.unlink(jsonlPath),
+      fsp2.unlink(summaryPath),
+      fsp2.unlink(path2.join(shardDir, `${base}.plan.json`)),
+      fsp2.unlink(path2.join(shardDir, `${base}.todos.json`))
+    ];
+    const results = await Promise.allSettled(deletions);
+    for (const r of results) {
+      if (r.status === "rejected") {
+        const msg = r.reason instanceof Error ? r.reason.message : String(r.reason);
+        if (r.reason?.code !== "ENOENT") {
+          console.warn(JSON.stringify({
+            level: "warn",
+            event: "session_store.delete_failed",
+            sessionId: id,
+            message: msg,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          }));
+        }
       }
     }
-    const idxT0 = Date.now();
-    let idxOutcome = "success";
-    let idxError;
-    try {
-      await this.onCloseCb?.(this.summary);
-    } catch (err) {
-      idxOutcome = "failure";
-      idxError = toErrorMessage(err);
-    } finally {
-      this.events?.emit("storage.write", {
-        sessionId: this.summary.id,
-        store: "session",
-        filePath: this.filePath,
-        operation: "index_append",
-        outcome: idxOutcome,
-        durationMs: Date.now() - idxT0,
-        ...idxError !== void 0 ? { error: idxError } : {},
-        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
-      });
-    }
+    await fsp2.rm(sessDir, { recursive: true, force: true }).catch((err) => {
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "session_store.rmdir_failed",
+        sessionId: id,
+        message: toErrorMessage(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    });
+    await this.writeTombstone(id);
+  }
+  async delete(id) {
+    await this.deleteSession(id);
+  }
+  async prune(maxAgeDays = 30) {
+    const cutoff = Date.now() - maxAgeDays * 864e5;
+    let deleted = 0;
+    let activeSessionId = null;
     try {
-      await this.handle.close();
+      const raw = await fsp2.readFile(path2.join(this.dir, "active.json"), "utf8");
+      const active = JSON.parse(raw);
+      activeSessionId = active.sessionId ?? null;
     } catch {
     }
-  }
-  async writeCheckpoint(promptIndex, promptPreview) {
-    const fileCount = this.pendingFileSnapshots.length;
-    if (fileCount > 0) {
-      await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
-      this.pendingFileSnapshots = [];
+    const isPrunableJsonl = (name) => name.endsWith(".jsonl") && name !== "_index.jsonl" && name !== "_mailbox.jsonl" && !name.endsWith(".replay.jsonl") && !name.endsWith(".audit.jsonl");
+    const pruneFile = async (dir, name, prefix) => {
+      const jsonlPath = path2.join(dir, name);
+      try {
+        const stat10 = await fsp2.stat(jsonlPath);
+        if (stat10.mtimeMs >= cutoff) return;
+      } catch {
+        return;
+      }
+      const base = name.replace(/\.jsonl$/, "");
+      const id = prefix ? `${prefix}/${base}` : base;
+      if (activeSessionId && id === activeSessionId) return;
+      await this.deleteSession(id);
+      deleted++;
+    };
+    const entries = await fsp2.readdir(this.dir, { withFileTypes: true }).catch(() => []);
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        if (isPrunableJsonl(entry.name)) await pruneFile(this.dir, entry.name, "");
+        continue;
+      }
+      if (!entry.isDirectory()) continue;
+      const dateDir = path2.join(this.dir, entry.name);
+      const files = await fsp2.readdir(dateDir, { withFileTypes: true }).catch(() => []);
+      for (const file of files) {
+        if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
+        await pruneFile(dateDir, file.name, entry.name);
+      }
     }
-    await this.append({
-      type: "checkpoint",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      promptIndex,
-      promptPreview
-    });
-    this.events?.emit("checkpoint.written", {
-      promptIndex,
-      promptPreview,
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      fileCount
-    });
+    if (deleted > 0) {
+      await this.compactIndex().catch(() => void 0);
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dateDir = path2.join(this.dir, entry.name);
+      try {
+        const remaining = await fsp2.readdir(dateDir);
+        if (remaining.length === 0) {
+          await fsp2.rmdir(dateDir).catch(() => void 0);
+        }
+      } catch {
+      }
+    }
+    return deleted;
   }
-  async writeFileSnapshot(promptIndex, files) {
-    await this.append({
-      type: "file_snapshot",
+  async clearHistory(id) {
+    await this.ensureShardDir(id);
+    const file = this.sessionPath(id, ".jsonl");
+    const meta = this.sessionPath(id, ".summary.json");
+    const record = `${JSON.stringify({
+      type: "session_start",
       ts: (/* @__PURE__ */ new Date()).toISOString(),
-      promptIndex,
-      files
-    });
+      id,
+      model: "unknown",
+      provider: "unknown"
+    })}
+`;
+    await fsp2.writeFile(file, record, "utf8");
+    await fsp2.unlink(meta).catch(() => void 0);
   }
-  /**
-   * 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) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    await this.flushBuffer();
-    await this.writeChain;
-    const CHUNK_SIZE = 65536;
-    let fd;
-    let fileOffset = 0;
-    let lineStartOffset = 0;
-    let checkpointByteOffset = -1;
-    let removedCount = 0;
-    let targetCheckpointSeen = false;
+  async summarize(id, mtime) {
     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 {
-              }
-            }
+      const file = this.sessionPath(id, ".jsonl");
+      let title = "(empty session)";
+      let startedAt = (/* @__PURE__ */ new Date(0)).toISOString();
+      let endedAt;
+      let model = "unknown";
+      let provider = "unknown";
+      let tokenIn = 0;
+      let tokenOut = 0;
+      let iterationCount = 0;
+      let toolCallCount = 0;
+      let toolErrorCount = 0;
+      let fileChangeCount = 0;
+      const toolBreakdown = {};
+      let outcome;
+      let lastEventType;
+      let hasError = false;
+      let sawStart = false;
+      for await (const e of this.iterSessionEvents(file)) {
+        lastEventType = e.type;
+        if (e.type === "session_start") {
+          if (!sawStart) {
+            sawStart = true;
+            startedAt = e.ts;
+            model = e.model ?? "unknown";
+            provider = e.provider ?? "unknown";
           }
-          chunkPos = idx + 1;
-          lineStartOffset = fileOffset + chunkPos;
-        }
-        fileOffset += bytesRead;
-        if (chunkPos >= bytesRead) {
-          lineStartOffset = fileOffset;
-        }
+        } else if (e.type === "session_end") {
+          endedAt = e.ts;
+        } else if (e.type === "user_input") {
+          if (title === "(empty session)") title = userInputTitle(e.content);
+        } else if (e.type === "llm_response") {
+          tokenIn += e.usage.input ?? 0;
+          tokenOut += e.usage.output ?? 0;
+        } else if (e.type === "in_flight_start") iterationCount++;
+        else if (e.type === "tool_call_start") {
+          toolCallCount++;
+          toolBreakdown[e.name] = (toolBreakdown[e.name] ?? 0) + 1;
+        } else if (e.type === "tool_result" && e.isError) toolErrorCount++;
+        else if (e.type === "file_snapshot") fileChangeCount += e.files.length;
+        else if (e.type === "error" || e.type === "provider_error") hasError = true;
       }
-    } finally {
-      await fd?.close();
+      if (lastEventType === "session_end") {
+        outcome = "completed";
+      } else if (lastEventType === "in_flight_start") {
+        outcome = "aborted";
+      } else if (hasError) {
+        outcome = "error";
+      }
+      return {
+        id,
+        title,
+        startedAt,
+        endedAt,
+        model,
+        provider,
+        tokenTotal: tokenIn + tokenOut,
+        iterationCount: iterationCount > 0 ? iterationCount : void 0,
+        toolCallCount: toolCallCount > 0 ? toolCallCount : void 0,
+        toolErrorCount: toolErrorCount > 0 ? toolErrorCount : void 0,
+        fileChangeCount: fileChangeCount > 0 ? fileChangeCount : void 0,
+        toolBreakdown: Object.keys(toolBreakdown).length > 0 ? toolBreakdown : {},
+        outcome
+      };
+    } catch {
+      return {
+        id,
+        title: "(damaged)",
+        startedAt: mtime,
+        model: "unknown",
+        provider: "unknown",
+        tokenTotal: 0
+      };
     }
-    if (checkpointByteOffset === -1) return 0;
-    await this.writeChain;
-    await this.handle.close();
-    const tmpPath = `${this.filePath}.rewind.tmp`;
-    const src = await fsp.open(this.filePath, "r", 384);
+  }
+  async *iterSessionEvents(file) {
+    const stream = createReadStream(file, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
     try {
-      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 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;
-        }
-        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");
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        try {
+          const parsed = JSON.parse(line);
+          if (parsed !== null && typeof parsed === "object" && typeof parsed.type === "string" && typeof parsed.ts === "string") {
+            yield parsed;
           }
+        } catch {
         }
-      } 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({
-      type: "rewound",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      toPromptIndex: targetPromptIndex,
-      revertedFiles: []
-    });
-    this.events?.emit("session.rewound", {
-      toPromptIndex: targetPromptIndex,
-      revertedFiles: [],
-      removedEvents: removedCount
-    });
-    return removedCount;
-  }
-  async clearSession() {
-    if (!this.filePath) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+    } finally {
+      lines.close();
+      stream.destroy();
     }
-    this.writeBuffer = [];
-    await this.writeChain;
-    const record = `${JSON.stringify({
-      type: "session_start",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      id: this.id,
-      model: this.meta.model ?? "unknown",
-      provider: this.meta.provider ?? "unknown"
-    })}
-`;
-    await fsp.writeFile(this.filePath, record, "utf8");
   }
-  /**
-   * Idea #1 — write an in-flight marker. The agent loop should call
-   * this at the start of each long-running operation; a matching
-   * `clearInFlightMarker` follows on clean exit. A stale marker
-   * (no end) is what `SessionRecovery.detectStale` looks for.
-   */
-  async writeInFlightMarker(context) {
-    if (!context || context.length > 500) {
-      throw new Error("In-flight context must be 1..500 chars");
+};
+function extractToolCallEnds(events) {
+  const result = [];
+  for (const e of events) {
+    if (e.type === "tool_call_end") {
+      result.push({
+        name: e.name,
+        id: e.id,
+        durationMs: e.durationMs,
+        ok: e.ok ?? false,
+        outputBytes: e.outputBytes,
+        outputTokens: e.outputTokens,
+        outputLines: e.outputLines
+      });
     }
-    await this.append({
-      type: "in_flight_start",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      context
-    });
-    this.events?.emit("in_flight.started", { context, ts: (/* @__PURE__ */ new Date()).toISOString() });
-  }
-  /**
-   * Idea #1 — close the in-flight marker. Idempotent in spirit
-   * (you can call it after a successful iteration even if you
-   * didn't open one this round) — but the session log records
-   * every call so postmortem tooling can see "the agent finished
-   * cleanly X times, then died without finishing Y".
-   */
-  async clearInFlightMarker(reason) {
-    await this.append({
-      type: "in_flight_end",
-      ts: (/* @__PURE__ */ new Date()).toISOString(),
-      reason
-    });
-    this.events?.emit("in_flight.ended", { reason, ts: (/* @__PURE__ */ new Date()).toISOString() });
   }
-};
-function userInputTitle(content) {
-  const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
-  return (text || "(non-text input)").slice(0, 60);
+  return result;
 }
 function compareSessionSummaries(a, b) {
   if (a.startedAt < b.startedAt) return 1;
   if (a.startedAt > b.startedAt) return -1;
   return a.id.localeCompare(b.id);
 }
+function matchesSessionFilter(s, criteria) {
+  if (criteria.since && s.startedAt < criteria.since) return false;
+  if (criteria.until && s.startedAt > criteria.until) return false;
+  if (criteria.provider && s.provider !== criteria.provider) return false;
+  if (criteria.model && s.model !== criteria.model) return false;
+  if (criteria.minTokens !== void 0 && s.tokenTotal < criteria.minTokens) return false;
+  if (criteria.titleContains) {
+    const needle = criteria.titleContains.toLowerCase();
+    if (!s.title.toLowerCase().includes(needle)) return false;
+  }
+  return true;
+}
 async function mapWithConcurrency(items, concurrency, fn) {
   if (items.length === 0) return [];
   const out = new Array(items.length);
@@ -2035,7 +2168,7 @@ var QueueStore = class {
     const t0 = Date.now();
     let raw;
     try {
-      raw = await fsp.readFile(this.file, "utf8");
+      raw = await fsp2.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
@@ -2116,7 +2249,7 @@ var QueueStore = class {
   async clear() {
     const t0 = Date.now();
     try {
-      await fsp.unlink(this.file);
+      await fsp2.unlink(this.file);
       this.events?.emit("storage.write", {
         sessionId: this.traceId ?? "~boot~",
         store: "queue",
@@ -2173,7 +2306,7 @@ var DefaultAttachmentStore = class {
     let spooledPath;
     let data = input.data;
     if (this.spoolDir && bytes >= this.spoolThreshold) {
-      await fsp.mkdir(this.spoolDir, { recursive: true });
+      await fsp2.mkdir(this.spoolDir, { recursive: true });
       spooledPath = path2.join(this.spoolDir, `${id}.bin`);
       await atomicWrite(spooledPath, input.data, {
         encoding: input.kind === "image" ? "base64" : "utf8"
@@ -2236,7 +2369,7 @@ var DefaultAttachmentStore = class {
       for (const att of this.items.values()) {
         if (att.path) toDelete.push(att.path);
       }
-      await Promise.all(toDelete.map((p) => fsp.unlink(p).catch(() => void 0)));
+      await Promise.all(toDelete.map((p) => fsp2.unlink(p).catch(() => void 0)));
     }
     this.items.clear();
     this.refs.length = 0;
@@ -2244,7 +2377,7 @@ var DefaultAttachmentStore = class {
   }
   async toBlock(att) {
     if (att.kind === "image") {
-      const data = att.data ?? (att.path ? await fsp.readFile(att.path, { encoding: "base64" }) : "");
+      const data = att.data ?? (att.path ? await fsp2.readFile(att.path, { encoding: "base64" }) : "");
       return {
         type: "image",
         source: {
@@ -2254,7 +2387,7 @@ var DefaultAttachmentStore = class {
         }
       };
     }
-    const raw = att.data ?? (att.path ? await fsp.readFile(att.path, "utf8") : "");
+    const raw = att.data ?? (att.path ? await fsp2.readFile(att.path, "utf8") : "");
     const label = att.meta.filename ? `<file path="${att.meta.filename}">` : "<pasted>";
     const close = att.meta.filename ? "</file>" : "</pasted>";
     return { type: "text", text: `${label}
@@ -2389,7 +2522,7 @@ var FileMemoryBackend = class {
     await ensureDir(path2.dirname(file));
     let existing = "";
     try {
-      existing = await fsp.readFile(file, "utf8");
+      existing = await fsp2.readFile(file, "utf8");
     } catch {
     }
     const id = `mem_${Date.now()}_${randomUUID().slice(0, 8)}`;
@@ -2406,7 +2539,7 @@ ${line}`;
     return withFileLock(file, async () => {
       let existing;
       try {
-        existing = await fsp.readFile(file, "utf8");
+        existing = await fsp2.readFile(file, "utf8");
       } catch {
         return 0;
       }
@@ -2442,7 +2575,7 @@ ${line}`;
   async readAll(scope, filePath) {
     const file = this.resolveFile(filePath, scope);
     try {
-      return await fsp.readFile(file, "utf8");
+      return await fsp2.readFile(file, "utf8");
     } catch {
       return "";
     }
@@ -2477,7 +2610,7 @@ ${line}`;
     const file = this.resolveFile(filePath, scope);
     let existing;
     try {
-      existing = await fsp.readFile(file, "utf8");
+      existing = await fsp2.readFile(file, "utf8");
     } catch {
       return 0;
     }
@@ -2497,7 +2630,7 @@ ${line}`;
     const next = lines.join("\n");
     const backup = `${file}.bak.${Date.now()}`;
     try {
-      await fsp.copyFile(file, backup);
+      await fsp2.copyFile(file, backup);
       await pruneConsolidateBackups(file);
     } catch {
     }
@@ -2513,11 +2646,11 @@ 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();
+  const backups = (await fsp2.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));
+        await fsp2.unlink(path2.join(dir, name));
       } catch {
       }
     })
@@ -3072,9 +3205,9 @@ ${body.trim()}`);
     if (!this.persistBackup || scope === "project-agents") return;
     try {
       const content = await this.backend.readAll(scope, this.files[scope]);
-      const { writeFile: writeFile7, mkdir: mkdir7 } = await import('fs/promises');
+      const { writeFile: writeFile8, mkdir: mkdir7 } = await import('fs/promises');
       await mkdir7(this.backupDir, { recursive: true });
-      await writeFile7(`${this.backupDir}/${scope}.md`, content, "utf8");
+      await writeFile8(`${this.backupDir}/${scope}.md`, content, "utf8");
     } catch {
     }
   }
@@ -3089,7 +3222,7 @@ function labelOf(scope) {
       return "User memory";
   }
 }
-var GraphMemoryBackend = class {
+var GraphMemoryBackend = class _GraphMemoryBackend {
   kind = "graph";
   file;
   graphFile;
@@ -3098,6 +3231,14 @@ var GraphMemoryBackend = class {
   edges = [];
   loadedScope = null;
   loaded = false;
+  /**
+   * Inverted index for O(1) term → node lookup during search.
+   * Built incrementally on remember/forget, rebuilt on loadGraph if absent.
+   * Maps lowercase term (min 3 chars) → Set of node IDs containing that term.
+   */
+  invertedIndex = /* @__PURE__ */ new Map();
+  /** Minimum term length to index — avoids noise from 1-2 char fragments. */
+  static MIN_TERM_LEN = 3;
   /**
    * Promise that resolves when the current in-flight _saveGraph completes.
    * Tests call flush() to await this before deleting the backend or its temp dir.
@@ -3120,6 +3261,7 @@ var GraphMemoryBackend = class {
       existing.type = entry.type;
       existing.tags = entry.tags;
       existing.priority = entry.priority;
+      this.updateNodeIndex(nodeId, entry);
     } else {
       this.nodes.set(nodeId, {
         id: nodeId,
@@ -3130,6 +3272,7 @@ var GraphMemoryBackend = class {
         tags: entry.tags,
         priority: entry.priority
       });
+      this.indexNode(nodeId, entry);
       const recentNodes = [...this.nodes.values()].slice(-100);
       for (const other of recentNodes) {
         if (other.id === nodeId) continue;
@@ -3161,7 +3304,10 @@ var GraphMemoryBackend = class {
           toRemove.push(id);
         }
       }
-      for (const id of toRemove) this.nodes.delete(id);
+      for (const id of toRemove) {
+        this.removeNodeFromIndex(id, this.nodes.get(id)?.entry);
+        this.nodes.delete(id);
+      }
       this.edges = this.edges.filter((e) => !toRemove.includes(e.from) && !toRemove.includes(e.to));
       this._saveDone = this._saveGraph(scope);
       await this._saveDone;
@@ -3199,20 +3345,36 @@ var GraphMemoryBackend = class {
   }
   async search(scope, query, _filePath, limit) {
     await this.loadGraph(scope);
-    const needle = query.toLowerCase().split(/\s+/);
-    const scored = [];
-    for (const node of this.nodes.values()) {
+    const needle = query.toLowerCase().split(/\s+/).filter((t) => t.length >= _GraphMemoryBackend.MIN_TERM_LEN);
+    const candidates = /* @__PURE__ */ new Map();
+    for (const term of needle) {
+      const nodeIds = this.invertedIndex.get(term);
+      if (!nodeIds) continue;
+      for (const nodeId of nodeIds) {
+        const node = this.nodes.get(nodeId);
+        if (!node || node.entry.scope !== scope) continue;
+        candidates.set(nodeId, (candidates.get(nodeId) ?? 0) + 1);
+      }
+    }
+    for (const [nodeId, node] of this.nodes) {
       if (node.entry.scope !== scope) continue;
-      const words = node.entry.text.toLowerCase().split(/\s+/);
+      if (candidates.has(nodeId)) continue;
+      if (node.priority === "critical" || node.priority === "high") {
+        candidates.set(nodeId, 0);
+      }
+    }
+    const scored = [];
+    for (const [nodeId] of candidates) {
+      const node = this.nodes.get(nodeId);
       let score = 0;
-      for (const n of needle) {
-        if (words.some((w) => w.includes(n))) score += 1;
-        if (node.entry.tags?.some((t) => t.toLowerCase().includes(n))) score += 2;
+      score += (candidates.get(nodeId) ?? 0) * 1;
+      for (const term of needle) {
+        if (node.entry.tags?.some((t) => t.toLowerCase().includes(term))) score += 2;
       }
       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.push({ entry: node.entry, score });
     }
     scored.sort((a, b) => b.score - a.score);
     const matched = scored.map((s) => s.entry);
@@ -3222,10 +3384,11 @@ var GraphMemoryBackend = class {
     await this.file.clear(scope, filePath);
     this.nodes.clear();
     this.edges = [];
+    this.invertedIndex = /* @__PURE__ */ new Map();
     this.loadedScope = scope;
     this.loaded = true;
     try {
-      await fsp.unlink(this.graphFile);
+      await fsp2.unlink(this.graphFile);
     } catch {
     }
   }
@@ -3265,7 +3428,7 @@ var GraphMemoryBackend = class {
   async loadGraph(scope) {
     if (this.loaded && this.loadedScope === scope) return;
     try {
-      const raw = await fsp.readFile(this.graphFile, "utf8");
+      const raw = await fsp2.readFile(this.graphFile, "utf8");
       const data = JSON.parse(raw);
       this.nodes = new Map(data.nodes);
       this.edges = data.edges;
@@ -3273,6 +3436,7 @@ var GraphMemoryBackend = class {
       this.nodes = /* @__PURE__ */ new Map();
       this.edges = [];
     }
+    this.buildInvertedIndex();
     this.loadedScope = scope;
     this.loaded = true;
   }
@@ -3286,10 +3450,10 @@ var GraphMemoryBackend = class {
         edges: this.edges
       };
       const dir = this.graphFile.substring(0, this.graphFile.lastIndexOf("/"));
-      await fsp.mkdir(dir, { recursive: true });
+      await fsp2.mkdir(dir, { recursive: true });
       const tmp = `${this.graphFile}.tmp`;
-      await fsp.writeFile(tmp, JSON.stringify(data));
-      await fsp.rename(tmp, this.graphFile);
+      await fsp2.writeFile(tmp, JSON.stringify(data));
+      await fsp2.rename(tmp, this.graphFile);
     } catch {
     }
   }
@@ -3300,6 +3464,86 @@ var GraphMemoryBackend = class {
   async flush() {
     await this._saveDone;
   }
+  // ── Inverted Index Helpers ───────────────────────────────────────────
+  /**
+   * Build the inverted index from all currently loaded nodes.
+   * Called on loadGraph() to reconstruct the index after loading from disk.
+   */
+  buildInvertedIndex() {
+    this.invertedIndex = /* @__PURE__ */ new Map();
+    for (const [nodeId, node] of this.nodes) {
+      for (const term of this.extractTerms(node.entry)) {
+        let nodeIds = this.invertedIndex.get(term);
+        if (!nodeIds) {
+          nodeIds = /* @__PURE__ */ new Set();
+          this.invertedIndex.set(term, nodeIds);
+        }
+        nodeIds.add(nodeId);
+      }
+    }
+  }
+  /**
+   * Index a node in the inverted index. Adds the node's ID to all term entries.
+   */
+  indexNode(nodeId, entry) {
+    for (const term of this.extractTerms(entry)) {
+      let nodeIds = this.invertedIndex.get(term);
+      if (!nodeIds) {
+        nodeIds = /* @__PURE__ */ new Set();
+        this.invertedIndex.set(term, nodeIds);
+      }
+      nodeIds.add(nodeId);
+    }
+  }
+  /**
+   * Remove a node's terms from the inverted index before deleting it.
+   * Used in forget() and when updating existing nodes.
+   */
+  removeNodeFromIndex(nodeId, entry) {
+    if (!entry) return;
+    for (const term of this.extractTerms(entry)) {
+      const nodeIds = this.invertedIndex.get(term);
+      if (nodeIds) {
+        nodeIds.delete(nodeId);
+        if (nodeIds.size === 0) {
+          this.invertedIndex.delete(term);
+        }
+      }
+    }
+  }
+  /**
+   * Update an existing node's entries in the inverted index.
+   * Removes old terms and adds new ones.
+   */
+  updateNodeIndex(nodeId, entry) {
+    const existing = this.nodes.get(nodeId);
+    if (existing) {
+      this.removeNodeFromIndex(nodeId, existing.entry);
+    }
+    this.indexNode(nodeId, entry);
+  }
+  /**
+   * Extract searchable terms from a memory entry.
+   * Returns lowercase words from text (min length) and full tag strings.
+   */
+  extractTerms(entry) {
+    const terms = [];
+    const words = entry.text.toLowerCase().split(/\s+/);
+    for (const word of words) {
+      if (word.length >= _GraphMemoryBackend.MIN_TERM_LEN) {
+        terms.push(word);
+      }
+    }
+    if (entry.tags) {
+      for (const tag of entry.tags) {
+        const lower = tag.toLowerCase();
+        if (lower.length >= _GraphMemoryBackend.MIN_TERM_LEN && !terms.includes(lower)) {
+          terms.push(lower);
+        }
+      }
+    }
+    return terms;
+  }
 };
 function wordOverlap(a, b) {
   const wordsA = new Set(a.toLowerCase().split(/\s+/).filter((w) => w.length > 2));
@@ -3853,7 +4097,12 @@ var BEHAVIOR_DEFAULTS = {
   },
   circuitBreaker: { ...DEFAULT_CIRCUIT_BREAKER_CONFIG },
   modelRuntime: {
-    reasoning: { mode: "auto", effort: "high", preserve: false },
+    // `effort` is intentionally undefined by default. Leaving it unset lets
+    // each model use its provider-recommended reasoning effort (or none at
+    // all) instead of forcing an opinionated value that may be unsupported,
+    // silently omitted, and surfaced as a per-request warning. Users who
+    // want a specific effort can opt in via `/settings` or the WebUI panel.
+    reasoning: { mode: "auto" },
     cache: {}
   }
 };
@@ -4109,6 +4358,7 @@ var DefaultConfigLoader = class {
   extraSources;
   events;
   traceId;
+  jsonCache = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.paths = opts.paths;
     this.strict = opts.strict ?? false;
@@ -4191,7 +4441,7 @@ var DefaultConfigLoader = class {
       await withFileLock(fp, async () => {
         let parsed;
         try {
-          const raw = await fsp.readFile(fp, "utf8");
+          const raw = await fsp2.readFile(fp, "utf8");
           const result = safeParse(raw);
           if (!result.ok || !isPlainRecord(result.value)) {
             return;
@@ -4306,7 +4556,7 @@ var DefaultConfigLoader = class {
     const fp = this.paths.syncConfig;
     const t0 = Date.now();
     try {
-      const raw = await fsp.readFile(fp, "utf8");
+      const raw = await fsp2.readFile(fp, "utf8");
       const parsed = safeParse(raw);
       if (!parsed.ok || !parsed.value) {
         this.events?.emit("storage.read", {
@@ -4367,10 +4617,42 @@ var DefaultConfigLoader = class {
     }
   }
   async readJson(file) {
-    let raw;
     const t0 = Date.now();
+    let mtimeMs = null;
+    try {
+      const stat10 = await fsp2.stat(file);
+      mtimeMs = stat10.mtimeMs;
+      const cached = this.jsonCache.get(file);
+      if (cached && cached.mtimeMs === mtimeMs) {
+        return structuredClone(cached.value);
+      }
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        this.jsonCache.set(file, { mtimeMs: null, value: {} });
+        return {};
+      }
+      this.events?.emit("storage.read", {
+        sessionId: "~config~",
+        store: "config",
+        filePath: file,
+        operation: "read_json",
+        outcome: "failure",
+        durationMs: Date.now() - t0,
+        error: storageErrorString(err),
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+      console.warn(JSON.stringify({
+        level: "warn",
+        event: "config.read_failed",
+        path: file,
+        message: toErrorMessage(err),
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+      return {};
+    }
+    let raw;
     try {
-      raw = await fsp.readFile(file, "utf8");
+      raw = await fsp2.readFile(file, "utf8");
     } catch (err) {
       if (err.code !== "ENOENT") {
         this.events?.emit("storage.read", {
@@ -4391,6 +4673,7 @@ var DefaultConfigLoader = class {
           timestamp: (/* @__PURE__ */ new Date()).toISOString()
         }));
       }
+      this.jsonCache.set(file, { mtimeMs: null, value: {} });
       return {};
     }
     const parsed = safeParse(raw);
@@ -4414,6 +4697,7 @@ var DefaultConfigLoader = class {
       }));
       return {};
     }
+    this.jsonCache.set(file, { mtimeMs, value: structuredClone(parsed.value) });
     return parsed.value;
   }
   validateBehavior(cfg) {
@@ -4608,7 +4892,7 @@ var RecoveryLock = class {
       startedAt: (/* @__PURE__ */ new Date()).toISOString()
     };
     try {
-      await fsp.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
+      await fsp2.writeFile(this.file, JSON.stringify(lock), { flag: "wx", mode: 384 });
     } catch (err) {
       const code = err.code;
       if (code === "EEXIST") {
@@ -4624,7 +4908,7 @@ var RecoveryLock = class {
    */
   async clear() {
     try {
-      await fsp.unlink(this.file);
+      await fsp2.unlink(this.file);
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return;
@@ -4634,7 +4918,7 @@ var RecoveryLock = class {
   async readLock() {
     let raw;
     try {
-      raw = await fsp.readFile(this.file, "utf8");
+      raw = await fsp2.readFile(this.file, "utf8");
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") return null;
@@ -4665,26 +4949,82 @@ function defaultIsPidAlive(pid) {
     return false;
   }
 }
-
-// src/storage/session-reader.ts
-var DefaultSessionReader = class {
+var DefaultSessionReader = class _DefaultSessionReader {
   store;
+  eventCache = /* @__PURE__ */ new Map();
+  eventCacheMtimes = /* @__PURE__ */ new Map();
+  static EVENT_CACHE_MAX_ENTRIES = 32;
   constructor(opts) {
     this.store = opts.store;
   }
+  async loadCachedSessionData(sessionId) {
+    const storeWithPath = this.store;
+    const rootDir = storeWithPath.dir;
+    if (!rootDir) {
+      return await this.store.load(sessionId);
+    }
+    const sessionPath = path2.join(rootDir, `${sessionId}.jsonl`);
+    let mtimeMs = null;
+    try {
+      const stat10 = await fsp2.stat(sessionPath);
+      mtimeMs = stat10.mtimeMs;
+    } catch {
+      this.eventCache.delete(sessionId);
+      this.eventCacheMtimes.delete(sessionId);
+      return await this.store.load(sessionId);
+    }
+    const cachedMtime = this.eventCacheMtimes.get(sessionId);
+    const cachedData = this.eventCache.get(sessionId);
+    if (cachedData && cachedMtime === mtimeMs) {
+      this.eventCache.delete(sessionId);
+      this.eventCacheMtimes.delete(sessionId);
+      this.eventCache.set(sessionId, cachedData);
+      this.eventCacheMtimes.set(sessionId, mtimeMs);
+      return cachedData;
+    }
+    const data = await this.store.load(sessionId);
+    this.eventCache.delete(sessionId);
+    this.eventCacheMtimes.delete(sessionId);
+    this.eventCache.set(sessionId, data);
+    this.eventCacheMtimes.set(sessionId, mtimeMs);
+    while (this.eventCache.size > _DefaultSessionReader.EVENT_CACHE_MAX_ENTRIES) {
+      const oldest = this.eventCache.keys().next().value;
+      if (oldest === void 0) break;
+      this.eventCache.delete(oldest);
+      this.eventCacheMtimes.delete(oldest);
+    }
+    if (data.metadata.endedAt) {
+      storeWithPath.clearLoadCache?.(sessionId);
+    }
+    return data;
+  }
   async query(q = {}) {
-    const raw = await this.store.list(q.limit ? Math.max(q.limit, 100) : 1e3);
-    const titleNeedle = q.titleContains?.toLowerCase();
-    const filtered = raw.filter((s) => {
-      if (q.since && s.startedAt < q.since) return false;
-      if (q.until && s.startedAt > q.until) return false;
-      if (q.provider && s.provider !== q.provider) return false;
-      if (q.model && s.model !== q.model) return false;
-      if (q.minTokens !== void 0 && s.tokenTotal < q.minTokens) return false;
-      if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
-      return true;
-    });
-    const out = filtered.map((s) => ({
+    const storeWithFilter = this.store;
+    let raw;
+    if (typeof storeWithFilter.listFiltered === "function") {
+      raw = await storeWithFilter.listFiltered({
+        since: q.since,
+        until: q.until,
+        provider: q.provider,
+        model: q.model,
+        minTokens: q.minTokens,
+        titleContains: q.titleContains,
+        limit: q.limit
+      });
+    } else {
+      const fetched = await this.store.list(q.limit ? Math.max(q.limit, 100) : 1e3);
+      const titleNeedle = q.titleContains?.toLowerCase();
+      raw = fetched.filter((s) => {
+        if (q.since && s.startedAt < q.since) return false;
+        if (q.until && s.startedAt > q.until) return false;
+        if (q.provider && s.provider !== q.provider) return false;
+        if (q.model && s.model !== q.model) return false;
+        if (q.minTokens !== void 0 && s.tokenTotal < q.minTokens) return false;
+        if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
+        return true;
+      });
+    }
+    const out = raw.map((s) => ({
       id: s.id,
       title: s.title,
       startedAt: s.startedAt,
@@ -4695,7 +5035,7 @@ var DefaultSessionReader = class {
     return q.limit ? out.slice(0, q.limit) : out;
   }
   async *replay(sessionId) {
-    const data = await this.store.load(sessionId);
+    const data = await this.loadCachedSessionData(sessionId);
     for (const e of data.events) yield e;
   }
   async search(q, sessionId, sessionQuery) {
@@ -4706,18 +5046,32 @@ var DefaultSessionReader = class {
     if (sessionId) {
       ids = [sessionId];
     } else {
-      const sessions = await this.store.list(1e3);
-      const titleNeedle = sessionQuery?.titleContains?.toLowerCase();
-      const filtered = sessions.filter((s) => {
-        if (sessionQuery?.since && s.startedAt < sessionQuery.since) return false;
-        if (sessionQuery?.until && s.startedAt > sessionQuery.until) return false;
-        if (sessionQuery?.provider && s.provider !== sessionQuery.provider) return false;
-        if (sessionQuery?.model && s.model !== sessionQuery.model) return false;
-        if (sessionQuery?.minTokens !== void 0 && s.tokenTotal < sessionQuery.minTokens) return false;
-        if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
-        return true;
-      });
-      ids = filtered.map((s) => s.id);
+      const storeWithFilter = this.store;
+      let sessions;
+      if (typeof storeWithFilter.listFiltered === "function") {
+        sessions = await storeWithFilter.listFiltered({
+          since: sessionQuery?.since,
+          until: sessionQuery?.until,
+          provider: sessionQuery?.provider,
+          model: sessionQuery?.model,
+          minTokens: sessionQuery?.minTokens,
+          titleContains: sessionQuery?.titleContains,
+          limit: 1e3
+        });
+      } else {
+        sessions = await this.store.list(1e3);
+        const titleNeedle = sessionQuery?.titleContains?.toLowerCase();
+        sessions = sessions.filter((s) => {
+          if (sessionQuery?.since && s.startedAt < sessionQuery.since) return false;
+          if (sessionQuery?.until && s.startedAt > sessionQuery.until) return false;
+          if (sessionQuery?.provider && s.provider !== sessionQuery.provider) return false;
+          if (sessionQuery?.model && s.model !== sessionQuery.model) return false;
+          if (sessionQuery?.minTokens !== void 0 && s.tokenTotal < sessionQuery.minTokens) return false;
+          if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
+          return true;
+        });
+      }
+      ids = sessions.map((s) => s.id);
     }
     const hits = [];
     const streaming = this.store.searchEvents?.bind(this.store);
@@ -4751,7 +5105,7 @@ var DefaultSessionReader = class {
     for (const id of ids) {
       let data;
       try {
-        data = await this.store.load(id);
+        data = await this.loadCachedSessionData(id);
       } catch {
         continue;
       }
@@ -4775,7 +5129,7 @@ var DefaultSessionReader = class {
     return hits;
   }
   async export(sessionId, opts) {
-    const data = await this.store.load(sessionId);
+    const data = await this.loadCachedSessionData(sessionId);
     const includeTools = opts.includeTools ?? true;
     const includeDiagnostics = opts.includeDiagnostics ?? true;
     const filtered = data.events.filter((e) => {
@@ -4796,7 +5150,7 @@ var DefaultSessionReader = class {
     return renderMarkdown(data.metadata, filtered);
   }
   async metadata(sessionId) {
-    const data = await this.store.load(sessionId);
+    const data = await this.loadCachedSessionData(sessionId);
     return data.metadata;
   }
 };
@@ -5214,7 +5568,7 @@ var AnnotationsStore = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fsp.readFile(fp, "utf8");
+      raw = await fsp2.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -5295,7 +5649,7 @@ var ReplayLogStore = class {
   events;
   traceId;
   writeChains = /* @__PURE__ */ new Map();
-  /** Per-session hash → entry index, kept in memory after the first load. */
+  /** Per-session hash → on-disk location, with lazy entry hydration. */
   cache = /* @__PURE__ */ new Map();
   /** Per-session entry count on disk, to detect when compaction is needed. */
   diskCount = /* @__PURE__ */ new Map();
@@ -5330,8 +5684,16 @@ var ReplayLogStore = class {
           const currentCount = this.diskCount.get(input.sessionId) ?? 0;
           const willEvict = currentCount + 1 > this.maxEntries;
           if (!willEvict) {
-            await fsp.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
-            cache.set(hash, entry);
+            const line = JSON.stringify(entry) + "\n";
+            let offset2 = 0;
+            try {
+              const stat10 = await fsp2.stat(fp);
+              offset2 = stat10.size;
+            } catch (err) {
+              if (err.code !== "ENOENT") throw err;
+            }
+            await fsp2.appendFile(fp, line, "utf8");
+            cache.set(hash, { entry, offset: offset2, length: Buffer.byteLength(line, "utf8") });
             this.diskCount.set(input.sessionId, currentCount + 1);
             this.events?.emit("storage.write", {
               sessionId: input.sessionId,
@@ -5348,7 +5710,12 @@ var ReplayLogStore = class {
           all.push(entry);
           const keep = all.slice(-this.maxEntries);
           const refreshed = /* @__PURE__ */ new Map();
-          for (const e of keep) refreshed.set(e.hash, e);
+          let offset = 0;
+          for (const e of keep) {
+            const line = JSON.stringify(e) + "\n";
+            refreshed.set(e.hash, { entry: e, offset, length: Buffer.byteLength(line, "utf8") });
+            offset += Buffer.byteLength(line, "utf8");
+          }
           this.cache.set(input.sessionId, refreshed);
           this.diskCount.set(input.sessionId, keep.length);
           await this.writeAll(input.sessionId, keep, "compact");
@@ -5381,6 +5748,8 @@ var ReplayLogStore = class {
     const t0 = Date.now();
     try {
       const cache = await this.ensureCache(sessionId);
+      const location = cache.get(hash);
+      const entry = location ? await this.hydrateEntry(sessionId, hash, location) : null;
       this.events?.emit("storage.read", {
         sessionId,
         store: "replay",
@@ -5390,7 +5759,7 @@ var ReplayLogStore = class {
         durationMs: Date.now() - t0,
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      return cache.get(hash) ?? null;
+      return entry;
     } catch (err) {
       this.events?.emit("storage.read", {
         sessionId,
@@ -5411,6 +5780,10 @@ var ReplayLogStore = class {
     const t0 = Date.now();
     try {
       const cache = await this.ensureCache(sessionId);
+      const entries = [];
+      for (const [hash, location] of cache) {
+        entries.push(await this.hydrateEntry(sessionId, hash, location));
+      }
       const durationMs = Date.now() - t0;
       this.events?.emit("storage.read", {
         sessionId,
@@ -5421,7 +5794,7 @@ var ReplayLogStore = class {
         durationMs,
         ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
       });
-      return [...cache.values()];
+      return entries;
     } catch (err) {
       const durationMs = Date.now() - t0;
       this.events?.emit("storage.read", {
@@ -5447,7 +5820,7 @@ var ReplayLogStore = class {
     const scan = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fsp.readdir(dir, { withFileTypes: true });
+        entries = await fsp2.readdir(dir, { withFileTypes: true });
       } catch (err) {
         if (depth === 0 && err.code !== "ENOENT") {
           console.warn(JSON.stringify({
@@ -5485,7 +5858,7 @@ var ReplayLogStore = class {
     return sessionScopedPath(this.dir, sessionId, ".replay.jsonl");
   }
   async countEntries(filePath) {
-    const handle = await fsp.open(filePath, "r");
+    const handle = await fsp2.open(filePath, "r");
     const buffer = Buffer.allocUnsafe(64 * 1024);
     let count = 0;
     let hasNonWhitespace = false;
@@ -5511,23 +5884,27 @@ var ReplayLogStore = class {
     if (hasNonWhitespace) count++;
     return count;
   }
+  parseReplayLine(line) {
+    try {
+      const parsed = safeParse(line);
+      if (!parsed.ok || !parsed.value) return null;
+      if ("entry" in parsed.value && parsed.value.entry) {
+        return parsed.value.entry;
+      }
+      return parsed.value;
+    } catch {
+      return null;
+    }
+  }
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fsp.readFile(fp, "utf8");
+      const raw = await fsp2.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
-        try {
-          const parsed = safeParse(line);
-          if (!parsed.ok || !parsed.value) continue;
-          if ("entry" in parsed.value && parsed.value.entry) {
-            out.push(parsed.value.entry);
-          } else {
-            out.push(parsed.value);
-          }
-        } catch {
-        }
+        const parsed = this.parseReplayLine(line);
+        if (parsed) out.push(parsed);
       }
       return out;
     } catch (err) {
@@ -5554,13 +5931,75 @@ var ReplayLogStore = class {
   async ensureCache(sessionId) {
     let cache = this.cache.get(sessionId);
     if (cache) return cache;
-    const all = await this.readAll(sessionId);
+    const fp = this.filePath(sessionId);
     cache = /* @__PURE__ */ new Map();
-    for (const e of all) cache.set(e.hash, e);
+    try {
+      const handle = await fsp2.open(fp, "r");
+      const CHUNK = 64 * 1024;
+      const buffer = Buffer.alloc(CHUNK);
+      let leftover = "";
+      let leftoverOffset = 0;
+      let fileOffset = 0;
+      try {
+        while (true) {
+          const { bytesRead } = await handle.read(buffer, 0, CHUNK, fileOffset);
+          if (bytesRead === 0) break;
+          const chunk = buffer.subarray(0, bytesRead).toString("utf8");
+          const text = leftover + chunk;
+          let lineStart = leftoverOffset;
+          let searchFrom = 0;
+          while (true) {
+            const newlineIndex = text.indexOf("\n", searchFrom);
+            if (newlineIndex === -1) break;
+            const line = text.slice(searchFrom, newlineIndex);
+            const lineLength = Buffer.byteLength(text.slice(searchFrom, newlineIndex + 1), "utf8");
+            if (line.trim()) {
+              const entry = this.parseReplayLine(line);
+              if (entry) {
+                cache.set(entry.hash, { offset: lineStart, length: lineLength });
+              }
+            }
+            lineStart += lineLength;
+            searchFrom = newlineIndex + 1;
+          }
+          leftover = text.slice(searchFrom);
+          leftoverOffset = lineStart;
+          fileOffset += bytesRead;
+        }
+        if (leftover.trim()) {
+          const entry = this.parseReplayLine(leftover);
+          if (entry) {
+            cache.set(entry.hash, { offset: leftoverOffset, length: Buffer.byteLength(leftover, "utf8") });
+          }
+        }
+      } finally {
+        await handle.close();
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
     this.cache.set(sessionId, cache);
-    this.diskCount.set(sessionId, all.length);
+    this.diskCount.set(sessionId, cache.size);
     return cache;
   }
+  async hydrateEntry(sessionId, hash, location) {
+    if (location.entry) return location.entry;
+    const fp = this.filePath(sessionId);
+    const handle = await fsp2.open(fp, "r");
+    try {
+      const buffer = Buffer.alloc(location.length);
+      const { bytesRead } = await handle.read(buffer, 0, location.length, location.offset);
+      const line = buffer.subarray(0, bytesRead).toString("utf8").trimEnd();
+      const entry = this.parseReplayLine(line);
+      if (!entry) {
+        throw new Error(`Replay entry ${hash} is unreadable`);
+      }
+      location.entry = entry;
+      return entry;
+    } finally {
+      await handle.close();
+    }
+  }
   enqueue(sessionId, fn) {
     const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
     const next = prev.then(fn, fn);
@@ -5589,19 +6028,19 @@ var SessionRecovery = class {
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
     const TAIL_SIZE = 8192;
-    let stat7;
+    let stat10;
     try {
-      stat7 = await fsp.stat(fp);
+      stat10 = await fsp2.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    if (stat7.size === 0) return null;
-    const position = Math.max(0, stat7.size - TAIL_SIZE);
+    if (stat10.size === 0) return null;
+    const position = Math.max(0, stat10.size - TAIL_SIZE);
     const buf = Buffer.alloc(TAIL_SIZE);
     let fh;
     try {
-      fh = await fsp.open(fp, "r");
+      fh = await fsp2.open(fp, "r");
       const { bytesRead } = await fh.read(buf, 0, TAIL_SIZE, position);
       let eventCount = 0;
       const raw = buf.subarray(0, bytesRead).toString("utf8");
@@ -5646,7 +6085,7 @@ var SessionRecovery = class {
     const fp = this.filePath(sessionId);
     let raw;
     try {
-      raw = await fsp.readFile(fp, "utf8");
+      raw = await fsp2.readFile(fp, "utf8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
@@ -5691,7 +6130,7 @@ var SessionRecovery = class {
     const collect = async (dir, prefix, depth) => {
       let entries;
       try {
-        entries = await fsp.readdir(dir, { withFileTypes: true });
+        entries = await fsp2.readdir(dir, { withFileTypes: true });
       } catch {
         return;
       }
@@ -5792,9 +6231,9 @@ var ToolAuditLog = class {
             isError: input.isError,
             index
           };
-          await fsp.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
+          await fsp2.appendFile(fp, JSON.stringify(entry) + "\n", "utf8");
           try {
-            const st = await fsp.stat(fp);
+            const st = await fsp2.stat(fp);
             this.tailStat.set(input.sessionId, { mtimeMs: st.mtimeMs, size: st.size });
           } catch {
           }
@@ -5841,7 +6280,7 @@ var ToolAuditLog = class {
     const cachedStat = this.tailStat.get(sessionId);
     if (cachedHash !== void 0 && cachedIndex !== void 0 && cachedStat) {
       try {
-        const st = await fsp.stat(fp);
+        const st = await fsp2.stat(fp);
         if (st.mtimeMs === cachedStat.mtimeMs && st.size === cachedStat.size) {
           return { prevHash: cachedHash, nextIndex: cachedIndex };
         }
@@ -5862,7 +6301,7 @@ var ToolAuditLog = class {
     this.tailHash.set(sessionId, prevHash);
     this.tailIndex.set(sessionId, nextIndex);
     try {
-      const st = await fsp.stat(fp);
+      const st = await fsp2.stat(fp);
       this.tailStat.set(sessionId, { mtimeMs: st.mtimeMs, size: st.size });
     } catch {
     }
@@ -5983,7 +6422,7 @@ var ToolAuditLog = class {
   async readAll(sessionId) {
     const fp = this.filePath(sessionId);
     try {
-      const raw = await fsp.readFile(fp, "utf8");
+      const raw = await fsp2.readFile(fp, "utf8");
       const out = [];
       for (const line of raw.split("\n")) {
         if (!line.trim()) continue;
@@ -6021,7 +6460,7 @@ var ToolAuditLog = class {
   }
   async sync(sessionId, fp) {
     try {
-      const fh = await fsp.open(fp, "r+");
+      const fh = await fsp2.open(fp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -6339,7 +6778,7 @@ var SessionRegistry = class {
   }
   async readAndPrune() {
     try {
-      const raw = await fsp.readFile(this.filePath, "utf8");
+      const raw = await fsp2.readFile(this.filePath, "utf8");
       const registry = JSON.parse(raw);
       const now = Date.now();
       let pruned = false;
@@ -6373,11 +6812,11 @@ var SessionRegistry = class {
     const retryDelayMs = 20;
     for (let attempt = 0; attempt < maxRetries; attempt++) {
       try {
-        await fsp.mkdir(path2.dirname(this.filePath), { recursive: true });
-        let lockHandle = await fsp.open(lockPath, "wx").catch(() => null);
+        await fsp2.mkdir(path2.dirname(this.filePath), { recursive: true });
+        let lockHandle = await fsp2.open(lockPath, "wx").catch(() => null);
         if (!lockHandle) {
           if (await this.breakStaleLock(lockPath)) {
-            lockHandle = await fsp.open(lockPath, "wx").catch(() => null);
+            lockHandle = await fsp2.open(lockPath, "wx").catch(() => null);
           }
           if (!lockHandle) {
             await new Promise((r) => setTimeout(r, retryDelayMs * (attempt + 1)));
@@ -6386,14 +6825,14 @@ var SessionRegistry = class {
         }
         try {
           await lockHandle.writeFile(String(process.pid)).catch(() => void 0);
-          const raw = await fsp.readFile(this.filePath, "utf8").catch(() => "{}");
+          const raw = await fsp2.readFile(this.filePath, "utf8").catch(() => "{}");
           const registry = JSON.parse(raw);
           fn(registry);
           await this.writeAtomicLocked(registry);
           return;
         } finally {
           await lockHandle.close();
-          await fsp.unlink(lockPath).catch(() => void 0);
+          await fsp2.unlink(lockPath).catch(() => void 0);
         }
       } catch {
         return;
@@ -6409,15 +6848,15 @@ var SessionRegistry = class {
    */
   async breakStaleLock(lockPath) {
     try {
-      const [stat7, content] = await Promise.all([
-        fsp.stat(lockPath),
-        fsp.readFile(lockPath, "utf8").catch(() => "")
+      const [stat10, content] = await Promise.all([
+        fsp2.stat(lockPath),
+        fsp2.readFile(lockPath, "utf8").catch(() => "")
       ]);
-      const ageMs = Date.now() - stat7.mtimeMs;
+      const ageMs = Date.now() - stat10.mtimeMs;
       const ownerPid = Number.parseInt(content.trim(), 10);
       const ownerDead = Number.isInteger(ownerPid) && ownerPid > 0 && ownerPid !== process.pid && !pidAlive(ownerPid);
       if (ownerDead || ageMs > STALE_LOCK_MS) {
-        await fsp.unlink(lockPath).catch(() => void 0);
+        await fsp2.unlink(lockPath).catch(() => void 0);
         return true;
       }
       return false;
@@ -6440,10 +6879,10 @@ var SessionRegistry = class {
       `.${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);
+      await fsp2.writeFile(tmp, JSON.stringify(registry, null, 2), "utf8");
+      await fsp2.rename(tmp, this.filePath);
     } catch (err) {
-      await fsp.unlink(tmp).catch(() => void 0);
+      await fsp2.unlink(tmp).catch(() => void 0);
       throw err;
     }
   }
@@ -6453,17 +6892,17 @@ var SessionRegistry = class {
       const base = path2.basename(this.filePath);
       const now = Date.now();
       const stale = [];
-      for (const name of await fsp.readdir(dir)) {
+      for (const name of await fsp2.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 });
+        const stat10 = await fsp2.stat(path2.join(dir, name)).catch(() => null);
+        if (!stat10) continue;
+        if (now - stat10.mtimeMs > STALE_TMP_MS) stale.push({ name, mtimeMs: stat10.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);
+          await fsp2.unlink(path2.join(dir, name)).catch(() => void 0);
         })
       );
     } catch {
@@ -6912,7 +7351,7 @@ var FleetNotifier = class {
   }
   async discover() {
     try {
-      const raw = await fsp.readFile(path2.join(this.baseDir, INSTANCES_FILE), "utf8");
+      const raw = await fsp2.readFile(path2.join(this.baseDir, INSTANCES_FILE), "utf8");
       const data = JSON.parse(raw);
       const list = Array.isArray(data?.instances) ? data.instances : [];
       return list.filter((i) => i && typeof i.httpPort === "number").filter((i) => i.pid !== this.selfPid).filter((i) => normRoot(i.projectRoot) === this.projectRoot).filter((i) => pidAlive2(i.pid)).map((i) => {
@@ -6939,7 +7378,7 @@ var DefaultSessionRewinder = class {
   projectRoot;
   async listCheckpoints(sessionId) {
     const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
-    const raw = await fsp.readFile(file, "utf8");
+    const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     const fileCountMap = /* @__PURE__ */ new Map();
     for (const event of events) {
@@ -6964,7 +7403,7 @@ var DefaultSessionRewinder = class {
   }
   async rewindToCheckpoint(sessionId, checkpointIndex) {
     const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
-    const raw = await fsp.readFile(file, "utf8");
+    const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     let targetIdx = -1;
     for (let i = 0; i < events.length; i++) {
@@ -7003,7 +7442,7 @@ var DefaultSessionRewinder = class {
   }
   async rewindLastN(sessionId, n) {
     const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
-    const raw = await fsp.readFile(file, "utf8");
+    const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     const checkpoints = [];
     for (const event of events) {
@@ -7032,7 +7471,7 @@ var DefaultSessionRewinder = class {
   }
   async rewindToStart(sessionId) {
     const file = path2.join(this.sessionsDir, `${sessionId}.jsonl`);
-    const raw = await fsp.readFile(file, "utf8");
+    const raw = await fsp2.readFile(file, "utf8");
     const events = parseEvents(raw);
     const allSnapshots = [];
     for (const event of events) {
@@ -7080,7 +7519,7 @@ async function revertSnapshots(snapshots, projectRoot) {
             revertedFiles.push(file.path);
           }
         } else if (file.action === "created") {
-          await fsp.unlink(file.path);
+          await fsp2.unlink(file.path);
           revertedFiles.push(file.path);
         } else if (file.action === "modified") {
           if (file.before !== null) {
@@ -7099,7 +7538,7 @@ async function loadTodosCheckpoint(filePath, events, traceId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp.readFile(filePath, "utf8");
+    raw = await fsp2.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -7238,7 +7677,7 @@ async function loadPlan(filePath, events) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp.readFile(filePath, "utf8");
+    raw = await fsp2.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: "~boot~",
@@ -7549,7 +7988,7 @@ async function loadTasks(filePath, events, traceId) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp.readFile(filePath, "utf8");
+    raw = await fsp2.readFile(filePath, "utf8");
   } catch (err) {
     events?.emit("storage.error", {
       sessionId: traceId ?? "~boot~",
@@ -7648,7 +8087,7 @@ async function mutateTasks(filePath, sessionId, fn, events, traceId) {
 async function loadDirectorState(filePath) {
   let raw;
   try {
-    raw = await fsp.readFile(filePath, "utf8");
+    raw = await fsp2.readFile(filePath, "utf8");
   } catch {
     return null;
   }
@@ -7663,7 +8102,7 @@ async function loadDirectorState(filePath) {
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
   try {
-    existing = await fsp.readFile(lockPath, "utf8");
+    existing = await fsp2.readFile(lockPath, "utf8");
   } catch {
   }
   if (existing) {
@@ -7687,7 +8126,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
 }
 async function releaseDirectorStateLock(lockPath) {
   try {
-    await fsp.unlink(lockPath);
+    await fsp2.unlink(lockPath);
   } catch {
   }
 }
@@ -7831,7 +8270,7 @@ async function loadGoal(filePath, events) {
   const t0 = Date.now();
   let raw;
   try {
-    raw = await fsp.readFile(filePath, "utf8");
+    raw = await fsp2.readFile(filePath, "utf8");
   } catch (err) {
     const code = err.code;
     if (code === "ENOENT") {
@@ -8084,12 +8523,12 @@ var DefaultPromptStore = class {
     await ensureDir(this.dir);
     const entries = [];
     try {
-      const files = await fsp.readdir(this.dir);
+      const files = await fsp2.readdir(this.dir);
       for (const file of files) {
         if (!file.endsWith(".json")) continue;
         try {
           const raw = JSON.parse(
-            await fsp.readFile(path2.join(this.dir, file), "utf8")
+            await fsp2.readFile(path2.join(this.dir, file), "utf8")
           );
           entries.push(raw.entry);
         } catch {
@@ -8104,7 +8543,7 @@ var DefaultPromptStore = class {
   async get(id) {
     const file = path2.join(this.dir, `${id}.json`);
     try {
-      const raw = JSON.parse(await fsp.readFile(file, "utf8"));
+      const raw = JSON.parse(await fsp2.readFile(file, "utf8"));
       return raw.entry;
     } catch {
       return null;
@@ -8119,7 +8558,7 @@ var DefaultPromptStore = class {
   async delete(id) {
     const file = path2.join(this.dir, `${id}.json`);
     try {
-      await fsp.unlink(file);
+      await fsp2.unlink(file);
       return true;
     } catch {
       return false;
@@ -8226,7 +8665,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev: rev
     };
-    await fsp.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fsp2.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -8258,8 +8697,8 @@ var CloudSync = class {
       const rel = segments.slice(2).join("/");
       const destPath = resolvePulledCategoryPath(cat, localPath, rel, entry.path);
       const blobData = await this.getBlob(token, owner, repoName, entry.sha);
-      await fsp.mkdir(path2.dirname(destPath), { recursive: true });
-      await fsp.writeFile(destPath, Buffer.from(blobData, "base64"));
+      await fsp2.mkdir(path2.dirname(destPath), { recursive: true });
+      await fsp2.writeFile(destPath, Buffer.from(blobData, "base64"));
     }
     const localRev = await this.hashLocalCategories(cfg.categories);
     const syncState = {
@@ -8268,7 +8707,7 @@ var CloudSync = class {
       lastSyncedAt: (/* @__PURE__ */ new Date()).toISOString(),
       localRev
     };
-    await fsp.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
+    await fsp2.writeFile(this.statePath, JSON.stringify(syncState, null, 2), "utf8");
     this.state = syncState;
     return {
       ok: true,
@@ -8287,7 +8726,7 @@ var CloudSync = class {
   }
   async loadState() {
     try {
-      const raw = await fsp.readFile(this.statePath, "utf8");
+      const raw = await fsp2.readFile(this.statePath, "utf8");
       this.state = JSON.parse(raw);
     } catch {
       this.state = null;
@@ -8365,17 +8804,17 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat7 = await fsp.stat(localPath);
-        if (stat7.isDirectory()) {
+        const stat10 = await fsp2.stat(localPath);
+        if (stat10.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fsp.readFile(file, "utf8");
+            const content = await fsp2.readFile(file, "utf8");
             const rel = path2.relative(localPath, file).replace(/\\/g, "/");
             entries.push({ path: `data/${cat}/${rel}`, content, mode: "100644" });
             hashes.push(content);
           }
         } else {
-          const content = await fsp.readFile(localPath, "utf8");
+          const content = await fsp2.readFile(localPath, "utf8");
           entries.push({ path: `data/${cat}`, content, mode: "100644" });
           hashes.push(content);
         }
@@ -8391,15 +8830,15 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat7 = await fsp.stat(localPath);
-        if (stat7.isDirectory()) {
+        const stat10 = await fsp2.stat(localPath);
+        if (stat10.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
-            const content = await fsp.readFile(file);
+            const content = await fsp2.readFile(file);
             hashes.push(content.toString("base64") + file);
           }
         } else {
-          const content = await fsp.readFile(localPath);
+          const content = await fsp2.readFile(localPath);
           hashes.push(content.toString("base64") + localPath);
         }
       } catch {
@@ -8426,7 +8865,7 @@ var CloudSync = class {
   }
   async walkDir(dir, base) {
     const results = [];
-    const entries = await fsp.readdir(dir, { withFileTypes: true });
+    const entries = await fsp2.readdir(dir, { withFileTypes: true });
     for (const entry of entries) {
       const full = path2.join(dir, entry.name);
       if (entry.isDirectory()) {