@wrongstack/core 0.313.1 → 0.316.1

package/dist/{chunk-UIWONWVG.js → chunk-NSOFPKGT.js}

@@ -4,26 +4,29 @@ import {
 import {
   SessionCatalogProjectClient,
   resolveSessionCatalogProjectServerUrl
-} from "./chunk-52RTVH4M.js";
+} from "./chunk-F3JWNST7.js";
 import {
-  SECRET_FILE_MODE
-} from "./chunk-H5E77KUJ.js";
-import {
-  DefaultSecretScrubber
-} from "./chunk-3E244UDA.js";
+  shouldSkipSessionDirectoryEntry
+} from "./chunk-JMULFFLN.js";
 import {
   isSessionTranscriptFileName,
   sessionScopedPath
-} from "./chunk-AD7ZFZCS.js";
+} from "./chunk-5BMIE7QG.js";
+import {
+  DefaultSecretScrubber
+} from "./chunk-QSTSJOCK.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-6FHWXLPT.js";
 import {
   buildChildEnv
-} from "./chunk-VB3H5WWB.js";
+} from "./chunk-6NWEVFEL.js";
 import {
   repairToolUseAdjacency
-} from "./chunk-M2WF6AXG.js";
+} from "./chunk-LSMMOS2Z.js";
 import {
   ulid
-} from "./chunk-4XV6IR37.js";
+} from "./chunk-HI3JGZR2.js";
 import {
   isPidAlive
 } from "./chunk-TRT2HRWZ.js";
@@ -31,7 +34,11 @@ import {
   atomicWrite,
   ensureDir,
   withFileLock
-} from "./chunk-7ZHZE5EO.js";
+} from "./chunk-OSGLYW5J.js";
+import {
+  effectiveInputTokens,
+  totalUsageTokens
+} from "./chunk-3ECENVHL.js";
 import {
   toErrorMessage
 } from "./chunk-TBRL2RCC.js";
@@ -292,8 +299,8 @@ function sha256(content) {
   return createHash("sha256").update(content).digest("hex");
 }
 function isInside(root, target) {
-  const relative3 = path.relative(root, target);
-  return relative3 === "" || !relative3.startsWith("..") && !path.isAbsolute(relative3);
+  const relative4 = path.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path.isAbsolute(relative4);
 }
 function normalizeRelative(input) {
   if (!input || path.isAbsolute(input)) return null;
@@ -305,8 +312,8 @@ function normalizeRelative(input) {
 function parseNulPaths(output) {
   return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
 }
-function isWrongStackWorktreePath(relative3) {
-  return relative3 === ".wrongstack/worktrees" || relative3.startsWith(".wrongstack/worktrees/");
+function isWrongStackWorktreePath(relative4) {
+  return relative4 === ".wrongstack/worktrees" || relative4.startsWith(".wrongstack/worktrees/");
 }
 var SessionCheckpointCas = class {
   rootDir;
@@ -332,16 +339,16 @@ var SessionCheckpointCas = class {
     }
     const relativePaths = [
       .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
-    ].filter((relative3) => !isWrongStackWorktreePath(relative3)).sort();
+    ].filter((relative4) => !isWrongStackWorktreePath(relative4)).sort();
     const unresolved = [];
     let scheduledBytes = 0;
     const captured = await mapWithConcurrency(
       relativePaths,
       CAPTURE_CONCURRENCY,
-      async (relative3) => {
-        const absolute = path.resolve(this.projectRoot, ...relative3.split("/"));
+      async (relative4) => {
+        const absolute = path.resolve(this.projectRoot, ...relative4.split("/"));
         if (!isInside(this.projectRoot, absolute)) {
-          unresolved.push({ path: relative3, reason: "path escapes project root" });
+          unresolved.push({ path: relative4, reason: "path escapes project root" });
           return null;
         }
         try {
@@ -351,27 +358,27 @@ var SessionCheckpointCas = class {
             const resolvedLink = path.resolve(path.dirname(absolute), linkTarget);
             if (path.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
               unresolved.push({
-                path: relative3,
+                path: relative4,
                 reason: "symlink target escapes project root"
               });
               return null;
             }
-            return { path: relative3, state: "symlink", linkTarget };
+            return { path: relative4, state: "symlink", linkTarget };
           }
           if (!stat11.isFile()) {
-            unresolved.push({ path: relative3, reason: "changed path is not a regular file" });
+            unresolved.push({ path: relative4, reason: "changed path is not a regular file" });
             return null;
           }
           if (stat11.size > MAX_BLOB_BYTES) {
             unresolved.push({
-              path: relative3,
+              path: relative4,
               reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
             });
             return null;
           }
           if (scheduledBytes + stat11.size > MAX_CHECKPOINT_BYTES) {
             unresolved.push({
-              path: relative3,
+              path: relative4,
               reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
             });
             return null;
@@ -380,12 +387,12 @@ var SessionCheckpointCas = class {
           const content = await fsp2.readFile(absolute);
           const blobHash = sha256(content);
           await this.putBlob(blobHash, content);
-          return { path: relative3, state: "file", blobHash, mode: stat11.mode & 511 };
+          return { path: relative4, state: "file", blobHash, mode: stat11.mode & 511 };
         } catch (err) {
           if (err.code === "ENOENT") {
-            return { path: relative3, state: "absent" };
+            return { path: relative4, state: "absent" };
           }
-          unresolved.push({ path: relative3, reason: toErrorMessage(err) });
+          unresolved.push({ path: relative4, reason: toErrorMessage(err) });
           return null;
         }
       }
@@ -412,11 +419,9 @@ var SessionCheckpointCas = class {
   }
   async materialize(checkpoint, targetRoot) {
     const target = path.resolve(targetRoot);
-    if (target === this.projectRoot) {
-      throw new Error("Refusing to materialize a workspace checkpoint over the parent project root");
-    }
     const targetStat = await fsp2.stat(target);
-    if (!targetStat.isDirectory()) throw new Error(`Checkpoint target is not a directory: ${target}`);
+    if (!targetStat.isDirectory())
+      throw new Error(`Checkpoint target is not a directory: ${target}`);
     const manifest = await this.loadManifest(checkpoint.manifestHash);
     if (manifest.baseHead !== checkpoint.baseHead.toLowerCase() || manifest.coverage !== checkpoint.coverage || manifest.entries.length !== checkpoint.entryCount || manifest.unresolved.length !== checkpoint.unresolvedCount) {
       throw new Error("Workspace checkpoint reference does not match its CAS manifest");
@@ -432,15 +437,18 @@ var SessionCheckpointCas = class {
         `Checkpoint target HEAD must equal ${manifest.baseHead}; got ${targetHead.stdout.trim() || "unknown"}`
       );
     }
-    const targetStatus = await this.runGit(
-      ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=matching"],
-      target
-    );
-    if (targetStatus.code !== 0 || targetStatus.stdoutTruncated) {
-      throw new Error("Unable to verify that the checkpoint target is clean");
-    }
-    if (targetStatus.stdout.length > 0) {
-      throw new Error("Checkpoint target must be a clean checkout before materialization");
+    const materializingParentRoot = target === this.projectRoot;
+    if (!materializingParentRoot) {
+      const targetStatus = await this.runGit(
+        ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--ignored=matching"],
+        target
+      );
+      if (targetStatus.code !== 0 || targetStatus.stdoutTruncated) {
+        throw new Error("Unable to verify that the checkpoint target is clean");
+      }
+      if (targetStatus.stdout.length > 0) {
+        throw new Error("Checkpoint target must be a clean checkout before materialization");
+      }
     }
     const realTarget = await fsp2.realpath(target);
     const writtenFiles = [];
@@ -455,7 +463,8 @@ var SessionCheckpointCas = class {
             throw new Error("absolute symlink target refused");
           }
           const resolvedLink = path.resolve(path.dirname(output), entry.linkTarget);
-          if (!isInside(target, resolvedLink)) throw new Error("symlink target escapes checkpoint root");
+          if (!isInside(target, resolvedLink))
+            throw new Error("symlink target escapes checkpoint root");
         }
         prepared.push({
           entry,
@@ -542,7 +551,8 @@ var SessionCheckpointCas = class {
     const target = this.manifestPath(hash);
     const existing = await fsp2.readFile(target).catch(() => null);
     if (existing) {
-      if (sha256(existing) !== hash) throw new Error(`Corrupt checkpoint manifest collision: ${hash}`);
+      if (sha256(existing) !== hash)
+        throw new Error(`Corrupt checkpoint manifest collision: ${hash}`);
       return;
     }
     await atomicWrite(target, encoded, { mode: 384 });
@@ -554,7 +564,8 @@ var SessionCheckpointCas = class {
   }
   async loadManifest(hash) {
     const raw = await fsp2.readFile(this.manifestPath(hash));
-    if (sha256(raw) !== hash) throw new Error(`Checkpoint manifest integrity check failed: ${hash}`);
+    if (sha256(raw) !== hash)
+      throw new Error(`Checkpoint manifest integrity check failed: ${hash}`);
     const parsed = JSON.parse(raw.toString("utf8"));
     if (parsed.version !== 1 || typeof parsed.baseHead !== "string" || parsed.coverage !== "git-head-plus-dirty" || !Array.isArray(parsed.entries) || !Array.isArray(parsed.unresolved)) {
       throw new Error(`Invalid workspace checkpoint manifest: ${hash}`);
@@ -575,8 +586,8 @@ var SessionCheckpointCas = class {
     }
     return parsed;
   }
-  async safeOutputPath(target, realTarget, relative3) {
-    const normalized = normalizeRelative(relative3);
+  async safeOutputPath(target, realTarget, relative4) {
+    const normalized = normalizeRelative(relative4);
     if (!normalized) throw new Error("invalid relative path");
     const output = path.resolve(target, ...normalized.split("/"));
     if (!isInside(target, output)) throw new Error("path escapes checkpoint target");
@@ -584,7 +595,8 @@ var SessionCheckpointCas = class {
     for (; ; ) {
       try {
         const real = await fsp2.realpath(probe);
-        if (!isInside(realTarget, real)) throw new Error("path resolves through a symlink outside checkpoint target");
+        if (!isInside(realTarget, real))
+          throw new Error("path resolves through a symlink outside checkpoint target");
         return output;
       } catch (err) {
         if (err.code !== "ENOENT") throw err;
@@ -596,7 +608,7 @@ var SessionCheckpointCas = class {
   }
 };
 function defaultRunGit(args, cwd) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const stdoutChunks = [];
     const stderrChunks = [];
     let stdoutBytes = 0;
@@ -639,8 +651,8 @@ function defaultRunGit(args, cwd) {
       stdoutTruncated,
       stderrTruncated
     });
-    child.on("error", (err) => resolve4(result(1, err.message)));
-    child.on("close", (code) => resolve4(result(code ?? 1)));
+    child.on("error", (err) => resolve5(result(1, err.message)));
+    child.on("close", (code) => resolve5(result(code ?? 1)));
   });
 }
 
@@ -649,19 +661,22 @@ 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 seedTime = Number.isNaN(Date.parse(startedAt)) ? Date.now() : Date.parse(startedAt);
+  const parsedTime = Date.parse(startedAt);
+  const isValidDate = !Number.isNaN(parsedTime) && /^\d{4}-\d{2}-\d{2}/.test(startedAt);
+  const seedTime = isValidDate ? parsedTime : Date.now();
+  const date = isValidDate ? startedAt.slice(0, 10) : new Date(seedTime).toISOString().slice(0, 10);
   return `${date}/sess_${ulid(seedTime)}`;
 }
 
 // src/storage/session-id-resolver.ts
 import * as path2 from "node:path";
 function resolveSessionId(query, candidateIds) {
-  const normalized = query.trim();
+  const trimmed = query.trim();
+  const normalized = trimmed.replace(/\\/g, "/");
   if (!normalized) return { status: "missing", query: normalized };
-  const uniqueIds = [...new Set(candidateIds)];
+  const uniqueIds = [...new Set(candidateIds.map((id) => id.replace(/\\/g, "/")))];
   if (uniqueIds.includes(normalized)) return { status: "resolved", id: normalized };
-  const leaf = (id) => path2.posix.basename(id.replace(/\\/g, "/"));
+  const leaf = (id) => path2.posix.basename(id);
   const exactLeafMatches = uniqueIds.filter((id) => leaf(id) === normalized);
   if (exactLeafMatches.length === 1) {
     return { status: "resolved", id: exactLeafMatches[0] };
@@ -680,7 +695,7 @@ function resolveSessionId(query, candidateIds) {
   if (prefixMatches.length > 1) {
     return { status: "ambiguous", query: normalized, candidates: prefixMatches.sort() };
   }
-  return { status: "missing", query: normalized };
+  return { status: "missing", query: trimmed };
 }
 function sessionIdResolutionError(resolution) {
   if (resolution.status === "ambiguous") {
@@ -752,7 +767,10 @@ function stripTerminalControls(value) {
   return out;
 }
 function sessionContentText(content) {
-  const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+  if (!content) return "";
+  const text = typeof content === "string" ? content : Array.isArray(content) ? content.filter(
+    (b) => Boolean(b && b.type === "text" && typeof b.text === "string")
+  ).map((b) => b.text).join(" ") : String(content);
   return stripTerminalControls(text).trim().replace(/\s+/g, " ");
 }
 function sessionContentPreview(content, maxLength = 160) {
@@ -765,7 +783,7 @@ function userInputTitle(content) {
 
 // src/storage/session-read-scrubber.ts
 function scrubPersistedSessionEvent(event, scrubber) {
-  return scrubber.scrubObject(event);
+  return scrubber.scrubObjectShared ? scrubber.scrubObjectShared(event) : scrubber.scrubObject(event);
 }
 function scrubPersistedSessionData(data, scrubber) {
   return scrubber.scrubObject(data);
@@ -793,13 +811,6 @@ import { createInterface } from "node:readline";
 // src/storage/session-store/directory-session-files.ts
 import * as fsp3 from "node:fs/promises";
 import * as path3 from "node:path";
-
-// src/storage/session-store/directory-scan.ts
-function shouldSkipSessionDirectoryEntry(name) {
-  return name.startsWith(".") && name !== ".wrongstack" || name === "shared" || name === "subagents" || name === "attachments";
-}
-
-// src/storage/session-store/directory-session-files.ts
 function sessionIdForFile(prefix, name) {
   const base = name.replace(/\.jsonl$/, "");
   return prefix ? `${prefix}/${base}` : base;
@@ -1099,6 +1110,68 @@ var SessionRecovery = class _SessionRecovery {
    * recent crash first.
    */
   async listResumable() {
+    const out = [];
+    for (const { sessionId } of await this.collectTranscripts()) {
+      const stale = await this.detectStaleExact(sessionId);
+      if (stale) out.push(stale);
+    }
+    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
+  }
+  /**
+   * List every session whose journal has no trailing `session_end`, newest
+   * file first. This is the read side of "recovery" as a user means it: the
+   * conversations a crash, a `kill`, or a closed laptop lid left hanging.
+   *
+   * Ordering is by file mtime, not by boundary timestamp: a journal with no
+   * lifecycle boundary at all (a session that never completed a turn) has no
+   * timestamp to sort on, and mtime is the one key every candidate has.
+   *
+   * @param options.limit Stop after this many unclosed sessions are found.
+   *   Candidates are examined newest-mtime-first, so the cap keeps the common
+   *   "give me the last one" call to a couple of tail reads instead of a scan
+   *   of every transcript the project ever wrote.
+   */
+  async listUnclosed(options = {}) {
+    const limit = options.limit ?? Number.POSITIVE_INFINITY;
+    if (limit <= 0) return [];
+    const candidates = await this.collectTranscripts();
+    candidates.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    const out = [];
+    for (const candidate of candidates) {
+      if (out.length >= limit) break;
+      const unclosed = await this.detectUnclosedExact(candidate);
+      if (unclosed) out.push(unclosed);
+    }
+    return out;
+  }
+  async detectUnclosedExact(candidate) {
+    if (candidate.size === 0) return null;
+    let boundary;
+    try {
+      boundary = await scanLatestLifecycleBoundary(candidate.path, candidate.size, {
+        countEvents: false
+      }).then((scan) => scan?.boundary ?? null);
+    } catch {
+      return null;
+    }
+    if (boundary?.type === "session_end") return null;
+    return {
+      sessionId: candidate.sessionId,
+      path: candidate.path,
+      lastBoundary: boundary ? boundary.type : null,
+      lastEventTs: boundary ? boundary.ts : new Date(candidate.modifiedAt).toISOString(),
+      stale: boundary?.type === "in_flight_start",
+      modifiedAt: candidate.modifiedAt
+    };
+  }
+  /**
+   * Every session transcript under `dir`, with the stat both scanners need.
+   *
+   * Modern sessions live inside date-shard subdirectories
+   * ("2026-06-11/<base>.jsonl"); legacy/flat sessions sit at the root. Scan
+   * both — a root-only scan silently misses every modern crash.
+   */
+  async collectTranscripts() {
     const out = [];
     const collect = async (dir, prefix, depth) => {
       let entries;
@@ -1120,12 +1193,18 @@ var SessionRecovery = class _SessionRecovery {
         if (!entry.isFile() || !isSessionTranscriptFileName(entry.name)) continue;
         const base = entry.name.slice(0, -".jsonl".length);
         const sessionId = prefix ? `${prefix}/${base}` : base;
-        const stale = await this.detectStaleExact(sessionId);
-        if (stale) out.push(stale);
+        const fp = path4.join(dir, entry.name);
+        let stat11;
+        try {
+          stat11 = await fs.stat(fp);
+        } catch {
+          continue;
+        }
+        out.push({ sessionId, path: fp, size: stat11.size, modifiedAt: stat11.mtimeMs });
       }
     };
     await collect(this.dir, "", 0);
-    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
+    return out;
   }
   // ── Internals ──────────────────────────────────────────────────────────
   filePath(sessionId) {
@@ -1149,7 +1228,8 @@ function hasNonWhitespace(line) {
   }
   return false;
 }
-async function scanLatestLifecycleBoundary(filePath, size) {
+async function scanLatestLifecycleBoundary(filePath, size, options = {}) {
+  const countEvents = options.countEvents !== false;
   const CHUNK_SIZE2 = 64 * 1024;
   const handle = await fs.open(filePath, "r");
   let position = size;
@@ -1176,7 +1256,7 @@ async function scanLatestLifecycleBoundary(filePath, size) {
         lineEnd = i;
       }
       laterLineFragment = data.subarray(0, lineEnd);
-      if (latestBoundary && latestBoundary.type !== "in_flight_start") {
+      if (latestBoundary && (!countEvents || latestBoundary.type !== "in_flight_start")) {
         return { boundary: latestBoundary, eventCount };
       }
     }
@@ -1201,6 +1281,19 @@ import * as path5 from "node:path";
 import { createReadStream as createReadStream2 } from "node:fs";
 import * as fsp4 from "node:fs/promises";
 import { createInterface as createInterface2 } from "node:readline";
+
+// src/storage/session-outcome.ts
+function resolveSessionOutcome(lastEventType, hadSessionError) {
+  if (lastEventType === "session_end") return "completed";
+  if (lastEventType === "in_flight_start") return "aborted";
+  if (hadSessionError) return "error";
+  return void 0;
+}
+function isSessionErrorEvent(event) {
+  return event.type === "error" || event.type === "provider_error";
+}
+
+// src/storage/session-summary-tracker.ts
 var SessionSummaryTracker = class {
   id;
   startedAt;
@@ -1220,7 +1313,14 @@ var SessionSummaryTracker = class {
   messageCount = 0;
   lastUserMessage;
   lastActivityAt;
-  outcome = void 0;
+  /**
+   * Whether an `error`/`provider_error` was seen. Not a latched outcome — see
+   * {@link resolveSessionOutcome} for why a trailing terminal marker outranks
+   * it, and why a failed tool_result is deliberately not counted here.
+   */
+  hadSessionError = false;
+  /** Type of the newest observed event; the terminal-marker signal. */
+  lastEventType;
   openToolUses = /* @__PURE__ */ new Set();
   constructor(opts) {
     this.id = opts.id;
@@ -1246,7 +1346,7 @@ var SessionSummaryTracker = class {
     this.messageCount = this.summary.messageCount ?? 0;
     this.lastUserMessage = this.summary.lastUserMessage;
     this.lastActivityAt = this.summary.lastActivityAt ?? this.summary.endedAt ?? opts.startedAt;
-    this.outcome = this.resumed ? void 0 : this.summary.outcome;
+    this.hadSessionError = this.resumed ? false : this.summary.outcome === "error";
   }
   get currentSummary() {
     return this.summary;
@@ -1271,13 +1371,17 @@ var SessionSummaryTracker = class {
       compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
       toolBreakdown: { ...this.toolBreakdown },
       lastActivityAt: this.lastActivityAt,
-      ...this.outcome !== void 0 ? { outcome: this.outcome } : {}
+      ...(() => {
+        const outcome = resolveSessionOutcome(this.lastEventType, this.hadSessionError);
+        return outcome !== void 0 ? { outcome } : {};
+      })()
     };
   }
   get pendingToolUses() {
     return Array.from(this.openToolUses);
   }
   observe(event) {
+    this.lastEventType = event.type;
     const eventActivityMs = Date.parse(event.ts);
     const lastActivityMs = Date.parse(this.lastActivityAt);
     if (Number.isFinite(eventActivityMs) && (!Number.isFinite(lastActivityMs) || eventActivityMs > lastActivityMs)) {
@@ -1295,17 +1399,14 @@ var SessionSummaryTracker = class {
       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";
-      }
+      if (event.isError) this.toolErrorCount++;
     } else if (event.type === "file_snapshot") {
       this.fileChangeCount += event.files.length;
     } else if (event.type === "compaction") {
       this.compactionCount++;
     }
-    if (event.type === "error" || event.type === "provider_error") {
-      this.outcome = "error";
+    if (isSessionErrorEvent(event)) {
+      this.hadSessionError = true;
     }
     if (event.type === "user_input") {
       if (this.summary.title === "(empty session)") {
@@ -1315,14 +1416,21 @@ var SessionSummaryTracker = class {
       this.messageCount++;
     } else if (event.type === "llm_response") {
       this.messageCount++;
-      this.tokenIn += event.usage.input;
+      this.tokenIn += effectiveInputTokens(event.usage);
       this.tokenOut += event.usage.output;
       this.summary = {
         ...this.summary,
-        tokenTotal: this.baseTokenTotal + this.tokenIn + this.tokenOut
+        tokenTotal: this.baseTokenTotal + this.tokenIn + this.tokenOut,
+        // Track the routed identity, not the one the session opened with. A
+        // mid-session /model switch or a fallback rotation leaves the
+        // create-time metadata stale, and this summary is what every session
+        // listing, picker and catalog row shows. Older journals have no
+        // model/provider on llm_response — those keep the create-time value.
+        ...event.model !== void 0 ? { model: event.model } : {},
+        ...event.provider !== void 0 ? { provider: event.provider } : {}
       };
     } else if (event.type === "session_end") {
-      const total = event.usage.input + event.usage.output;
+      const total = totalUsageTokens(event.usage);
       if (total > 0) {
         this.summary = {
           ...this.summary,
@@ -1346,7 +1454,8 @@ var SessionSummaryTracker = class {
     this.messageCount = 0;
     this.lastUserMessage = void 0;
     this.lastActivityAt = this.startedAt;
-    this.outcome = void 0;
+    this.hadSessionError = false;
+    this.lastEventType = void 0;
     this.openToolUses = /* @__PURE__ */ new Set();
     this.tokenIn = 0;
     this.tokenOut = 0;
@@ -1399,7 +1508,7 @@ var SessionSummaryTracker = class {
       fileChangeCount: this.fileChangeCount,
       compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
       toolBreakdown: { ...this.toolBreakdown },
-      outcome: this.outcome ?? "completed"
+      outcome: resolveSessionOutcome(this.lastEventType, this.hadSessionError)
     };
     const resolvedName = this.resolveNameCb ? await this.resolveNameCb().catch(() => null) : null;
     if (resolvedName !== null) {
@@ -1425,7 +1534,8 @@ var SessionSummaryTracker = class {
     this.messageCount = 0;
     this.lastUserMessage = void 0;
     this.lastActivityAt = resetAt;
-    this.outcome = void 0;
+    this.hadSessionError = false;
+    this.lastEventType = void 0;
     this.openToolUses = /* @__PURE__ */ new Set();
     this.summary = {
       id: this.id,
@@ -1457,6 +1567,16 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
   static FLUSH_SIZE = 50;
   static WRITE_BUFFER_MAX_EVENTS = 2e3;
   static WRITE_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
+  /**
+   * Absolute ceiling for ONE event, even via the empty-buffer exemption in
+   * `push`. That exemption exists so a legitimately huge user prompt is
+   * persisted instead of silently dropped (its bytes are already resident —
+   * accepting it costs one reference, not a copy); without a ceiling an
+   * unbounded payload could pin memory and stall the event loop on
+   * stringify. 64MiB is 4x the retention budget and far above any real
+   * prompt, so it only fires on pathological input.
+   */
+  static MAX_SINGLE_EVENT_BYTES = 64 * 1024 * 1024;
   writeBuffer = [];
   writeBufferBytes = 0;
   flushTimer = null;
@@ -1464,6 +1584,8 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
   lastBufferOverflowWarnAt = 0;
   appendFailCount = 0;
   lastAppendWarnAt = 0;
+  invalidEventCount = 0;
+  lastInvalidEventWarnAt = 0;
   writeChain = Promise.resolve();
   flushPromise = null;
   /**
@@ -1482,12 +1604,31 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
     try {
       return Buffer.byteLength(JSON.stringify(event), "utf8") + 1;
     } catch {
-      return _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES + 1;
+      return Number.NaN;
     }
   }
   push(event) {
     const bytes = this.eventBytes(event);
-    if (this.writeBuffer.length >= _SessionWriteBuffer.WRITE_BUFFER_MAX_EVENTS || bytes > _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES || this.writeBufferBytes + bytes > _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES) {
+    if (!Number.isFinite(bytes)) {
+      this.invalidEventCount++;
+      const now = Date.now();
+      if (now - this.lastInvalidEventWarnAt > 5e3) {
+        this.lastInvalidEventWarnAt = now;
+        console.warn(
+          JSON.stringify({
+            level: "error",
+            event: "session.buffer_push_invalid",
+            sessionId: this.opts.sessionId,
+            reason: "event is not JSON-serializable",
+            droppedEvents: this.invalidEventCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+      return false;
+    }
+    const oversizedSingleEvent = bytes > _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES && bytes <= _SessionWriteBuffer.MAX_SINGLE_EVENT_BYTES && this.writeBuffer.length === 0;
+    if (this.writeBuffer.length >= _SessionWriteBuffer.WRITE_BUFFER_MAX_EVENTS || !oversizedSingleEvent && (bytes > _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES || this.writeBufferBytes + bytes > _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES)) {
       this.bufferOverflowCount++;
       const now = Date.now();
       if (now - this.lastBufferOverflowWarnAt > 5e3) {
@@ -1520,7 +1661,7 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
       flight.started = true;
       if (flight.stolen) return;
       try {
-        return await this.opts.getHandle().appendFile(flight.data, "utf8");
+        await this.opts.getHandle().appendFile(flight.data, "utf8");
       } catch (err) {
         if (isClosedHandleError(err)) {
           const reloaded = await fsp5.open(this.opts.filePath, "a", 384);
@@ -1644,6 +1785,12 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
   /**
    * Last-gasp synchronous append (SIGKILL/SIGTERM traps, `process.on('exit')`).
    *
+   * If an async append is actively writing when teardown arrives, flushSync
+   * must not open a second append descriptor and race it. It defers with a
+   * structured `session.flush_sync_deferred` warning, leaving the buffer
+   * untouched for the already-running flush loop to drain if the process
+   * survives.
+   *
    * Failure contract: nothing is discarded before the write is known to have
    * landed. Buffered events stay in `writeBuffer` — it is cleared only after
    * `fsyncSync` returns — and a stolen in-flight batch is handed back to the
@@ -1658,6 +1805,21 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
     const chunks = [];
     const flight = this.inFlight;
     const stole = flight !== null && !flight.started && !flight.stolen;
+    if (flight !== null && flight.started && !flight.stolen) {
+      console.warn(
+        JSON.stringify({
+          level: "error",
+          event: "session.flush_sync_deferred",
+          sessionId: this.opts.sessionId,
+          filePath: this.opts.filePath,
+          message: "in-flight async append already started; sync append deferred to avoid write race",
+          pendingEvents: this.writeBuffer.length,
+          pendingBytes: this.writeBufferBytes,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+      return;
+    }
     if (stole && flight) {
       flight.stolen = true;
       chunks.push(flight.data);
@@ -1710,7 +1872,7 @@ var SessionWriteBuffer = class _SessionWriteBuffer {
     this.lastBufferOverflowWarnAt = 0;
   }
   shouldFlushNow() {
-    return this.writeBuffer.length >= _SessionWriteBuffer.FLUSH_SIZE;
+    return this.writeBuffer.length >= _SessionWriteBuffer.FLUSH_SIZE || this.writeBufferBytes >= _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES;
   }
 };
 
@@ -1739,6 +1901,18 @@ function scrubSessionWriterEvent(event, secretScrubber) {
   if (event.type === "llm_response") {
     return { ...event, content: secretScrubber.scrubObject(event.content) };
   }
+  if (event.type === "tool_use") {
+    return { ...event, input: secretScrubber.scrubObject(event.input) };
+  }
+  if (event.type === "tool_call_start") {
+    return { ...event, input: secretScrubber.scrubObject(event.input) };
+  }
+  if (event.type === "tool_result") {
+    return {
+      ...event,
+      content: typeof event.content === "string" ? secretScrubber.scrub(event.content) : secretScrubber.scrubObject(event.content)
+    };
+  }
   if (event.type === "file_snapshot") {
     return {
       ...event,
@@ -1749,6 +1923,9 @@ function scrubSessionWriterEvent(event, secretScrubber) {
       }))
     };
   }
+  if (event.type === "side_effect") {
+    return secretScrubber.scrubObject(event);
+  }
   return event;
 }
 
@@ -1761,6 +1938,8 @@ async function findSessionCheckpointTruncatePlan(filePath, targetPromptIndex) {
   let pendingLine = Buffer.alloc(0);
   let checkpointByteOffset = -1;
   let removedCount = 0;
+  const removedSubagentTranscriptPaths = /* @__PURE__ */ new Set();
+  const retainedSubagentTranscriptPaths = /* @__PURE__ */ new Set();
   try {
     fd = await fsp6.open(filePath, "r", 384);
     while (true) {
@@ -1775,15 +1954,20 @@ async function findSessionCheckpointTruncatePlan(filePath, targetPromptIndex) {
         const idx = chunk.indexOf("\n", chunkPos);
         if (idx === -1) break;
         const lineStartOffset = chunkFileOffset + chunkPos;
+        const lineBytes = chunk.subarray(chunkPos, idx);
         if (checkpointByteOffset !== -1) {
           removedCount++;
+          collectSubagentTranscriptPath(lineBytes, removedSubagentTranscriptPaths);
         } else {
-          const lineBytes = chunk.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.type === "agent_session_linked") {
+                if (typeof event.transcriptPath === "string" && event.transcriptPath.trim()) {
+                  retainedSubagentTranscriptPaths.add(event.transcriptPath);
+                }
+              } else if (event.type === "checkpoint") {
                 if (event.promptIndex === targetPromptIndex) {
                   checkpointByteOffset = lineStartOffset;
                 } else if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
@@ -1803,7 +1987,23 @@ async function findSessionCheckpointTruncatePlan(filePath, targetPromptIndex) {
     await fd?.close();
   }
   if (checkpointByteOffset === -1) return null;
-  return { checkpointByteOffset, removedCount };
+  return {
+    checkpointByteOffset,
+    removedCount,
+    removedSubagentTranscriptPaths: [...removedSubagentTranscriptPaths].filter((transcriptPath) => !retainedSubagentTranscriptPaths.has(transcriptPath)).sort()
+  };
+}
+function collectSubagentTranscriptPath(lineBytes, out) {
+  const line = new TextDecoder("utf-8", { fatal: false }).decode(lineBytes);
+  if (!line.trim()) return;
+  try {
+    const event = JSON.parse(line);
+    if (event.type !== "agent_session_linked") return;
+    if (typeof event.transcriptPath === "string" && event.transcriptPath.trim()) {
+      out.add(event.transcriptPath);
+    }
+  } catch {
+  }
 }
 async function rewriteSessionToCheckpoint(filePath, checkpointByteOffset) {
   const tmpPath = `${filePath}.rewind.tmp`;
@@ -1862,6 +2062,7 @@ var CRITICAL_EVENT_TYPES = /* @__PURE__ */ new Set([
   "user_input",
   "llm_response",
   "checkpoint",
+  "rewound",
   "in_flight_start",
   "in_flight_end"
 ]);
@@ -1877,6 +2078,7 @@ var FileSessionWriter = class _FileSessionWriter {
     this.meta = meta;
     this.events = events;
     this.resumed = opts.resumed ?? false;
+    this.lifecyclePreambleTs = this.resumed ? (/* @__PURE__ */ new Date()).toISOString() : startedAt;
     this.manifestFile = opts.dir ? path5.join(opts.dir, `${path5.basename(id)}.summary.json`) : "";
     this.filePath = opts.filePath ?? "";
     this.secretScrubber = opts.secretScrubber;
@@ -1932,6 +2134,7 @@ var FileSessionWriter = class _FileSessionWriter {
     return this.initPromise;
   }
   resumed;
+  lifecyclePreambleTs;
   secretScrubber;
   checkpointCas;
   /** Mutable slot for onAppend callback — constructor opts seed it, setOnAppend replaces it. */
@@ -2013,7 +2216,18 @@ var FileSessionWriter = class _FileSessionWriter {
 `)).then(() => {
           if (!critical) return;
           return this.handle.datasync().catch(() => void 0);
-        }).catch(() => void 0);
+        }).catch((err) => {
+          console.warn(
+            JSON.stringify({
+              level: "error",
+              event: "session.sync_journal_write_failed",
+              sessionId: this.id,
+              eventType: appendEvent.type,
+              message: toErrorMessage(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        });
       });
     } else if (critical || this.buffer.shouldFlushNow()) {
       this.buffer.cancelTimer();
@@ -2082,7 +2296,7 @@ var FileSessionWriter = class _FileSessionWriter {
   async writeSessionStartLazy() {
     this.buffer.push({
       type: this.resumed ? "session_resumed" : "session_start",
-      ts: this.startedAt,
+      ts: this.lifecyclePreambleTs,
       id: this.id,
       model: this.meta.model ?? "unknown",
       provider: this.meta.provider ?? "unknown"
@@ -2188,7 +2402,7 @@ var FileSessionWriter = class _FileSessionWriter {
 `)).then(() => {
           if (!isCriticalEvent(scrubbed)) return;
           return this.handle.datasync().catch(() => void 0);
-        }).catch(() => void 0);
+        });
       }
     }
     if (isCriticalEvent(scrubbed) || this.buffer.shouldFlushNow()) {
@@ -2220,7 +2434,7 @@ var FileSessionWriter = class _FileSessionWriter {
 `)).then(() => {
             if (!isCriticalEvent(scrubbed)) return;
             return this.handle.datasync().catch(() => void 0);
-          }).catch(() => void 0);
+          });
         }
       }
       scrubbedBatch.push(scrubbed);
@@ -2453,6 +2667,7 @@ var FileSessionWriter = class _FileSessionWriter {
     }
     try {
       await rewriteSessionToCheckpoint(this.filePath, plan.checkpointByteOffset);
+      await this.deleteRewoundSubagentTranscripts(plan.removedSubagentTranscriptPaths);
       this.handle = await fsp7.open(this.filePath, "a", 384);
     } catch (err) {
       this.handle = await fsp7.open(this.filePath, "a", 384).catch(() => this.handle);
@@ -2476,6 +2691,42 @@ var FileSessionWriter = class _FileSessionWriter {
     });
     return plan.removedCount;
   }
+  async deleteRewoundSubagentTranscripts(transcriptPaths) {
+    if (transcriptPaths.length === 0) return;
+    const sessionsRoot = this.id.includes("/") ? path5.dirname(path5.dirname(this.filePath)) : path5.dirname(this.filePath);
+    const allowedRoot = path5.join(sessionsRoot, "subagents");
+    const realAllowedRoot = await fsp7.realpath(allowedRoot).catch(() => null);
+    if (!realAllowedRoot) return;
+    const deleted = [];
+    for (const transcriptPath of transcriptPaths) {
+      const resolved = path5.resolve(transcriptPath);
+      const relative4 = path5.relative(realAllowedRoot, resolved);
+      if (relative4.startsWith("..") || path5.isAbsolute(relative4)) continue;
+      await fsp7.rm(resolved, { force: true }).then(
+        () => {
+          deleted.push(resolved);
+        },
+        (err) => {
+          console.warn(
+            JSON.stringify({
+              level: "warn",
+              event: "session.rewind_subagent_delete_failed",
+              sessionId: this.id,
+              filePath: resolved,
+              error: toErrorMessage(err),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            })
+          );
+        }
+      );
+    }
+    if (deleted.length > 0) {
+      this.events?.emit("session.rewind_subagents_deleted", {
+        sessionId: this.id,
+        transcriptPaths: deleted
+      });
+    }
+  }
   async clearSession() {
     if (!this.filePath) return;
     this.buffer.cancelTimer();
@@ -2588,7 +2839,8 @@ async function deleteSessionArtifacts({
     fsp8.unlink(sessionPath(rootDir, id, ".summary.json")),
     fsp8.unlink(sessionPath(rootDir, id, ".plan.json")),
     fsp8.unlink(sessionPath(rootDir, id, ".tasks.json")),
-    fsp8.unlink(sessionPath(rootDir, id, ".todos.json"))
+    fsp8.unlink(sessionPath(rootDir, id, ".todos.json")),
+    fsp8.unlink(shardManifestPath(rootDir, path7.dirname(id) === "." ? "" : path7.dirname(id)))
   ];
   const results = await Promise.allSettled(deletions);
   for (const result of results) {
@@ -2708,6 +2960,12 @@ function inheritsIntoFork(event) {
     case "in_flight_start":
     case "in_flight_end":
     case "rewound":
+    case "agent_spawned":
+    case "agent_session_linked":
+    case "agent_stopped":
+    case "agent_error":
+    case "delegate_started":
+    case "delegate_completed":
       return false;
     // Parent snapshots describe mutations owned by the parent journal. A
     // child that shares the current workspace must not inherit authority to
@@ -2786,6 +3044,25 @@ async function forkSession(host, id, opts = {}) {
 // src/storage/session-store/load-cache.ts
 var LOAD_CACHE_MAX_ENTRIES = 50;
 var LOAD_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+var SIZE_WALK_MAX_DEPTH = 12;
+function approximateRetainedBytes(value, depth = 0) {
+  if (value === null || value === void 0) return 0;
+  const type = typeof value;
+  if (type === "string") return value.length * 2;
+  if (type === "number" || type === "boolean") return 8;
+  if (type !== "object") return 0;
+  if (depth >= SIZE_WALK_MAX_DEPTH) return 0;
+  if (Array.isArray(value)) {
+    let bytes2 = 32;
+    for (const item of value) bytes2 += approximateRetainedBytes(item, depth + 1);
+    return bytes2;
+  }
+  let bytes = 48;
+  for (const [key, child] of Object.entries(value)) {
+    bytes += key.length * 2 + approximateRetainedBytes(child, depth + 1);
+  }
+  return bytes;
+}
 var SessionLoadCache = class {
   constructor(entries = /* @__PURE__ */ new Map()) {
     this.entries = entries;
@@ -2826,25 +3103,27 @@ var SessionLoadCache = class {
   }
   set(id, stat11, data) {
     this.delete(id);
-    while (stat11.size <= LOAD_CACHE_MAX_BYTES && (this.entries.size >= LOAD_CACHE_MAX_ENTRIES || this.bytes + stat11.size > LOAD_CACHE_MAX_BYTES)) {
+    const cost = approximateRetainedBytes(data);
+    while (cost <= LOAD_CACHE_MAX_BYTES && (this.entries.size >= LOAD_CACHE_MAX_ENTRIES || this.bytes + cost > LOAD_CACHE_MAX_BYTES)) {
       const oldest = this.entries.keys().next().value;
       if (oldest === void 0) break;
       this.delete(oldest);
     }
-    if (stat11.size <= LOAD_CACHE_MAX_BYTES) {
-      this.entries.set(id, { mtimeMs: stat11.mtimeMs, size: stat11.size, data });
-      this.bytes += stat11.size;
+    if (cost <= LOAD_CACHE_MAX_BYTES) {
+      this.entries.set(id, { mtimeMs: stat11.mtimeMs, size: stat11.size, data, bytes: cost });
+      this.bytes += cost;
     }
   }
   delete(sessionId) {
     const cached = this.entries.get(sessionId);
-    if (cached) this.bytes = Math.max(0, this.bytes - cached.size);
+    if (cached) this.bytes = Math.max(0, this.bytes - (cached.bytes ?? cached.size));
     this.entries.delete(sessionId);
   }
 };
 
 // src/storage/session-store/load-session-data.ts
 import { createReadStream as createReadStream3 } from "node:fs";
+import { stat as fspStat } from "node:fs/promises";
 import { createInterface as createInterface3 } from "node:readline";
 
 // src/storage/session-tool-call-ends.ts
@@ -2869,6 +3148,7 @@ function extractToolCallEnds(events) {
 var DEFAULT_MAX_RETAINED_EVENT_BYTES = 96 * 1024 * 1024;
 var EVICT_TO_FRACTION = 0.9;
 var SNAPSHOT_ENVELOPE_BYTES = 256;
+var LOAD_PROGRESS_INTERVAL_MS = 250;
 async function loadSessionDataFromFile(params) {
   const events = [];
   const eventBytes = [];
@@ -2886,12 +3166,24 @@ async function loadSessionDataFromFile(params) {
   const messages = params.full ? [] : void 0;
   const openToolUses = params.full ? /* @__PURE__ */ new Set() : void 0;
   let exactJournalActive = false;
+  let messageIndexOffset = 0;
   let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
   let lastSnapshot;
+  const totalBytes = params.onLoadProgress ? (await fspStat(params.file)).size : 0;
   const stream = createReadStream3(params.file, { encoding: "utf8" });
   const rl = createInterface3({ input: stream, crlfDelay: Infinity });
+  let loadedBytes = 0;
+  let lastProgressAt = 0;
+  const progressIntervalMs = params.progressIntervalMs ?? LOAD_PROGRESS_INTERVAL_MS;
   try {
     for await (const line of rl) {
+      if (params.onLoadProgress) {
+        loadedBytes += Buffer.byteLength(line, "utf8") + 1;
+        if (Date.now() - lastProgressAt >= progressIntervalMs) {
+          lastProgressAt = Date.now();
+          params.onLoadProgress({ loadedBytes, totalBytes });
+        }
+      }
       if (!line.trim()) continue;
       try {
         const parsed = JSON.parse(line);
@@ -2945,9 +3237,11 @@ async function loadSessionDataFromFile(params) {
             messages,
             openToolUses,
             exactJournalActive,
+            messageIndexOffset,
             usage
           });
           exactJournalActive = replayState.exactJournalActive;
+          messageIndexOffset = replayState.messageIndexOffset;
           usage = replayState.usage ?? usage;
         } else if (ev.type === "llm_response") {
           usage = accumulateUsage(usage, ev);
@@ -2955,6 +3249,9 @@ async function loadSessionDataFromFile(params) {
       } catch {
       }
     }
+    if (params.onLoadProgress) {
+      params.onLoadProgress({ loadedBytes: totalBytes, totalBytes });
+    }
   } finally {
     rl.close();
     stream.close();
@@ -2967,7 +3264,7 @@ async function loadSessionDataFromFile(params) {
         detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
       });
     }
-    const repaired = repairToolUseAdjacency(messages);
+    const repaired = repairToolUseAdjacency(messages, { preserveTrailingToolUse: true });
     if (repaired.report.changed) {
       params.events?.emit("session.damaged", {
         sessionId: params.id,
@@ -3020,14 +3317,16 @@ function isSessionEventLike(value) {
 function replaySessionEvent(params) {
   const { ev, messages, openToolUses } = params;
   let exactJournalActive = params.exactJournalActive;
+  let messageIndexOffset = params.messageIndexOffset;
   if (ev.type === "message_appended" && ev.version === 1) {
     const message = replayableMessage(ev.message, ev.ts);
     if (message) {
-      if (!exactJournalActive) {
+      if (!exactJournalActive && shouldReplaceLegacyReplay(messages, ev.ts)) {
         messages.length = 0;
         openToolUses.clear();
-        exactJournalActive = true;
+        messageIndexOffset = 0;
       }
+      exactJournalActive = true;
       messages.push(message);
       trackMessageToolState(message, openToolUses);
     } else {
@@ -3035,8 +3334,9 @@ function replaySessionEvent(params) {
     }
   } else if (ev.type === "message_updated" && ev.version === 1) {
     const message = replayableMessage(ev.message, ev.ts);
-    if (message && exactJournalActive && ev.index >= 0 && ev.index < messages.length) {
-      messages[ev.index] = message;
+    const index = ev.index - messageIndexOffset;
+    if (message && exactJournalActive && index >= 0 && index < messages.length) {
+      messages[index] = message;
       openToolUses.clear();
       for (const current of messages) trackMessageToolState(current, openToolUses);
     } else {
@@ -3050,12 +3350,15 @@ function replaySessionEvent(params) {
       );
     } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
       exactJournalActive = true;
+      messageIndexOffset = 0;
     } else {
       emitDamaged(params, "Ignored malformed messages_replaced event");
     }
   } else if (ev.type === "messages_dropped" && ev.version === 1) {
     if (exactJournalActive && Number.isInteger(ev.count) && ev.count > 0) {
-      messages.splice(0, Math.min(ev.count, messages.length));
+      const dropped = Math.min(ev.count, messages.length);
+      messages.splice(0, dropped);
+      messageIndexOffset += dropped;
       openToolUses.clear();
       for (const current of messages) trackMessageToolState(current, openToolUses);
     } else if (!exactJournalActive) {
@@ -3069,7 +3372,9 @@ function replaySessionEvent(params) {
         params,
         `Ignored context_snapshot event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
       );
-    } else if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+    } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+      messageIndexOffset = 0;
+    } else {
       emitDamaged(params, "Ignored malformed context_snapshot event");
     }
   } else if (ev.type === "messages_replaced" || ev.type === "message_appended" || ev.type === "message_updated" || ev.type === "messages_dropped") {
@@ -3084,11 +3389,11 @@ function replaySessionEvent(params) {
         if (b.type === "tool_use") openToolUses.add(b.id);
       }
     }
-    return { exactJournalActive, usage: accumulateUsage(params.usage, ev) };
+    return { exactJournalActive, messageIndexOffset, usage: accumulateUsage(params.usage, ev) };
   } else if (!exactJournalActive && ev.type === "tool_result") {
     if (!openToolUses.has(ev.id)) {
       emitDamaged(params, `Orphan tool_result "${ev.id}" has no matching tool_use`);
-      return { exactJournalActive };
+      return { exactJournalActive, messageIndexOffset };
     }
     openToolUses.delete(ev.id);
     const resultBlock = {
@@ -3105,7 +3410,12 @@ function replaySessionEvent(params) {
       messages.push({ role: "user", content: [resultBlock], ts: ev.ts });
     }
   }
-  return { exactJournalActive };
+  return { exactJournalActive, messageIndexOffset };
+}
+function shouldReplaceLegacyReplay(messages, eventTs) {
+  if (messages.length === 0) return true;
+  const lastTs = messages[messages.length - 1]?.ts;
+  return typeof lastTs === "string" && lastTs >= eventTs;
 }
 function accumulateUsage(usage, ev) {
   return {
@@ -3128,7 +3438,7 @@ import * as path8 from "node:path";
 function isPrunableSessionJsonl(name) {
   return isSessionTranscriptFileName(name);
 }
-async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
+async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession, isSessionInUse) {
   const cutoff = Date.now() - maxAgeDays * 864e5;
   let deleted = 0;
   const pruneFile = async (dir, name, prefix) => {
@@ -3141,6 +3451,7 @@ async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
     }
     const base = name.replace(/\.jsonl$/, "");
     const id = prefix ? `${prefix}/${base}` : base;
+    if (isSessionInUse && await isSessionInUse(id)) return;
     await deleteSession(id);
     deleted++;
   };
@@ -3246,8 +3557,8 @@ var MAX_REVALIDATE_BYTES = 5 * 1024 * 1024;
 var VALIDATION_CONCURRENCY = 8;
 var NOTICE_PATH_LIMIT = 20;
 function isInside2(root, target) {
-  const relative3 = path9.relative(root, target);
-  return relative3 === "" || !relative3.startsWith("..") && !path9.isAbsolute(relative3);
+  const relative4 = path9.relative(root, target);
+  return relative4 === "" || !relative4.startsWith("..") && !path9.isAbsolute(relative4);
 }
 function errno(err) {
   return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
@@ -3357,8 +3668,8 @@ function formatResumeValidationNotice(validation, projectRoot) {
   if (validation.staleFiles.length === 0) return null;
   const root = path9.resolve(projectRoot);
   const shown = validation.staleFiles.slice(0, NOTICE_PATH_LIMIT).map((entry) => {
-    const relative3 = path9.relative(root, entry.path);
-    const display = isInside2(root, entry.path) ? relative3 || "." : entry.path;
+    const relative4 = path9.relative(root, entry.path);
+    const display = isInside2(root, entry.path) ? relative4 || "." : entry.path;
     return `- ${JSON.stringify(display)} [${entry.status}]`;
   });
   const omitted = validation.staleFiles.length - shown.length;
@@ -3420,7 +3731,6 @@ async function summarizeSessionEventSequence(opts) {
       }
     }
     const toolBreakdown = {};
-    let outcome;
     let lastEventType;
     let hasError = false;
     let sawStart = false;
@@ -3467,23 +3777,21 @@ async function summarizeSessionEventSequence(opts) {
         }
       } else if (e.type === "llm_response") {
         messageCount++;
-        tokenIn += e.usage.input ?? 0;
-        tokenOut += e.usage.output ?? 0;
+        if (e.usage) {
+          tokenIn += effectiveInputTokens(e.usage);
+          tokenOut += e.usage.output ?? 0;
+        }
+        if (e.model) model = e.model;
+        if (e.provider) provider = e.provider;
       } 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";
+      else if (isSessionErrorEvent(e)) hasError = true;
     }
+    const outcome = resolveSessionOutcome(lastEventType, hasError);
     return {
       id,
       title,
@@ -3594,10 +3902,7 @@ async function executeResumeSession(params) {
   let resumeValidation;
   if (projectRoot) {
     try {
-      const validationEvents = eventsDropped > 0 ? (await searchEvents(
-        canonicalId,
-        (ev) => ev.type === "file_observation"
-      )).map((h) => h.event) : data.events;
+      const validationEvents = eventsDropped > 0 ? (await searchEvents(canonicalId, (ev) => ev.type === "file_observation")).map((h) => h.event) : data.events;
       resumeValidation = await validateResumeFileObservations(validationEvents, projectRoot);
       const notice = formatResumeValidationNotice(resumeValidation, projectRoot);
       if (notice) {
@@ -3635,26 +3940,32 @@ async function executeResumeSession(params) {
     });
   }
   const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
+  const recoveredMessages = appendSyntheticRecoveryMessages(
+    carriedMessages,
+    recoveryPlan.pendingEvents,
+    synthesizedResults
+  );
+  const { pendingToolUseCount: _healedPendingToolUseCount, ...dataWithoutPendingToolUseCount } = data;
+  const resumedBase = synthesizedResults.length > 0 ? dataWithoutPendingToolUseCount : data;
   const resumedData = {
-    ...data,
+    ...resumedBase,
     ...resumeValidation ? { resumeValidation } : {},
-    messages: [...carriedMessages, ...noticeMessages]
+    messages: [...recoveredMessages, ...noticeMessages]
   };
   let handle;
   try {
     handle = await openSessionForAppend(file);
   } catch (err) {
     emitSessionStoreError(events, canonicalId, file, "resume", toErrorMessage(err), false);
-    throw new Error(
-      `Failed to open session "${canonicalId}" for append: ${toErrorMessage(err)}`,
-      { cause: err }
-    );
+    throw new Error(`Failed to open session "${canonicalId}" for append: ${toErrorMessage(err)}`, {
+      cause: err
+    });
   }
   try {
     const writer = new FileSessionWriter(
       canonicalId,
       handle,
-      (/* @__PURE__ */ new Date()).toISOString(),
+      data.metadata.startedAt,
       {
         id: canonicalId,
         model: data.metadata.model,
@@ -3703,6 +4014,71 @@ async function executeResumeSession(params) {
     throw err;
   }
 }
+function appendSyntheticRecoveryMessages(messages, pendingEvents, synthesizedResults) {
+  if (synthesizedResults.length === 0) return messages;
+  const next = [...messages];
+  for (const result of synthesizedResults) {
+    if (result.type !== "tool_result") continue;
+    const toolUse = findToolUseBlock(next, result.id) ?? findToolUseBlockInEvents(pendingEvents, result.id);
+    if (!toolUse) continue;
+    if (!isLastMessageToolUseFor(next, result.id)) {
+      next.push({
+        role: "assistant",
+        content: [toolUse],
+        ts: result.ts
+      });
+    }
+    next.push({
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          tool_use_id: result.id,
+          content: typeof result.content === "string" ? result.content : JSON.stringify(result.content),
+          is_error: result.isError
+        }
+      ],
+      ts: result.ts
+    });
+  }
+  return next;
+}
+function findToolUseBlock(messages, id) {
+  for (const message of messages) {
+    if (message.role !== "assistant" || !Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (block.type === "tool_use" && block.id === id) return block;
+    }
+  }
+  return null;
+}
+function findToolUseBlockInEvents(events, id) {
+  for (let i = events.length - 1; i >= 0; i--) {
+    const event = events[i];
+    if (!event) continue;
+    if (event.type === "llm_response") {
+      const block = event.content.find((item) => item.type === "tool_use" && item.id === id);
+      if (block) return block;
+    } else if (event.type === "message_appended" && event.message.role === "assistant" && Array.isArray(event.message.content)) {
+      const block = event.message.content.find(
+        (item) => item.type === "tool_use" && item.id === id
+      );
+      if (block) return block;
+    } else if (event.type === "tool_use" && event.id === id) {
+      return { type: "tool_use", id: event.id, name: event.name, input: recordInput(event.input) };
+    } else if (event.type === "tool_call_start" && event.id === id) {
+      return { type: "tool_use", id: event.id, name: event.name, input: recordInput(event.input) };
+    }
+  }
+  return null;
+}
+function recordInput(input) {
+  return input !== null && typeof input === "object" && !Array.isArray(input) ? input : {};
+}
+function isLastMessageToolUseFor(messages, id) {
+  const last = messages[messages.length - 1];
+  return last?.role === "assistant" && Array.isArray(last.content) && last.content.some((block) => block.type === "tool_use" && block.id === id);
+}
 async function openSessionForAppend(file) {
   const handle = await fsp12.open(file, "a+", 384);
   try {
@@ -3723,6 +4099,7 @@ async function openSessionForAppend(file) {
 
 // src/storage/session-store/search-events.ts
 import * as fsp13 from "node:fs/promises";
+import { StringDecoder } from "node:string_decoder";
 async function searchSessionEvents(args) {
   const { file, secretScrubber, predicate, limit, signal } = args;
   const out = [];
@@ -3739,6 +4116,7 @@ async function searchSessionEvents(args) {
     fh = await fsp13.open(file, "r");
     const CHUNK = 64 * 1024;
     const buf = Buffer.alloc(CHUNK);
+    const decoder = new StringDecoder("utf8");
     let leftover = "";
     let eventIndex = 0;
     for (let position = 0; ; position += buf.byteLength) {
@@ -3748,7 +4126,7 @@ async function searchSessionEvents(args) {
       }
       const { bytesRead } = await fh.read(buf, 0, CHUNK, position);
       if (bytesRead === 0) break;
-      const text = leftover + buf.subarray(0, bytesRead).toString("utf8");
+      const text = leftover + decoder.write(buf.subarray(0, bytesRead));
       const parts = text.split("\n");
       leftover = parts.pop() ?? "";
       for (const line of parts) {
@@ -3762,6 +4140,7 @@ async function searchSessionEvents(args) {
         eventIndex++;
       }
     }
+    leftover += decoder.end();
     const trailing = parseSessionEventLine(leftover.trim() ? leftover : "", secretScrubber);
     if (trailing && predicate(trailing, eventIndex, trailing.ts)) {
       out.push({ event: trailing, eventIndex, ts: trailing.ts });
@@ -4037,7 +4416,10 @@ async function compactIndexInner(indexFile, entries, deletedIds) {
       parts.push(JSON.stringify({ action: "delete", id }));
     }
   }
-  if (parts.length === 0) return;
+  if (parts.length === 0) {
+    await atomicWrite(indexFile, "", { mode: 384 });
+    return;
+  }
   const lines = parts.join("\n") + "\n";
   await atomicWrite(indexFile, lines, { mode: 384 });
 }
@@ -4412,7 +4794,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
     if (resolution.status === "resolved") return resolution.id;
     throw sessionIdResolutionError(resolution);
   }
-  async resume(id) {
+  async resume(id, onLoadProgress) {
     const canonicalId = await this.resolveId(id);
     const file = this.sessionPath(canonicalId, ".jsonl");
     return executeResumeSession({
@@ -4425,7 +4807,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       checkpointCas: this.checkpointCas,
       onAppend: this.onAppend,
       onAppendBatch: this.onAppendBatch,
-      load: (loadId) => this.load(loadId),
+      load: (loadId) => this.load(loadId, onLoadProgress),
       readSummaryManifest: (summaryId) => this.readSummaryManifest(summaryId),
       searchEvents: (searchId, pred) => this.searchEvents(searchId, pred),
       persistCatalogSummary: (sum) => this.persistCatalogSummary(sum),
@@ -4433,13 +4815,13 @@ var DefaultSessionStore = class _DefaultSessionStore {
       sessionsDir: this.dir
     });
   }
-  async load(id) {
-    return this.loadInternal(id, { full: true });
+  async load(id, onLoadProgress) {
+    return this.loadInternal(id, { full: true }, onLoadProgress);
   }
   async loadEventsOnly(id) {
     return this.loadInternal(id, { full: false });
   }
-  async loadInternal(id, mode) {
+  async loadInternal(id, mode, onLoadProgress) {
     const file = this.sessionPath(id, ".jsonl");
     const t0 = Date.now();
     let outcome = "success";
@@ -4451,6 +4833,7 @@ var DefaultSessionStore = class _DefaultSessionStore {
       const cached = this.loadCache.getFresh(id, stat11, mode.full);
       if (cached) {
         cacheHit = true;
+        onLoadProgress?.({ loadedBytes: stat11.size, totalBytes: stat11.size });
         return cached;
       }
       const data = await loadSessionDataFromFile({
@@ -4458,7 +4841,8 @@ var DefaultSessionStore = class _DefaultSessionStore {
         file,
         full: mode.full,
         events: this.events,
-        secretScrubber: this.secretScrubber
+        secretScrubber: this.secretScrubber,
+        onLoadProgress
       });
       if (mode.full) {
         this.loadCache.set(id, stat11, data);
@@ -4910,7 +5294,12 @@ var DefaultSessionStore = class _DefaultSessionStore {
         holderId: this.maintenanceHolderId
       });
     }
-    const deleted = await pruneSessionFiles(this.dir, maxAgeDays, (id) => this.deleteSession(id));
+    const deleted = await pruneSessionFiles(
+      this.dir,
+      maxAgeDays,
+      (id) => this.deleteSession(id),
+      this.isSessionInUse
+    );
     if (deleted > 0) {
       await this.compactIndex().catch(() => void 0);
     }
@@ -4926,6 +5315,9 @@ var DefaultSessionStore = class _DefaultSessionStore {
       ensureShardDir: (sid) => this.ensureShardDir(sid),
       sessionPath: (sid, ext) => this.sessionPath(sid, ext)
     });
+    if (!this.catalogClient) {
+      await this.appendToIndexStrict(await this.summaryFor(canonical));
+    }
     this.clearLoadCache(canonical);
     if (id !== canonical) this.clearLoadCache(id);
   }
@@ -4954,6 +5346,7 @@ export {
   scrubPersistedSessionSummary,
   extractInterruptedTools,
   SessionRecovery,
+  summarizeSessionFile,
   DefaultSessionStore
 };
-//# sourceMappingURL=chunk-UIWONWVG.js.map
+//# sourceMappingURL=chunk-NSOFPKGT.js.map