@wrongstack/core 0.310.1 → 0.313.1

package/dist/chunk-UIWONWVG.js

@@ -0,0 +1,4959 @@
+import {
+  mapWithConcurrency
+} from "./chunk-SZ6AYUIZ.js";
+import {
+  SessionCatalogProjectClient,
+  resolveSessionCatalogProjectServerUrl
+} from "./chunk-52RTVH4M.js";
+import {
+  SECRET_FILE_MODE
+} from "./chunk-H5E77KUJ.js";
+import {
+  DefaultSecretScrubber
+} from "./chunk-3E244UDA.js";
+import {
+  isSessionTranscriptFileName,
+  sessionScopedPath
+} from "./chunk-AD7ZFZCS.js";
+import {
+  buildChildEnv
+} from "./chunk-VB3H5WWB.js";
+import {
+  repairToolUseAdjacency
+} from "./chunk-M2WF6AXG.js";
+import {
+  ulid
+} from "./chunk-4XV6IR37.js";
+import {
+  isPidAlive
+} from "./chunk-TRT2HRWZ.js";
+import {
+  atomicWrite,
+  ensureDir,
+  withFileLock
+} from "./chunk-7ZHZE5EO.js";
+import {
+  toErrorMessage
+} from "./chunk-TBRL2RCC.js";
+
+// src/storage/director-state.ts
+import * as fsp from "node:fs/promises";
+import { hostname } from "node:os";
+async function loadDirectorState(filePath) {
+  let raw;
+  try {
+    raw = await fsp.readFile(filePath, "utf8");
+  } catch {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    if (parsed?.version !== 1) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function acquireDirectorStateLock(lockPath, processId = process.pid) {
+  let existing;
+  try {
+    existing = await fsp.readFile(lockPath, "utf8");
+  } catch {
+  }
+  if (existing) {
+    try {
+      const lock2 = JSON.parse(existing);
+      if (isPidAlive(lock2.pid)) return false;
+    } catch {
+    }
+  }
+  const lock = {
+    pid: processId,
+    hostname: hostname(),
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await atomicWrite(lockPath, JSON.stringify(lock), { mode: 384 });
+  return true;
+}
+async function releaseDirectorStateLock(lockPath) {
+  try {
+    await fsp.unlink(lockPath);
+  } catch {
+  }
+}
+var DirectorStateCheckpoint = class {
+  snapshot;
+  filePath;
+  lockPath;
+  timer = null;
+  debounceMs;
+  writing = false;
+  rewriteRequested = false;
+  constructor(filePath, init, debounceMs = 250) {
+    this.filePath = filePath;
+    this.lockPath = `${filePath}.lock`;
+    this.debounceMs = debounceMs;
+    this.snapshot = {
+      version: 1,
+      directorRunId: init.directorRunId,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      spawnCount: 0,
+      maxSpawns: init.maxSpawns,
+      spawnDepth: init.spawnDepth,
+      maxSpawnDepth: init.maxSpawnDepth,
+      directorBudget: init.directorBudget,
+      subagents: [],
+      tasks: []
+    };
+  }
+  /**
+   * Attempt to acquire the lock for this checkpoint. Call this before
+   * resuming a crashed director run. If it returns false, another
+   * director process is still running this fleet — do not resume.
+   */
+  async acquireLock() {
+    return acquireDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Release the lock on graceful shutdown. Call `flush()` first to ensure
+   * the final checkpoint state is on disk before removing the lock.
+   * Without this, the next resume will see a stale-lock and refuse.
+   */
+  async releaseLock() {
+    return releaseDirectorStateLock(this.lockPath);
+  }
+  /**
+   * Resume from a snapshot previously loaded via `loadDirectorState()`.
+   * Use this when `--resume <runId>` is triggered — the snapshot has
+   * the full fleet state (subagents, tasks) from before the crash; the
+   * checkpoint continues from there.
+   */
+  resume(snapshot) {
+    this.snapshot = snapshot;
+  }
+  /**
+   * Reconciles tasks and worktrees that were left in 'running' or 'allocated'
+   * state when the previous director crashed. Transitions abandoned tasks to
+   * 'failed' with a descriptive error and returns the list of repaired task IDs.
+   */
+  reconcileCrashedState(reason = "Director crashed or was terminated while task was in flight") {
+    const repairedTaskIds = [];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: this.snapshot.tasks.map((task) => {
+        if (task.status === "running") {
+          repairedTaskIds.push(task.taskId);
+          return {
+            ...task,
+            status: "failed",
+            completedAt: now,
+            error: task.error ? `${task.error} (${reason})` : reason,
+            worktree: task.worktree && task.worktree.status === "allocated" ? { ...task.worktree, status: "failed", error: reason } : task.worktree
+          };
+        }
+        return task;
+      })
+    };
+    if (repairedTaskIds.length > 0) {
+      this.bumpUpdatedAt();
+      this.schedule();
+    }
+    return repairedTaskIds;
+  }
+  /**
+   * After resume, pin the live spawn ceiling from the current profile/flag
+   * while preserving `spawnCount` (cumulative used budget). Checkpoint
+   * metadata previously stored a historical `maxSpawns` that can diverge
+   * from the live runtime ceiling — operators need the live value to win.
+   */
+  applyLiveMaxSpawns(maxSpawns) {
+    if (this.snapshot.maxSpawns === maxSpawns) return;
+    this.snapshot = {
+      ...this.snapshot,
+      maxSpawns
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  current() {
+    return this.snapshot;
+  }
+  recordSpawn(sub, spawnCount) {
+    this.snapshot = {
+      ...this.snapshot,
+      spawnCount,
+      subagents: [...this.snapshot.subagents.filter((s) => s.id !== sub.id), sub]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskAssigned(task) {
+    const exists = this.snapshot.tasks.some((t) => t.taskId === task.taskId);
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: exists ? this.snapshot.tasks.map((t) => t.taskId === task.taskId ? { ...t, ...task } : t) : [...this.snapshot.tasks, task]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskStatus(taskId, patch) {
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: this.snapshot.tasks.map((t) => t.taskId === taskId ? { ...t, ...patch } : t)
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  recordTaskWorktree(taskId, worktree) {
+    const exists = this.snapshot.tasks.some((t) => t.taskId === taskId);
+    this.snapshot = {
+      ...this.snapshot,
+      tasks: exists ? this.snapshot.tasks.map((t) => t.taskId === taskId ? { ...t, worktree } : t) : [
+        ...this.snapshot.tasks,
+        {
+          taskId,
+          subagentId: worktree.subagentId,
+          status: "running",
+          worktree
+        }
+      ]
+    };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  setUsage(usage) {
+    this.snapshot = { ...this.snapshot, usage };
+    this.bumpUpdatedAt();
+    this.schedule();
+  }
+  /** Force a synchronous flush — used by Director.shutdown(). */
+  async flush() {
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+    await this.persist();
+    while (this.rewriteRequested) {
+      this.rewriteRequested = false;
+      await this.persist();
+    }
+  }
+  bumpUpdatedAt() {
+    this.snapshot = { ...this.snapshot, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  schedule() {
+    if (this.timer) return;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      void this.persist();
+    }, this.debounceMs);
+  }
+  async persist() {
+    if (this.writing) {
+      this.rewriteRequested = true;
+      return;
+    }
+    this.writing = true;
+    try {
+      await atomicWrite(this.filePath, JSON.stringify(this.snapshot, null, 2), {
+        mode: 384
+      });
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "director_state.checkpoint_write_failed",
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    } finally {
+      this.writing = false;
+      if (this.rewriteRequested) {
+        this.rewriteRequested = false;
+        this.schedule();
+      }
+    }
+  }
+};
+
+// src/storage/session-checkpoint-cas.ts
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import * as fsp2 from "node:fs/promises";
+import * as path from "node:path";
+var HASH_RE = /^[a-f\d]{64}$/;
+var CAPTURE_CONCURRENCY = 8;
+var MAX_GIT_OUTPUT = 16 * 1024 * 1024;
+var MAX_BLOB_BYTES = 64 * 1024 * 1024;
+var MAX_CHECKPOINT_BYTES = 512 * 1024 * 1024;
+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);
+}
+function normalizeRelative(input) {
+  if (!input || path.isAbsolute(input)) return null;
+  const normalized = input.replace(/\\/g, "/").replace(/^\.\//, "");
+  const resolved = path.posix.normalize(normalized);
+  if (!resolved || resolved === "." || resolved === ".." || resolved.startsWith("../")) return null;
+  return resolved;
+}
+function parseNulPaths(output) {
+  return output.split("\0").map(normalizeRelative).filter((value) => value !== null);
+}
+function isWrongStackWorktreePath(relative3) {
+  return relative3 === ".wrongstack/worktrees" || relative3.startsWith(".wrongstack/worktrees/");
+}
+var SessionCheckpointCas = class {
+  rootDir;
+  projectRoot;
+  runGit;
+  constructor(opts) {
+    this.rootDir = path.resolve(opts.rootDir);
+    this.projectRoot = path.resolve(opts.projectRoot);
+    this.runGit = opts.runGit ?? defaultRunGit;
+  }
+  async capture(_sessionId, _promptIndex) {
+    const head = await this.runGit(["rev-parse", "--verify", "HEAD"], this.projectRoot);
+    const baseHead = head.stdout.trim();
+    if (head.code !== 0 || head.stdoutTruncated || !/^[a-f\d]{40,64}$/i.test(baseHead)) {
+      return void 0;
+    }
+    const [tracked, untracked] = await Promise.all([
+      this.runGit(["diff", "HEAD", "--name-only", "-z", "--"], this.projectRoot),
+      this.runGit(["ls-files", "--others", "--exclude-standard", "-z"], this.projectRoot)
+    ]);
+    if (tracked.code !== 0 || untracked.code !== 0 || tracked.stdoutTruncated || untracked.stdoutTruncated) {
+      return void 0;
+    }
+    const relativePaths = [
+      .../* @__PURE__ */ new Set([...parseNulPaths(tracked.stdout), ...parseNulPaths(untracked.stdout)])
+    ].filter((relative3) => !isWrongStackWorktreePath(relative3)).sort();
+    const unresolved = [];
+    let scheduledBytes = 0;
+    const captured = await mapWithConcurrency(
+      relativePaths,
+      CAPTURE_CONCURRENCY,
+      async (relative3) => {
+        const absolute = path.resolve(this.projectRoot, ...relative3.split("/"));
+        if (!isInside(this.projectRoot, absolute)) {
+          unresolved.push({ path: relative3, reason: "path escapes project root" });
+          return null;
+        }
+        try {
+          const stat11 = await fsp2.lstat(absolute);
+          if (stat11.isSymbolicLink()) {
+            const linkTarget = await fsp2.readlink(absolute);
+            const resolvedLink = path.resolve(path.dirname(absolute), linkTarget);
+            if (path.isAbsolute(linkTarget) || !isInside(this.projectRoot, resolvedLink)) {
+              unresolved.push({
+                path: relative3,
+                reason: "symlink target escapes project root"
+              });
+              return null;
+            }
+            return { path: relative3, state: "symlink", linkTarget };
+          }
+          if (!stat11.isFile()) {
+            unresolved.push({ path: relative3, reason: "changed path is not a regular file" });
+            return null;
+          }
+          if (stat11.size > MAX_BLOB_BYTES) {
+            unresolved.push({
+              path: relative3,
+              reason: `file exceeds ${MAX_BLOB_BYTES}-byte checkpoint blob limit`
+            });
+            return null;
+          }
+          if (scheduledBytes + stat11.size > MAX_CHECKPOINT_BYTES) {
+            unresolved.push({
+              path: relative3,
+              reason: `checkpoint exceeds ${MAX_CHECKPOINT_BYTES}-byte aggregate blob limit`
+            });
+            return null;
+          }
+          scheduledBytes += stat11.size;
+          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 };
+        } catch (err) {
+          if (err.code === "ENOENT") {
+            return { path: relative3, state: "absent" };
+          }
+          unresolved.push({ path: relative3, reason: toErrorMessage(err) });
+          return null;
+        }
+      }
+    );
+    const capturedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const manifest = {
+      version: 1,
+      baseHead: baseHead.toLowerCase(),
+      coverage: "git-head-plus-dirty",
+      entries: captured.filter((entry) => entry !== null),
+      unresolved: [...unresolved].sort((a, b) => a.path.localeCompare(b.path))
+    };
+    const encoded = JSON.stringify(manifest);
+    const manifestHash = sha256(encoded);
+    await this.putManifest(manifestHash, encoded);
+    return {
+      manifestHash,
+      baseHead: manifest.baseHead,
+      entryCount: manifest.entries.length,
+      unresolvedCount: manifest.unresolved.length,
+      capturedAt,
+      coverage: manifest.coverage
+    };
+  }
+  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}`);
+    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");
+    }
+    if (manifest.unresolved.length > 0) {
+      throw new Error(
+        `Workspace checkpoint has ${manifest.unresolved.length} unresolved path(s); exact materialization refused`
+      );
+    }
+    const targetHead = await this.runGit(["rev-parse", "--verify", "HEAD"], target);
+    if (targetHead.code !== 0 || targetHead.stdoutTruncated || targetHead.stdout.trim().toLowerCase() !== manifest.baseHead) {
+      throw new Error(
+        `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 realTarget = await fsp2.realpath(target);
+    const writtenFiles = [];
+    const deletedFiles = [];
+    const errors = [];
+    const prepared = [];
+    for (const entry of manifest.entries) {
+      try {
+        const output = await this.safeOutputPath(target, realTarget, entry.path);
+        if (entry.state === "symlink") {
+          if (path.isAbsolute(entry.linkTarget)) {
+            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");
+        }
+        prepared.push({
+          entry,
+          output,
+          ...entry.state === "file" ? { content: await this.readBlob(entry.blobHash) } : {}
+        });
+      } catch (err) {
+        errors.push(`${entry.path}: ${toErrorMessage(err)}`);
+      }
+    }
+    if (errors.length > 0) {
+      return { targetRoot: target, writtenFiles, deletedFiles, errors };
+    }
+    for (const { entry, output, content } of prepared) {
+      try {
+        if (entry.state === "absent") {
+          await fsp2.unlink(output).catch((err) => {
+            if (err.code !== "ENOENT") throw err;
+          });
+          deletedFiles.push(entry.path);
+          continue;
+        }
+        if (entry.state === "symlink") {
+          await fsp2.unlink(output).catch((err) => {
+            if (err.code !== "ENOENT") throw err;
+          });
+          await fsp2.mkdir(path.dirname(output), { recursive: true });
+          await fsp2.symlink(entry.linkTarget, output);
+          writtenFiles.push(entry.path);
+          continue;
+        }
+        if (!content) throw new Error("CAS blob was not prepared");
+        await atomicWrite(output, content, { mode: entry.mode });
+        await fsp2.chmod(output, entry.mode).catch(() => void 0);
+        writtenFiles.push(entry.path);
+      } catch (err) {
+        errors.push(`${entry.path}: ${toErrorMessage(err)}`);
+      }
+    }
+    return { targetRoot: target, writtenFiles, deletedFiles, errors };
+  }
+  objectPath(hash) {
+    if (!HASH_RE.test(hash)) throw new Error(`Invalid CAS object hash: ${hash}`);
+    return path.join(this.rootDir, "objects", hash.slice(0, 2), hash.slice(2));
+  }
+  manifestPath(hash) {
+    if (!HASH_RE.test(hash)) throw new Error(`Invalid checkpoint manifest hash: ${hash}`);
+    return path.join(this.rootDir, "manifests", `${hash}.json`);
+  }
+  async putBlob(hash, content) {
+    const target = this.objectPath(hash);
+    await fsp2.mkdir(path.dirname(target), { recursive: true });
+    try {
+      const existing = await fsp2.readFile(target);
+      if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      return;
+    } catch (err) {
+      if (err.code !== "ENOENT") throw err;
+    }
+    const temp = path.join(
+      path.dirname(target),
+      `.${path.basename(target)}.${process.pid}.${randomUUID()}.tmp`
+    );
+    let handle;
+    try {
+      handle = await fsp2.open(temp, "wx", 384);
+      await handle.writeFile(content);
+      await handle.sync();
+      await handle.close();
+      handle = void 0;
+      try {
+        await fsp2.link(temp, target);
+      } catch (err) {
+        if (err.code !== "EEXIST") throw err;
+        const existing = await fsp2.readFile(target);
+        if (sha256(existing) !== hash) throw new Error(`Corrupt CAS object collision: ${hash}`);
+      }
+    } finally {
+      await handle?.close().catch(() => void 0);
+      await fsp2.unlink(temp).catch(() => void 0);
+    }
+  }
+  async putManifest(hash, encoded) {
+    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}`);
+      return;
+    }
+    await atomicWrite(target, encoded, { mode: 384 });
+  }
+  async readBlob(hash) {
+    const content = await fsp2.readFile(this.objectPath(hash));
+    if (sha256(content) !== hash) throw new Error(`CAS blob integrity check failed: ${hash}`);
+    return content;
+  }
+  async loadManifest(hash) {
+    const raw = await fsp2.readFile(this.manifestPath(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}`);
+    }
+    const entriesValid = parsed.entries.every((entry) => {
+      if (!entry || typeof entry !== "object") return false;
+      const candidate = entry;
+      if (typeof candidate.path !== "string" || !normalizeRelative(candidate.path)) return false;
+      if (candidate.state === "absent") return true;
+      if (candidate.state === "symlink") return typeof candidate.linkTarget === "string";
+      return candidate.state === "file" && typeof candidate.blobHash === "string" && HASH_RE.test(candidate.blobHash) && typeof candidate.mode === "number" && Number.isInteger(candidate.mode) && candidate.mode >= 0 && candidate.mode <= 511;
+    });
+    const unresolvedValid = parsed.unresolved.every(
+      (entry) => entry !== null && typeof entry === "object" && typeof entry.path === "string" && typeof entry.reason === "string"
+    );
+    if (!entriesValid || !unresolvedValid) {
+      throw new Error(`Invalid workspace checkpoint manifest entries: ${hash}`);
+    }
+    return parsed;
+  }
+  async safeOutputPath(target, realTarget, relative3) {
+    const normalized = normalizeRelative(relative3);
+    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");
+    let probe = output;
+    for (; ; ) {
+      try {
+        const real = await fsp2.realpath(probe);
+        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;
+        const parent = path.dirname(probe);
+        if (parent === probe) throw err;
+        probe = parent;
+      }
+    }
+  }
+};
+function defaultRunGit(args, cwd) {
+  return new Promise((resolve4) => {
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    let stdoutBytes = 0;
+    let stderrBytes = 0;
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    const child = spawn("git", args, {
+      cwd,
+      env: buildChildEnv(),
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: AbortSignal.timeout(3e4),
+      windowsHide: true
+    });
+    child.stdout?.on("data", (chunk) => {
+      const remaining = MAX_GIT_OUTPUT - stdoutBytes;
+      if (remaining <= 0) {
+        stdoutTruncated = true;
+        return;
+      }
+      const kept = chunk.subarray(0, remaining);
+      stdoutChunks.push(kept);
+      stdoutBytes += kept.length;
+      if (kept.length < chunk.length) stdoutTruncated = true;
+    });
+    child.stderr?.on("data", (chunk) => {
+      const remaining = MAX_GIT_OUTPUT - stderrBytes;
+      if (remaining <= 0) {
+        stderrTruncated = true;
+        return;
+      }
+      const kept = chunk.subarray(0, remaining);
+      stderrChunks.push(kept);
+      stderrBytes += kept.length;
+      if (kept.length < chunk.length) stderrTruncated = true;
+    });
+    const result = (code, extraStderr) => ({
+      code,
+      stdout: Buffer.concat(stdoutChunks).toString("utf8"),
+      stderr: `${Buffer.concat(stderrChunks).toString("utf8")}${extraStderr ?? ""}`,
+      stdoutTruncated,
+      stderrTruncated
+    });
+    child.on("error", (err) => resolve4(result(1, err.message)));
+    child.on("close", (code) => resolve4(result(code ?? 1)));
+  });
+}
+
+// src/storage/session-id.ts
+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);
+  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();
+  if (!normalized) return { status: "missing", query: normalized };
+  const uniqueIds = [...new Set(candidateIds)];
+  if (uniqueIds.includes(normalized)) return { status: "resolved", id: normalized };
+  const leaf = (id) => path2.posix.basename(id.replace(/\\/g, "/"));
+  const exactLeafMatches = uniqueIds.filter((id) => leaf(id) === normalized);
+  if (exactLeafMatches.length === 1) {
+    return { status: "resolved", id: exactLeafMatches[0] };
+  }
+  if (exactLeafMatches.length > 1) {
+    return {
+      status: "ambiguous",
+      query: normalized,
+      candidates: exactLeafMatches.sort()
+    };
+  }
+  const prefixMatches = uniqueIds.filter(
+    (id) => id.startsWith(normalized) || leaf(id).startsWith(normalized)
+  );
+  if (prefixMatches.length === 1) return { status: "resolved", id: prefixMatches[0] };
+  if (prefixMatches.length > 1) {
+    return { status: "ambiguous", query: normalized, candidates: prefixMatches.sort() };
+  }
+  return { status: "missing", query: normalized };
+}
+function sessionIdResolutionError(resolution) {
+  if (resolution.status === "ambiguous") {
+    return new Error(
+      `Ambiguous session id "${resolution.query}". Matches: ${resolution.candidates.join(", ")}`
+    );
+  }
+  return new Error(`Session not found: ${resolution.query}`);
+}
+
+// src/storage/session-workspace-checkpoints.ts
+function requiredCheckpointCas(checkpointCas, operation) {
+  if (!checkpointCas) {
+    throw new Error(`Workspace checkpoint ${operation} requires a projectRoot-aware session store`);
+  }
+  return checkpointCas;
+}
+function captureCheckpoint(checkpointCas, sessionId, promptIndex) {
+  return requiredCheckpointCas(checkpointCas, "capture").capture(sessionId, promptIndex);
+}
+function materializeCheckpoint(checkpointCas, checkpoint, targetRoot) {
+  return requiredCheckpointCas(checkpointCas, "materialization").materialize(
+    checkpoint,
+    targetRoot
+  );
+}
+
+// src/storage/session-helpers.ts
+function consumeControlString(value, start) {
+  let index = start;
+  while (index < value.length) {
+    const code = value.charCodeAt(index);
+    if (code === 7 || code === 156) return index;
+    if (code === 27 && value.charCodeAt(index + 1) === 92) return index + 1;
+    index++;
+  }
+  return value.length;
+}
+function consumeCsi(value, start) {
+  let index = start;
+  while (index < value.length && value.charCodeAt(index) < 64) index++;
+  return index;
+}
+function stripTerminalControls(value) {
+  let out = "";
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index);
+    if (code === 27) {
+      const family = value.charCodeAt(index + 1);
+      if (family === 91) index = consumeCsi(value, index + 2);
+      else if ([93, 80, 88, 94, 95].includes(family)) {
+        index = consumeControlString(value, index + 2);
+      } else index++;
+      continue;
+    }
+    if (code === 155) {
+      index = consumeCsi(value, index + 1);
+      continue;
+    }
+    if ([144, 152, 157, 158, 159].includes(code)) {
+      index = consumeControlString(value, index + 1);
+      continue;
+    }
+    if (code < 32 && code !== 9 && code !== 10 && code !== 13 || code >= 127 && code <= 159) {
+      continue;
+    }
+    out += value[index];
+  }
+  return out;
+}
+function sessionContentText(content) {
+  const text = typeof content === "string" ? content : content.filter((b) => b.type === "text").map((b) => b.text).join(" ");
+  return stripTerminalControls(text).trim().replace(/\s+/g, " ");
+}
+function sessionContentPreview(content, maxLength = 160) {
+  const text = sessionContentText(content) || "(non-text input)";
+  return text.length > maxLength ? `${text.slice(0, Math.max(0, maxLength - 1))}\u2026` : text;
+}
+function userInputTitle(content) {
+  return sessionContentPreview(content, 60);
+}
+
+// src/storage/session-read-scrubber.ts
+function scrubPersistedSessionEvent(event, scrubber) {
+  return scrubber.scrubObject(event);
+}
+function scrubPersistedSessionData(data, scrubber) {
+  return scrubber.scrubObject(data);
+}
+function scrubPersistedSessionSummary(summary, scrubber) {
+  const scrubbed = scrubber.scrubObject(summary);
+  const { name: _name, lastUserMessage: _lastUserMessage, ...rest } = scrubbed;
+  const title = sessionContentText(scrubbed.title) || "(empty session)";
+  const name = scrubbed.name === void 0 ? "" : sessionContentText(scrubbed.name);
+  const lastUserMessage = scrubbed.lastUserMessage === void 0 ? "" : sessionContentText(scrubbed.lastUserMessage);
+  return {
+    ...rest,
+    title,
+    ...name ? { name } : {},
+    ...lastUserMessage ? { lastUserMessage } : {}
+  };
+}
+
+// src/storage/session-recovery.ts
+import { createReadStream } from "node:fs";
+import * as fs from "node:fs/promises";
+import * as path4 from "node:path";
+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;
+}
+function childPrefixFor(entry, prefix, depth) {
+  return depth === 0 ? entry.name : `${prefix}/${entry.name}`;
+}
+async function collectSessionFiles(dir, prefix = "", depth = 0) {
+  let entries;
+  try {
+    entries = await fsp3.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const dirEntries = [];
+  const files = [];
+  for (const entry of entries) {
+    if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
+    if (entry.isDirectory()) {
+      dirEntries.push(entry);
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
+      files.push({ id: sessionIdForFile(prefix, entry.name), filePath: path3.join(dir, entry.name) });
+    }
+  }
+  const childFileArrays = await Promise.all(
+    dirEntries.map(
+      (entry) => collectSessionFiles(path3.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+    )
+  );
+  return [...childFileArrays.flat(), ...files];
+}
+async function collectSessionIds(dir, prefix = "", depth = 0) {
+  let entries;
+  try {
+    entries = await fsp3.readdir(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const dirEntries = [];
+  const fileIds = [];
+  for (const entry of entries) {
+    if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
+    if (entry.isDirectory()) {
+      dirEntries.push(entry);
+    } else if (entry.isFile() && isSessionTranscriptFileName(entry.name)) {
+      fileIds.push(sessionIdForFile(prefix, entry.name));
+    }
+  }
+  const childIdArrays = await Promise.all(
+    dirEntries.map(
+      (entry) => collectSessionIds(path3.join(dir, entry.name), childPrefixFor(entry, prefix, depth), depth + 1)
+    )
+  );
+  return [...childIdArrays.flat(), ...fileIds];
+}
+
+// src/storage/session-recovery.ts
+function extractInterruptedTools(plan) {
+  const tools = [];
+  const openCalls = /* @__PURE__ */ new Map();
+  let anonymousSeq = 0;
+  for (const ev of plan.pendingEvents) {
+    if ((ev.type === "tool_use" || ev.type === "tool_call_start") && typeof ev.name === "string") {
+      const toolName = ev.name;
+      const rawId = ev.id;
+      const callId = rawId ?? toolName;
+      openCalls.set(callId, {
+        id: rawId,
+        name: toolName,
+        args: ev.input ?? ev.args,
+        ts: ev.ts
+      });
+    } else if (ev.type === "tool_result" || ev.type === "tool_call_end") {
+      const callId = ev.id ?? ev.toolUseId ?? ev.name;
+      if (callId) openCalls.delete(callId);
+    } else if (ev.type === "llm_response" && Array.isArray(ev.content)) {
+      for (const block of ev.content) {
+        if (block && block.type === "tool_use" && typeof block.name === "string") {
+          const rawId = block.id;
+          const callId = rawId ?? `${block.name}#${++anonymousSeq}`;
+          openCalls.set(callId, {
+            id: rawId,
+            name: block.name,
+            args: block.input,
+            ts: ev.ts
+          });
+        }
+      }
+    } else if (ev.type === "message_appended" && ev.message) {
+      const msg = ev.message;
+      if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block && block.type === "tool_use" && typeof block.name === "string") {
+            const rawId = block.id;
+            const callId = rawId ?? `${block.name}#${++anonymousSeq}`;
+            openCalls.set(callId, {
+              id: rawId,
+              name: block.name,
+              args: block.input,
+              ts: ev.ts
+            });
+          } else if (block && block.type === "tool_result") {
+            const callId = block.tool_use_id ?? block.id;
+            if (callId) openCalls.delete(callId);
+          }
+        }
+      }
+    }
+  }
+  for (const call of openCalls.values()) {
+    let argsSummary;
+    if (call.args && typeof call.args === "object") {
+      try {
+        const str = JSON.stringify(call.args);
+        argsSummary = str.length > 80 ? `${str.slice(0, 77)}...` : str;
+      } catch {
+      }
+    }
+    tools.push({
+      id: call.id,
+      name: call.name,
+      argsSummary,
+      ts: call.ts
+    });
+  }
+  return tools;
+}
+var SessionRecovery = class _SessionRecovery {
+  constructor(dir) {
+    this.dir = dir;
+  }
+  dir;
+  static MAX_PENDING_EVENTS = 1e4;
+  static MAX_PENDING_BYTES = 16 * 1024 * 1024;
+  /**
+   * Build a recovery plan from ALREADY-LOADED events without touching disk.
+   * executeResumeSession uses this because load() has already paid for the
+   * transcript read; recover()'s file scan would duplicate it.
+   */
+  static buildRecoveryPlan(events, sessionId) {
+    const pendingEvents = [];
+    const pendingSizes = [];
+    let pendingBytes = 0;
+    let lastCheckpoint = null;
+    let latestBoundary = null;
+    for (const event of events) {
+      if (!event || typeof event !== "object" || typeof event.type !== "string") continue;
+      if (event.type === "checkpoint") {
+        lastCheckpoint = event;
+        pendingEvents.length = 0;
+        pendingSizes.length = 0;
+        pendingBytes = 0;
+        continue;
+      }
+      if (isLifecycleBoundary(event)) latestBoundary = event;
+      const bytes = Buffer.byteLength(JSON.stringify(event), "utf8");
+      if (bytes > _SessionRecovery.MAX_PENDING_BYTES) continue;
+      while (pendingEvents.length >= _SessionRecovery.MAX_PENDING_EVENTS || pendingBytes + bytes > _SessionRecovery.MAX_PENDING_BYTES) {
+        pendingBytes -= pendingSizes.shift();
+        pendingEvents.shift();
+      }
+      pendingEvents.push(event);
+      pendingSizes.push(bytes);
+      pendingBytes += bytes;
+    }
+    const inFlightStart = latestBoundary?.type === "in_flight_start" ? latestBoundary : null;
+    return {
+      sessionId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context: inFlightStart?.context ?? null
+    };
+  }
+  /**
+   * Scan a session log and return a `StaleSession` if and only if the newest
+   * lifecycle boundary is an `in_flight_start` without a later
+   * `in_flight_end`/`session_end`. Ordinary provider/tool events after the
+   * marker do not make the session clean. Returns `null` when:
+   *   - the log does not exist;
+   *   - the log is empty;
+   *   - the latest lifecycle boundary is `in_flight_end` or `session_end`;
+   *   - there is no lifecycle boundary (legacy/pre-marker log).
+   *
+   * The reverse scanner is chunked and line-aware. It can cross arbitrarily
+   * large JSONL records (for example a large tool result) without imposing a
+   * fixed tail-size correctness limit. Clean logs normally return after the
+   * first chunk; stale logs continue counting lines so `eventCount` remains
+   * the documented total rather than a tail-only approximation.
+   */
+  async resolveId(query) {
+    const resolution = resolveSessionId(query, await collectSessionIds(this.dir));
+    if (resolution.status === "resolved") return resolution.id;
+    if (resolution.status === "missing") return resolution.query;
+    throw sessionIdResolutionError(resolution);
+  }
+  async detectStale(sessionId) {
+    const canonicalId = await this.resolveId(sessionId);
+    return this.detectStaleExact(canonicalId);
+  }
+  async detectStaleExact(sessionId) {
+    const fp = this.filePath(sessionId);
+    let stat11;
+    try {
+      stat11 = await fs.stat(fp);
+    } catch {
+      return null;
+    }
+    if (stat11.size === 0) return null;
+    try {
+      const scan = await scanLatestLifecycleBoundary(fp, stat11.size);
+      if (scan?.boundary.type !== "in_flight_start") return null;
+      return {
+        sessionId,
+        path: fp,
+        lastEventTs: scan.boundary.ts,
+        context: scan.boundary.context,
+        eventCount: scan.eventCount
+      };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Generate a recovery plan for a session. The plan describes
+   * the persisted tail after the last checkpoint, plus the dangling in-flight
+   * marker if present. SessionStore.resume() independently reconstructs state
+   * from the journal and does not re-run these events as commands.
+   *
+   * Returns a non-null plan for ANY session that has at least
+   * one event after a checkpoint (or, for legacy sessions, at
+   * least one event). Pure read; no mutation.
+   */
+  async recover(sessionId) {
+    const canonicalId = await this.resolveId(sessionId);
+    const fp = this.filePath(canonicalId);
+    const pendingEvents = [];
+    const pendingSizes = [];
+    let pendingBytes = 0;
+    let lastCheckpoint = null;
+    let latestBoundary = null;
+    let sawEvent = false;
+    const stream = createReadStream(fp, { encoding: "utf8" });
+    const lines = createInterface({ input: stream, crlfDelay: Infinity });
+    try {
+      for await (const line of lines) {
+        if (!line.trim()) continue;
+        let event;
+        try {
+          event = JSON.parse(line);
+        } catch {
+          continue;
+        }
+        if (!event || typeof event !== "object" || typeof event.type !== "string") continue;
+        sawEvent = true;
+        if (event.type === "checkpoint") {
+          lastCheckpoint = event;
+          pendingEvents.length = 0;
+          pendingSizes.length = 0;
+          pendingBytes = 0;
+        } else {
+          const bytes = Buffer.byteLength(line, "utf8");
+          if (bytes <= _SessionRecovery.MAX_PENDING_BYTES) {
+            while (pendingEvents.length >= _SessionRecovery.MAX_PENDING_EVENTS || pendingBytes + bytes > _SessionRecovery.MAX_PENDING_BYTES) {
+              pendingEvents.shift();
+              pendingBytes = Math.max(0, pendingBytes - pendingSizes.shift());
+            }
+            pendingEvents.push(event);
+            pendingSizes.push(bytes);
+            pendingBytes += bytes;
+          }
+        }
+        if (isLifecycleBoundary(event)) latestBoundary = event;
+      }
+    } catch {
+      return null;
+    } finally {
+      lines.close();
+      stream.close();
+    }
+    if (!sawEvent) return null;
+    const inFlightStart = latestBoundary?.type === "in_flight_start" ? latestBoundary : null;
+    const context = inFlightStart && inFlightStart.type === "in_flight_start" ? inFlightStart.context : null;
+    return {
+      sessionId: canonicalId,
+      stale: inFlightStart !== null,
+      lastCheckpoint,
+      pendingEvents,
+      inFlightStart,
+      context
+    };
+  }
+  /**
+   * List every stale session in a directory. Returns an array
+   * (possibly empty) sorted by `lastEventTs` descending — most
+   * recent crash first.
+   */
+  async listResumable() {
+    const out = [];
+    const collect = async (dir, prefix, depth) => {
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        return;
+      }
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        if (entry.name === "shared" || entry.name === "subagents" || entry.name === "attachments")
+          continue;
+        if (entry.isDirectory()) {
+          if (depth === 0) {
+            await collect(path4.join(dir, entry.name), entry.name, depth + 1);
+          }
+          continue;
+        }
+        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);
+      }
+    };
+    await collect(this.dir, "", 0);
+    return out.sort((a, b) => b.lastEventTs.localeCompare(a.lastEventTs));
+  }
+  // ── Internals ──────────────────────────────────────────────────────────
+  filePath(sessionId) {
+    return sessionScopedPath(this.dir, sessionId, ".jsonl");
+  }
+};
+function isLifecycleBoundary(event) {
+  return event.type === "in_flight_start" || event.type === "in_flight_end" || event.type === "session_end";
+}
+function parseLifecycleBoundary(line) {
+  try {
+    const parsed = JSON.parse(line.toString("utf8"));
+    return isLifecycleBoundary(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function hasNonWhitespace(line) {
+  for (const byte of line) {
+    if (byte !== 9 && byte !== 10 && byte !== 13 && byte !== 32) return true;
+  }
+  return false;
+}
+async function scanLatestLifecycleBoundary(filePath, size) {
+  const CHUNK_SIZE2 = 64 * 1024;
+  const handle = await fs.open(filePath, "r");
+  let position = size;
+  let laterLineFragment = Buffer.alloc(0);
+  let latestBoundary = null;
+  let eventCount = 0;
+  const observeLine = (line) => {
+    if (!hasNonWhitespace(line)) return null;
+    eventCount++;
+    return parseLifecycleBoundary(line);
+  };
+  try {
+    while (position > 0) {
+      const length = Math.min(CHUNK_SIZE2, position);
+      position -= length;
+      const chunk = Buffer.allocUnsafe(length);
+      const { bytesRead } = await handle.read(chunk, 0, length, position);
+      const data = Buffer.concat([chunk.subarray(0, bytesRead), laterLineFragment]);
+      let lineEnd = data.length;
+      for (let i = data.length - 1; i >= 0; i--) {
+        if (data[i] !== 10) continue;
+        const boundary2 = observeLine(data.subarray(i + 1, lineEnd));
+        if (!latestBoundary && boundary2) latestBoundary = boundary2;
+        lineEnd = i;
+      }
+      laterLineFragment = data.subarray(0, lineEnd);
+      if (latestBoundary && latestBoundary.type !== "in_flight_start") {
+        return { boundary: latestBoundary, eventCount };
+      }
+    }
+    const boundary = observeLine(laterLineFragment);
+    if (!latestBoundary && boundary) latestBoundary = boundary;
+    return latestBoundary ? { boundary: latestBoundary, eventCount } : null;
+  } finally {
+    await handle.close();
+  }
+}
+
+// src/storage/session-store.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import * as fsp19 from "node:fs/promises";
+import * as path11 from "node:path";
+
+// src/storage/file-session-writer.ts
+import * as fsp7 from "node:fs/promises";
+import * as path5 from "node:path";
+
+// src/storage/session-summary-tracker.ts
+import { createReadStream as createReadStream2 } from "node:fs";
+import * as fsp4 from "node:fs/promises";
+import { createInterface as createInterface2 } from "node:readline";
+var SessionSummaryTracker = class {
+  id;
+  startedAt;
+  meta;
+  resumed;
+  resolveNameCb;
+  summary;
+  tokenIn = 0;
+  tokenOut = 0;
+  baseTokenTotal = 0;
+  iterationCount = 0;
+  toolCallCount = 0;
+  toolErrorCount = 0;
+  toolBreakdown = {};
+  fileChangeCount = 0;
+  compactionCount = 0;
+  messageCount = 0;
+  lastUserMessage;
+  lastActivityAt;
+  outcome = void 0;
+  openToolUses = /* @__PURE__ */ new Set();
+  constructor(opts) {
+    this.id = opts.id;
+    this.startedAt = opts.startedAt;
+    this.meta = opts.meta;
+    this.resumed = opts.resumed ?? false;
+    this.resolveNameCb = opts.resolveName;
+    this.summary = opts.initialSummary ? { ...opts.initialSummary, id: opts.id } : {
+      id: opts.id,
+      title: "(empty session)",
+      startedAt: opts.startedAt,
+      model: opts.meta.model ?? "unknown",
+      provider: opts.meta.provider ?? "unknown",
+      tokenTotal: 0
+    };
+    this.baseTokenTotal = this.summary.tokenTotal;
+    this.iterationCount = this.summary.iterationCount ?? 0;
+    this.toolCallCount = this.summary.toolCallCount ?? 0;
+    this.toolErrorCount = this.summary.toolErrorCount ?? 0;
+    this.toolBreakdown = { ...this.summary.toolBreakdown ?? {} };
+    this.fileChangeCount = this.summary.fileChangeCount ?? 0;
+    this.compactionCount = this.summary.compactionCount ?? 0;
+    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;
+  }
+  get currentSummary() {
+    return this.summary;
+  }
+  /**
+   * Non-destructive materialization of every live counter into a summary
+   * snapshot. Unlike finalize(), it stamps no endedAt, applies no final
+   * outcome, and resolves no name — mid-session metadata checkpoints use it
+   * so a killed process leaves accurate listing metadata behind without
+   * pretending the session ended cleanly.
+   */
+  snapshot() {
+    const { lastUserMessage: _lastUserMessage, ...rest } = this.summary;
+    return {
+      ...rest,
+      messageCount: this.messageCount,
+      ...this.lastUserMessage !== void 0 ? { lastUserMessage: this.lastUserMessage } : {},
+      iterationCount: this.iterationCount,
+      toolCallCount: this.toolCallCount,
+      toolErrorCount: this.toolErrorCount,
+      fileChangeCount: this.fileChangeCount,
+      compactionCount: this.compactionCount > 0 ? this.compactionCount : void 0,
+      toolBreakdown: { ...this.toolBreakdown },
+      lastActivityAt: this.lastActivityAt,
+      ...this.outcome !== void 0 ? { outcome: this.outcome } : {}
+    };
+  }
+  get pendingToolUses() {
+    return Array.from(this.openToolUses);
+  }
+  observe(event) {
+    const eventActivityMs = Date.parse(event.ts);
+    const lastActivityMs = Date.parse(this.lastActivityAt);
+    if (Number.isFinite(eventActivityMs) && (!Number.isFinite(lastActivityMs) || eventActivityMs > lastActivityMs)) {
+      this.lastActivityAt = event.ts;
+    }
+    if (event.type === "llm_response") {
+      for (const block of event.content) {
+        if (block.type === "tool_use") this.openToolUses.add(block.id);
+      }
+    }
+    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";
+      }
+    } else if (event.type === "file_snapshot") {
+      this.fileChangeCount += event.files.length;
+    } else if (event.type === "compaction") {
+      this.compactionCount++;
+    }
+    if (event.type === "error" || event.type === "provider_error") {
+      this.outcome = "error";
+    }
+    if (event.type === "user_input") {
+      if (this.summary.title === "(empty session)") {
+        this.summary = { ...this.summary, title: userInputTitle(event.content) };
+      }
+      this.lastUserMessage = sessionContentPreview(event.content);
+      this.messageCount++;
+    } else if (event.type === "llm_response") {
+      this.messageCount++;
+      this.tokenIn += event.usage.input;
+      this.tokenOut += event.usage.output;
+      this.summary = {
+        ...this.summary,
+        tokenTotal: this.baseTokenTotal + 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: Math.max(this.summary.tokenTotal, total)
+        };
+      }
+    } else if (event.type === "in_flight_start") {
+      this.iterationCount++;
+    }
+  }
+  async recomputeFromDisk(filePath) {
+    if (!filePath) return;
+    const accessible = await fsp4.access(filePath).then(() => true).catch(() => false);
+    if (!accessible) return;
+    this.iterationCount = 0;
+    this.toolCallCount = 0;
+    this.toolErrorCount = 0;
+    this.toolBreakdown = {};
+    this.fileChangeCount = 0;
+    this.compactionCount = 0;
+    this.messageCount = 0;
+    this.lastUserMessage = void 0;
+    this.lastActivityAt = this.startedAt;
+    this.outcome = void 0;
+    this.openToolUses = /* @__PURE__ */ new Set();
+    this.tokenIn = 0;
+    this.tokenOut = 0;
+    this.baseTokenTotal = 0;
+    const { lastUserMessage: _lastUserMessage, ...summaryWithoutPreview } = this.summary;
+    this.summary = {
+      ...summaryWithoutPreview,
+      title: "(empty session)",
+      tokenTotal: 0,
+      messageCount: 0,
+      lastActivityAt: this.startedAt
+    };
+    const input = createReadStream2(filePath, { encoding: "utf8" });
+    const lines = createInterface2({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    try {
+      for await (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.length === 0) continue;
+        try {
+          this.observe(JSON.parse(trimmed));
+        } catch {
+        }
+      }
+    } finally {
+      lines.close();
+      input.destroy();
+    }
+  }
+  async finalize() {
+    const endedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const observedActivityMs = Date.parse(this.lastActivityAt);
+    const endedAtMs = Date.parse(endedAt);
+    const finalActivityAt = Number.isFinite(observedActivityMs) && observedActivityMs > endedAtMs ? this.lastActivityAt : endedAt;
+    const previousName = this.summary.name;
+    const {
+      lastUserMessage: _lastUserMessage,
+      name: _name,
+      ...summaryWithoutDisplay
+    } = this.summary;
+    this.summary = {
+      ...summaryWithoutDisplay,
+      ...previousName !== void 0 ? { name: previousName } : {},
+      endedAt,
+      lastActivityAt: finalActivityAt,
+      messageCount: this.messageCount,
+      ...this.lastUserMessage !== void 0 ? { lastUserMessage: this.lastUserMessage } : {},
+      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"
+    };
+    const resolvedName = this.resolveNameCb ? await this.resolveNameCb().catch(() => null) : null;
+    if (resolvedName !== null) {
+      const { name: _drop, ...summaryWithoutName } = this.summary;
+      this.summary = {
+        ...summaryWithoutName,
+        ...resolvedName.name !== void 0 ? { name: resolvedName.name } : {}
+      };
+    }
+    return this.summary;
+  }
+  reset(resetAt) {
+    const explicitName = this.summary.name;
+    this.baseTokenTotal = 0;
+    this.tokenIn = 0;
+    this.tokenOut = 0;
+    this.iterationCount = 0;
+    this.toolCallCount = 0;
+    this.toolErrorCount = 0;
+    this.toolBreakdown = {};
+    this.fileChangeCount = 0;
+    this.compactionCount = 0;
+    this.messageCount = 0;
+    this.lastUserMessage = void 0;
+    this.lastActivityAt = resetAt;
+    this.outcome = void 0;
+    this.openToolUses = /* @__PURE__ */ new Set();
+    this.summary = {
+      id: this.id,
+      title: "(empty session)",
+      ...explicitName !== void 0 ? { name: explicitName } : {},
+      startedAt: resetAt,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown",
+      tokenTotal: 0,
+      lastActivityAt: resetAt,
+      messageCount: 0
+    };
+  }
+};
+
+// src/storage/session-write-buffer.ts
+import { closeSync, fsyncSync, openSync, writeSync } from "node:fs";
+import * as fsp5 from "node:fs/promises";
+function isClosedHandleError(err) {
+  const code = err?.code;
+  return code === "EBADF" || code === "ERR_CLOSED_RESOURCE" || code === "ERR_INVALID_HANDLE";
+}
+var SessionWriteBuffer = class _SessionWriteBuffer {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  static FLUSH_INTERVAL_MS = 500;
+  static FLUSH_SIZE = 50;
+  static WRITE_BUFFER_MAX_EVENTS = 2e3;
+  static WRITE_BUFFER_MAX_BYTES = 16 * 1024 * 1024;
+  writeBuffer = [];
+  writeBufferBytes = 0;
+  flushTimer = null;
+  bufferOverflowCount = 0;
+  lastBufferOverflowWarnAt = 0;
+  appendFailCount = 0;
+  lastAppendWarnAt = 0;
+  writeChain = Promise.resolve();
+  flushPromise = null;
+  /**
+   * Batch currently inside enqueueWrite. `flushSync` may steal it if the
+   * async append has not started, so a dying process writes in-flight +
+   * remaining buffer as one ordered append instead of racing a second fd.
+   */
+  inFlight = null;
+  get isClosed() {
+    return false;
+  }
+  get length() {
+    return this.writeBuffer.length;
+  }
+  eventBytes(event) {
+    try {
+      return Buffer.byteLength(JSON.stringify(event), "utf8") + 1;
+    } catch {
+      return _SessionWriteBuffer.WRITE_BUFFER_MAX_BYTES + 1;
+    }
+  }
+  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) {
+      this.bufferOverflowCount++;
+      const now = Date.now();
+      if (now - this.lastBufferOverflowWarnAt > 5e3) {
+        console.warn(
+          JSON.stringify({
+            level: "error",
+            event: "session.buffer_overflow",
+            sessionId: this.opts.sessionId,
+            bufferedEvents: this.writeBuffer.length,
+            bufferedBytes: this.writeBufferBytes,
+            droppedEvents: this.bufferOverflowCount,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        this.bufferOverflowCount = 0;
+        this.lastBufferOverflowWarnAt = now;
+      }
+      return false;
+    }
+    this.writeBuffer.push(event);
+    this.writeBufferBytes += bytes;
+    return true;
+  }
+  enqueueWrite(data) {
+    return this.enqueueFlight({ data, stolen: false, started: false });
+  }
+  enqueueFlight(flight) {
+    const write = this.writeChain.then(async () => {
+      if (flight.stolen) return;
+      flight.started = true;
+      if (flight.stolen) return;
+      try {
+        return await this.opts.getHandle().appendFile(flight.data, "utf8");
+      } catch (err) {
+        if (isClosedHandleError(err)) {
+          const reloaded = await fsp5.open(this.opts.filePath, "a", 384);
+          this.opts.setHandle(reloaded);
+          return await reloaded.appendFile(flight.data, "utf8");
+        }
+        throw err;
+      }
+    });
+    this.writeChain = write.then(
+      () => void 0,
+      () => void 0
+    );
+    return write;
+  }
+  scheduleFlush(isClosed = false) {
+    if (this.flushTimer || isClosed) return;
+    this.flushTimer = setTimeout(() => {
+      this.flushTimer = null;
+      this.flushBuffer(isClosed).catch(() => {
+      });
+    }, _SessionWriteBuffer.FLUSH_INTERVAL_MS);
+  }
+  cancelTimer() {
+    if (this.flushTimer) {
+      clearTimeout(this.flushTimer);
+      this.flushTimer = null;
+    }
+  }
+  async flushBuffer(isClosed = false, opts = {}) {
+    if (this.flushPromise) {
+      const joined = this.flushPromise;
+      const continueIfDirty = () => {
+        if (this.writeBuffer.length === 0) return Promise.resolve();
+        return this.flushBuffer(isClosed, opts);
+      };
+      if (opts.datasync === true) {
+        return joined.then(
+          () => this.opts.getHandle().datasync().catch(() => void 0).then(continueIfDirty)
+        );
+      }
+      return joined.then(continueIfDirty);
+    }
+    const flush = (async () => {
+      while (this.writeBuffer.length > 0) await this.flushBufferOnce(isClosed, opts);
+    })().finally(() => {
+      if (this.flushPromise === flush) this.flushPromise = null;
+    });
+    this.flushPromise = flush;
+    return flush;
+  }
+  async flushBufferOnce(isClosed, opts) {
+    if (this.writeBuffer.length === 0) return;
+    const events = this.writeBuffer;
+    const eventCount = events.length;
+    const eventBytes = this.writeBufferBytes;
+    const batch = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    this.writeBuffer = [];
+    this.writeBufferBytes = 0;
+    const flight = { data: batch, stolen: false, started: false };
+    this.inFlight = flight;
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    try {
+      await this.enqueueFlight(flight);
+      if (flight.stolen) {
+        return;
+      }
+      if (opts?.datasync === true) {
+        await this.opts.getHandle().datasync().catch(() => void 0);
+      }
+    } catch (err) {
+      if (flight.stolen) return;
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      const newer = this.writeBuffer;
+      this.writeBuffer = events;
+      this.writeBufferBytes = eventBytes;
+      for (const newerEvent of newer) this.push(newerEvent);
+      this.appendFailCount += eventCount;
+      const now = Date.now();
+      if (now - this.lastAppendWarnAt > 5e3) {
+        const suppressed = this.appendFailCount - 1;
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "session.flush_failed",
+            sessionId: this.opts.sessionId,
+            message: toErrorMessage(err),
+            ...suppressed > 0 ? { suppressed } : {},
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        this.lastAppendWarnAt = now;
+        this.appendFailCount = 0;
+      }
+      if (!isClosed) this.scheduleFlush(isClosed);
+      throw err;
+    } finally {
+      this.opts.events?.emit("storage.write", {
+        sessionId: this.opts.sessionId,
+        store: "session",
+        filePath: this.opts.filePath,
+        operation: "flush",
+        outcome,
+        durationMs: Date.now() - t0,
+        ...errorMsg !== void 0 ? { error: errorMsg } : {},
+        ...eventCount !== void 0 ? { eventCount } : {},
+        ...this.opts.getTraceId?.() ? { traceId: this.opts.getTraceId() } : {}
+      });
+      if (this.inFlight === flight) this.inFlight = null;
+    }
+  }
+  async drainWriteChain() {
+    await this.writeChain;
+  }
+  async drainFlushPromise() {
+    await this.flushPromise?.catch(() => void 0);
+  }
+  /**
+   * Last-gasp synchronous append (SIGKILL/SIGTERM traps, `process.on('exit')`).
+   *
+   * 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
+   * async write chain, so a survivable failure (EACCES, ENOSPC, EMFILE) loses
+   * nothing. Failure is never silent: a structured `session.flush_sync_failed`
+   * warning names exactly what was still pending, which is what SIGKILL-trap
+   * tests assert against.
+   */
+  flushSync() {
+    if (!this.opts.filePath) return;
+    this.cancelTimer();
+    const chunks = [];
+    const flight = this.inFlight;
+    const stole = flight !== null && !flight.started && !flight.stolen;
+    if (stole && flight) {
+      flight.stolen = true;
+      chunks.push(flight.data);
+    }
+    const events = this.writeBuffer;
+    if (events.length > 0) {
+      chunks.push(events.map((e) => JSON.stringify(e)).join("\n") + "\n");
+    }
+    if (chunks.length === 0) return;
+    let fd;
+    try {
+      fd = openSync(this.opts.filePath, "a");
+      writeSync(fd, chunks.join(""), null, "utf8");
+      fsyncSync(fd);
+      if (this.writeBuffer === events) {
+        this.writeBuffer = [];
+        this.writeBufferBytes = 0;
+      }
+    } catch (err) {
+      if (stole && flight) flight.stolen = false;
+      console.warn(
+        JSON.stringify({
+          level: "error",
+          event: "session.flush_sync_failed",
+          sessionId: this.opts.sessionId,
+          filePath: this.opts.filePath,
+          message: toErrorMessage(err),
+          pendingEvents: events.length,
+          pendingBytes: this.writeBufferBytes,
+          hadInFlightBatch: stole,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    } finally {
+      if (fd !== void 0) {
+        try {
+          closeSync(fd);
+        } catch {
+        }
+      }
+    }
+  }
+  clear() {
+    this.cancelTimer();
+    this.writeBuffer = [];
+    this.writeBufferBytes = 0;
+    this.appendFailCount = 0;
+    this.lastAppendWarnAt = 0;
+    this.bufferOverflowCount = 0;
+    this.lastBufferOverflowWarnAt = 0;
+  }
+  shouldFlushNow() {
+    return this.writeBuffer.length >= _SessionWriteBuffer.FLUSH_SIZE;
+  }
+};
+
+// src/storage/session-writer-scrubber.ts
+function scrubSessionWriterEvent(event, secretScrubber) {
+  const persistMessage = (message) => {
+    const { _estTokens: _ignored, ...persisted } = message;
+    return {
+      ...persisted,
+      content: typeof persisted.content === "string" ? secretScrubber?.scrub(persisted.content) ?? persisted.content : secretScrubber?.scrubObject(persisted.content) ?? persisted.content
+    };
+  };
+  if (event.type === "context_snapshot" || event.type === "messages_replaced") {
+    return { ...event, messages: event.messages.map(persistMessage) };
+  }
+  if (event.type === "message_appended" || event.type === "message_updated") {
+    return { ...event, message: persistMessage(event.message) };
+  }
+  if (!secretScrubber) return event;
+  if (event.type === "user_input") {
+    return {
+      ...event,
+      content: typeof event.content === "string" ? secretScrubber.scrub(event.content) : secretScrubber.scrubObject(event.content)
+    };
+  }
+  if (event.type === "llm_response") {
+    return { ...event, content: secretScrubber.scrubObject(event.content) };
+  }
+  if (event.type === "file_snapshot") {
+    return {
+      ...event,
+      files: event.files.map((f) => ({
+        ...f,
+        before: f.before !== null ? secretScrubber.scrub(f.before) : null,
+        after: f.after !== null ? secretScrubber.scrub(f.after) : null
+      }))
+    };
+  }
+  return event;
+}
+
+// src/storage/session-writer-truncate.ts
+import * as fsp6 from "node:fs/promises";
+var CHUNK_SIZE = 65536;
+async function findSessionCheckpointTruncatePlan(filePath, targetPromptIndex) {
+  let fd;
+  let fileOffset = 0;
+  let pendingLine = Buffer.alloc(0);
+  let checkpointByteOffset = -1;
+  let removedCount = 0;
+  try {
+    fd = await fsp6.open(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;
+      const carriedBytes = pendingLine.length;
+      const chunk = carriedBytes === 0 ? buf.subarray(0, bytesRead) : Buffer.concat([pendingLine, buf.subarray(0, bytesRead)]);
+      const chunkFileOffset = fileOffset - carriedBytes;
+      let chunkPos = 0;
+      while (chunkPos < chunk.length) {
+        const idx = chunk.indexOf("\n", chunkPos);
+        if (idx === -1) break;
+        const lineStartOffset = chunkFileOffset + chunkPos;
+        if (checkpointByteOffset !== -1) {
+          removedCount++;
+        } 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.promptIndex === targetPromptIndex) {
+                  checkpointByteOffset = lineStartOffset;
+                } else if (event.promptIndex !== void 0 && event.promptIndex > targetPromptIndex) {
+                  checkpointByteOffset = lineStartOffset;
+                }
+              }
+            } catch {
+            }
+          }
+        }
+        chunkPos = idx + 1;
+      }
+      pendingLine = chunk.subarray(chunkPos);
+      fileOffset += bytesRead;
+    }
+  } finally {
+    await fd?.close();
+  }
+  if (checkpointByteOffset === -1) return null;
+  return { checkpointByteOffset, removedCount };
+}
+async function rewriteSessionToCheckpoint(filePath, checkpointByteOffset) {
+  const tmpPath = `${filePath}.rewind.tmp`;
+  const src = await fsp6.open(filePath, "r", 384);
+  let srcClosed = false;
+  const closeSrc = async () => {
+    if (srcClosed) return;
+    srcClosed = true;
+    await src.close();
+  };
+  try {
+    const statResult = await src.stat();
+    const totalSize = statResult.size;
+    const prefixBytes = checkpointByteOffset;
+    let newlineAfterCheckpoint = prefixBytes;
+    if (prefixBytes < totalSize) {
+      const probeBuf = Buffer.alloc(Math.min(CHUNK_SIZE, totalSize - prefixBytes));
+      const { bytesRead: probeRead } = await src.read(probeBuf, 0, probeBuf.length, prefixBytes);
+      if (probeRead > 0) {
+        const nl = probeBuf.indexOf("\n");
+        newlineAfterCheckpoint = nl !== -1 ? prefixBytes + nl + 1 : totalSize;
+      }
+    } else {
+      newlineAfterCheckpoint = totalSize;
+    }
+    const writeFd = await fsp6.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;
+      }
+      await writeFd.sync();
+    } finally {
+      await writeFd.close();
+    }
+    await closeSrc();
+    await fsp6.rename(tmpPath, filePath);
+  } catch (err) {
+    await closeSrc().catch(() => void 0);
+    await fsp6.unlink(tmpPath).catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/storage/file-session-writer.ts
+function isClosedHandleError2(err) {
+  const code = err?.code;
+  return code === "EBADF" || code === "ERR_CLOSED_RESOURCE" || code === "ERR_INVALID_HANDLE";
+}
+var CRITICAL_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "user_input",
+  "llm_response",
+  "checkpoint",
+  "in_flight_start",
+  "in_flight_end"
+]);
+function isCriticalEvent(event) {
+  return CRITICAL_EVENT_TYPES.has(event.type);
+}
+var METADATA_CHECKPOINT_INTERVAL_MS = 1e4;
+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.checkpointCas = opts.checkpointCas;
+    this._onAppend = opts.onAppend;
+    this._onAppendBatch = opts.onAppendBatch;
+    this.onCloseCb = opts.onClose;
+    this.onMetadataCheckpointCb = opts.onMetadataCheckpoint;
+    this.metadataCheckpointMs = opts.metadataCheckpointMs ?? METADATA_CHECKPOINT_INTERVAL_MS;
+    this.summaryTracker = new SessionSummaryTracker({
+      id,
+      startedAt,
+      meta,
+      resumed: this.resumed,
+      initialSummary: opts.initialSummary,
+      resolveName: opts.resolveName
+    });
+    this.buffer = new SessionWriteBuffer({
+      sessionId: id,
+      filePath: this.filePath,
+      getHandle: () => this.handle,
+      setHandle: (h) => {
+        this.handle = h;
+      },
+      events: this.events,
+      getTraceId: () => this.traceId
+    });
+    this.traceId = traceId;
+  }
+  id;
+  handle;
+  startedAt;
+  meta;
+  events;
+  closed = false;
+  closePromise = null;
+  manifestFile;
+  summaryTracker;
+  buffer;
+  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;
+  secretScrubber;
+  checkpointCas;
+  /** Mutable slot for onAppend callback — constructor opts seed it, setOnAppend replaces it. */
+  _onAppend;
+  /** Implements SessionWriter.onAppend — public getter/setter for direct property access. */
+  get onAppend() {
+    return this._onAppend;
+  }
+  set onAppend(cb) {
+    this._onAppend = cb;
+  }
+  /** Mutable slot for onAppendBatch callback. */
+  _onAppendBatch;
+  /** Implements SessionWriter.onAppendBatch — public getter/setter for direct property access. */
+  get onAppendBatch() {
+    return this._onAppendBatch;
+  }
+  set onAppendBatch(cb) {
+    this._onAppendBatch = cb;
+  }
+  onCloseCb;
+  /** Mid-session metadata checkpoint throttle. 0 disables checkpointing. */
+  metadataCheckpointMs;
+  /** One-shot guard for the "interval set but no sink" warning below. */
+  _checkpointNoSinkWarned = false;
+  onMetadataCheckpointCb;
+  /** Set whenever summary counters changed since the last metadata checkpoint. */
+  metadataDirty = false;
+  metadataTimer = null;
+  metadataCheckpointInFlight = null;
+  /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
+  traceId;
+  /**
+   * Set or replace the onAppend callback. Used by telemetry bridges that
+   * receive the writer as an already-constructed dependency.
+   */
+  setOnAppend(cb) {
+    this._onAppend = cb;
+  }
+  /**
+   * Set or replace the onAppendBatch callback.
+   */
+  setOnAppendBatch(cb) {
+    this._onAppendBatch = cb;
+  }
+  pendingFileSnapshots = [];
+  pendingFileSnapshotBytes = 0;
+  static PENDING_FILE_SNAPSHOT_MAX_ENTRIES = 256;
+  static PENDING_FILE_SNAPSHOT_MAX_BYTES = 16 * 1024 * 1024;
+  /** Prompt whose tool work is currently executing. Set by writeCheckpoint. */
+  activePromptIndex = null;
+  /**
+   * Buffer an event from a synchronous Context callback. ensureInit() starts
+   * by pushing the lifecycle preamble synchronously, so session_start always
+   * precedes observations even though these callbacks cannot await append().
+   */
+  bufferSynchronousEvent(event) {
+    if (this.closed) return;
+    void this.ensureInit();
+    const appendEvent = scrubSessionWriterEvent(event, this.secretScrubber);
+    this.summaryTracker.observe(appendEvent);
+    this.metadataDirty = true;
+    this.scheduleMetadataCheckpoint();
+    try {
+      this._onAppend?.(appendEvent);
+    } catch {
+    }
+    const critical = isCriticalEvent(appendEvent);
+    if (!this.buffer.push(appendEvent)) {
+      this.buffer.cancelTimer();
+      void this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0).then(() => {
+        if (this.buffer.push(appendEvent)) {
+          if (!critical) return;
+          this.buffer.cancelTimer();
+          void this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0);
+          return;
+        }
+        void this.buffer.drainWriteChain().then(() => this.buffer.enqueueWrite(`${JSON.stringify(appendEvent)}
+`)).then(() => {
+          if (!critical) return;
+          return this.handle.datasync().catch(() => void 0);
+        }).catch(() => void 0);
+      });
+    } else if (critical || this.buffer.shouldFlushNow()) {
+      this.buffer.cancelTimer();
+      void this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => {
+      });
+    } else {
+      this.buffer.scheduleFlush(this.closed);
+    }
+  }
+  recordFileChange(input) {
+    if (this.closed) return;
+    if (this.activePromptIndex === null) {
+      const bytes = Buffer.byteLength(input.path, "utf8") + (input.before ? Buffer.byteLength(input.before, "utf8") : 0) + (input.after ? Buffer.byteLength(input.after, "utf8") : 0);
+      if (this.pendingFileSnapshots.length >= _FileSessionWriter.PENDING_FILE_SNAPSHOT_MAX_ENTRIES || bytes > _FileSessionWriter.PENDING_FILE_SNAPSHOT_MAX_BYTES || this.pendingFileSnapshotBytes + bytes > _FileSessionWriter.PENDING_FILE_SNAPSHOT_MAX_BYTES) {
+        console.warn(
+          JSON.stringify({
+            level: "error",
+            event: "session.file_snapshot_buffer_overflow",
+            sessionId: this.id,
+            bufferedFiles: this.pendingFileSnapshots.length,
+            bufferedBytes: this.pendingFileSnapshotBytes,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+        return;
+      }
+      this.pendingFileSnapshots.push(input);
+      this.pendingFileSnapshotBytes += bytes;
+      return;
+    }
+    const event = {
+      type: "file_snapshot",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      promptIndex: this.activePromptIndex,
+      files: [input]
+    };
+    this.bufferSynchronousEvent(event);
+  }
+  recordFileObservation(input) {
+    if (!input.path || !/^[a-f\d]{64}$/i.test(input.hash) || !Number.isFinite(input.mtimeMs))
+      return;
+    this.bufferSynchronousEvent({
+      type: "file_observation",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      path: input.path,
+      hash: input.hash.toLowerCase(),
+      mtimeMs: input.mtimeMs,
+      source: input.source
+    });
+  }
+  recordSideEffect(input) {
+    this.append({
+      type: "side_effect",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      toolUseId: input.toolUseId,
+      toolName: input.toolName,
+      input: input.input,
+      outcome: input.outcome,
+      risk: input.risk
+    }).catch(() => {
+    });
+  }
+  get pendingToolUses() {
+    return this.summaryTracker.pendingToolUses;
+  }
+  async writeSessionStartLazy() {
+    this.buffer.push({
+      type: this.resumed ? "session_resumed" : "session_start",
+      ts: this.startedAt,
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    });
+  }
+  /**
+   * Arm the mid-session metadata checkpoint timer if it is not already armed.
+   * Called after every observed event; the timer itself is unref'd so an idle
+   * session never keeps the process alive for a cosmetic sidecar refresh.
+   */
+  scheduleMetadataCheckpoint() {
+    if (this.closed || this.metadataTimer) return;
+    if (this.metadataCheckpointMs <= 0) return;
+    if (!this.onMetadataCheckpointCb && !this.manifestFile) {
+      if (!this._checkpointNoSinkWarned) {
+        this._checkpointNoSinkWarned = true;
+        console.warn(
+          JSON.stringify({
+            level: "warn",
+            event: "session.metadata_checkpoint_no_sink",
+            sessionId: this.id,
+            message: "metadataCheckpointMs set but neither onMetadataCheckpoint nor manifestFile configured; mid-session checkpoints disabled.",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        );
+      }
+      return;
+    }
+    this.metadataTimer = setTimeout(() => {
+      this.metadataTimer = null;
+      void this.runMetadataCheckpoint();
+    }, this.metadataCheckpointMs);
+    this.metadataTimer.unref?.();
+  }
+  /**
+   * Persist a mid-session summary snapshot: the `.summary.json` sidecar under
+   * the manifest lock, then the store-level index row / catalog upsert via
+   * `onMetadataCheckpoint`. Runs at most once per throttle interval and only
+   * when summary counters changed since the last checkpoint; a failed
+   * checkpoint stays dirty and retries on the next armed tick.
+   */
+  runMetadataCheckpoint() {
+    if (this.closed || !this.metadataDirty) return Promise.resolve();
+    if (this.metadataCheckpointInFlight) return this.metadataCheckpointInFlight;
+    const {
+      endedAt: _priorEndedAt,
+      outcome: _priorOutcome,
+      ...snapshot
+    } = this.summaryTracker.snapshot();
+    const run = (async () => {
+      const t0 = Date.now();
+      let outcome = "success";
+      let errorMsg;
+      try {
+        if (this.manifestFile) {
+          await withFileLock(this.manifestFile, async () => {
+            await atomicWrite(this.manifestFile, JSON.stringify(snapshot), { mode: 384 });
+          });
+        }
+        this.metadataDirty = false;
+        await this.onMetadataCheckpointCb?.(snapshot);
+        if (this.metadataDirty && !this.closed) this.scheduleMetadataCheckpoint();
+      } catch (err) {
+        outcome = "failure";
+        errorMsg = toErrorMessage(err);
+        this.metadataDirty = true;
+        this.scheduleMetadataCheckpoint();
+      } finally {
+        this.metadataCheckpointInFlight = null;
+        this.events?.emit("storage.write", {
+          sessionId: this.id,
+          store: "session",
+          filePath: this.manifestFile || this.filePath,
+          operation: "metadata_checkpoint",
+          outcome,
+          durationMs: Date.now() - t0,
+          ...errorMsg !== void 0 ? { error: errorMsg } : {},
+          ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+        });
+      }
+    })();
+    this.metadataCheckpointInFlight = run;
+    return run;
+  }
+  async append(event) {
+    if (this.closed) return;
+    await this.ensureInit();
+    const scrubbed = scrubSessionWriterEvent(event, this.secretScrubber);
+    this.summaryTracker.observe(scrubbed);
+    this.metadataDirty = true;
+    this.scheduleMetadataCheckpoint();
+    try {
+      this._onAppend?.(scrubbed);
+    } catch {
+    }
+    let pushed = this.buffer.push(scrubbed);
+    if (!pushed) {
+      this.buffer.cancelTimer();
+      await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0);
+      pushed = this.buffer.push(scrubbed);
+      if (!pushed) {
+        await this.buffer.drainWriteChain().then(() => this.buffer.enqueueWrite(`${JSON.stringify(scrubbed)}
+`)).then(() => {
+          if (!isCriticalEvent(scrubbed)) return;
+          return this.handle.datasync().catch(() => void 0);
+        }).catch(() => void 0);
+      }
+    }
+    if (isCriticalEvent(scrubbed) || this.buffer.shouldFlushNow()) {
+      this.buffer.cancelTimer();
+      await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => {
+      });
+    } else {
+      this.buffer.scheduleFlush(this.closed);
+    }
+  }
+  async appendBatch(events) {
+    if (this.closed || events.length === 0) return;
+    await this.ensureInit();
+    const scrubbedBatch = [];
+    for (const event of events) {
+      const scrubbed = scrubSessionWriterEvent(event, this.secretScrubber);
+      this.summaryTracker.observe(scrubbed);
+      try {
+        this._onAppend?.(scrubbed);
+      } catch {
+      }
+      let pushed = this.buffer.push(scrubbed);
+      if (!pushed) {
+        this.buffer.cancelTimer();
+        await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => void 0);
+        pushed = this.buffer.push(scrubbed);
+        if (!pushed) {
+          await this.buffer.drainWriteChain().then(() => this.buffer.enqueueWrite(`${JSON.stringify(scrubbed)}
+`)).then(() => {
+            if (!isCriticalEvent(scrubbed)) return;
+            return this.handle.datasync().catch(() => void 0);
+          }).catch(() => void 0);
+        }
+      }
+      scrubbedBatch.push(scrubbed);
+    }
+    if (scrubbedBatch.length > 0) {
+      this.metadataDirty = true;
+      this.scheduleMetadataCheckpoint();
+    }
+    try {
+      this._onAppendBatch?.(scrubbedBatch);
+    } catch {
+    }
+    const hasCritical = scrubbedBatch.some(isCriticalEvent);
+    if (hasCritical || this.buffer.shouldFlushNow()) {
+      this.buffer.cancelTimer();
+      await this.buffer.flushBuffer(this.closed, { datasync: true }).catch(() => {
+      });
+    } else {
+      this.buffer.scheduleFlush(this.closed);
+    }
+  }
+  /**
+   * Flush buffered events to disk immediately. Critical events
+   * (user_input, llm_response, checkpoint, in_flight_*) already flush
+   * themselves inside append()/appendBatch(), so calling this matters for
+   * non-critical tails that would otherwise sit in the in-memory buffer
+   * for up to 500ms.
+   *
+   * Idempotent — cancels any pending timer, writes whatever has accumulated,
+   * then asks the OS to synchronize the file data before resolving. Even an
+   * empty-buffer flush synchronizes any earlier timer-driven append.
+   */
+  async flush() {
+    if (this.closed) return;
+    this.buffer.cancelTimer();
+    await this.buffer.flushBuffer(this.closed, { datasync: true });
+    await this.buffer.drainWriteChain();
+    try {
+      await this.handle.datasync();
+    } catch (err) {
+      if (isClosedHandleError2(err)) {
+        this.handle = await fsp7.open(this.filePath, "a", 384);
+        return;
+      }
+      throw err;
+    }
+  }
+  /**
+   * Last-gasp synchronous drain for hard-exit paths (process.exit after
+   * rapid Ctrl+C). The async write chain cannot be awaited when the process
+   * is about to die, but whatever still sits in the in-memory buffer CAN be
+   * saved with a blocking append. A failed sync append leaves the buffer
+   * intact so a subsequent close()/flush() can retry. An in-flight async
+   * write may still be cut off by a hard exit.
+   */
+  flushSync() {
+    this.buffer.flushSync();
+  }
+  async close() {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.doClose().catch(async (err) => {
+      if (this.metadataTimer) {
+        clearTimeout(this.metadataTimer);
+        this.metadataTimer = null;
+      }
+      await this.metadataCheckpointInFlight?.catch(() => void 0);
+      this.closed = false;
+      this.closePromise = null;
+      if (this.buffer.length > 0) this.buffer.scheduleFlush(this.closed);
+      if (this.metadataDirty) this.scheduleMetadataCheckpoint();
+      throw err;
+    });
+    return this.closePromise;
+  }
+  async doClose() {
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
+    await this.ensureInit();
+    if (this.pendingFileSnapshots.length > 0) {
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
+      this.pendingFileSnapshots = [];
+      this.pendingFileSnapshotBytes = 0;
+    }
+    this.closed = true;
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
+    this.buffer.cancelTimer();
+    await this.buffer.flushBuffer(this.closed, { datasync: true });
+    await this.buffer.drainWriteChain();
+    try {
+      await this.handle.datasync();
+    } catch (err) {
+      if (!isClosedHandleError2(err)) throw err;
+    }
+    const summary = await this.summaryTracker.finalize();
+    const manifestT0 = Date.now();
+    let manifestOutcome = "success";
+    let manifestError;
+    const idxT0 = Date.now();
+    let idxOutcome = "success";
+    let idxError;
+    const persistSummary = async () => {
+      if (this.manifestFile) {
+        try {
+          await atomicWrite(this.manifestFile, JSON.stringify(summary), { mode: 384 });
+        } catch (err) {
+          manifestOutcome = "failure";
+          manifestError = toErrorMessage(err);
+        }
+      }
+      try {
+        await this.onCloseCb?.(summary);
+      } catch (err) {
+        idxOutcome = "failure";
+        idxError = toErrorMessage(err);
+      }
+    };
+    if (this.manifestFile) await withFileLock(this.manifestFile, persistSummary);
+    else await persistSummary();
+    if (this.manifestFile) {
+      this.events?.emit("storage.write", {
+        sessionId: this.id,
+        store: "session",
+        filePath: this.manifestFile,
+        operation: "close",
+        outcome: manifestOutcome,
+        durationMs: Date.now() - manifestT0,
+        ...manifestError !== void 0 ? { error: manifestError } : {},
+        ...this.traceId !== void 0 ? { traceId: this.traceId } : {}
+      });
+    }
+    this.events?.emit("storage.write", {
+      sessionId: 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 } : {}
+    });
+    try {
+      await this.handle.close();
+    } catch {
+    }
+  }
+  async writeCheckpoint(promptIndex, promptPreview) {
+    const fileCount = this.pendingFileSnapshots.length;
+    if (fileCount > 0) {
+      await this.writeFileSnapshot(promptIndex, [...this.pendingFileSnapshots]);
+      this.pendingFileSnapshots = [];
+      this.pendingFileSnapshotBytes = 0;
+    }
+    let workspaceCheckpoint;
+    try {
+      workspaceCheckpoint = await this.checkpointCas?.capture(this.id, promptIndex);
+    } catch (err) {
+      console.warn(
+        JSON.stringify({
+          level: "warn",
+          event: "session.workspace_checkpoint_capture_failed",
+          sessionId: this.id,
+          promptIndex,
+          message: toErrorMessage(err),
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        })
+      );
+    }
+    await this.append({
+      type: "checkpoint",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      promptIndex,
+      promptPreview,
+      ...workspaceCheckpoint ? { workspaceCheckpoint } : {}
+    });
+    this.activePromptIndex = promptIndex;
+    this.events?.emit("checkpoint.written", {
+      sessionId: this.id,
+      promptIndex,
+      promptPreview,
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      fileCount,
+      ...workspaceCheckpoint ? { workspaceCheckpoint } : {}
+    });
+  }
+  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, revertedFiles = []) {
+    if (!this.filePath) return 0;
+    this.buffer.cancelTimer();
+    await this.buffer.flushBuffer(this.closed, { datasync: true });
+    await this.buffer.drainWriteChain();
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
+    const plan = await findSessionCheckpointTruncatePlan(this.filePath, targetPromptIndex).catch(
+      (err) => {
+        this.scheduleMetadataCheckpoint();
+        throw err;
+      }
+    );
+    if (!plan) {
+      this.scheduleMetadataCheckpoint();
+      return 0;
+    }
+    await this.buffer.drainWriteChain();
+    try {
+      await this.handle.close();
+    } catch {
+    }
+    try {
+      await rewriteSessionToCheckpoint(this.filePath, plan.checkpointByteOffset);
+      this.handle = await fsp7.open(this.filePath, "a", 384);
+    } catch (err) {
+      this.handle = await fsp7.open(this.filePath, "a", 384).catch(() => this.handle);
+      this.scheduleMetadataCheckpoint();
+      throw err;
+    }
+    await this.summaryTracker.recomputeFromDisk(this.filePath);
+    const reverted = [...revertedFiles];
+    await this.append({
+      type: "rewound",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      toPromptIndex: targetPromptIndex,
+      revertedFiles: reverted
+    });
+    this.activePromptIndex = targetPromptIndex;
+    this.events?.emit("session.rewound", {
+      sessionId: this.id,
+      toPromptIndex: targetPromptIndex,
+      revertedFiles: reverted,
+      removedEvents: plan.removedCount
+    });
+    return plan.removedCount;
+  }
+  async clearSession() {
+    if (!this.filePath) return;
+    this.buffer.cancelTimer();
+    await this.buffer.drainFlushPromise();
+    this.buffer.clear();
+    await this.buffer.drainWriteChain();
+    if (this.metadataTimer) {
+      clearTimeout(this.metadataTimer);
+      this.metadataTimer = null;
+    }
+    await this.metadataCheckpointInFlight?.catch(() => void 0);
+    const resetAt = (/* @__PURE__ */ new Date()).toISOString();
+    const record = `${JSON.stringify({
+      type: "session_start",
+      ts: resetAt,
+      id: this.id,
+      model: this.meta.model ?? "unknown",
+      provider: this.meta.provider ?? "unknown"
+    })}
+`;
+    await this.handle.close();
+    await atomicWrite(this.filePath, record, { mode: 384 });
+    this.summaryTracker.reset(resetAt);
+    this.metadataDirty = true;
+    this.scheduleMetadataCheckpoint();
+    this.activePromptIndex = null;
+    this.pendingFileSnapshots = [];
+    this.pendingFileSnapshotBytes = 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", {
+      sessionId: this.id,
+      context,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * 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) {
+    if (this.pendingFileSnapshots.length > 0) {
+      await this.writeFileSnapshot(this.activePromptIndex ?? 0, [...this.pendingFileSnapshots]);
+      this.pendingFileSnapshots = [];
+      this.pendingFileSnapshotBytes = 0;
+    }
+    await this.append({
+      type: "in_flight_end",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      reason
+    });
+    this.events?.emit("in_flight.ended", {
+      sessionId: this.id,
+      reason,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
+
+// src/storage/session-store/delete-session-artifacts.ts
+import * as fsp8 from "node:fs/promises";
+import * as path7 from "node:path";
+
+// src/storage/session-store/paths.ts
+import * as path6 from "node:path";
+function sessionPath(storeDir, id, ext) {
+  return sessionScopedPath(storeDir, id, ext);
+}
+function shardManifestPath(storeDir, shardKey) {
+  return shardKey ? path6.join(storeDir, shardKey, "_manifest.json") : path6.join(storeDir, "_manifest.json");
+}
+function shardKeyForSessionId(id) {
+  const dirName = path6.dirname(id);
+  return dirName === "." ? "" : dirName;
+}
+async function ensureShardDir(storeDir, id) {
+  const dirPath = path6.dirname(sessionScopedPath(storeDir, id, ""));
+  await ensureDir(dirPath);
+  return dirPath;
+}
+
+// src/storage/session-store/delete-session-artifacts.ts
+async function deleteSessionArtifacts({
+  rootDir,
+  id,
+  jsonlPath
+}) {
+  const shardDir = path7.dirname(jsonlPath);
+  const base = path7.basename(id);
+  const sessDir = path7.join(shardDir, base);
+  const deletions = [
+    fsp8.unlink(jsonlPath),
+    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"))
+  ];
+  const results = await Promise.allSettled(deletions);
+  for (const result of results) {
+    if (result.status === "rejected") {
+      warnDeleteFailure(id, result.reason);
+    }
+  }
+  await fsp8.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()
+      })
+    );
+  });
+}
+function warnDeleteFailure(id, reason) {
+  const msg = reason instanceof Error ? reason.message : String(reason);
+  if (reason?.code === "ENOENT") return;
+  console.warn(
+    JSON.stringify({
+      level: "warn",
+      event: "session_store.delete_failed",
+      sessionId: id,
+      message: msg,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    })
+  );
+}
+
+// src/storage/session-store/delete-session-guards.ts
+async function assertSessionCanBeDeleted(sessionId, isSessionInUse) {
+  if (!isSessionInUse) return;
+  const reason = await isSessionInUse(sessionId);
+  if (reason) {
+    throw new Error(`Session ${sessionId} is in use (${reason}) and cannot be deleted.`);
+  }
+}
+
+// src/storage/session-store/events.ts
+function emitSessionStoreRead(events, sessionId, filePath, operation, outcome, durationMs, error) {
+  events?.emit("storage.read", {
+    sessionId,
+    store: "session",
+    filePath,
+    operation,
+    outcome,
+    durationMs,
+    ...error !== void 0 ? { error } : {}
+  });
+}
+function emitSessionStoreWrite(events, sessionId, filePath, operation, outcome, durationMs, eventCount, error) {
+  events?.emit("storage.write", {
+    sessionId,
+    store: "session",
+    filePath,
+    operation,
+    outcome,
+    durationMs,
+    ...eventCount !== void 0 ? { eventCount } : {},
+    ...error !== void 0 ? { error } : {}
+  });
+}
+function emitSessionStoreError(events, sessionId, filePath, operation, error, recoverable) {
+  events?.emit("storage.error", {
+    sessionId,
+    store: "session",
+    filePath,
+    operation,
+    error,
+    recoverable
+  });
+}
+
+// src/storage/session-store/fork-session.ts
+import { createHash as createHash2 } from "node:crypto";
+
+// src/storage/session-store/replay.ts
+function isReplayableMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return (candidate.role === "user" || candidate.role === "assistant" || candidate.role === "system") && (typeof candidate.content === "string" || Array.isArray(candidate.content));
+}
+function trackMessageToolState(message, openToolUses) {
+  if (!Array.isArray(message.content)) return;
+  for (const block of message.content) {
+    if (block.type === "tool_use") openToolUses.add(block.id);
+    else if (block.type === "tool_result") openToolUses.delete(block.tool_use_id);
+  }
+}
+function replayableMessage(value, fallbackTs) {
+  if (!isReplayableMessage(value)) return null;
+  const { _estTokens: _ignored, ...message } = value;
+  return message.ts === void 0 && fallbackTs ? { ...message, ts: fallbackTs } : message;
+}
+function applyContextSnapshot(target, openToolUses, snapshot) {
+  if (!Array.isArray(snapshot) || !snapshot.every(isReplayableMessage)) return false;
+  target.length = 0;
+  openToolUses.clear();
+  for (const raw of snapshot) {
+    const message = replayableMessage(raw);
+    if (!message) return false;
+    target.push(message);
+    trackMessageToolState(message, openToolUses);
+  }
+  return true;
+}
+function inheritsIntoFork(event) {
+  switch (event.type) {
+    case "session_start":
+    case "session_resumed":
+    case "session_forked":
+    case "session_end":
+    case "in_flight_start":
+    case "in_flight_end":
+    case "rewound":
+      return false;
+    // Parent snapshots describe mutations owned by the parent journal. A
+    // child that shares the current workspace must not inherit authority to
+    // rewind those historical side effects.
+    case "file_snapshot":
+      return false;
+    default:
+      return true;
+  }
+}
+
+// src/storage/session-store/fork-session.ts
+async function forkSession(host, id, opts = {}) {
+  const parentEvents = await host.readRawEvents(id);
+  let boundary = parentEvents.length - 1;
+  let targetCheckpoint;
+  if (opts.checkpointPromptIndex !== void 0) {
+    boundary = -1;
+    for (let i = 0; i < parentEvents.length; i++) {
+      const event = parentEvents[i];
+      if (event?.type === "checkpoint" && event.promptIndex === opts.checkpointPromptIndex) {
+        boundary = i;
+        targetCheckpoint = event;
+      }
+    }
+    if (boundary === -1) {
+      throw new Error(`Checkpoint ${opts.checkpointPromptIndex} not found in session "${id}"`);
+    }
+  }
+  const parentPrefix = parentEvents.slice(0, boundary + 1);
+  const workspaceCheckpoint = targetCheckpoint?.workspaceCheckpoint;
+  const checkpointHash = createHash2("sha256").update(parentPrefix.map((event) => JSON.stringify(event)).join("\n") + "\n", "utf8").digest("hex");
+  const inherited = parentPrefix.filter(inheritsIntoFork);
+  const activeIdentity = [...parentEvents].reverse().find(
+    (event) => event.type === "session_start" || event.type === "session_resumed"
+  );
+  const writer = await host.create({
+    id: "",
+    title: "",
+    model: activeIdentity?.model,
+    provider: activeIdentity?.provider
+  });
+  try {
+    await writer.append({
+      type: "session_forked",
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      parentSessionId: id,
+      parentCheckpointPromptIndex: opts.checkpointPromptIndex,
+      parentCheckpointHash: checkpointHash,
+      workspace: "shared-current",
+      workspaceCheckpointHash: workspaceCheckpoint?.manifestHash
+    });
+    const batchSize = 250;
+    for (let offset = 0; offset < inherited.length; offset += batchSize) {
+      await writer.appendBatch(inherited.slice(offset, offset + batchSize));
+    }
+    await writer.flush();
+    await writer.close();
+    const data = await host.load(writer.id);
+    return {
+      id: writer.id,
+      data,
+      parentSessionId: id,
+      checkpointPromptIndex: opts.checkpointPromptIndex,
+      checkpointHash,
+      workspace: "shared-current",
+      workspaceCheckpoint
+    };
+  } catch (err) {
+    await writer.close().catch(() => void 0);
+    await host.delete(writer.id).catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/storage/session-store/load-cache.ts
+var LOAD_CACHE_MAX_ENTRIES = 50;
+var LOAD_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+var SessionLoadCache = class {
+  constructor(entries = /* @__PURE__ */ new Map()) {
+    this.entries = entries;
+  }
+  entries;
+  bytes = 0;
+  clear(sessionId) {
+    if (sessionId !== void 0) {
+      this.delete(sessionId);
+      return;
+    }
+    this.entries.clear();
+    this.bytes = 0;
+  }
+  /**
+   * A hit hands back fresh `messages` / `events` arrays over the cached
+   * contents.
+   *
+   * The entry outlives every caller, and callers treat what they get as their
+   * own: `resume()` passes `messages` straight into a live conversation, and
+   * anything walking `events` may splice it. Returning the cached arrays
+   * themselves let one caller's edit rewrite what the next one loads. The
+   * elements are still shared — copying them would defeat the cache — so
+   * entries remain read-only *contents* behind private containers.
+   */
+  getFresh(id, stat11, full) {
+    const cached = this.entries.get(id);
+    if (!cached || cached.mtimeMs !== stat11.mtimeMs || cached.size !== stat11.size) {
+      return null;
+    }
+    this.entries.delete(id);
+    this.entries.set(id, cached);
+    return {
+      ...cached.data,
+      messages: full ? [...cached.data.messages] : [],
+      events: [...cached.data.events]
+    };
+  }
+  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 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;
+    }
+  }
+  delete(sessionId) {
+    const cached = this.entries.get(sessionId);
+    if (cached) this.bytes = Math.max(0, this.bytes - cached.size);
+    this.entries.delete(sessionId);
+  }
+};
+
+// src/storage/session-store/load-session-data.ts
+import { createReadStream as createReadStream3 } from "node:fs";
+import { createInterface as createInterface3 } from "node:readline";
+
+// src/storage/session-tool-call-ends.ts
+function extractToolCallEnds(events) {
+  const out = [];
+  for (const event of events) {
+    if (event.type !== "tool_call_end") continue;
+    out.push({
+      name: event.name,
+      id: event.id,
+      durationMs: event.durationMs,
+      ok: event.ok ?? true,
+      outputBytes: event.outputBytes ?? event.outputSize,
+      outputTokens: event.outputTokens,
+      outputLines: event.outputLines
+    });
+  }
+  return out;
+}
+
+// src/storage/session-store/load-session-data.ts
+var DEFAULT_MAX_RETAINED_EVENT_BYTES = 96 * 1024 * 1024;
+var EVICT_TO_FRACTION = 0.9;
+var SNAPSHOT_ENVELOPE_BYTES = 256;
+async function loadSessionDataFromFile(params) {
+  const events = [];
+  const eventBytes = [];
+  const eventBudget = params.maxRetainedEventBytes ?? DEFAULT_MAX_RETAINED_EVENT_BYTES;
+  const evictTo = Math.floor(eventBudget * EVICT_TO_FRACTION);
+  let retainedBytes = 0;
+  let eventsDropped = 0;
+  let lastSnapshotAbsIndex = -1;
+  let sessionStartEvent;
+  let sessionEndEvent;
+  let sessionModel;
+  let sessionProvider;
+  let sessionPendingToolUses;
+  let sessionForkedEvent;
+  const messages = params.full ? [] : void 0;
+  const openToolUses = params.full ? /* @__PURE__ */ new Set() : void 0;
+  let exactJournalActive = false;
+  let usage = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+  let lastSnapshot;
+  const stream = createReadStream3(params.file, { encoding: "utf8" });
+  const rl = createInterface3({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      try {
+        const parsed = JSON.parse(line);
+        if (!isSessionEventLike(parsed)) continue;
+        const ev = scrubPersistedSessionEvent(parsed, params.secretScrubber);
+        events.push(ev);
+        eventBytes.push(line.length);
+        retainedBytes += line.length;
+        if (isSnapshotEvent(ev)) {
+          if (lastSnapshot !== void 0) {
+            stripSnapshotPayload(lastSnapshot);
+            const slot = lastSnapshotAbsIndex - eventsDropped;
+            if (slot >= 0 && slot < eventBytes.length) {
+              const refund = eventBytes[slot] - SNAPSHOT_ENVELOPE_BYTES;
+              if (refund > 0) {
+                retainedBytes -= refund;
+                eventBytes[slot] = SNAPSHOT_ENVELOPE_BYTES;
+              }
+            }
+          }
+          lastSnapshot = ev;
+          lastSnapshotAbsIndex = eventsDropped + events.length - 1;
+        }
+        if (retainedBytes > eventBudget) {
+          let cut = 0;
+          while (cut < eventBytes.length && retainedBytes > evictTo) {
+            retainedBytes -= eventBytes[cut];
+            cut++;
+          }
+          events.splice(0, cut);
+          eventBytes.splice(0, cut);
+          eventsDropped += cut;
+        }
+        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 === "session_forked" && !sessionForkedEvent) {
+          sessionForkedEvent = ev;
+        }
+        if (params.full && messages !== void 0 && openToolUses !== void 0) {
+          const replayState = replaySessionEvent({
+            ev,
+            id: params.id,
+            events: params.events,
+            messages,
+            openToolUses,
+            exactJournalActive,
+            usage
+          });
+          exactJournalActive = replayState.exactJournalActive;
+          usage = replayState.usage ?? usage;
+        } else if (ev.type === "llm_response") {
+          usage = accumulateUsage(usage, ev);
+        }
+      } catch {
+      }
+    }
+  } finally {
+    rl.close();
+    stream.close();
+  }
+  let finalMessages = [];
+  if (params.full && messages !== void 0 && openToolUses !== void 0) {
+    if (openToolUses.size > 0) {
+      params.events?.emit("session.damaged", {
+        sessionId: params.id,
+        detail: `${openToolUses.size} tool_use blocks without matching results - replay repaired`
+      });
+    }
+    const repaired = repairToolUseAdjacency(messages);
+    if (repaired.report.changed) {
+      params.events?.emit("session.damaged", {
+        sessionId: params.id,
+        detail: `Repaired replay adjacency: removed ${repaired.report.removedToolUses.length} tool_use, ${repaired.report.removedToolResults.length} tool_result, ${repaired.report.removedMessages} empty messages`
+      });
+    }
+    finalMessages = repaired.messages;
+  }
+  const meta = {
+    id: params.id,
+    startedAt: sessionStartEvent?.ts ?? (/* @__PURE__ */ new Date(0)).toISOString(),
+    endedAt: sessionEndEvent?.ts,
+    model: sessionModel,
+    provider: sessionProvider,
+    pendingToolUses: sessionPendingToolUses,
+    forkedFrom: sessionForkedEvent ? {
+      sessionId: sessionForkedEvent.parentSessionId,
+      checkpointPromptIndex: sessionForkedEvent.parentCheckpointPromptIndex,
+      checkpointHash: sessionForkedEvent.parentCheckpointHash,
+      workspace: sessionForkedEvent.workspace,
+      workspaceCheckpointHash: sessionForkedEvent.workspaceCheckpointHash
+    } : void 0
+  };
+  const toolCallEnds = extractToolCallEnds(events);
+  const pendingToolUseCount = openToolUses && openToolUses.size > 0 ? openToolUses.size : void 0;
+  return {
+    metadata: meta,
+    events,
+    messages: finalMessages,
+    usage,
+    toolCallEnds,
+    ...pendingToolUseCount !== void 0 ? { pendingToolUseCount } : {},
+    ...eventsDropped > 0 ? { eventsDropped } : {}
+  };
+}
+function isSnapshotEvent(event) {
+  return event.type === "messages_replaced" || event.type === "context_snapshot";
+}
+function stripSnapshotPayload(event) {
+  if (event.messages.length === 0) return;
+  event.messagesOmitted = event.messages.length;
+  event.messages = [];
+}
+function isStrippedSnapshot(event) {
+  return event.messages.length === 0 && typeof event.messagesOmitted === "number" && event.messagesOmitted > 0;
+}
+function isSessionEventLike(value) {
+  return value !== null && typeof value === "object" && typeof value.type === "string" && typeof value.ts === "string";
+}
+function replaySessionEvent(params) {
+  const { ev, messages, openToolUses } = params;
+  let exactJournalActive = params.exactJournalActive;
+  if (ev.type === "message_appended" && ev.version === 1) {
+    const message = replayableMessage(ev.message, ev.ts);
+    if (message) {
+      if (!exactJournalActive) {
+        messages.length = 0;
+        openToolUses.clear();
+        exactJournalActive = true;
+      }
+      messages.push(message);
+      trackMessageToolState(message, openToolUses);
+    } else {
+      emitDamaged(params, "Ignored malformed message_appended event");
+    }
+  } 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;
+      openToolUses.clear();
+      for (const current of messages) trackMessageToolState(current, openToolUses);
+    } else {
+      emitDamaged(params, `Ignored malformed message_updated event at index ${ev.index}`);
+    }
+  } else if (ev.type === "messages_replaced" && ev.version === 1) {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored messages_replaced event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (applyContextSnapshot(messages, openToolUses, ev.messages)) {
+      exactJournalActive = true;
+    } 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));
+      openToolUses.clear();
+      for (const current of messages) trackMessageToolState(current, openToolUses);
+    } else if (!exactJournalActive) {
+      emitDamaged(params, "Ignored messages_dropped event outside the exact journal");
+    } else {
+      emitDamaged(params, `Ignored malformed messages_dropped event (count ${String(ev.count)})`);
+    }
+  } else if (ev.type === "context_snapshot") {
+    if (isStrippedSnapshot(ev)) {
+      emitDamaged(
+        params,
+        `Ignored context_snapshot event whose payload was stripped before persistence (${String(ev.messagesOmitted)} messages)`
+      );
+    } else if (!applyContextSnapshot(messages, openToolUses, ev.messages)) {
+      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") {
+    emitDamaged(params, `Ignored ${ev.type} event with unsupported version`);
+  } else if (!exactJournalActive && ev.type === "user_input") {
+    openToolUses.clear();
+    messages.push({ role: "user", content: ev.content, ts: ev.ts });
+  } else if (ev.type === "llm_response") {
+    if (!exactJournalActive) {
+      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);
+      }
+    }
+    return { exactJournalActive, 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 };
+    }
+    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 });
+    }
+  }
+  return { exactJournalActive };
+}
+function accumulateUsage(usage, ev) {
+  return {
+    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)
+  };
+}
+function emitDamaged(params, detail) {
+  params.events?.emit("session.damaged", {
+    sessionId: params.id,
+    detail
+  });
+}
+
+// src/storage/session-store/prune-helpers.ts
+import * as fsp9 from "node:fs/promises";
+import * as path8 from "node:path";
+function isPrunableSessionJsonl(name) {
+  return isSessionTranscriptFileName(name);
+}
+async function pruneSessionFiles(storeDir, maxAgeDays, deleteSession) {
+  const cutoff = Date.now() - maxAgeDays * 864e5;
+  let deleted = 0;
+  const pruneFile = async (dir, name, prefix) => {
+    const jsonlPath = path8.join(dir, name);
+    try {
+      const stat11 = await fsp9.stat(jsonlPath);
+      if (stat11.mtimeMs >= cutoff) return;
+    } catch {
+      return;
+    }
+    const base = name.replace(/\.jsonl$/, "");
+    const id = prefix ? `${prefix}/${base}` : base;
+    await deleteSession(id);
+    deleted++;
+  };
+  const entries = await fsp9.readdir(storeDir, { withFileTypes: true }).catch(() => []);
+  for (const entry of entries) {
+    if (entry.isFile()) {
+      if (isPrunableSessionJsonl(entry.name)) await pruneFile(storeDir, entry.name, "");
+      continue;
+    }
+    if (!entry.isDirectory()) continue;
+    const dateDir = path8.join(storeDir, entry.name);
+    const files = await fsp9.readdir(dateDir, { withFileTypes: true }).catch(() => []);
+    for (const file of files) {
+      if (!file.isFile() || !isPrunableSessionJsonl(file.name)) continue;
+      await pruneFile(dateDir, file.name, entry.name);
+    }
+  }
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const dateDir = path8.join(storeDir, entry.name);
+    try {
+      const remaining = await fsp9.readdir(dateDir);
+      if (remaining.length === 0) {
+        await fsp9.rmdir(dateDir).catch(() => void 0);
+      }
+    } catch {
+    }
+  }
+  return deleted;
+}
+
+// src/storage/session-store/rename-session.ts
+import * as fsp10 from "node:fs/promises";
+async function executeRenameSession(params) {
+  const {
+    id,
+    name,
+    manifest,
+    jsonlPath,
+    events,
+    secretScrubber,
+    readSummaryManifest,
+    summaryFor,
+    appendToIndexStrict: appendToIndexStrict2
+  } = params;
+  const trimmed = sessionContentText(secretScrubber.scrub(name));
+  try {
+    await fsp10.stat(jsonlPath);
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      throw new Error(`Session not found: ${id}`);
+    }
+    throw err;
+  }
+  const t0 = Date.now();
+  let outcome = "success";
+  let errorMsg;
+  let updated;
+  try {
+    updated = await withFileLock(manifest, async () => {
+      const summary = await readSummaryManifest(id) ?? await summaryFor(id);
+      const { name: _drop, ...rest } = summary;
+      const next = trimmed ? { ...rest, name: trimmed } : rest;
+      await atomicWrite(manifest, JSON.stringify(next), { mode: 384 });
+      try {
+        await appendToIndexStrict2(next);
+      } catch (err) {
+        await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 });
+        throw err;
+      }
+      return next;
+    });
+  } catch (err) {
+    outcome = "failure";
+    errorMsg = toErrorMessage(err);
+    emitSessionStoreError(events, id, manifest, "rename", errorMsg, false);
+    throw err;
+  } finally {
+    emitSessionStoreWrite(
+      events,
+      id,
+      manifest,
+      "rename",
+      outcome,
+      Date.now() - t0,
+      void 0,
+      errorMsg
+    );
+  }
+  return updated;
+}
+
+// src/storage/session-store/resume-session.ts
+import * as fsp12 from "node:fs/promises";
+import * as path10 from "node:path";
+
+// src/storage/session-resume-validation.ts
+import { createHash as createHash3 } from "node:crypto";
+import * as fsp11 from "node:fs/promises";
+import * as path9 from "node:path";
+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);
+}
+function errno(err) {
+  return err && typeof err === "object" && "code" in err ? String(err.code) : void 0;
+}
+function latestObservations(events, projectRoot) {
+  const latest = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.type !== "file_observation" || typeof event.path !== "string" || event.path.length === 0 || typeof event.hash !== "string" || !/^[a-f\d]{64}$/i.test(event.hash)) {
+      continue;
+    }
+    const normalized = path9.resolve(projectRoot, event.path);
+    latest.set(normalized, {
+      path: normalized,
+      hash: event.hash.toLowerCase(),
+      ts: event.ts
+    });
+  }
+  return [...latest.values()];
+}
+async function validateOne(observation, lexicalRoot, realRoot) {
+  const base = {
+    path: observation.path,
+    observedAt: observation.ts,
+    expectedHash: observation.hash
+  };
+  if (!isInside2(lexicalRoot, observation.path)) {
+    return {
+      ...base,
+      status: "outside_project",
+      detail: "Recorded path is outside the active project root."
+    };
+  }
+  let realFile;
+  try {
+    realFile = await fsp11.realpath(observation.path);
+  } catch (err) {
+    if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
+    return { ...base, status: "unreadable", detail: toErrorMessage(err) };
+  }
+  if (!isInside2(realRoot, realFile)) {
+    return {
+      ...base,
+      status: "outside_project",
+      detail: "Recorded path resolves through a symlink outside the active project root."
+    };
+  }
+  try {
+    const stat11 = await fsp11.stat(realFile);
+    if (!stat11.isFile()) {
+      return { ...base, status: "unreadable", detail: "Path is no longer a regular file." };
+    }
+    if (stat11.size > MAX_REVALIDATE_BYTES) {
+      return {
+        ...base,
+        status: "unreadable",
+        detail: `File now exceeds the ${MAX_REVALIDATE_BYTES}-byte validation limit.`
+      };
+    }
+    const content = await fsp11.readFile(realFile, "utf8");
+    const actualHash = createHash3("sha256").update(content, "utf8").digest("hex");
+    if (actualHash === observation.hash) return null;
+    return { ...base, status: "modified", actualHash };
+  } catch (err) {
+    if (errno(err) === "ENOENT") return { ...base, status: "deleted" };
+    return { ...base, status: "unreadable", detail: toErrorMessage(err) };
+  }
+}
+async function validateResumeFileObservations(events, projectRoot) {
+  const lexicalRoot = path9.resolve(projectRoot);
+  const realRoot = await fsp11.realpath(lexicalRoot).catch(() => lexicalRoot);
+  const observations = latestObservations(events, lexicalRoot);
+  const results = await mapWithConcurrency(
+    observations,
+    VALIDATION_CONCURRENCY,
+    (observation) => validateOne(observation, lexicalRoot, realRoot)
+  );
+  return {
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    checkedFileCount: observations.length,
+    staleFiles: results.filter((entry) => entry !== null)
+  };
+}
+var RESUME_NOTICE_HEADERS = [
+  "[SESSION RESUME FILE VALIDATION]",
+  "[SESSION RESUME INTERRUPTED WORK]",
+  "[SESSION RESUME CRASH RECOVERY]"
+];
+function formatCrashRecoveryNotice(interruptedTools, lastContext) {
+  if (interruptedTools.length === 0) return null;
+  const plural = interruptedTools.length === 1 ? "call was" : "calls were";
+  const lines = [
+    "[SESSION RESUME CRASH RECOVERY]",
+    `The previous run stopped mid-iteration${lastContext ? ` while: ${lastContext}` : ""} \u2014 ${interruptedTools.length} tool ${plural} left without a recorded result.`,
+    "Those interrupted tool calls were removed from the restored conversation and were NOT re-executed; their workspace side effects were NOT rolled back."
+  ];
+  for (const tool of interruptedTools.slice(0, NOTICE_PATH_LIMIT)) {
+    lines.push(`- ${tool.name}${tool.argsSummary ? ` (${tool.argsSummary})` : ""}`);
+  }
+  return lines.join("\n");
+}
+function isResumeNoticeMessage(message) {
+  if (message.role !== "system" || typeof message.content !== "string") return false;
+  return RESUME_NOTICE_HEADERS.some((header) => message.content === header || message.content.startsWith(`${header}
+`));
+}
+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;
+    return `- ${JSON.stringify(display)} [${entry.status}]`;
+  });
+  const omitted = validation.staleFiles.length - shown.length;
+  if (omitted > 0) shown.push(`- ... and ${omitted} more stale path(s)`);
+  return [
+    "[SESSION RESUME FILE VALIDATION]",
+    `Journal hash validation found ${validation.staleFiles.length} previously observed file(s) whose current state cannot be trusted.`,
+    "Prior tool results and reasoning based on these paths are stale. Re-read each relevant file before relying on it or editing it.",
+    ...shown
+  ].join("\n");
+}
+function formatInterruptedToolNotice(pendingToolUseCount) {
+  if (!Number.isFinite(pendingToolUseCount) || pendingToolUseCount <= 0) return null;
+  const plural = pendingToolUseCount === 1 ? "tool call was" : "tool calls were";
+  return [
+    "[SESSION RESUME INTERRUPTED WORK]",
+    `The previous run left ${pendingToolUseCount} ${plural} in flight \u2014 no result was recorded before it stopped (crash or interrupt).`,
+    "Those interrupted tool calls were removed from the restored conversation and were NOT re-executed. Re-run the work if it still needs doing."
+  ].join("\n");
+}
+
+// src/storage/session-store/summary-builder.ts
+import { createReadStream as createReadStream4 } from "node:fs";
+import { createInterface as createInterface4 } from "node:readline";
+async function summarizeSessionFile(opts) {
+  return summarizeSessionEventSequence({
+    id: opts.id,
+    events: iterateSessionEvents(opts.file, opts.secretScrubber),
+    mtime: opts.mtime
+  });
+}
+async function summarizeSessionEvents(opts) {
+  return summarizeSessionEventSequence(opts);
+}
+async function summarizeSessionEventSequence(opts) {
+  const { id, events, mtime } = opts;
+  try {
+    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;
+    let messageCount = 0;
+    let lastUserMessage;
+    let lastUserMessageMs = Number.NEGATIVE_INFINITY;
+    let lastActivityAt = startedAt;
+    let lastActivityMs = Date.parse(startedAt);
+    if (lastActivityMs === 0 || !Number.isFinite(lastActivityMs)) {
+      const mtimeMs = Date.parse(mtime);
+      if (Number.isFinite(mtimeMs) && mtimeMs > 0) {
+        lastActivityAt = mtime;
+        lastActivityMs = mtimeMs;
+      }
+    }
+    const toolBreakdown = {};
+    let outcome;
+    let lastEventType;
+    let hasError = false;
+    let sawStart = false;
+    for await (const e of events) {
+      lastEventType = e.type;
+      const eventActivityMs = Date.parse(e.ts);
+      if (Number.isFinite(eventActivityMs) && (!Number.isFinite(lastActivityMs) || eventActivityMs > lastActivityMs)) {
+        lastActivityAt = e.ts;
+        lastActivityMs = eventActivityMs;
+      }
+      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_resumed") {
+        if (!sawStart) {
+          sawStart = true;
+          startedAt = e.ts;
+        }
+        if (e.model) model = e.model;
+        if (e.provider) provider = e.provider;
+      } else if (e.type === "session_end") {
+        endedAt = e.ts;
+      } else if (e.type === "user_input") {
+        if (title === "(empty session)") title = userInputTitle(e.content);
+        const userMessageMs = Date.parse(e.ts);
+        if (!Number.isFinite(userMessageMs) || userMessageMs >= lastUserMessageMs) {
+          lastUserMessage = sessionContentPreview(e.content);
+          if (Number.isFinite(userMessageMs)) lastUserMessageMs = userMessageMs;
+        }
+        messageCount++;
+      } else if (e.type === "message_appended" && e.version === 1 && e.message) {
+        messageCount++;
+        if (e.message.role === "user") {
+          if (title === "(empty session)") title = userInputTitle(e.message.content);
+          const userMessageMs = Date.parse(e.ts);
+          if (!Number.isFinite(userMessageMs) || userMessageMs >= lastUserMessageMs) {
+            lastUserMessage = sessionContentPreview(e.message.content);
+            if (Number.isFinite(userMessageMs)) lastUserMessageMs = userMessageMs;
+          }
+        }
+      } else if (e.type === "llm_response") {
+        messageCount++;
+        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,
+      lastActivityAt,
+      messageCount,
+      ...lastUserMessage !== void 0 ? { lastUserMessage } : {},
+      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,
+      lastActivityAt: mtime,
+      messageCount: 0
+    };
+  }
+}
+async function* iterateSessionEvents(file, secretScrubber) {
+  const stream = createReadStream4(file, { encoding: "utf8" });
+  const lines = createInterface4({ 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 scrubPersistedSessionEvent(parsed, secretScrubber);
+        }
+      } catch {
+      }
+    }
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+
+// src/storage/session-store/resume-session.ts
+async function executeResumeSession(params) {
+  const {
+    canonicalId,
+    file,
+    projectRoot,
+    events,
+    secretScrubber,
+    checkpointCas,
+    onAppend,
+    onAppendBatch,
+    load,
+    readSummaryManifest,
+    searchEvents,
+    persistCatalogSummary,
+    logWarn,
+    sessionsDir
+  } = params;
+  const t0 = Date.now();
+  const data = await load(canonicalId);
+  const persistedSummary = await readSummaryManifest(canonicalId);
+  const fileStat = await fsp12.stat(file);
+  const eventsDropped = data.eventsDropped ?? 0;
+  const derivedSummary = eventsDropped > 0 ? await summarizeSessionFile({
+    id: canonicalId,
+    file,
+    mtime: fileStat.mtime.toISOString(),
+    secretScrubber
+  }) : await summarizeSessionEvents({
+    id: canonicalId,
+    events: data.events,
+    mtime: fileStat.mtime.toISOString()
+  });
+  const initialSummary = {
+    ...derivedSummary,
+    ...persistedSummary?.name !== void 0 ? { name: persistedSummary.name } : {}
+  };
+  let recoveryPlan = SessionRecovery.buildRecoveryPlan(data.events, canonicalId);
+  if (eventsDropped > 0 && sessionsDir) {
+    const fromDisk = await new SessionRecovery(sessionsDir).recover(canonicalId);
+    if (fromDisk) recoveryPlan = fromDisk;
+  }
+  const interruptedTools = recoveryPlan.stale ? extractInterruptedTools(recoveryPlan) : [];
+  const synthesizedResults = interruptedTools.flatMap(
+    (tool) => typeof tool.id === "string" ? [
+      {
+        type: "tool_result",
+        ts: (/* @__PURE__ */ new Date()).toISOString(),
+        id: tool.id,
+        content: "[interrupted] No result was recorded \u2014 the previous process stopped before this call completed. Re-run it if still needed.",
+        isError: true
+      }
+    ] : []
+  );
+  if (synthesizedResults.length > 0) data.events.push(...synthesizedResults);
+  const noticeMessages = [];
+  let resumeValidation;
+  if (projectRoot) {
+    try {
+      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) {
+        noticeMessages.push({
+          role: "system",
+          content: notice,
+          ts: resumeValidation.checkedAt
+        });
+      }
+    } catch (err) {
+      emitSessionStoreError(
+        events,
+        canonicalId,
+        file,
+        "resume_validation",
+        toErrorMessage(err),
+        true
+      );
+    }
+  }
+  const interruptedNotice = recoveryPlan.stale ? null : formatInterruptedToolNotice(data.pendingToolUseCount ?? 0);
+  if (interruptedNotice) {
+    noticeMessages.push({
+      role: "system",
+      content: interruptedNotice,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const crashNotice = formatCrashRecoveryNotice(interruptedTools, recoveryPlan.context);
+  if (crashNotice) {
+    noticeMessages.push({
+      role: "system",
+      content: crashNotice,
+      ts: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  const carriedMessages = data.messages.filter((message) => !isResumeNoticeMessage(message));
+  const resumedData = {
+    ...data,
+    ...resumeValidation ? { resumeValidation } : {},
+    messages: [...carriedMessages, ...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 }
+    );
+  }
+  try {
+    const writer = new FileSessionWriter(
+      canonicalId,
+      handle,
+      (/* @__PURE__ */ new Date()).toISOString(),
+      {
+        id: canonicalId,
+        model: data.metadata.model,
+        provider: data.metadata.provider
+      },
+      events,
+      {
+        resumed: true,
+        initialSummary,
+        dir: path10.dirname(file),
+        filePath: file,
+        secretScrubber,
+        checkpointCas,
+        onAppend,
+        onAppendBatch,
+        resolveName: async () => {
+          const current = await readSummaryManifest(canonicalId);
+          if (!current) return null;
+          return current.name === void 0 ? {} : { name: sessionContentText(secretScrubber.scrub(current.name)) };
+        },
+        onClose: (s) => persistCatalogSummary(s),
+        // Resumed sessions checkpoint their index/catalog metadata mid-flight
+        // too, so a kill during a resumed session still leaves fresh listing
+        // state behind.
+        onMetadataCheckpoint: (s) => persistCatalogSummary(s)
+      }
+    );
+    if (synthesizedResults.length > 0) {
+      await writer.appendBatch(synthesizedResults);
+      await writer.flush();
+    }
+    if (recoveryPlan.stale) {
+      await writer.clearInFlightMarker("recovered");
+      await writer.flush();
+    }
+    emitSessionStoreWrite(events, canonicalId, file, "resume", "success", Date.now() - t0);
+    return { writer, data: resumedData };
+  } catch (err) {
+    await handle.close().catch(
+      (e) => logWarn("Session handle close failed", {
+        event: "session_store.handle_close_failed",
+        message: e instanceof Error ? e.message : String(e)
+      })
+    );
+    emitSessionStoreError(events, canonicalId, file, "resume", toErrorMessage(err), true);
+    throw err;
+  }
+}
+async function openSessionForAppend(file) {
+  const handle = await fsp12.open(file, "a+", 384);
+  try {
+    const stat11 = await handle.stat();
+    if (stat11.size > 0) {
+      const tail = Buffer.allocUnsafe(1);
+      const { bytesRead } = await handle.read(tail, 0, 1, stat11.size - 1);
+      if (bytesRead === 1 && tail[0] !== 10) {
+        await handle.appendFile("\n", "utf8");
+      }
+    }
+    return handle;
+  } catch (err) {
+    await handle.close().catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/storage/session-store/search-events.ts
+import * as fsp13 from "node:fs/promises";
+async function searchSessionEvents(args) {
+  const { file, secretScrubber, predicate, limit, signal } = args;
+  const out = [];
+  let stat11;
+  try {
+    stat11 = await fsp13.stat(file);
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  if (stat11.size === 0) return [];
+  let fh;
+  try {
+    fh = await fsp13.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;
+        const ev = parseSessionEventLine(line, secretScrubber);
+        if (!ev) 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++;
+      }
+    }
+    const trailing = parseSessionEventLine(leftover.trim() ? leftover : "", secretScrubber);
+    if (trailing && predicate(trailing, eventIndex, trailing.ts)) {
+      out.push({ event: trailing, eventIndex, ts: trailing.ts });
+    }
+    return out;
+  } finally {
+    if (fh) await fh.close().catch(() => void 0);
+  }
+}
+function parseSessionEventLine(line, secretScrubber) {
+  if (!line) return null;
+  try {
+    const parsed = JSON.parse(line);
+    if (parsed === null || typeof parsed !== "object" || typeof parsed.type !== "string" || typeof parsed.ts !== "string") {
+      return null;
+    }
+    return scrubPersistedSessionEvent(parsed, secretScrubber);
+  } catch {
+    return null;
+  }
+}
+
+// src/storage/session-store/session-store-clear.ts
+import * as fsp14 from "node:fs/promises";
+async function executeClearSessionHistory(params) {
+  const {
+    canonical,
+    catalogClient,
+    maintenanceHolderId,
+    ensureShardDir: ensureShardDir2,
+    sessionPath: sessionPath2
+  } = params;
+  const maintenance = catalogClient ? await catalogClient.call("acquire_maintenance", {
+    sessionId: canonical,
+    operation: "clear",
+    holderId: maintenanceHolderId,
+    holderPid: process.pid
+  }) : void 0;
+  await ensureShardDir2(canonical);
+  const file = sessionPath2(canonical, ".jsonl");
+  const meta = sessionPath2(canonical, ".summary.json");
+  const backupSuffix = maintenance ? `.${maintenance.leaseId}.clear-backup` : void 0;
+  const fileBackup = backupSuffix ? `${file}${backupSuffix}` : void 0;
+  const metaBackup = backupSuffix ? `${meta}${backupSuffix}` : void 0;
+  let fileStaged = false;
+  let metaStaged = false;
+  const record = `${JSON.stringify({
+    type: "session_start",
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    id: canonical,
+    model: "unknown",
+    provider: "unknown"
+  })}
+`;
+  try {
+    if (fileBackup) {
+      try {
+        await fsp14.rename(file, fileBackup);
+        fileStaged = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    if (metaBackup) {
+      try {
+        await fsp14.rename(meta, metaBackup);
+        metaStaged = true;
+      } catch (error) {
+        if (error.code !== "ENOENT") throw error;
+      }
+    }
+    await atomicWrite(file, record);
+    if (!metaBackup) await fsp14.unlink(meta).catch(() => void 0);
+    if (catalogClient) {
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await catalogClient.call("upsert_summary", {
+        summary: {
+          id: canonical,
+          title: "",
+          startedAt: now,
+          model: "unknown",
+          provider: "unknown",
+          tokenTotal: 0,
+          lastActivityAt: now
+        },
+        transcriptRelativePath: `${canonical}.jsonl`,
+        summaryRelativePath: `${canonical}.summary.json`
+      });
+    }
+    if (fileStaged && fileBackup) await fsp14.unlink(fileBackup).catch(() => void 0);
+    if (metaStaged && metaBackup) await fsp14.unlink(metaBackup).catch(() => void 0);
+  } catch (error) {
+    if (fileStaged && fileBackup) {
+      await fsp14.unlink(file).catch(() => void 0);
+      await fsp14.rename(fileBackup, file).catch(() => void 0);
+    }
+    if (metaStaged && metaBackup) {
+      await fsp14.unlink(meta).catch(() => void 0);
+      await fsp14.rename(metaBackup, meta).catch(() => void 0);
+    }
+    throw error;
+  } finally {
+    if (maintenance && catalogClient) {
+      await catalogClient.call("release_maintenance", { lease: maintenance }).catch(() => void 0);
+    }
+  }
+}
+
+// src/storage/session-store/session-store-index.ts
+import * as fsp16 from "node:fs/promises";
+
+// src/storage/session-summary.ts
+function compareSessionSummaries(a, b) {
+  const aActivity = a.lastActivityAt ?? a.endedAt ?? a.startedAt;
+  const bActivity = b.lastActivityAt ?? b.endedAt ?? b.startedAt;
+  if (aActivity < bActivity) return 1;
+  if (aActivity > bActivity) return -1;
+  if (a.startedAt < b.startedAt) return 1;
+  if (a.startedAt > b.startedAt) return -1;
+  return a.id.localeCompare(b.id);
+}
+function matchesSessionFilter(summary, criteria) {
+  if (criteria.since && summary.startedAt < criteria.since) return false;
+  if (criteria.until && summary.startedAt > criteria.until) return false;
+  if (criteria.provider && summary.provider !== criteria.provider) return false;
+  if (criteria.model && summary.model !== criteria.model) return false;
+  if (criteria.minTokens !== void 0 && summary.tokenTotal < criteria.minTokens) return false;
+  if (criteria.titleContains) {
+    const needle = criteria.titleContains.toLocaleLowerCase();
+    if (!summary.title.toLocaleLowerCase().includes(needle)) return false;
+  }
+  return true;
+}
+
+// src/storage/session-store/index-reader.ts
+import * as fsp15 from "node:fs/promises";
+function applySessionIndexLines(raw, byId, deleted) {
+  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);
+        byId.delete(entry.id);
+        continue;
+      }
+      if (entry.action === "create" && entry.id) {
+        deleted.delete(entry.id);
+        byId.delete(entry.id);
+        continue;
+      }
+      if (entry.id && !deleted.has(entry.id)) {
+        byId.set(entry.id, entry);
+      }
+    } catch {
+    }
+  }
+}
+async function readFileRange(file, start, end) {
+  const length = end - start;
+  if (length <= 0) return { raw: "", end: start };
+  const buffer = Buffer.allocUnsafe(length);
+  let offset = 0;
+  let handle;
+  try {
+    handle = await fsp15.open(file, "r");
+    while (offset < length) {
+      const { bytesRead } = await handle.read(buffer, offset, length - offset, start + offset);
+      if (bytesRead === 0) return null;
+      offset += bytesRead;
+    }
+    let completeLength = buffer.length;
+    if (buffer.at(-1) !== 10) {
+      const lastNewline = buffer.lastIndexOf(10);
+      const trailing = buffer.subarray(lastNewline + 1).toString("utf8").trim();
+      try {
+        if (trailing) JSON.parse(trailing);
+        else completeLength = lastNewline + 1;
+      } catch {
+        completeLength = lastNewline + 1;
+      }
+    }
+    return {
+      raw: buffer.subarray(0, completeLength).toString("utf8"),
+      end: start + completeLength
+    };
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => void 0);
+  }
+}
+
+// src/storage/session-store/session-store-index.ts
+var COMPACT_EVERY = 30;
+var NO_DELETED_IDS = /* @__PURE__ */ new Set();
+async function appendToIndexStrict(dir, indexFile, summary, invalidateShard, onAppended, compactInner) {
+  await ensureDir(dir);
+  let shouldCompact = false;
+  await withFileLock(indexFile, async () => {
+    await invalidateShard(summary.id);
+    const line = JSON.stringify(summary) + "\n";
+    await fsp16.appendFile(indexFile, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
+    const res = onAppended();
+    shouldCompact = res.shouldCompact;
+  });
+  if (shouldCompact) {
+    await withFileLock(indexFile, () => compactInner());
+  }
+}
+async function writeTombstone(dir, indexFile, id, invalidateShard, onTombstone) {
+  try {
+    await ensureDir(dir);
+    await withFileLock(indexFile, async () => {
+      const line = JSON.stringify({ action: "delete", id }) + "\n";
+      await fsp16.appendFile(indexFile, line, { encoding: "utf8", mode: SECRET_FILE_MODE });
+      onTombstone();
+      await invalidateShard(id);
+    });
+  } catch {
+  }
+}
+async function readIndexFile(indexFile, currentCache) {
+  let stat11;
+  try {
+    const s = await fsp16.stat(indexFile);
+    stat11 = { mtimeMs: s.mtimeMs, size: s.size, ino: s.ino, birthtimeMs: s.birthtimeMs };
+  } catch {
+    return { summaries: [], deletedIds: NO_DELETED_IDS, cache: null };
+  }
+  if (currentCache !== null && currentCache.mtimeMs === stat11.mtimeMs && currentCache.size === stat11.size && currentCache.ino === stat11.ino && currentCache.birthtimeMs === stat11.birthtimeMs) {
+    return {
+      summaries: currentCache.summaries,
+      deletedIds: currentCache.deleted,
+      cache: currentCache
+    };
+  }
+  const cached = currentCache;
+  const sameFile = cached !== null && cached.ino === stat11.ino && cached.birthtimeMs === stat11.birthtimeMs;
+  if (cached && sameFile && stat11.size > cached.size) {
+    const appended = await readFileRange(indexFile, cached.size, stat11.size);
+    if (appended !== null) {
+      applySessionIndexLines(appended.raw, cached.byId, cached.deleted);
+      const summaries2 = Array.from(cached.byId.values()).sort(compareSessionSummaries);
+      const nextCache2 = {
+        ...stat11,
+        size: appended.end,
+        summaries: summaries2,
+        byId: cached.byId,
+        deleted: cached.deleted
+      };
+      return { summaries: summaries2, deletedIds: cached.deleted, cache: nextCache2 };
+    }
+  }
+  let raw;
+  try {
+    raw = await fsp16.readFile(indexFile, "utf8");
+  } catch {
+    return { summaries: [], deletedIds: NO_DELETED_IDS, cache: null };
+  }
+  const deleted = /* @__PURE__ */ new Set();
+  const byId = /* @__PURE__ */ new Map();
+  applySessionIndexLines(raw, byId, deleted);
+  const summaries = Array.from(byId.values());
+  summaries.sort(compareSessionSummaries);
+  const nextCache = { ...stat11, summaries, byId, deleted };
+  return { summaries, deletedIds: deleted, cache: nextCache };
+}
+async function compactIndexInner(indexFile, entries, deletedIds) {
+  const parts = entries.map((s) => JSON.stringify(s));
+  if (deletedIds) {
+    for (const id of deletedIds) {
+      parts.push(JSON.stringify({ action: "delete", id }));
+    }
+  }
+  if (parts.length === 0) return;
+  const lines = parts.join("\n") + "\n";
+  await atomicWrite(indexFile, lines, { mode: 384 });
+}
+
+// src/storage/session-store/shard-manifest.ts
+import * as fsp17 from "node:fs/promises";
+async function readOrBuildShardManifestEntry(opts) {
+  try {
+    const raw = await fsp17.readFile(opts.manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      summaries: Array.isArray(parsed.summaries) ? parsed.summaries : [],
+      ids: Array.isArray(parsed.ids) ? parsed.ids : []
+    };
+  } catch {
+  }
+  const refs = await opts.collectSessionFilesInShard(opts.shardKey);
+  const candidates = await mapWithConcurrency(
+    refs,
+    opts.concurrency,
+    async (ref) => {
+      const manifest = await opts.readSummaryManifest(ref.id);
+      if (manifest) return { summary: manifest, needsBackfill: false };
+      const summary = await opts.summaryHeaderFor(ref);
+      if (!summary) return null;
+      const hydrated = await opts.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) };
+  await atomicWrite(opts.manifestPath, JSON.stringify(entry), { mode: 384 }).catch(
+    () => void 0
+  );
+  return entry;
+}
+
+// src/storage/session-store/strict-empty-check.ts
+import { createReadStream as createReadStream5 } from "node:fs";
+import { createInterface as createInterface5 } from "node:readline";
+var EMPTY_SESSION_EVENT_TYPES = /* @__PURE__ */ new Set(["session_start", "session_resumed", "session_end"]);
+async function isStrictlyEmptySessionFile(file) {
+  const input = createReadStream5(file, { encoding: "utf8" });
+  const lines = createInterface5({ input, crlfDelay: Infinity });
+  let sawSessionStart = false;
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      let event;
+      try {
+        event = JSON.parse(line);
+      } catch {
+        return false;
+      }
+      if (event === null || typeof event !== "object" || Array.isArray(event)) return false;
+      const type = event.type;
+      if (typeof type !== "string" || !EMPTY_SESSION_EVENT_TYPES.has(type)) return false;
+      if (type === "session_start") sawSessionStart = true;
+    }
+  } catch {
+    return false;
+  } finally {
+    lines.close();
+    input.destroy();
+  }
+  return sawSessionStart;
+}
+
+// src/storage/session-store/summary-header.ts
+import * as fsp18 from "node:fs/promises";
+async function readSessionSummaryHeader(ref, secretScrubber) {
+  let mtime = (/* @__PURE__ */ new Date(0)).toISOString();
+  try {
+    const stat11 = await fsp18.stat(ref.filePath);
+    if (!stat11.isFile()) return damagedSummary(ref.id, stat11.mtime.toISOString());
+    mtime = stat11.mtime.toISOString();
+  } catch {
+    return null;
+  }
+  try {
+    for await (const event of iterateSessionEvents(ref.filePath, secretScrubber)) {
+      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 emptySessionSummary(ref.id, (/* @__PURE__ */ new Date(0)).toISOString());
+  } catch {
+    return damagedSummary(ref.id, mtime);
+  }
+}
+function emptySessionSummary(id, startedAt) {
+  return {
+    id,
+    title: "(empty session)",
+    startedAt,
+    model: "unknown",
+    provider: "unknown",
+    tokenTotal: 0
+  };
+}
+function damagedSummary(id, startedAt) {
+  return {
+    id,
+    title: "(damaged)",
+    startedAt,
+    model: "unknown",
+    provider: "unknown",
+    tokenTotal: 0
+  };
+}
+
+// src/storage/session-store.ts
+var SESSION_FILTER_POOL_LIMIT = 1e4;
+var DefaultSessionStore = class _DefaultSessionStore {
+  dir;
+  events;
+  secretScrubber;
+  projectRoot;
+  checkpointCas;
+  isSessionInUse;
+  logger;
+  onAppend;
+  onAppendBatch;
+  catalogClient;
+  maintenanceHolderId = randomUUID2();
+  _loadCache = /* @__PURE__ */ new Map();
+  loadCache = new SessionLoadCache(this._loadCache);
+  _indexCache = null;
+  /**
+   * Tombstoned ids — hidden even if their JSONL remains on disk.
+   * Convention: readIndex() REASSIGNS this set from the parsed index file
+   * MERGED with _manualTombstones; writeTombstone() adds in-place immediately
+   * so an incremental cache rebuild can never resurrect a just-deleted
+   * session.
+   */
+  _indexDeletedIds = /* @__PURE__ */ new Set();
+  /**
+   * Tombstones added by THIS store between reads. Merged into every fresh
+   * snapshot so a read racing writeTombstone cannot drop an in-flight
+   * deletion; entries are pruned once the parsed index file itself carries
+   * them.
+   */
+  _manualTombstones = /* @__PURE__ */ new Set();
+  /**
+   * File-truth tombstones from the last readIndex() parse (EXCLUDES
+   * _manualTombstones additions). compactIndexInner persists THIS snapshot so
+   * concurrent writeTombstones that landed after the parse are not written
+   * prematurely — they persist through their own append path instead.
+   */
+  _indexFileDeletedIds = /* @__PURE__ */ new Set();
+  shardManifestCache = /* @__PURE__ */ new Map();
+  static LIST_SCAN_CONCURRENCY = 32;
+  indexAppendCount = 0;
+  constructor(opts) {
+    this.dir = opts.dir;
+    this.projectRoot = opts.projectRoot ? path11.resolve(opts.projectRoot) : void 0;
+    this.checkpointCas = this.projectRoot ? new SessionCheckpointCas({
+      rootDir: path11.join(this.dir, "_cas"),
+      projectRoot: this.projectRoot
+    }) : void 0;
+    this.events = opts.events;
+    this.secretScrubber = opts.secretScrubber ?? new DefaultSecretScrubber();
+    this.isSessionInUse = opts.isSessionInUse;
+    this.logger = opts.logger;
+    this.onAppend = opts.onAppend;
+    this.onAppendBatch = opts.onAppendBatch;
+    const builtRuntime = import.meta.url.includes("/dist/");
+    this.catalogClient = this.projectRoot && (builtRuntime || process.env["WRONGSTACK_SESSION_CATALOG_FORCE"] === "1") && resolveSessionCatalogProjectServerUrl() ? new SessionCatalogProjectClient({
+      projectDir: path11.dirname(this.dir),
+      projectRoot: this.projectRoot
+    }) : void 0;
+  }
+  logWarn(msg, ctx) {
+    if (this.logger) {
+      this.logger.warn(msg, ctx);
+    } else {
+      console.warn(JSON.stringify({ ...ctx, message: msg, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
+    }
+  }
+  scrubSummaries(summaries) {
+    return summaries.map((summary) => scrubPersistedSessionSummary(summary, this.secretScrubber));
+  }
+  clearLoadCache(sessionId) {
+    this.loadCache.clear(sessionId);
+  }
+  async dispose() {
+    await this.catalogClient?.close();
+    this.clearLoadCache();
+  }
+  get indexFile() {
+    return path11.join(this.dir, "_index.jsonl");
+  }
+  sessionPath(id, ext) {
+    return sessionPath(this.dir, id, ext);
+  }
+  shardManifestPath(shardKey) {
+    return shardManifestPath(this.dir, shardKey);
+  }
+  shardKeyForSessionId(id) {
+    return shardKeyForSessionId(id);
+  }
+  async invalidateShardManifestBySessionId(id) {
+    const shardKey = this.shardKeyForSessionId(id);
+    const manifestPath = this.shardManifestPath(shardKey);
+    await withFileLock(manifestPath, async () => {
+      this.shardManifestCache.delete(shardKey);
+      try {
+        await fsp19.unlink(manifestPath);
+      } catch (err) {
+        if (err.code !== "ENOENT") throw err;
+      }
+    });
+  }
+  async ensureShardDir(id) {
+    return ensureShardDir(this.dir, id);
+  }
+  /**
+   * Create a fresh session writer.
+   *
+   * @threadSafety Failure-prone steps (manifest invalidation, sidecar
+   * removal, catalog upsert, the durable `{action:'create'}` index row)
+   * run BEFORE the truncating `'w'` open, so no rejection path can destroy
+   * prior bytes. Ordinary index summary rows never undelete a tombstone
+   * (the parser only honors `{action:'create'}`), so a swallowed create-row
+   * would leave a live writer whose id stays hidden forever — that append
+   * is therefore required, not best-effort.
+   */
+  async create(meta) {
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const id = meta.id && meta.id.length > 0 ? meta.id : generateSessionId(startedAt);
+    const shardDir = await this.ensureShardDir(id);
+    const file = this.sessionPath(id, ".jsonl");
+    const inUseBy = this.isSessionInUse ? await this.isSessionInUse(id) : null;
+    if (inUseBy) {
+      throw new Error(`Refusing to create session ${id}: in use (${inUseBy}).`);
+    }
+    const t0 = Date.now();
+    try {
+      await this.invalidateShardManifestBySessionId(id);
+    } catch (cause) {
+      throw new Error(
+        `Failed to invalidate stale shard manifest for ${id}: ${toErrorMessage(cause)}`,
+        { cause }
+      );
+    }
+    const sidecar = path11.join(shardDir, `${path11.basename(id)}.summary.json`);
+    try {
+      await fsp19.rm(sidecar, { force: true });
+    } catch (cause) {
+      emitSessionStoreError(this.events, id, sidecar, "create", toErrorMessage(cause), true);
+      try {
+        await fsp19.access(sidecar);
+        throw new Error(
+          `Failed to remove stale session sidecar for ${id}: ${toErrorMessage(cause)}`,
+          { cause }
+        );
+      } catch (accessErr) {
+        const code = accessErr.code;
+        if (code !== "ENOENT" && code !== "ENAMETOOLONG") throw accessErr;
+      }
+    }
+    if (this.catalogClient) {
+      await this.catalogClient.call("upsert_summary", {
+        summary: {
+          id,
+          title: meta.title ?? "",
+          startedAt,
+          model: meta.model ?? "",
+          provider: meta.provider ?? "",
+          tokenTotal: 0,
+          lastActivityAt: startedAt
+        },
+        transcriptRelativePath: `${id}.jsonl`,
+        summaryRelativePath: `${id}.summary.json`
+      });
+    }
+    try {
+      await withFileLock(this.indexFile, async () => {
+        try {
+          await fsp19.appendFile(this.indexFile, `${JSON.stringify({ action: "create", id })}
+`, {
+            encoding: "utf8",
+            mode: 384
+          });
+        } finally {
+          this._indexCache = null;
+        }
+        this._manualTombstones.delete(id);
+        this._indexDeletedIds.delete(id);
+      });
+    } catch (cause) {
+      throw new Error(
+        `Failed to record session create in the index for ${id}: ${toErrorMessage(cause)}`,
+        { cause }
+      );
+    }
+    let handle;
+    try {
+      handle = await fsp19.open(file, "w", 384);
+    } catch (err) {
+      emitSessionStoreError(this.events, id, file, "create", toErrorMessage(err), false);
+      throw new Error(`Failed to open session file: ${toErrorMessage(err)}`, { cause: err });
+    }
+    await this.invalidateShardManifestBySessionId(id).catch(() => void 0);
+    try {
+      const writer = new FileSessionWriter(id, handle, startedAt, meta, this.events, {
+        dir: shardDir,
+        filePath: file,
+        secretScrubber: this.secretScrubber,
+        checkpointCas: this.checkpointCas,
+        onAppend: this.onAppend,
+        onAppendBatch: this.onAppendBatch,
+        resolveName: async () => {
+          const current = await this.readSummaryManifest(id);
+          if (!current) return null;
+          return current.name === void 0 ? {} : { name: sessionContentText(this.secretScrubber.scrub(current.name)) };
+        },
+        onClose: (s) => this.persistCatalogSummary(s),
+        // Mid-session metadata checkpoints reuse the same sink as close so
+        // killed sessions leave accurate index rows / catalog entries behind.
+        onMetadataCheckpoint: (s) => this.persistCatalogSummary(s)
+      });
+      emitSessionStoreWrite(this.events, id, file, "create", "success", Date.now() - t0);
+      return writer;
+    } catch (err) {
+      await handle.close().catch(
+        (e) => this.logWarn("Session handle close failed", {
+          event: "session_store.handle_close_failed",
+          message: e instanceof Error ? e.message : String(e)
+        })
+      );
+      emitSessionStoreError(this.events, id, file, "create", toErrorMessage(err), true);
+      throw err;
+    }
+  }
+  async fork(id, opts = {}) {
+    return forkSession(this, id, opts);
+  }
+  async readRawEvents(id) {
+    const hits = await this.searchEvents(id, () => true);
+    return hits.map((hit) => hit.event);
+  }
+  async captureWorkspaceCheckpoint(sessionId, promptIndex) {
+    return captureCheckpoint(this.checkpointCas, sessionId, promptIndex);
+  }
+  async materializeWorkspaceCheckpoint(checkpoint, targetRoot) {
+    return materializeCheckpoint(this.checkpointCas, checkpoint, targetRoot);
+  }
+  async resolveId(query) {
+    if (this.catalogClient) {
+      return this.catalogClient.call("resolve_id", { query });
+    }
+    const normalized = query.trim();
+    if (!normalized) throw new Error("Session not found: (empty query)");
+    if (normalized) {
+      try {
+        const stat11 = await fsp19.stat(this.sessionPath(normalized, ".jsonl"));
+        if (stat11.isFile()) return normalized;
+      } catch {
+      }
+    }
+    const ids = await this.collectSessionIds(this.dir);
+    const resolution = resolveSessionId(normalized, ids);
+    if (resolution.status === "resolved") return resolution.id;
+    throw sessionIdResolutionError(resolution);
+  }
+  async resume(id) {
+    const canonicalId = await this.resolveId(id);
+    const file = this.sessionPath(canonicalId, ".jsonl");
+    return executeResumeSession({
+      id,
+      canonicalId,
+      file,
+      projectRoot: this.projectRoot,
+      events: this.events,
+      secretScrubber: this.secretScrubber,
+      checkpointCas: this.checkpointCas,
+      onAppend: this.onAppend,
+      onAppendBatch: this.onAppendBatch,
+      load: (loadId) => this.load(loadId),
+      readSummaryManifest: (summaryId) => this.readSummaryManifest(summaryId),
+      searchEvents: (searchId, pred) => this.searchEvents(searchId, pred),
+      persistCatalogSummary: (sum) => this.persistCatalogSummary(sum),
+      logWarn: (msg, ctx) => this.logWarn(msg, ctx),
+      sessionsDir: this.dir
+    });
+  }
+  async load(id) {
+    return this.loadInternal(id, { full: true });
+  }
+  async loadEventsOnly(id) {
+    return this.loadInternal(id, { full: false });
+  }
+  async loadInternal(id, mode) {
+    const file = this.sessionPath(id, ".jsonl");
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    let cacheHit = false;
+    try {
+      const s = await fsp19.stat(file);
+      const stat11 = { mtimeMs: s.mtimeMs, size: s.size };
+      const cached = this.loadCache.getFresh(id, stat11, mode.full);
+      if (cached) {
+        cacheHit = true;
+        return cached;
+      }
+      const data = await loadSessionDataFromFile({
+        id,
+        file,
+        full: mode.full,
+        events: this.events,
+        secretScrubber: this.secretScrubber
+      });
+      if (mode.full) {
+        this.loadCache.set(id, stat11, data);
+      }
+      return data;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      throw err;
+    } finally {
+      emitSessionStoreRead(
+        this.events,
+        id,
+        file,
+        mode.full ? "load" : "load_events_only",
+        outcome,
+        Date.now() - t0,
+        errorMsg
+      );
+      if (cacheHit) {
+        this.events?.emit("storage.cache_hit", {
+          sessionId: id,
+          store: "session",
+          filePath: file,
+          operation: mode.full ? "load" : "load_events_only",
+          durationMs: Date.now() - t0
+        });
+      }
+    }
+  }
+  async searchEvents(id, predicate, opts) {
+    return searchSessionEvents({
+      file: this.sessionPath(id, ".jsonl"),
+      secretScrubber: this.secretScrubber,
+      predicate,
+      limit: opts?.limit,
+      signal: opts?.signal
+    });
+  }
+  async list(limit = 20) {
+    if (this.catalogClient) {
+      const records = await this.catalogClient.call("list_catalog", { limit });
+      return this.scrubSummaries(records);
+    }
+    try {
+      const [indexed, scanned] = await Promise.all([
+        this.readIndex(),
+        // Wide scan bound: mergeIndexWithScan slices to `limit`, so killed
+        // sessions deep in history stay visible instead of being dropped by
+        // the user-facing page size before the union runs.
+        this.listFromDirectoryScan(SESSION_FILTER_POOL_LIMIT).catch(() => [])
+      ]);
+      return this.scrubSummaries(this.mergeIndexWithScan(indexed, scanned, limit));
+    } catch {
+      return [];
+    }
+  }
+  async listFiltered(criteria) {
+    const limit = criteria.limit ?? 100;
+    if (this.catalogClient) {
+      const records = await this.catalogClient.call("list_catalog", {
+        limit,
+        ...criteria
+      });
+      return this.scrubSummaries(records);
+    }
+    try {
+      const [indexed, scanned] = await Promise.all([
+        this.readIndex(),
+        // Same best-effort contract as list(): scan failures enrich nothing
+        // but must not blank the filtered result set.
+        this.listFromDirectoryScan(SESSION_FILTER_POOL_LIMIT).catch(() => [])
+      ]);
+      const pool = this.mergeIndexWithScan(indexed, scanned, SESSION_FILTER_POOL_LIMIT);
+      return this.scrubSummaries(pool).filter((s) => matchesSessionFilter(s, criteria)).slice(0, limit);
+    } catch {
+      return [];
+    }
+  }
+  async appendToIndexStrict(summary) {
+    await appendToIndexStrict(
+      this.dir,
+      this.indexFile,
+      summary,
+      (id) => this.invalidateShardManifestBySessionId(id),
+      () => {
+        this._indexCache = null;
+        this.indexAppendCount++;
+        const shouldCompact = this.indexAppendCount >= COMPACT_EVERY;
+        if (shouldCompact) this.indexAppendCount = 0;
+        return { shouldCompact };
+      },
+      () => this.compactIndexInner()
+    );
+  }
+  async appendToIndex(summary) {
+    await this.appendToIndexStrict(summary).catch(() => void 0);
+  }
+  async persistCatalogSummary(summary) {
+    if (!this.catalogClient) {
+      await this.appendToIndex(summary);
+      return;
+    }
+    await this.catalogClient.call("upsert_summary", {
+      summary,
+      transcriptRelativePath: `${summary.id}.jsonl`,
+      summaryRelativePath: `${summary.id}.summary.json`
+    });
+  }
+  async writeTombstone(id) {
+    await writeTombstone(
+      this.dir,
+      this.indexFile,
+      id,
+      (sid) => this.invalidateShardManifestBySessionId(sid),
+      () => {
+        this._manualTombstones.add(id);
+        this._indexDeletedIds.add(id);
+        this._indexCache = null;
+        this.indexAppendCount++;
+      }
+    );
+  }
+  async compactIndex() {
+    const t0 = Date.now();
+    let outcome = "success";
+    let errorMsg;
+    try {
+      await withFileLock(this.indexFile, () => this.compactIndexInner());
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+    } finally {
+      emitSessionStoreWrite(
+        this.events,
+        "~compact~",
+        this.indexFile,
+        "compact",
+        outcome,
+        Date.now() - t0,
+        void 0,
+        errorMsg
+      );
+    }
+  }
+  /**
+   * Compact the local index in place.
+   *
+   * Contract carried into the shared compactIndexInner helper
+   * (session-store-index.ts): `entries` MUST already exclude tombstoned ids,
+   * and the deleted-set argument is persisted VERBATIM — neither the helper
+   * nor its callers may resurrect filtered rows or invent deletions.
+   * Locking: callers MUST already hold the indexFile lock (both do:
+   * compactIndex() below and the appendToIndexStrict compaction hook);
+   * readIndex() inside reads that same locked file, so no second lock may
+   * be taken here (non-reentrant → deadlock).
+   *
+   * That same lock is what makes the _indexFileDeletedIds snapshot safe to
+   * pass across the await below: writeTombstone() appends under the identical
+   * non-reentrant indexFile lock, so no tombstone can land between our
+   * readIndex() and the snapshot handed to the helper. Compaction would
+   * otherwise be racing a delete it cannot see.
+   */
+  async compactIndexInner() {
+    const entries = await this.readIndex();
+    await compactIndexInner(this.indexFile, entries, this._indexFileDeletedIds);
+    this._indexCache = null;
+  }
+  async readIndex() {
+    const { summaries, deletedIds, cache } = await readIndexFile(this.indexFile, this._indexCache);
+    this._indexCache = cache;
+    const merged = new Set(deletedIds);
+    for (const manual of this._manualTombstones) {
+      merged.add(manual);
+      if (deletedIds.has(manual)) this._manualTombstones.delete(manual);
+    }
+    this._indexFileDeletedIds = deletedIds;
+    this._indexDeletedIds = merged;
+    return summaries;
+  }
+  /**
+   * Merge close-time index rows with directory-scan results, keyed by id.
+   * Scanned entries win — their metadata is re-derived from the transcript,
+   * so it reflects mid-session activity that index rows (written on close)
+   * cannot know about. Indexed-only ids fill gaps; duplicates within the
+   * index resolve last-wins, matching append order.
+   */
+  mergeIndexWithScan(indexed, scanned, limit) {
+    const byId = /* @__PURE__ */ new Map();
+    for (const row of indexed) byId.set(row.id, row);
+    for (const row of scanned) byId.set(row.id, row);
+    return [...byId.values()].filter((row) => !this._indexDeletedIds.has(row.id)).sort(compareSessionSummaries).slice(0, limit);
+  }
+  /**
+   * Rebuild the index from what is actually on disk.
+   *
+   * @returns the number of healthy, live entries in the rebuilt index. Both
+   * backends report that same quantity: ids whose summary could not be derived
+   * are excluded (the catalog counts them as `damaged`; the local scan drops
+   * them when `summaryFor` rejects), and ids carrying a surviving tombstone are
+   * excluded (the catalog rebuilds only from live files; the local branch skips
+   * them explicitly). It is NOT a count of rows written to the file — tombstone
+   * rows are persisted but never counted.
+   */
+  async rebuildIndex() {
+    if (this.catalogClient) {
+      const result = await this.catalogClient.call("rebuild_catalog", {}, { timeoutMs: 12e4 });
+      return result.indexed;
+    }
+    return withFileLock(this.indexFile, async () => {
+      await this.readIndex();
+      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 parts = [];
+      let tombstoned = 0;
+      for (const s of valid) {
+        if (this._indexDeletedIds.has(s.id)) {
+          tombstoned++;
+          continue;
+        }
+        parts.push(JSON.stringify(s));
+      }
+      for (const id of this._indexDeletedIds) {
+        parts.push(JSON.stringify({ action: "delete", id }));
+      }
+      const lines = parts.join("\n") + "\n";
+      await atomicWrite(this.indexFile, lines, { mode: 384 });
+      this._indexCache = null;
+      return valid.length - tombstoned;
+    });
+  }
+  async listFromDirectoryScan(limit) {
+    const shardKeys = await this.collectShardKeys();
+    const shardEntries = await mapWithConcurrency(
+      shardKeys,
+      _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+      async (shardKey) => await this.readOrBuildShardManifest(shardKey)
+    );
+    const out = [];
+    for (const entry of shardEntries) {
+      for (const summary of entry.summaries) {
+        out.push({ summary, needsBackfill: false });
+      }
+    }
+    out.sort((a, b) => compareSessionSummaries(a.summary, b.summary));
+    const selected = out.slice(0, limit);
+    const summaries = await mapWithConcurrency(
+      selected,
+      Math.min(_DefaultSessionStore.LIST_SCAN_CONCURRENCY, Math.max(1, limit)),
+      async (candidate) => candidate.summary
+    );
+    return summaries.filter((s) => s !== null);
+  }
+  async collectShardKeys() {
+    let entries;
+    try {
+      entries = await fsp19.readdir(this.dir, { withFileTypes: true });
+    } catch {
+      return [""];
+    }
+    const shardKeys = [""];
+    for (const entry of entries) {
+      if (shouldSkipSessionDirectoryEntry(entry.name)) continue;
+      if (entry.isDirectory()) shardKeys.push(entry.name);
+    }
+    return shardKeys;
+  }
+  async readOrBuildShardManifest(shardKey) {
+    const manifestPath = this.shardManifestPath(shardKey);
+    const cached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
+    if (cached) return cached;
+    return withFileLock(manifestPath, async () => {
+      const lockedCached = await this.freshShardManifestCacheEntry(shardKey, manifestPath);
+      if (lockedCached) return lockedCached;
+      const entry = await readOrBuildShardManifestEntry({
+        shardKey,
+        manifestPath,
+        concurrency: _DefaultSessionStore.LIST_SCAN_CONCURRENCY,
+        collectSessionFilesInShard: (key) => this.collectSessionFilesInShard(key),
+        readSummaryManifest: (id) => this.readSummaryManifest(id),
+        summaryHeaderFor: (ref) => this.summaryHeaderFor(ref),
+        summaryFor: (id) => this.summaryFor(id)
+      });
+      try {
+        const stat11 = await fsp19.stat(manifestPath);
+        this.shardManifestCache.set(shardKey, {
+          entry,
+          mtimeMs: stat11.mtimeMs,
+          size: stat11.size,
+          ino: stat11.ino
+        });
+      } catch {
+        this.shardManifestCache.delete(shardKey);
+      }
+      return entry;
+    });
+  }
+  async freshShardManifestCacheEntry(shardKey, manifestPath) {
+    const cached = this.shardManifestCache.get(shardKey);
+    if (!cached) return void 0;
+    try {
+      const stat11 = await fsp19.stat(manifestPath);
+      if (stat11.mtimeMs === cached.mtimeMs && stat11.size === cached.size && stat11.ino === cached.ino) {
+        return cached.entry;
+      }
+    } catch {
+    }
+    this.shardManifestCache.delete(shardKey);
+    return void 0;
+  }
+  async collectSessionFilesInShard(shardKey) {
+    const dir = shardKey ? path11.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 collectSessionFiles(dir, prefix = "", depth = 0) {
+    return collectSessionFiles(dir, prefix, depth);
+  }
+  async collectSessionIds(dir, prefix = "", depth = 0) {
+    return collectSessionIds(dir, prefix, depth);
+  }
+  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 stat11 = await fsp19.stat(full);
+      const summary = await this.summarize(id, stat11.mtime.toISOString());
+      await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
+        const msg = toErrorMessage(err);
+        emitSessionStoreError(this.events, id, manifest, "summary_fallback", msg, true);
+        this.logWarn("Session manifest write failed", {
+          event: "session_store.manifest_write_failed",
+          sessionId: id,
+          message: msg
+        });
+      });
+      outcome = "failure";
+      errorMsg = "summary fallback \u2014 manifest rebuilt";
+      emitSessionStoreRead(
+        this.events,
+        id,
+        manifest,
+        "summary",
+        outcome,
+        Date.now() - t0,
+        errorMsg
+      );
+      return summary;
+    } catch (err) {
+      outcome = "failure";
+      errorMsg = toErrorMessage(err);
+      emitSessionStoreRead(
+        this.events,
+        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 {
+      const raw = await fsp19.readFile(manifest, "utf8");
+      emitSessionStoreRead(this.events, id, manifest, "summary", "success", Date.now() - startTime);
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+  async summaryHeaderFor(ref) {
+    return readSessionSummaryHeader(ref, this.secretScrubber);
+  }
+  async deleteSession(id) {
+    const jsonlPath = this.sessionPath(id, ".jsonl");
+    await deleteSessionArtifacts({ rootDir: this.dir, id, jsonlPath });
+    await this.writeTombstone(id);
+  }
+  async isEmpty(id) {
+    const canonicalId = await this.resolveId(id);
+    return isStrictlyEmptySessionFile(this.sessionPath(canonicalId, ".jsonl"));
+  }
+  async delete(id) {
+    if (this.catalogClient) {
+      const canonical = await this.resolveId(id);
+      const lease = await this.catalogClient.call("acquire_maintenance", {
+        sessionId: canonical,
+        operation: "delete",
+        holderId: this.maintenanceHolderId
+      });
+      try {
+        await this.catalogClient.call("delete", { sessionId: canonical, lease });
+      } catch (error) {
+        await this.catalogClient.call("release_maintenance", { lease }).catch(() => void 0);
+        throw error;
+      }
+      this.clearLoadCache(canonical);
+      return;
+    }
+    await assertSessionCanBeDeleted(id, this.isSessionInUse);
+    await this.deleteSession(id);
+  }
+  async rename(id, name) {
+    if (this.catalogClient) {
+      const canonical = await this.resolveId(id);
+      const summary = await this.catalogClient.call("rename", {
+        sessionId: canonical,
+        name: sessionContentText(this.secretScrubber.scrub(name))
+      });
+      this.clearLoadCache(canonical);
+      return summary;
+    }
+    const manifest = this.sessionPath(id, ".summary.json");
+    const jsonlPath = this.sessionPath(id, ".jsonl");
+    const updated = await executeRenameSession({
+      id,
+      name,
+      manifest,
+      jsonlPath,
+      events: this.events,
+      secretScrubber: this.secretScrubber,
+      readSummaryManifest: (sid) => this.readSummaryManifest(sid),
+      summaryFor: (sid) => this.summaryFor(sid),
+      appendToIndexStrict: (sum) => this.appendToIndexStrict(sum)
+    });
+    this.clearLoadCache(id);
+    return updated;
+  }
+  async prune(maxAgeDays = 30) {
+    if (this.catalogClient) {
+      return this.catalogClient.call("prune", {
+        maxAgeDays,
+        holderId: this.maintenanceHolderId
+      });
+    }
+    const deleted = await pruneSessionFiles(this.dir, maxAgeDays, (id) => this.deleteSession(id));
+    if (deleted > 0) {
+      await this.compactIndex().catch(() => void 0);
+    }
+    return deleted;
+  }
+  async clearHistory(id) {
+    const canonical = this.catalogClient ? await this.resolveId(id) : id;
+    await executeClearSessionHistory({
+      id,
+      canonical,
+      catalogClient: this.catalogClient,
+      maintenanceHolderId: this.maintenanceHolderId,
+      ensureShardDir: (sid) => this.ensureShardDir(sid),
+      sessionPath: (sid, ext) => this.sessionPath(sid, ext)
+    });
+    this.clearLoadCache(canonical);
+    if (id !== canonical) this.clearLoadCache(id);
+  }
+  async summarize(id, mtime) {
+    return summarizeSessionFile({
+      id,
+      file: this.sessionPath(id, ".jsonl"),
+      mtime,
+      secretScrubber: this.secretScrubber
+    });
+  }
+};
+
+export {
+  loadDirectorState,
+  DirectorStateCheckpoint,
+  sessionContentPreview,
+  userInputTitle,
+  SessionCheckpointCas,
+  sanitizeModel,
+  generateSessionId,
+  resolveSessionId,
+  sessionIdResolutionError,
+  scrubPersistedSessionEvent,
+  scrubPersistedSessionData,
+  scrubPersistedSessionSummary,
+  extractInterruptedTools,
+  SessionRecovery,
+  DefaultSessionStore
+};
+//# sourceMappingURL=chunk-UIWONWVG.js.map