@wrongstack/core 0.273.0 → 0.274.0

package/dist/coordination/index.js

@@ -1,6 +1,6 @@
 import { randomUUID, createHash, randomBytes } from 'crypto';
-import * as fsp6 from 'fs/promises';
-import * as path5 from 'path';
+import * as fsp7 from 'fs/promises';
+import * as path6 from 'path';
 import { isAbsolute, resolve } from 'path';
 import * as os from 'os';
 import { hostname } from 'os';
@@ -154,17 +154,17 @@ function formatHumanPrompt(request) {
   return lines.join("\n");
 }
 async function atomicWrite(targetPath, content, opts = {}) {
-  const dir = path5.dirname(targetPath);
-  await fsp6.mkdir(dir, { recursive: true });
-  const tmp = path5.join(dir, `.${path5.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
+  const dir = path6.dirname(targetPath);
+  await fsp7.mkdir(dir, { recursive: true });
+  const tmp = path6.join(dir, `.${path6.basename(targetPath)}.${randomBytes(6).toString("hex")}.tmp`);
   try {
     if (typeof content === "string") {
-      await fsp6.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
+      await fsp7.writeFile(tmp, content, { flag: "wx", encoding: opts.encoding ?? "utf8" });
     } else {
-      await fsp6.writeFile(tmp, content, { flag: "wx" });
+      await fsp7.writeFile(tmp, content, { flag: "wx" });
     }
     try {
-      const fh = await fsp6.open(tmp, "r+");
+      const fh = await fsp7.open(tmp, "r+");
       try {
         await fh.sync();
       } finally {
@@ -174,50 +174,50 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat7 = await fsp6.stat(targetPath);
+      const stat7 = await fsp7.stat(targetPath);
       mode = stat7.mode & 511;
     } catch {
       mode = opts.mode;
     }
     if (mode !== void 0) {
-      await fsp6.chmod(tmp, mode);
+      await fsp7.chmod(tmp, mode);
     }
     await renameWithRetry(tmp, targetPath);
   } catch (err) {
     try {
-      await fsp6.unlink(tmp);
+      await fsp7.unlink(tmp);
     } catch {
     }
     throw err;
   }
 }
 async function ensureDir(dir) {
-  await fsp6.mkdir(dir, { recursive: true });
+  await fsp7.mkdir(dir, { recursive: true });
 }
 async function withFileLock(targetPath, fn, opts = {}) {
-  const dir = path5.dirname(targetPath);
-  await fsp6.mkdir(dir, { recursive: true });
-  const lockPath = path5.join(dir, `.${path5.basename(targetPath)}.lock`);
+  const dir = path6.dirname(targetPath);
+  await fsp7.mkdir(dir, { recursive: true });
+  const lockPath = path6.join(dir, `.${path6.basename(targetPath)}.lock`);
   const timeoutMs = opts.timeoutMs ?? 5e3;
   const staleMs = opts.staleMs ?? 3e4;
   const started = Date.now();
   let handle;
   for (; ; ) {
     try {
-      handle = await fsp6.open(lockPath, "wx");
+      handle = await fsp7.open(lockPath, "wx");
       await handle.writeFile(`${process.pid}:${Date.now()}`);
       break;
     } catch (err) {
       const code = err.code;
       if (code === "ENOENT") {
-        await fsp6.mkdir(dir, { recursive: true });
+        await fsp7.mkdir(dir, { recursive: true });
         continue;
       }
       if (code !== "EEXIST") throw err;
       try {
-        const stat7 = await fsp6.stat(lockPath);
+        const stat7 = await fsp7.stat(lockPath);
         if (Date.now() - stat7.mtimeMs > staleMs) {
-          await fsp6.unlink(lockPath);
+          await fsp7.unlink(lockPath);
           continue;
         }
       } catch {
@@ -237,7 +237,7 @@ async function withFileLock(targetPath, fn, opts = {}) {
     } catch {
     }
     try {
-      await fsp6.unlink(lockPath);
+      await fsp7.unlink(lockPath);
     } catch {
     }
   }
@@ -245,14 +245,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 fsp6.rename(from, to);
+    await fsp7.rename(from, to);
     return;
   }
   const delays = [10, 25, 60, 120, 250];
   let lastErr;
   for (let i = 0; i <= delays.length; i++) {
     try {
-      await fsp6.rename(from, to);
+      await fsp7.rename(from, to);
       return;
     } catch (err) {
       lastErr = err;
@@ -275,7 +275,7 @@ function toErrorMessage(err) {
 async function acquireDirectorStateLock(lockPath, processId = process.pid) {
   let existing;
   try {
-    existing = await fsp6.readFile(lockPath, "utf8");
+    existing = await fsp7.readFile(lockPath, "utf8");
   } catch {
   }
   if (existing) {
@@ -299,7 +299,7 @@ async function acquireDirectorStateLock(lockPath, processId = process.pid) {
 }
 async function releaseDirectorStateLock(lockPath) {
   try {
-    await fsp6.unlink(lockPath);
+    await fsp7.unlink(lockPath);
   } catch {
   }
 }
@@ -525,7 +525,7 @@ async function expandGlob(pattern) {
   async function walk(dir, pat) {
     let entries;
     try {
-      entries = await fsp6.readdir(dir);
+      entries = await fsp7.readdir(dir);
     } catch {
       return;
     }
@@ -547,7 +547,7 @@ async function expandGlob(pattern) {
       for (const e of entries) {
         const full = `${dir}${SEP}${e}`;
         try {
-          const stat7 = await fsp6.stat(full);
+          const stat7 = await fsp7.stat(full);
           if (stat7.isDirectory()) await walk(full, rest);
         } catch {
         }
@@ -565,7 +565,7 @@ async function expandGlob(pattern) {
       if (entries.includes(seg)) {
         const full = `${dir}${SEP}${seg}`;
         try {
-          const stat7 = await fsp6.stat(full);
+          const stat7 = await fsp7.stat(full);
           if (stat7.isDirectory()) await walk(full, rest);
         } catch {
         }
@@ -673,8 +673,8 @@ function truncate(s, max) {
   return s.length <= max ? s : `${s.slice(0, max - 1)}\u2026`;
 }
 function projectSlug(absRoot) {
-  const base = slugify(path5.basename(absRoot));
-  const hash = createHash("sha256").update(path5.resolve(absRoot)).digest("hex").slice(0, 6);
+  const base = slugify(path6.basename(absRoot));
+  const hash = createHash("sha256").update(path6.resolve(absRoot)).digest("hex").slice(0, 6);
   return `${base}-${hash}`;
 }
 function slugify(name) {
@@ -682,8 +682,8 @@ function slugify(name) {
 }
 function wstackGlobalRoot() {
   const fromEnv = process.env["WRONGSTACK_HOME"];
-  if (fromEnv && fromEnv.trim().length > 0) return path5.resolve(fromEnv);
-  return path5.join(os.homedir(), ".wrongstack");
+  if (fromEnv && fromEnv.trim().length > 0) return path6.resolve(fromEnv);
+  return path6.join(os.homedir(), ".wrongstack");
 }
 
 // src/types/errors.ts
@@ -999,8 +999,8 @@ var CollabSession = class extends EventEmitter {
     for (const filePath of allFiles) {
       try {
         const [content, stat7] = await Promise.all([
-          fsp6.readFile(filePath, "utf8"),
-          fsp6.stat(filePath)
+          fsp7.readFile(filePath, "utf8"),
+          fsp7.stat(filePath)
         ]);
         const ext = filePath.split(".").pop() ?? "";
         const language = ext === "ts" || ext === "tsx" ? "typescript" : ext === "js" || ext === "jsx" ? "javascript" : ext === "md" ? "markdown" : ext === "json" ? "json" : void 0;
@@ -1422,7 +1422,7 @@ Emit each evaluation immediately. Do not wait until you have read all reports.`;
     for (const file of this.snapshot.files) {
       if (file.snapshotMtimeMs === void 0 && file.snapshotSizeBytes === void 0) continue;
       try {
-        const stat7 = await fsp6.stat(file.path);
+        const stat7 = await fsp7.stat(file.path);
         const mtimeChanged = file.snapshotMtimeMs !== void 0 && stat7.mtimeMs > file.snapshotMtimeMs + 1;
         const sizeChanged = file.snapshotSizeBytes !== void 0 && stat7.size !== file.snapshotSizeBytes;
         if (mtimeChanged || sizeChanged) {
@@ -7235,7 +7235,7 @@ var Director = class _Director {
     this.fleetManager = opts.fleetManager;
     this.logger = opts.logger;
     if (this.sharedScratchpadPath) {
-      void fsp6.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
+      void fsp7.mkdir(this.sharedScratchpadPath, { recursive: true }).catch((err) => this.logShutdownError("shared_scratchpad_mkdir", err));
     }
     this.transport = new InMemoryBridgeTransport();
     this.bridge = new InMemoryAgentBridge(
@@ -7835,7 +7835,7 @@ var Director = class _Director {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp6.mkdir(path5.dirname(this.manifestPath), { recursive: true });
+    await fsp7.mkdir(path6.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -8066,10 +8066,10 @@ var Director = class _Director {
    */
   async readSession(subagentId, tail) {
     if (!this.sessionsRoot) return null;
-    const filePath = path5.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
+    const filePath = path6.join(this.sessionsRoot, this.directorRunId, `${subagentId}.jsonl`);
     let raw;
     try {
-      raw = await fsp6.readFile(filePath, "utf8");
+      raw = await fsp7.readFile(filePath, "utf8");
     } catch {
       return null;
     }
@@ -8596,13 +8596,13 @@ async function readSubagentPartial(opts, subagentId) {
   if (!opts.sessionsRoot) return void 0;
   const candidates = [];
   if (opts.directorRunId) {
-    candidates.push(path5.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
+    candidates.push(path6.join(opts.sessionsRoot, opts.directorRunId, `${subagentId}.jsonl`));
   } else {
     try {
-      const entries = await fsp6.readdir(opts.sessionsRoot, { withFileTypes: true });
+      const entries = await fsp7.readdir(opts.sessionsRoot, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          candidates.push(path5.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
+          candidates.push(path6.join(opts.sessionsRoot, entry.name, `${subagentId}.jsonl`));
         }
       }
     } catch {
@@ -8612,7 +8612,7 @@ async function readSubagentPartial(opts, subagentId) {
   for (const file of candidates) {
     let raw;
     try {
-      raw = await fsp6.readFile(file, "utf8");
+      raw = await fsp7.readFile(file, "utf8");
     } catch {
       continue;
     }
@@ -8858,1456 +8858,1674 @@ function makeAgentSubagentRunner(opts) {
 function defaultFormatTaskInput(task) {
   return task.description ?? "";
 }
-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 ? path6.join(opts.dir, `${path6.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 path5.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 path5.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 = path5.dirname(path5.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 = path5.join(shardDir, `${path5.basename(id)}.jsonl`);
-    const t0 = Date.now();
-    let handle;
-    try {
-      handle = await fsp6.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)
-      });
-      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 flush() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
     }
+    await this.flushBuffer();
   }
-  async resume(id) {
-    const file = this.sessionPath(id, ".jsonl");
-    const t0 = Date.now();
-    const data = await this.load(id);
-    let handle;
-    try {
-      handle = await fsp6.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: path5.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;
-    }
+  /** 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);
   }
-  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 fsp6.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 fsp6.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 } : {}
+      });
     }
   }
-  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);
+  observeForSummary(event) {
+    if (event.type === "llm_response") {
+      for (const block of event.content) {
+        if (block.type === "tool_use") this.openToolUses.add(block.id);
       }
-      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) {
-    try {
-      await ensureDir(this.dir);
-      const line = JSON.stringify(summary) + "\n";
-      await fsp6.appendFile(this.indexFile, line, "utf8");
-      this._indexCache = null;
-      this.indexAppendCount++;
-      if (this.indexAppendCount >= _DefaultSessionStore.COMPACT_EVERY) {
-        await this.compactIndex();
-        this.indexAppendCount = 0;
+    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";
       }
-    } catch {
+    } else if (event.type === "file_snapshot") {
+      this.fileChangeCount += event.files.length;
+    } else if (event.type === "compaction") {
+      this.compactionCount++;
     }
-  }
-  /** 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 fsp6.appendFile(this.indexFile, line, "utf8");
-      this._indexCache = null;
-      this.indexAppendCount++;
-    } catch {
+    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++;
     }
   }
-  /**
-   * 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;
+  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 } : {}
+        });
+      }
+    }
+    const idxT0 = Date.now();
+    let idxOutcome = "success";
+    let idxError;
     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 fsp6.writeFile(tmp, lines, "utf8");
-      await fsp6.rename(tmp, this.indexFile);
-      this._indexCache = null;
+      await this.onCloseCb?.(this.summary);
     } catch (err) {
-      outcome = "failure";
-      errorMsg = toErrorMessage(err);
+      idxOutcome = "failure";
+      idxError = toErrorMessage(err);
     } finally {
-      this.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
+      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 } : {}
+      });
     }
-  }
-  /**
-   * 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.
-   */
-  async readIndex() {
-    let stat7;
     try {
-      const s = await fsp6.stat(this.indexFile);
-      stat7 = { mtimeMs: s.mtimeMs, size: s.size };
+      await this.handle.close();
     } catch {
-      this._indexCache = null;
-      return [];
     }
-    if (this._indexCache !== null && this._indexCache.mtimeMs === stat7.mtimeMs && this._indexCache.size === stat7.size) {
-      return [...this._indexCache.summaries];
+  }
+  async writeCheckpoint(promptIndex, promptPreview) {
+    const fileCount = this.pendingFileSnapshots.length;
+    if (fileCount > 0) {
+      await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
+      this.pendingFileSnapshots = [];
     }
-    let raw;
-    try {
-      raw = await fsp6.readFile(this.indexFile, "utf8");
-    } catch {
-      this._indexCache = null;
-      return [];
+    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
+    });
+  }
+  /**
+   * 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;
     }
-    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;
+    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 fsp7.open(this.filePath, "r", 384);
+      while (true) {
+        const buf = Buffer.alloc(CHUNK_SIZE);
+        const { bytesRead } = await fd.read(buf, 0, CHUNK_SIZE, fileOffset);
+        if (bytesRead === 0) break;
+        let chunkPos = 0;
+        while (chunkPos < bytesRead) {
+          const idx = buf.indexOf("\n", chunkPos);
+          if (idx === -1) {
+            lineStartOffset = fileOffset + chunkPos;
+            break;
+          }
+          if (checkpointByteOffset !== -1) {
+            removedCount++;
+          } else {
+            const lineBytes = buf.subarray(chunkPos, idx);
+            const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
+            if (line.trim()) {
+              try {
+                const event = JSON.parse(line);
+                if (event.type === "checkpoint") {
+                  if (event.promptIndex === targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                    targetCheckpointSeen = true;
+                  } else if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                    checkpointByteOffset = lineStartOffset;
+                  }
+                } else if (targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                } else if (targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex === void 0) {
+                  removedCount++;
+                } else if (!targetCheckpointSeen && event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  removedCount++;
+                }
+              } catch {
+              }
+            }
+          }
+          chunkPos = idx + 1;
+          lineStartOffset = fileOffset + chunkPos;
         }
-        if (entry.id && !deleted.has(entry.id)) {
-          seen.set(entry.id, entry);
+        fileOffset += bytesRead;
+        if (chunkPos >= bytesRead) {
+          lineStartOffset = fileOffset;
         }
-      } catch {
       }
+    } finally {
+      await fd?.close();
     }
-    const summaries = Array.from(seen.values());
-    this._indexCache = { ...stat7, summaries };
-    return [...summaries];
-  }
-  /**
-   * 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 fsp6.writeFile(tmp, lines, "utf8");
-    await fsp6.rename(tmp, this.indexFile);
-    this._indexCache = null;
-    return valid.length;
-  }
-  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);
-  }
-  async collectSessionFiles(dir, prefix = "", depth = 0) {
-    let entries;
+    if (checkpointByteOffset === -1) return 0;
+    await this.writeChain;
+    await this.handle.close();
+    const tmpPath = `${this.filePath}.rewind.tmp`;
+    const src = await fsp7.open(this.filePath, "r", 384);
     try {
-      entries = await fsp6.readdir(dir, { withFileTypes: true });
-    } catch {
-      return [];
-    }
-    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: path5.join(dir, entry.name) });
+      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 childFileArrays = await Promise.all(
-      dirEntries.map((entry) => {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionFiles(path5.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 fsp6.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 writeFd = await fsp7.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;
+        }
+        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;
+        }
+        if (leftover.trim()) {
+          try {
+            JSON.parse(leftover);
+          } catch {
+            await writeFd.write(`${leftover}
+`, void 0, "utf8");
+          }
+        }
+      } finally {
+        await writeFd.close();
       }
-    }
-    const childIdArrays = await Promise.all(
-      dirEntries.map((entry) => {
-        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
-        return this.collectSessionIds(path5.join(dir, entry.name), childPrefix, depth + 1);
-      })
-    );
-    return [...childIdArrays.flat(), ...fileIds];
-  }
-  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 {
-      const full = this.sessionPath(id, ".jsonl");
-      const stat7 = await fsp6.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;
+      await src.close();
+      await fsp7.rename(tmpPath, this.filePath);
+      this.handle = await fsp7.open(this.filePath, "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
-      };
+      await fsp7.unlink(tmpPath).catch(() => void 0);
+      this.handle = await fsp7.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 readSummaryManifest(id, startTime = Date.now()) {
-    const manifest = this.sessionPath(id, ".summary.json");
-    try {
-      const raw = await fsp6.readFile(manifest, "utf8");
-      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
-      return JSON.parse(raw);
-    } catch {
-      return null;
+  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 fsp7.writeFile(this.filePath, record, "utf8");
   }
-  async summaryHeaderFor(ref) {
-    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
-    try {
-      const stat7 = await fsp6.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;
-    }
-    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
-      };
+  /**
+   * 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");
     }
+    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() });
   }
   /**
-   * Delete a session and all associated files: JSONL, summary, plan/todos
-   * sidecars, and the session directory (fleet.json, shared/, subagents/).
+   * 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 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).
    *
-   * 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.
+   * Max size is capped to prevent unbounded memory growth in long-running
+   * processes. When the limit is reached, the oldest entry is evicted.
    */
-  async deleteSession(id) {
-    const jsonlPath = this.sessionPath(id, ".jsonl");
-    const summaryPath = this.sessionPath(id, ".summary.json");
-    const shardDir = path5.dirname(path5.join(this.dir, id));
-    const base = path5.basename(id);
-    const sessDir = path5.join(shardDir, base);
-    const deletions = [
-      fsp6.unlink(jsonlPath),
-      fsp6.unlink(summaryPath),
-      fsp6.unlink(path5.join(shardDir, `${base}.plan.json`)),
-      fsp6.unlink(path5.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()
-          }));
-        }
-      }
+  _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();
     }
-    await fsp6.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()
-      }));
+  }
+  // ── 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 } : {}
     });
-    await this.writeTombstone(id);
   }
-  async delete(id) {
-    await this.deleteSession(id);
+  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 } : {}
+    });
   }
-  async prune(maxAgeDays = 30) {
-    const cutoff = Date.now() - maxAgeDays * 864e5;
-    let deleted = 0;
-    let activeSessionId = null;
+  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 path6.join(this.dir, "_index.jsonl");
+  }
+  /** Join session ID to its absolute path within the store directory. */
+  sessionPath(id, ext) {
+    return path6.join(this.dir, `${id}${ext}`);
+  }
+  shardManifestPath(shardKey) {
+    return shardKey ? path6.join(this.dir, shardKey, "_manifest.json") : path6.join(this.dir, "_manifest.json");
+  }
+  shardKeyForSessionId(id) {
+    const dirName = path6.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 = path6.dirname(path6.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 = path6.join(shardDir, `${path6.basename(id)}.jsonl`);
+    const t0 = Date.now();
+    let handle;
     try {
-      const raw = await fsp6.readFile(path5.join(this.dir, "active.json"), "utf8");
-      const active = JSON.parse(raw);
-      activeSessionId = active.sessionId ?? null;
-    } catch {
+      handle = await fsp7.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 }
+      );
     }
-    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 = path5.join(dir, name);
-      try {
-        const stat7 = await fsp6.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 fsp6.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 = path5.join(this.dir, entry.name);
-      const files = await fsp6.readdir(dateDir, { withFileTypes: true }).catch(() => []);
-      for (const file of files) {
-        if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
-        await pruneFile(dateDir, file.name, entry.name);
-      }
+    try {
+      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;
     }
-    if (deleted > 0) {
-      await this.compactIndex().catch(() => void 0);
+  }
+  async resume(id) {
+    const file = this.sessionPath(id, ".jsonl");
+    const t0 = Date.now();
+    const data = await this.load(id);
+    let handle;
+    try {
+      handle = await fsp7.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 }
+      );
     }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dateDir = path5.join(this.dir, entry.name);
-      try {
-        const remaining = await fsp6.readdir(dateDir);
-        if (remaining.length === 0) {
-          await fsp6.rmdir(dateDir).catch(() => void 0);
+    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: path6.dirname(file),
+          filePath: file,
+          secretScrubber: this.secretScrubber,
+          onClose: (s) => this.appendToIndex(s)
         }
-      } catch {
-      }
+      );
+      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;
     }
-    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 fsp6.writeFile(file, record, "utf8");
-    await fsp6.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";
+      const s = await fsp7.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 fsp7.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 });
+              }
+            }
           }
-        } 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;
+        } 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: stat7.mtimeMs, size: stat7.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 stat7;
+    try {
+      stat7 = await fsp7.stat(file);
+    } catch (err) {
+      if (err.code === "ENOENT") return [];
+      throw err;
+    }
+    if (stat7.size === 0) return [];
+    let fh;
     try {
-      for await (const line of lines) {
-        if (!line.trim()) continue;
+      fh = await fsp7.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 ? path5.join(opts.dir, `${path5.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;
-  closed = false;
-  closePromise = null;
-  manifestFile;
-  summary;
-  tokenIn = 0;
-  tokenOut = 0;
-  filePath;
-  get transcriptPath() {
-    return this.filePath || void 0;
-  }
-  /**
-   * 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.
-   */
-  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;
   /**
-   * 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.
+   * 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.
    */
-  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;
-  }
-  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);
-  }
-  get pendingToolUses() {
-    return Array.from(this.openToolUses);
-  }
-  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 listFiltered(criteria) {
+    const limit = criteria.limit ?? 100;
     try {
-      await this.enqueueWrite(record);
+      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 [];
     }
   }
-  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 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;
+  // ── 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 fsp7.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;
       }
-      await this.flushBuffer();
-    } else {
-      this.scheduleFlush();
-    }
-  }
-  /**
-   * 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;
+    } catch {
     }
-    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);
+  /** 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 fsp7.appendFile(this.indexFile, line, "utf8");
+      this._indexCache = null;
+      this.invalidateShardManifestBySessionId(id);
+      this.indexAppendCount++;
+    } catch {
+    }
   }
   /**
-   * 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).
+   * Compact the index: read all entries, drop tombstones, deduplicate
+   * (keep latest per session), and rewrite. Atomic via temp+rename.
    */
-  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 compactIndex() {
     const t0 = Date.now();
     let outcome = "success";
     let errorMsg;
     try {
-      await this.enqueueWrite(batch);
+      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 fsp7.writeFile(tmp, lines, "utf8");
+      await fsp7.rename(tmp, this.indexFile);
+      this._indexCache = null;
     } 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.emitWrite("~compact~", this.indexFile, "compact", outcome, Date.now() - t0, void 0, errorMsg);
     }
   }
-  observeForSummary(event) {
-    if (event.type === "llm_response") {
-      for (const block of event.content) {
-        if (block.type === "tool_use") this.openToolUses.add(block.id);
+  /**
+   * 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.
+   */
+  async readIndex() {
+    let stat7;
+    try {
+      const s = await fsp7.stat(this.indexFile);
+      stat7 = { mtimeMs: s.mtimeMs, size: s.size };
+    } catch {
+      this._indexCache = null;
+      return [];
+    }
+    if (this._indexCache !== null && this._indexCache.mtimeMs === stat7.mtimeMs && this._indexCache.size === stat7.size) {
+      return [...this._indexCache.summaries];
+    }
+    let raw;
+    try {
+      raw = await fsp7.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 {
       }
     }
-    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";
+    const summaries = Array.from(seen.values());
+    this._indexCache = { ...stat7, summaries };
+    return [...summaries];
+  }
+  /**
+   * 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 fsp7.writeFile(tmp, lines, "utf8");
+    await fsp7.rename(tmp, this.indexFile);
+    this._indexCache = null;
+    return valid.length;
+  }
+  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 });
       }
-    } 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";
+    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 collectShardKeys() {
+    let entries;
+    try {
+      entries = await fsp7.readdir(this.dir, { withFileTypes: true });
+    } catch {
+      return [""];
     }
-    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++;
+    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 close() {
-    if (this.closePromise) return this.closePromise;
-    this.closePromise = this.doClose();
-    return this.closePromise;
+  async readOrBuildShardManifest(shardKey) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (cached) return cached;
+    const manifestPath = this.shardManifestPath(shardKey);
+    try {
+      const raw = await fsp7.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 ? path6.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 doClose() {
-    this.closed = true;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+  async collectSessionFiles(dir, prefix = "", depth = 0) {
+    let entries;
+    try {
+      entries = await fsp7.readdir(dir, { withFileTypes: true });
+    } catch {
+      return [];
     }
-    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 } : {}
-        });
+    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: path6.join(dir, entry.name) });
+      }
+    }
+    const childFileArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionFiles(path6.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 fsp7.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 idxT0 = Date.now();
-    let idxOutcome = "success";
-    let idxError;
+    const childIdArrays = await Promise.all(
+      dirEntries.map((entry) => {
+        const childPrefix = depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+        return this.collectSessionIds(path6.join(dir, entry.name), childPrefix, depth + 1);
+      })
+    );
+    return [...childIdArrays.flat(), ...fileIds];
+  }
+  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.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 } : {}
+      const full = this.sessionPath(id, ".jsonl");
+      const stat7 = await fsp7.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;
+    } 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
+      };
     }
+  }
+  async readSummaryManifest(id, startTime = Date.now()) {
+    const manifest = this.sessionPath(id, ".summary.json");
     try {
-      await this.handle.close();
+      const raw = await fsp7.readFile(manifest, "utf8");
+      this.emitRead(id, manifest, "summary", "success", Date.now() - startTime);
+      return JSON.parse(raw);
     } catch {
+      return null;
     }
   }
-  async writeCheckpoint(promptIndex, promptPreview) {
-    const fileCount = this.pendingFileSnapshots.length;
-    if (fileCount > 0) {
-      await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
-      this.pendingFileSnapshots = [];
+  async summaryHeaderFor(ref) {
+    let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+    try {
+      const stat7 = await fsp7.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;
+    }
+    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
+      };
     }
-    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
-    });
   }
   /**
-   * 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.
+   * 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 truncateToCheckpoint(targetPromptIndex) {
-    if (!this.filePath) return 0;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
+  async deleteSession(id) {
+    const jsonlPath = this.sessionPath(id, ".jsonl");
+    const summaryPath = this.sessionPath(id, ".summary.json");
+    const shardDir = path6.dirname(path6.join(this.dir, id));
+    const base = path6.basename(id);
+    const sessDir = path6.join(shardDir, base);
+    const deletions = [
+      fsp7.unlink(jsonlPath),
+      fsp7.unlink(summaryPath),
+      fsp7.unlink(path6.join(shardDir, `${base}.plan.json`)),
+      fsp7.unlink(path6.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()
+          }));
+        }
+      }
     }
-    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;
+    await fsp7.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 {
-      fd = await fsp6.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;
-        }
+      const raw = await fsp7.readFile(path6.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 = path6.join(dir, name);
+      try {
+        const stat7 = await fsp7.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 fsp7.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;
       }
-    } finally {
-      await fd?.close();
-    }
-    if (checkpointByteOffset === -1) return 0;
-    await this.writeChain;
-    await this.handle.close();
-    const tmpPath = `${this.filePath}.rewind.tmp`;
-    const src = await fsp6.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;
+      if (!entry.isDirectory()) continue;
+      const dateDir = path6.join(this.dir, entry.name);
+      const files = await fsp7.readdir(dateDir, { withFileTypes: true }).catch(() => []);
+      for (const file of files) {
+        if (!file.isFile() || !isPrunableJsonl(file.name)) continue;
+        await pruneFile(dateDir, file.name, entry.name);
       }
-      const writeFd = await fsp6.open(tmpPath, "w", 384);
+    }
+    if (deleted > 0) {
+      await this.compactIndex().catch(() => void 0);
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const dateDir = path6.join(this.dir, entry.name);
       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 fsp6.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");
-          }
+        const remaining = await fsp7.readdir(dateDir);
+        if (remaining.length === 0) {
+          await fsp7.rmdir(dateDir).catch(() => void 0);
         }
-      } finally {
-        await writeFd.close();
+      } catch {
       }
-      await src.close();
-      await fsp6.rename(tmpPath, this.filePath);
-      this.handle = await fsp6.open(this.filePath, "a", 384);
-    } catch (err) {
-      await fsp6.unlink(tmpPath).catch(() => void 0);
-      this.handle = await fsp6.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;
+    return deleted;
   }
-  async clearSession() {
-    if (!this.filePath) return;
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    this.writeBuffer = [];
-    await this.writeChain;
+  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(),
-      id: this.id,
-      model: this.meta.model ?? "unknown",
-      provider: this.meta.provider ?? "unknown"
+      id,
+      model: "unknown",
+      provider: "unknown"
     })}
 `;
-    await fsp6.writeFile(this.filePath, record, "utf8");
+    await fsp7.writeFile(file, record, "utf8");
+    await fsp7.unlink(meta).catch(() => void 0);
   }
-  /**
-   * 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");
+  async summarize(id, mtime) {
+    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;
+      }
+      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
+      };
     }
-    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() });
+  async *iterSessionEvents(file) {
+    const stream = createReadStream(file, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+      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 {
+      lines.close();
+      stream.destroy();
+    }
   }
 };
-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);
+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
+      });
+    }
+  }
+  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);
@@ -10333,9 +10551,9 @@ function makeDirectorSessionFactory(opts) {
   let dir;
   if (opts.store) {
     store = opts.store;
-    dir = opts.sessionsRoot ? path5.join(opts.sessionsRoot, runId) : "(caller-managed)";
+    dir = opts.sessionsRoot ? path6.join(opts.sessionsRoot, runId) : "(caller-managed)";
   } else if (opts.sessionsRoot) {
-    dir = path5.join(opts.sessionsRoot, runId);
+    dir = path6.join(opts.sessionsRoot, runId);
     store = new DefaultSessionStore({ dir });
   } else {
     throw new Error("makeDirectorSessionFactory requires either `store` or `sessionsRoot`");
@@ -10647,7 +10865,7 @@ var FleetManager = class {
       })),
       usage: this.usage.snapshot()
     };
-    await fsp6.mkdir(path5.dirname(this.manifestPath), { recursive: true });
+    await fsp7.mkdir(path6.dirname(this.manifestPath), { recursive: true });
     await atomicWrite(this.manifestPath, JSON.stringify(manifest, null, 2), { mode: 384 });
     return this.manifestPath;
   }
@@ -10802,12 +11020,18 @@ var DefaultMailbox = class {
   _byTo = /* @__PURE__ */ new Map();
   /** Secondary index: sender → Set of messages (points into _messageCache). */
   _byFrom = /* @__PURE__ */ new Map();
+  /** Counts malformed JSONL lines skipped during parsing for observability. */
+  _corruptionCount = 0;
   constructor(sessionDir) {
-    this.filePath = path5.join(sessionDir, MAILBOX_FILE);
+    this.filePath = path6.join(sessionDir, MAILBOX_FILE);
   }
   get mailboxPath() {
     return this.filePath;
   }
+  /** Returns the count of malformed JSONL lines encountered during reads. */
+  get corruptionCount() {
+    return this._corruptionCount;
+  }
   // ── Send ──────────────────────────────────────────────────────────────
   async send(input) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -10828,10 +11052,13 @@ var DefaultMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR;
-    await fsp6.mkdir(path5.dirname(this.filePath), { recursive: true });
+    await fsp7.mkdir(path6.dirname(this.filePath), { recursive: true });
     await withFileLock(this.filePath, async () => {
-      await fsp6.appendFile(this.filePath, line, "utf8");
+      await fsp7.appendFile(this.filePath, line, "utf8");
       this._pushToCache(msg);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._messageCacheMtime = mtime;
+      this._messageCacheSize = size;
     });
     return msg;
   }
@@ -10908,9 +11135,10 @@ var DefaultMailbox = class {
       }
       if (changed) {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp6.writeFile(this.filePath, serialized, "utf8");
+        await fsp7.writeFile(this.filePath, serialized, "utf8");
       }
-      this._setMessageCache(all);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._setMessageCache(all, mtime, size);
     });
     return updated;
   }
@@ -10966,8 +11194,9 @@ var DefaultMailbox = class {
   }
   async clearAll() {
     await withFileLock(this.filePath, async () => {
-      await fsp6.writeFile(this.filePath, "", "utf8");
-      this._setMessageCache([]);
+      await fsp7.writeFile(this.filePath, "", "utf8");
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._setMessageCache([], mtime, size);
     });
   }
   async purgeStale(opts) {
@@ -10998,9 +11227,10 @@ var DefaultMailbox = class {
       remaining = kept.length;
       if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR) + LINE_SEPARATOR;
-        await fsp6.writeFile(this.filePath, content, "utf8");
+        await fsp7.writeFile(this.filePath, content, "utf8");
       }
-      this._setMessageCache(kept);
+      const { mtime, size } = await this._statUnderLockOrAbsent();
+      this._setMessageCache(kept, mtime, size);
     });
     return {
       completedPurged,
@@ -11020,7 +11250,7 @@ var DefaultMailbox = class {
   // ── Internal ──────────────────────────────────────────────────────────
   async _readAll() {
     try {
-      const raw = await fsp6.readFile(this.filePath, "utf8");
+      const raw = await fsp7.readFile(this.filePath, "utf8");
       return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -11052,7 +11282,9 @@ var DefaultMailbox = class {
         const msg = parsed;
         this._messageCache.push(msg);
         this._indexMsg(msg);
-      } catch {
+      } catch (err) {
+        this._corruptionCount++;
+        console.debug(`[mailbox] skipped malformed line during incremental read: ${err.message}`);
       }
     }
     return this._messageCache;
@@ -11074,19 +11306,38 @@ var DefaultMailbox = class {
           delete parsed["readAt"];
         }
         messages.push(parsed);
-      } catch {
+      } catch (err) {
+        this._corruptionCount++;
+        console.debug(`[mailbox] skipped malformed line during full parse: ${err.message}`);
       }
     }
     return messages;
   }
+  /**
+   * Stat the mailbox file under the assumption that we are holding the
+   * file lock, and that a write to the file has just completed. Returns
+   * the (mtimeMs, size) pair, or (-1, -1) if the file does not exist
+   * (e.g. ackMany/purgeStale on a session that has never sent a message).
+   */
+  async _statUnderLockOrAbsent() {
+    try {
+      const st = await fsp7.stat(this.filePath);
+      return { mtime: st.mtimeMs, size: st.size };
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        return { mtime: -1, size: -1 };
+      }
+      throw err;
+    }
+  }
   async _readAllCached() {
     try {
-      const st = await fsp6.stat(this.filePath);
+      const st = await fsp7.stat(this.filePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
       if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
-        const fd = await fsp6.open(this.filePath, "r");
+        const fd = await fsp7.open(this.filePath, "r");
         try {
           const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
           this._messageCacheMtime = st.mtimeMs;
@@ -11118,16 +11369,8 @@ var DefaultMailbox = class {
     }
     this._messageCache = messages;
     this._buildIndexes(messages);
-    if (mtime !== void 0 && size !== void 0) {
-      this._messageCacheMtime = mtime;
-      this._messageCacheSize = size;
-      return;
-    }
-    void fsp6.stat(this.filePath).then((st) => {
-      this._messageCacheMtime = st.mtimeMs;
-      this._messageCacheSize = st.size;
-    }).catch(() => {
-    });
+    this._messageCacheMtime = mtime;
+    this._messageCacheSize = size;
   }
   _pushToCache(msg) {
     if (this._messageCache === null) return;
@@ -11307,7 +11550,7 @@ var REGISTRY_CACHE_TTL_MS = 2e3;
 var LINE_SEPARATOR2 = "\n";
 var MESSAGE_CACHE_MAX_ENTRIES2 = 1e4;
 function resolveProjectDir(projectRoot, globalRoot) {
-  return path5.join(globalRoot, "projects", projectSlug(projectRoot));
+  return path6.join(globalRoot, "projects", projectSlug(projectRoot));
 }
 var GlobalMailbox = class {
   /** Path to the JSONL message file. */
@@ -11360,14 +11603,14 @@ var GlobalMailbox = class {
    * @param hqPublisher — optional HQ publisher, or getter, for cross-project telemetry
    */
   constructor(projectDir, events, hqPublisher) {
-    this.messagePath = path5.join(projectDir, MAILBOX_FILE2);
-    this.registryPath = path5.join(projectDir, "_mailbox.registry.json");
-    this.clientRegistryPath = path5.join(projectDir, CLIENT_REGISTRY_FILE);
+    this.messagePath = path6.join(projectDir, MAILBOX_FILE2);
+    this.registryPath = path6.join(projectDir, "_mailbox.registry.json");
+    this.clientRegistryPath = path6.join(projectDir, CLIENT_REGISTRY_FILE);
     this._events = events;
     this._hqPublisher = hqPublisher;
   }
   get hqMailboxId() {
-    return `${path5.basename(path5.dirname(this.messagePath))}:mailbox`;
+    return `${path6.basename(path6.dirname(this.messagePath))}:mailbox`;
   }
   get hqPublisher() {
     return typeof this._hqPublisher === "function" ? this._hqPublisher() : this._hqPublisher;
@@ -11404,9 +11647,9 @@ var GlobalMailbox = class {
       taskContext: input.taskContext
     };
     const line = JSON.stringify(msg) + LINE_SEPARATOR2;
-    await fsp6.mkdir(path5.dirname(this.messagePath), { recursive: true });
+    await fsp7.mkdir(path6.dirname(this.messagePath), { recursive: true });
     await withFileLock(this.messagePath, async () => {
-      await fsp6.appendFile(this.messagePath, line, "utf8");
+      await fsp7.appendFile(this.messagePath, line, "utf8");
       this._pushToCache(msg);
     });
     this.publishHqMailboxEvent({ mailboxId: this.hqMailboxId, action: "message.sent", message: msg });
@@ -11472,7 +11715,7 @@ var GlobalMailbox = class {
       }
       if (changed) {
         const serialized = all.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-        await fsp6.writeFile(this.messagePath, serialized, "utf8");
+        await fsp7.writeFile(this.messagePath, serialized, "utf8");
       }
       cacheSnapshot = all;
     });
@@ -11690,7 +11933,7 @@ var GlobalMailbox = class {
   }
   async clearAll() {
     await withFileLock(this.messagePath, async () => {
-      await fsp6.writeFile(this.messagePath, "", "utf8");
+      await fsp7.writeFile(this.messagePath, "", "utf8");
     });
     this._setMessageCache([]);
   }
@@ -11722,7 +11965,7 @@ var GlobalMailbox = class {
       remaining = kept.length;
       if (kept.length < all.length) {
         const content = kept.map((m) => JSON.stringify(m)).join(LINE_SEPARATOR2) + LINE_SEPARATOR2;
-        await fsp6.writeFile(this.messagePath, content, "utf8");
+        await fsp7.writeFile(this.messagePath, content, "utf8");
       }
       this._setMessageCache(kept);
     });
@@ -11742,7 +11985,7 @@ var GlobalMailbox = class {
    */
   async _readMessages() {
     try {
-      const raw = await fsp6.readFile(this.messagePath, "utf8");
+      const raw = await fsp7.readFile(this.messagePath, "utf8");
       return this._parseLines(raw);
     } catch (err) {
       if (err.code === "ENOENT") return [];
@@ -11832,12 +12075,12 @@ var GlobalMailbox = class {
    */
   async _readMessagesCached() {
     try {
-      const st = await fsp6.stat(this.messagePath);
+      const st = await fsp7.stat(this.messagePath);
       if (this._messageCache !== null && this._messageCacheMtime === st.mtimeMs && this._messageCacheSize === st.size) {
         return this._messageCache;
       }
       if (this._messageCache !== null && this._messageCacheSize >= 0 && st.size > this._messageCacheSize) {
-        const fd = await fsp6.open(this.messagePath, "r");
+        const fd = await fsp7.open(this.messagePath, "r");
         try {
           const updated = await this._readNewMessagesOnly(fd, this._messageCacheSize, st.size);
           this._messageCacheMtime = st.mtimeMs;
@@ -11875,7 +12118,7 @@ var GlobalMailbox = class {
       this._messageCacheMtime = mtime;
       this._messageCacheSize = size;
     } else {
-      void fsp6.stat(this.messagePath).then((st) => {
+      void fsp7.stat(this.messagePath).then((st) => {
         this._messageCacheMtime = st.mtimeMs;
         this._messageCacheSize = st.size;
       }).catch(() => {
@@ -11899,14 +12142,14 @@ var GlobalMailbox = class {
     this._messageCache.push(msg);
   }
   async _ensureRegistry() {
-    await fsp6.mkdir(path5.dirname(this.registryPath), { recursive: true });
+    await fsp7.mkdir(path6.dirname(this.registryPath), { recursive: true });
   }
   async _readRegistry(opts) {
     if (!opts?.fresh && this._registryCache && Date.now() - this._registryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._registryCache);
     }
     try {
-      const raw = await fsp6.readFile(this.registryPath, "utf8");
+      const raw = await fsp7.readFile(this.registryPath, "utf8");
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, agent] of Object.entries(data)) {
@@ -11939,19 +12182,19 @@ var GlobalMailbox = class {
       obj[id] = agent;
     }
     const tmp = `${this.registryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp6.writeFile(tmp, JSON.stringify(obj), "utf8");
-    await fsp6.rename(tmp, this.registryPath);
+    await fsp7.writeFile(tmp, JSON.stringify(obj), "utf8");
+    await fsp7.rename(tmp, this.registryPath);
   }
   // ── Client registry internals ───────────────────────────────────────────
   async _ensureClientRegistry() {
-    await fsp6.mkdir(path5.dirname(this.clientRegistryPath), { recursive: true });
+    await fsp7.mkdir(path6.dirname(this.clientRegistryPath), { recursive: true });
   }
   async _readClientRegistry(opts) {
     if (!opts?.fresh && this._clientRegistryCache && Date.now() - this._clientRegistryCacheAt < REGISTRY_CACHE_TTL_MS) {
       return new Map(this._clientRegistryCache);
     }
     try {
-      const raw = await fsp6.readFile(this.clientRegistryPath, "utf8");
+      const raw = await fsp7.readFile(this.clientRegistryPath, "utf8");
       const data = JSON.parse(raw);
       const map = /* @__PURE__ */ new Map();
       for (const [id, client] of Object.entries(data)) {
@@ -11984,8 +12227,8 @@ var GlobalMailbox = class {
       obj[id] = client;
     }
     const tmp = `${this.clientRegistryPath}.${randomUUID().slice(0, 8)}.tmp`;
-    await fsp6.writeFile(tmp, JSON.stringify(obj), "utf8");
-    await fsp6.rename(tmp, this.clientRegistryPath);
+    await fsp7.writeFile(tmp, JSON.stringify(obj), "utf8");
+    await fsp7.rename(tmp, this.clientRegistryPath);
   }
 };
 function defaultResolveProjectDir(ctx) {
@@ -12458,13 +12701,13 @@ function makeDependencyWatcherConfig(opts) {
   const globPatterns = patterns.filter((p) => p.includes("*"));
   const plainPatterns = patterns.filter((p) => !p.includes("*"));
   function matchesPattern(filePath) {
-    const basename6 = filePath.split("/").pop()?.split("\\").pop() ?? "";
-    if (plainPatterns.includes(basename6)) return true;
+    const basename7 = filePath.split("/").pop()?.split("\\").pop() ?? "";
+    if (plainPatterns.includes(basename7)) return true;
     for (const gp of globPatterns) {
       const regex = new RegExp(
         "^" + gp.replace(/\./g, "\\.").replace(/\*/g, ".*") + "$"
       );
-      if (regex.test(basename6)) return true;
+      if (regex.test(basename7)) return true;
     }
     return false;
   }
@@ -12591,11 +12834,11 @@ function createMailboxHooks(opts) {
 var DEFAULT_MAX_ENTRIES = 1e4;
 var LOG_FILENAME = "package-authors.json";
 function logPath(storageDir) {
-  return path5.join(storageDir, LOG_FILENAME);
+  return path6.join(storageDir, LOG_FILENAME);
 }
 async function loadLog(storageDir, projectRoot) {
   try {
-    const raw = await fsp6.readFile(logPath(storageDir), "utf-8");
+    const raw = await fsp7.readFile(logPath(storageDir), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed.entries || !Array.isArray(parsed.entries)) {
       return { projectRoot, entries: [] };
@@ -12609,13 +12852,13 @@ async function loadLog(storageDir, projectRoot) {
   }
 }
 async function saveLog(storageDir, log) {
-  await fsp6.mkdir(storageDir, { recursive: true });
+  await fsp7.mkdir(storageDir, { recursive: true });
   const tmp = `${logPath(storageDir)}.tmp.${Date.now()}`;
-  await fsp6.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
-  await fsp6.rename(tmp, logPath(storageDir));
+  await fsp7.writeFile(tmp, JSON.stringify(log, null, 2) + "\n", "utf-8");
+  await fsp7.rename(tmp, logPath(storageDir));
 }
 function detectEcosystem(manifestPath) {
-  const name = path5.basename(manifestPath).toLowerCase();
+  const name = path6.basename(manifestPath).toLowerCase();
   if (name === "package.json") return "npm";
   if (name === "go.mod") return "go";
   if (name === "cargo.toml") return "cargo";
@@ -12898,8 +13141,8 @@ var KnowledgeGraph = class {
     return this.index;
   }
   constructor(sessionDir) {
-    this.filePath = path5.join(sessionDir, "_knowledge_graph");
-    this.graphFilePath = path5.join(this.filePath, "graph.jsonl");
+    this.filePath = path6.join(sessionDir, "_knowledge_graph");
+    this.graphFilePath = path6.join(this.filePath, "graph.jsonl");
   }
   // ── Write ──────────────────────────────────────────────────────────────
   /**
@@ -13080,23 +13323,23 @@ var KnowledgeGraph = class {
     }
   }
   async _persist(node) {
-    await fsp6.mkdir(this.filePath, { recursive: true });
+    await fsp7.mkdir(this.filePath, { recursive: true });
     const line = JSON.stringify(node) + "\n";
     await withFileLock(this.graphFilePath, async () => {
-      await fsp6.appendFile(this.graphFilePath, line, "utf8");
+      await fsp7.appendFile(this.graphFilePath, line, "utf8");
     });
   }
   async _append(node) {
-    await fsp6.mkdir(this.filePath, { recursive: true });
+    await fsp7.mkdir(this.filePath, { recursive: true });
     const line = JSON.stringify({ op: "update", node }) + "\n";
     await withFileLock(this.graphFilePath, async () => {
-      await fsp6.appendFile(this.graphFilePath, line, "utf8");
+      await fsp7.appendFile(this.graphFilePath, line, "utf8");
     });
   }
   /** Rebuild in-memory state from the log file. Call on startup. */
   async load() {
     try {
-      const content = await fsp6.readFile(this.graphFilePath, "utf8");
+      const content = await fsp7.readFile(this.graphFilePath, "utf8");
       const lines = content.split("\n").filter(Boolean);
       for (const line of lines) {
         try {
@@ -15527,11 +15770,11 @@ var AgentMonitorService = class {
     this._onEntry?.(entry);
   }
   async _appendToFile(subagentId, entry) {
-    const dir = path5.join(this._transcriptsDir, subagentId);
-    await fsp6.mkdir(dir, { recursive: true });
-    const filePath = path5.join(dir, "transcript.jsonl");
+    const dir = path6.join(this._transcriptsDir, subagentId);
+    await fsp7.mkdir(dir, { recursive: true });
+    const filePath = path6.join(dir, "transcript.jsonl");
     const line = JSON.stringify(entry) + "\n";
-    await fsp6.appendFile(filePath, line, { encoding: "utf8" });
+    await fsp7.appendFile(filePath, line, { encoding: "utf8" });
   }
   _uid() {
     return `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;