claude-code-replay 0.1.0

package/dist/main.mjs

@@ -0,0 +1,3150 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { realpathSync as realpathSync3 } from "node:fs";
+import { pathToFileURL } from "node:url";
+
+// src/cli.ts
+import * as fs7 from "node:fs";
+import * as os3 from "node:os";
+import * as path10 from "node:path";
+import { Command, CommanderError, InvalidArgumentError } from "commander";
+
+// src/actions.ts
+import { spawnSync } from "node:child_process";
+import * as fs3 from "node:fs";
+import * as path4 from "node:path";
+
+// src/collect.ts
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+
+// src/fs-walk.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+function walkFiles(root, opts) {
+  const { filter, onError, followSymlinks = false } = opts;
+  const out = [];
+  const visited = followSymlinks ? /* @__PURE__ */ new Set() : null;
+  function walk(dir) {
+    let target = dir;
+    if (visited) {
+      let real;
+      let st;
+      try {
+        real = fs.realpathSync(dir);
+        st = fs.statSync(real);
+      } catch (e) {
+        onError?.(dir, e instanceof Error ? e : new Error(String(e)));
+        return;
+      }
+      const key = `${st.dev}:${st.ino}`;
+      if (visited.has(key)) return;
+      visited.add(key);
+      target = real;
+    }
+    let entries;
+    try {
+      entries = fs.readdirSync(target, { withFileTypes: true });
+    } catch (e) {
+      onError?.(dir, e instanceof Error ? e : new Error(String(e)));
+      return;
+    }
+    for (const e of entries) {
+      const full = path.join(target, e.name);
+      if (e.isDirectory()) {
+        walk(full);
+      } else if (filter(e)) {
+        out.push(full);
+      }
+    }
+  }
+  walk(root);
+  out.sort();
+  return out;
+}
+
+// src/collect.ts
+function strField(input, key) {
+  const v = input[key];
+  return typeof v === "string" ? v : "";
+}
+function asToolInput(ev) {
+  const input = ev.input;
+  switch (ev.toolName) {
+    case "Bash":
+      return { tool: "Bash", command: strField(input, "command") };
+    case "Write":
+      return {
+        tool: "Write",
+        file_path: strField(input, "file_path"),
+        content: strField(input, "content")
+      };
+    case "Edit":
+      return {
+        tool: "Edit",
+        file_path: strField(input, "file_path"),
+        // For Edit we preserve the raw form: callers (actions.doEdit) need
+        // to distinguish missing/non-string old_string from "" to halt.
+        // strField collapses both to ""; the only consumer that cares
+        // (actions.doEdit) does its own typeof check on event.input directly.
+        old_string: typeof input.old_string === "string" ? input.old_string : "",
+        new_string: strField(input, "new_string"),
+        replace_all: Boolean(input.replace_all)
+      };
+    case "Read":
+      return {
+        tool: "Read",
+        file_path: strField(input, "file_path"),
+        offset: typeof input.offset === "number" ? input.offset : null,
+        limit: typeof input.limit === "number" ? input.limit : null
+      };
+    default:
+      return null;
+  }
+}
+var CollectFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CollectFailure";
+  }
+};
+var TOOL_PARSE_HALT_RE = /"type"\s*:\s*"(?:tool_use|tool_result)"/;
+function* iterJsonl(p) {
+  const CHUNK_SIZE = 64 * 1024;
+  const fd = fs2.openSync(p, "r");
+  try {
+    const buf = Buffer.alloc(CHUNK_SIZE);
+    let partial = "";
+    let lineNo = 0;
+    let bytesRead;
+    while ((bytesRead = fs2.readSync(fd, buf, 0, CHUNK_SIZE, null)) > 0) {
+      partial += buf.toString("utf8", 0, bytesRead);
+      let nl;
+      while ((nl = partial.indexOf("\n")) !== -1) {
+        const raw = partial.slice(0, nl).trim();
+        partial = partial.slice(nl + 1);
+        const i = lineNo++;
+        if (!raw) continue;
+        const parsed = parseOrThrow(raw, p, i);
+        if (parsed !== void 0) yield [i, parsed];
+      }
+    }
+    const tail = partial.trim();
+    if (tail) {
+      const parsed = parseOrThrow(tail, p, lineNo);
+      if (parsed !== void 0) yield [lineNo, parsed];
+    }
+  } finally {
+    fs2.closeSync(fd);
+  }
+}
+function parseOrThrow(raw, p, lineNo) {
+  try {
+    return JSON.parse(raw);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (TOOL_PARSE_HALT_RE.test(raw)) {
+      throw new CollectFailure(
+        `unparseable tool_use/tool_result line at ${path2.basename(p)}:${lineNo}: ${msg} (silently skipping would drop a Write/Edit/Read event from replay)`
+      );
+    }
+    process.stderr.write(`warn: skip ${path2.basename(p)}:${lineNo}: ${msg}
+`);
+    return void 0;
+  }
+}
+function flattenText(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    return content.filter((p) => p != null && typeof p === "object" && "text" in p).map((p) => typeof p.text === "string" ? p.text : "").join("\n");
+  }
+  return "";
+}
+function collect(logsDirs, cutoffTs) {
+  const dirs = typeof logsDirs === "string" ? [logsDirs] : logsDirs;
+  const rawEvents = [];
+  const jsonls = [];
+  for (const dir of dirs) {
+    for (const j of walkFiles(dir, {
+      filter: (e) => e.isFile() && e.name.endsWith(".jsonl")
+    })) {
+      jsonls.push(j);
+    }
+  }
+  for (const jsonl of jsonls) {
+    const uses = [];
+    const results = /* @__PURE__ */ new Map();
+    for (const [lineNo, obj] of iterJsonl(jsonl)) {
+      const otype = obj.type;
+      if (otype !== "assistant" && otype !== "user") continue;
+      const message = obj.message ?? {};
+      const content = message.content;
+      if (!Array.isArray(content)) continue;
+      for (const item of content) {
+        if (!item || typeof item !== "object") continue;
+        const it = item;
+        const itype = it.type;
+        if (itype === "tool_use") {
+          uses.push({
+            timestamp: obj.timestamp ?? "",
+            sessionId: obj.sessionId ?? null,
+            sessionFile: path2.basename(jsonl),
+            lineInSession: lineNo,
+            isSidechain: Boolean(obj.isSidechain),
+            cwd: obj.cwd ?? null,
+            toolUseId: it.id ?? "",
+            toolName: it.name ?? "",
+            input: it.input ?? {}
+          });
+        } else if (itype === "tool_result") {
+          const tuId = it.tool_use_id;
+          if (typeof tuId !== "string" || !tuId) continue;
+          results.set(tuId, {
+            isError: Boolean(it.is_error),
+            text: flattenText(it.content)
+          });
+        }
+      }
+    }
+    for (const u of uses) {
+      const r = results.get(u.toolUseId);
+      const resultText = r ? r.text : null;
+      const re = {
+        ...u,
+        isError: Boolean(r?.isError),
+        resultText
+      };
+      if (cutoffTs != null) {
+        if (!re.timestamp) {
+          process.stderr.write(
+            `warn: cutoff active; dropping ${u.sessionFile}:${u.lineInSession} (${u.toolName}) \u2014 event has no timestamp
+`
+          );
+          continue;
+        }
+        if (re.timestamp >= cutoffTs) continue;
+      }
+      rawEvents.push(re);
+    }
+  }
+  rawEvents.sort((a, b) => {
+    if (a.timestamp < b.timestamp) return -1;
+    if (a.timestamp > b.timestamp) return 1;
+    if (a.sessionFile < b.sessionFile) return -1;
+    if (a.sessionFile > b.sessionFile) return 1;
+    return a.lineInSession - b.lineInSession;
+  });
+  return rawEvents.map((e, i) => ({ index: i, ...e }));
+}
+
+// src/paths.ts
+import * as path3 from "node:path";
+var OutsideSourceRoot = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OutsideSourceRoot";
+  }
+};
+function relativeIfInside(p, root) {
+  const rel = path3.relative(root, p);
+  if (rel === "") return "";
+  if (rel.startsWith("..") || path3.isAbsolute(rel)) return null;
+  return rel;
+}
+function sortByLengthDesc(roots) {
+  return [...roots].sort((a, b) => b.length - a.length);
+}
+function rewritePath(p, sourceRoots, target) {
+  if (!path3.isAbsolute(p)) {
+    return p;
+  }
+  for (const root of sortByLengthDesc(sourceRoots)) {
+    const rel = relativeIfInside(p, root);
+    if (rel === null) continue;
+    return rel === "" ? target : path3.join(target, rel);
+  }
+  throw new OutsideSourceRoot(
+    `${p} is not under any of: ${sourceRoots.join(", ")}`
+  );
+}
+function rewriteCommand(cmd, sourceRoots, target) {
+  let out = cmd;
+  for (const root of sortByLengthDesc(sourceRoots)) {
+    const re = new RegExp(
+      escapeRegExp(root) + "(?=/|$|[^A-Za-z0-9._/-])",
+      "g"
+    );
+    out = out.replace(re, target);
+  }
+  return out;
+}
+function escapeRegExp(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function pathInsideAny(p, sourceRoots) {
+  for (const root of sourceRoots) {
+    if (relativeIfInside(p, root) !== null) return true;
+  }
+  return false;
+}
+function pathIsInsideOrEqual(inner, outer) {
+  const rel = path3.relative(outer, inner);
+  if (rel === "") return true;
+  return !rel.startsWith("..") && !path3.isAbsolute(rel);
+}
+
+// src/actions.ts
+var REPLAY_SHELL = process.env.SHELL || "/bin/bash";
+var SAFE_ENV_KEYS = ["PATH", "LANG", "LC_ALL", "TERM", "TMPDIR", "TZ"];
+var CMD_SPLITTER = /(\s*(?:&&|\|\||;|\n|\|)\s*)/;
+var HEX_TOKEN_RE = /(?<=\s|^)[0-9a-f]{7,40}(?=\s|$)/g;
+var GIT_SHA_CONSUMING_RE = /^\s*git(?:\s+-[A-Za-z]\S*)*\s+(?:cherry-pick|revert|reset|rev-parse|show|log|branch|tag|merge|rebase|checkout|diff|range-diff|describe)\b/;
+function toLocalGitDate(ts) {
+  const d = new Date(ts);
+  if (Number.isNaN(d.getTime())) return ts;
+  const pad = (n) => String(n).padStart(2, "0");
+  const offMin = -d.getTimezoneOffset();
+  const sign = offMin >= 0 ? "+" : "-";
+  const abs = Math.abs(offMin);
+  const offStr = `${sign}${pad(Math.floor(abs / 60))}${pad(abs % 60)}`;
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())} ` + offStr;
+}
+var HOST_GIT_IDENTITY;
+function readHostGitIdentity() {
+  if (HOST_GIT_IDENTITY !== void 0) return HOST_GIT_IDENTITY;
+  const read = (key) => {
+    const r = spawnSync("git", ["config", "--get", key], { encoding: "utf8" });
+    return r.status === 0 ? r.stdout.trim() : "";
+  };
+  const name = read("user.name");
+  const email = read("user.email");
+  HOST_GIT_IDENTITY = name && email ? { name, email } : null;
+  return HOST_GIT_IDENTITY;
+}
+var ActionFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ActionFailure";
+  }
+};
+var ExecuteFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ExecuteFailure";
+  }
+};
+function currentTargetHead(target) {
+  try {
+    const result = spawnSync(
+      "git",
+      ["-C", target, "rev-parse", "HEAD"],
+      { encoding: "utf8", timeout: 5e3 }
+    );
+    if (result.error) return { kind: "error", err: result.error };
+    if (result.signal) {
+      return {
+        kind: "error",
+        err: new Error(`git rev-parse killed by signal ${result.signal}`)
+      };
+    }
+    if (result.status !== 0) {
+      const stderr = (result.stderr || "").trim();
+      if (/unknown revision|ambiguous argument 'HEAD'|does not have any commits/i.test(
+        stderr
+      )) {
+        return { kind: "empty" };
+      }
+      return {
+        kind: "error",
+        err: new Error(
+          `git rev-parse HEAD exited ${result.status}${stderr ? `: ${stderr}` : ""}`
+        )
+      };
+    }
+    const head = result.stdout.trim();
+    return head ? { kind: "sha", sha: head } : { kind: "empty" };
+  } catch (e) {
+    return {
+      kind: "error",
+      err: e instanceof Error ? e : new Error(String(e))
+    };
+  }
+}
+function cmdHasShaToken(cmd) {
+  const parts = cmd.split(CMD_SPLITTER);
+  for (let i = 0; i < parts.length; i += 2) {
+    const part = parts[i];
+    if (GIT_SHA_CONSUMING_RE.test(part) && HEX_TOKEN_RE.test(part)) return true;
+    GIT_SHA_CONSUMING_RE.lastIndex = 0;
+    HEX_TOKEN_RE.lastIndex = 0;
+  }
+  return false;
+}
+function rewriteGitHashes(cmd, target, emit, context) {
+  const head = currentTargetHead(target);
+  switch (head.kind) {
+    case "empty":
+      return cmd;
+    case "error":
+      if (emit && cmdHasShaToken(cmd)) {
+        const idx = context?.index;
+        const where = typeof idx === "number" ? ` at event index ${idx}` : "";
+        emit(
+          `warn: rewriteGitHashes skipped${where} (${head.err.message}); original SHAs preserved verbatim in command: ${cmd}`
+        );
+      }
+      return cmd;
+    case "sha": {
+      const sha = head.sha;
+      const parts = cmd.split(CMD_SPLITTER);
+      const out = [];
+      for (let i = 0; i < parts.length; i++) {
+        if (i % 2 === 1) {
+          out.push(parts[i]);
+          continue;
+        }
+        let part = parts[i];
+        if (GIT_SHA_CONSUMING_RE.test(part)) {
+          part = part.replace(HEX_TOKEN_RE, sha);
+        }
+        out.push(part);
+      }
+      return out.join("");
+    }
+  }
+}
+function doWrite(event, target, sourceRoots) {
+  const ti = asToolInput(event);
+  if (ti?.tool !== "Write") {
+    throw new ActionFailure(`doWrite called for non-Write tool '${event.toolName}'`);
+  }
+  const filePath = ti.file_path;
+  const content = ti.content;
+  let dst;
+  try {
+    dst = rewritePath(filePath, sourceRoots, target);
+  } catch (e) {
+    if (e instanceof OutsideSourceRoot) {
+      throw new ActionFailure(`Write outside source root: ${e.message}`);
+    }
+    throw e;
+  }
+  fs3.mkdirSync(path4.dirname(dst), { recursive: true });
+  fs3.writeFileSync(dst, content);
+  return `wrote ${dst} (${Buffer.byteLength(content, "utf8")} bytes)`;
+}
+function doEdit(event, target, sourceRoots) {
+  const ti = asToolInput(event);
+  if (ti?.tool !== "Edit") {
+    throw new ActionFailure(`doEdit called for non-Edit tool '${event.toolName}'`);
+  }
+  const filePath = ti.file_path;
+  if (ti.old_string === "") {
+    throw new ActionFailure(
+      `Edit has missing/empty old_string (would silently prepend new_string): ${filePath}`
+    );
+  }
+  const oldStr = ti.old_string;
+  const newStr = ti.new_string;
+  const replaceAll = ti.replace_all;
+  let dst;
+  try {
+    dst = rewritePath(filePath, sourceRoots, target);
+  } catch (e) {
+    if (e instanceof OutsideSourceRoot) {
+      throw new ActionFailure(`Edit outside source root: ${e.message}`);
+    }
+    throw e;
+  }
+  if (!fs3.existsSync(dst)) {
+    throw new ActionFailure(`Edit target missing: ${dst}`);
+  }
+  const current = fs3.readFileSync(dst, "utf8");
+  if (!current.includes(oldStr)) {
+    const preview = JSON.stringify(oldStr.slice(0, 80));
+    throw new ActionFailure(`Edit old_string not in ${dst}: ${preview}`);
+  }
+  let updated;
+  if (replaceAll) {
+    updated = current.split(oldStr).join(newStr);
+  } else {
+    const idx = current.indexOf(oldStr);
+    updated = current.slice(0, idx) + newStr + current.slice(idx + oldStr.length);
+  }
+  fs3.writeFileSync(dst, updated);
+  return `edited ${dst}`;
+}
+function executeBash(event, target, sourceRoots, commandOverride, emit) {
+  const ti = asToolInput(event);
+  const originalCmd = ti?.tool === "Bash" ? ti.command : "";
+  const cmd = typeof commandOverride === "string" && commandOverride !== "" ? commandOverride : originalCmd;
+  let rewritten = rewriteCommand(cmd, sourceRoots, target);
+  rewritten = rewriteGitHashes(rewritten, target, emit, { index: event.index });
+  const env = { HOME: target };
+  for (const k of SAFE_ENV_KEYS) {
+    if (process.env[k] !== void 0) env[k] = process.env[k];
+  }
+  const ts = event.timestamp || "";
+  if (ts) {
+    const pinned = toLocalGitDate(ts);
+    env.GIT_AUTHOR_DATE = pinned;
+    env.GIT_COMMITTER_DATE = pinned;
+  }
+  const identity = readHostGitIdentity();
+  if (identity) {
+    env.GIT_AUTHOR_NAME = identity.name;
+    env.GIT_AUTHOR_EMAIL = identity.email;
+    env.GIT_COMMITTER_NAME = identity.name;
+    env.GIT_COMMITTER_EMAIL = identity.email;
+  }
+  const result = spawnSync(rewritten, {
+    shell: REPLAY_SHELL,
+    cwd: target,
+    encoding: "utf8",
+    env
+  });
+  if (result.status !== 0) {
+    const tail = (result.stderr || result.stdout || "").slice(-600);
+    const cause = result.error ? `spawn error: ${result.error.message}` : result.signal ? `signal ${result.signal}` : `exit ${result.status}`;
+    throw new ExecuteFailure(
+      `classifier-approved Bash failed (${cause}): ${rewritten}
+${tail}`
+    );
+  }
+  return `exit 0 (${rewritten.slice(0, 80)})`;
+}
+function applyAction(event, target, sourceRoots) {
+  const tool = event.toolName;
+  if (tool === "Write") return doWrite(event, target, sourceRoots);
+  if (tool === "Edit") return doEdit(event, target, sourceRoots);
+  throw new ActionFailure(`no action handler for tool '${tool}'`);
+}
+
+// src/checkpoints.ts
+import * as fs4 from "node:fs";
+import * as path5 from "node:path";
+var CheckpointFailure = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CheckpointFailure";
+  }
+};
+var CAT_N_LINE = /^\s*\d+\t(.*)$/;
+var TRUNCATION_MARKER = /\n\s*\[Lines \d+-\d+ omitted\]\s*$/;
+var SENTINEL_ENVELOPE = /^<system-reminder>[\s\S]*<\/system-reminder>\s*$/;
+function trimTrailingNewline(s) {
+  return s.endsWith("\n") ? s.slice(0, -1) : s;
+}
+function stripCatN(text) {
+  const out = [];
+  for (const raw of text.split("\n")) {
+    const m = CAT_N_LINE.exec(raw);
+    if (m) {
+      out.push(m[1]);
+    } else {
+      out.push(raw);
+    }
+  }
+  return out.join("\n");
+}
+function lineDiff(a, b) {
+  const out = [];
+  const maxLen = Math.max(a.length, b.length);
+  for (let i = 0; i < maxLen; i++) {
+    const av = a[i];
+    const bv = b[i];
+    if (av === bv) continue;
+    if (av !== void 0) out.push(`-${av}`);
+    if (bv !== void 0) out.push(`+${bv}`);
+  }
+  return out.join("\n");
+}
+function applyFullRead(dst, expected) {
+  fs4.mkdirSync(path5.dirname(dst), { recursive: true });
+  fs4.writeFileSync(dst, expected);
+  return `APPLIED Read ${dst} (${Buffer.byteLength(expected, "utf8")} bytes)`;
+}
+function snapshotMatchesExpected(body, expected, isChunked, offset, truncated) {
+  const text = body.toString("utf8");
+  const reencoded = Buffer.from(text, "utf8");
+  const isBinary = !reencoded.equals(body);
+  if (isBinary) {
+    if (isChunked || truncated) return false;
+    return Buffer.from(expected, "utf8").equals(body);
+  }
+  if (isChunked) {
+    const textLines = text.split("\n");
+    const start = Math.max(0, (offset ?? 1) - 1);
+    const expectedLines = expected.split("\n");
+    const end = start + expectedLines.length;
+    return textLines.slice(start, end).join("\n") === expected;
+  }
+  if (truncated) {
+    const prefixLen = expected.length;
+    return text.slice(0, prefixLen) === expected;
+  }
+  return trimTrailingNewline(text) === trimTrailingNewline(expected);
+}
+function trySnapshot(event, target, sourceRoots, snapshotIndex, expected, isChunked, offset, truncated) {
+  const ti = asToolInput(event);
+  const filePath = ti?.tool === "Read" ? ti.file_path : "";
+  let dst;
+  try {
+    dst = rewritePath(filePath, sourceRoots, target);
+  } catch (e) {
+    if (e instanceof OutsideSourceRoot) return null;
+    throw e;
+  }
+  const rel = path5.relative(target, dst);
+  if (rel.startsWith("..") || path5.isAbsolute(rel)) return null;
+  const relative4 = rel === "" ? "." : rel;
+  const body = snapshotIndex.findAtOrBefore(relative4, event.timestamp || "");
+  if (body === null) return null;
+  if (!snapshotMatchesExpected(body, expected, isChunked, offset, truncated)) {
+    return null;
+  }
+  fs4.mkdirSync(path5.dirname(dst), { recursive: true });
+  fs4.writeFileSync(dst, body);
+  return `SNAPSHOT Read ${dst} (${body.length} bytes)`;
+}
+function doRead(event, target, sourceRoots, applyReads, snapshotIndex) {
+  const ti = asToolInput(event);
+  if (ti?.tool !== "Read") {
+    throw new CheckpointFailure(`doRead called for non-Read tool '${event.toolName}'`);
+  }
+  const filePath = ti.file_path;
+  let dst;
+  try {
+    dst = rewritePath(filePath, sourceRoots, target);
+  } catch (e) {
+    if (e instanceof OutsideSourceRoot) {
+      throw new CheckpointFailure(`Read outside source root: ${e.message}`);
+    }
+    throw e;
+  }
+  let raw = event.resultText || "";
+  if (SENTINEL_ENVELOPE.test(raw.trim())) {
+    raw = "";
+  }
+  const truncated = TRUNCATION_MARKER.test(raw);
+  if (truncated) {
+    raw = raw.replace(TRUNCATION_MARKER, "");
+  }
+  const expected = stripCatN(raw);
+  const offset = ti.offset;
+  const limit = ti.limit;
+  const isChunked = offset !== null || limit !== null;
+  const tryHealOrHalt = (failureMsg) => {
+    if (snapshotIndex !== null) {
+      const heal = trySnapshot(
+        event,
+        target,
+        sourceRoots,
+        snapshotIndex,
+        expected,
+        isChunked,
+        offset,
+        truncated
+      );
+      if (heal !== null) return heal;
+    }
+    if (applyReads && !isChunked && !truncated) {
+      return applyFullRead(dst, expected);
+    }
+    throw new CheckpointFailure(failureMsg);
+  };
+  if (!fs4.existsSync(dst)) {
+    return tryHealOrHalt(`Read target missing: ${dst}`);
+  }
+  const onDisk = fs4.readFileSync(dst, "utf8");
+  if (isChunked) {
+    const diskLines = onDisk.split("\n");
+    const startIdx = Math.max(0, (offset ?? 1) - 1);
+    const expectedLines = expected.split("\n");
+    const endIdx = startIdx + expectedLines.length;
+    const diskSlice = diskLines.slice(startIdx, endIdx).join("\n");
+    if (diskSlice !== expected) {
+      const diff = lineDiff(expectedLines, diskLines.slice(startIdx, endIdx));
+      return tryHealOrHalt(
+        `Read chunk mismatch ${dst} [off=${offset} limit=${limit}]:
+${diff}`
+      );
+    }
+    return `OK Read ${dst} chunk`;
+  }
+  if (truncated) {
+    const prefixLen = expected.length;
+    if (onDisk.slice(0, prefixLen) !== expected) {
+      return tryHealOrHalt(`Read truncated-prefix mismatch ${dst}`);
+    }
+    return `OK Read ${dst} (truncated prefix)`;
+  }
+  if (trimTrailingNewline(onDisk) !== trimTrailingNewline(expected)) {
+    const diff = lineDiff(expected.split("\n"), onDisk.split("\n"));
+    return tryHealOrHalt(`Read full mismatch ${dst}:
+${diff.slice(0, 1e3)}`);
+  }
+  return `OK Read ${dst}`;
+}
+function runCheckpoint(event, target, sourceRoots, opts = {}) {
+  const applyReads = opts.applyReads ?? false;
+  const snapshotIndex = opts.snapshotIndex ?? null;
+  if (event.toolName === "Read") {
+    return doRead(event, target, sourceRoots, applyReads, snapshotIndex);
+  }
+  throw new CheckpointFailure(
+    `no checkpoint handler for tool '${event.toolName}'`
+  );
+}
+
+// src/llm-classifier/index.ts
+import * as path7 from "node:path";
+
+// src/llm-classifier/cache.ts
+import * as crypto from "node:crypto";
+import * as fs5 from "node:fs";
+import * as os from "node:os";
+import * as path6 from "node:path";
+var META_FILENAME = "meta.json";
+var INCLUDED_TOOLS = /* @__PURE__ */ new Set(["Bash", "Write", "Edit", "Read"]);
+function buildPayload(events) {
+  const out = [];
+  for (const ev of events) {
+    if (ev.isError) continue;
+    const tool = ev.toolName;
+    if (!INCLUDED_TOOLS.has(tool)) continue;
+    const ti = asToolInput(ev);
+    let inputValue = "";
+    if (ti?.tool === "Bash") inputValue = ti.command;
+    else if (ti?.tool === "Write" || ti?.tool === "Edit" || ti?.tool === "Read") {
+      inputValue = ti.file_path;
+    }
+    out.push([ev.index, tool, inputValue]);
+  }
+  return out;
+}
+function payloadIndices(events) {
+  const out = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (!e.isError && INCLUDED_TOOLS.has(e.toolName)) out.add(e.index);
+  }
+  return out;
+}
+function bashIndices(events) {
+  const out = /* @__PURE__ */ new Set();
+  for (const e of events) {
+    if (e.toolName === "Bash" && !e.isError) out.add(e.index);
+  }
+  return out;
+}
+var DEFAULT_BATCH_THRESHOLD = 50;
+var DEFAULT_BATCH_MAX_SIZE = 100;
+function buildBatches(payload, threshold = DEFAULT_BATCH_THRESHOLD, maxSize = DEFAULT_BATCH_MAX_SIZE) {
+  const batches = [];
+  let current = [];
+  for (const ev of payload) {
+    current.push(ev);
+    const [, tool, input] = ev;
+    const isGitCommit = tool === "Bash" && input.includes("git commit");
+    if (current.length >= maxSize) {
+      batches.push(current);
+      current = [];
+    } else if (current.length >= threshold && isGitCommit) {
+      batches.push(current);
+      current = [];
+    }
+  }
+  if (current.length > 0) batches.push(current);
+  return batches;
+}
+function hashOne(v) {
+  const h = crypto.createHash("sha256");
+  h.update(JSON.stringify(v), "utf8");
+  return "sha256:" + h.digest("hex");
+}
+function cacheKeyComponents(systemPrompt, intents, sourceRoots, initialState, events) {
+  const components = {
+    systemPrompt: hashOne(systemPrompt),
+    intents: hashOne([...intents]),
+    sourceRoots: hashOne([...sourceRoots]),
+    initialState: hashOne([...initialState]),
+    events: hashOne(events)
+  };
+  const h = crypto.createHash("sha256");
+  h.update(
+    JSON.stringify([
+      components.systemPrompt,
+      components.intents,
+      components.sourceRoots,
+      components.initialState,
+      components.events
+    ]),
+    "utf8"
+  );
+  const key = "sha256:" + h.digest("hex");
+  return { key, components };
+}
+function batchFilename(batchNo) {
+  return `batch-${batchNo.toString().padStart(4, "0")}.json`;
+}
+function encodeTargetForCacheKey(target) {
+  return target.replace(/\//g, "-");
+}
+function cacheDirForTarget(target) {
+  const root = process.env.XDG_CACHE_HOME || path6.join(os.homedir(), ".cache");
+  return path6.join(root, "claude-code-replay", encodeTargetForCacheKey(target));
+}
+function readMeta(cacheDir) {
+  const file = path6.join(cacheDir, META_FILENAME);
+  if (!fs5.existsSync(file)) return null;
+  try {
+    const data = JSON.parse(fs5.readFileSync(file, "utf8"));
+    if (typeof data.key !== "string") return null;
+    if (typeof data.num_batches !== "number") return null;
+    const components = data.components && typeof data.components === "object" ? data.components : void 0;
+    const last_event_ts = typeof data.last_event_ts === "string" ? data.last_event_ts : void 0;
+    return { key: data.key, num_batches: data.num_batches, components, last_event_ts };
+  } catch {
+    return null;
+  }
+}
+function readCachedLastEventTs(cacheDir) {
+  return readMeta(cacheDir)?.last_event_ts ?? null;
+}
+function readBatchEntry(cacheDir, batchNo) {
+  const file = path6.join(cacheDir, batchFilename(batchNo));
+  if (!fs5.existsSync(file)) return null;
+  try {
+    const data = JSON.parse(fs5.readFileSync(file, "utf8"));
+    const primary = data.primary;
+    if (typeof primary !== "string") return null;
+    const retry = typeof data.retry === "string" ? data.retry : null;
+    return { primary, retry };
+  } catch {
+    return null;
+  }
+}
+var ALL_COMPONENTS = [
+  "systemPrompt",
+  "intents",
+  "sourceRoots",
+  "initialState",
+  "events"
+];
+function loadAllBatches(cacheDir, expectedKey, expectedNumBatches, currentComponents) {
+  const meta = readMeta(cacheDir);
+  if (meta === null) {
+    return { kind: "miss", reason: "no-meta" };
+  }
+  if (meta.key !== expectedKey) {
+    const changed = diffComponents(meta.components, currentComponents);
+    wipeCacheDir(cacheDir);
+    return { kind: "miss", reason: "key-mismatch", changedComponents: changed };
+  }
+  if (meta.num_batches !== expectedNumBatches) {
+    wipeCacheDir(cacheDir);
+    return {
+      kind: "miss",
+      reason: "count-mismatch",
+      stored: meta.num_batches,
+      expected: expectedNumBatches
+    };
+  }
+  const entries = [];
+  for (let i = 0; i < expectedNumBatches; i++) {
+    const entry = readBatchEntry(cacheDir, i + 1);
+    if (entry === null) {
+      wipeCacheDir(cacheDir);
+      return { kind: "miss", reason: "missing-batch", batchNo: i + 1 };
+    }
+    entries.push(entry);
+  }
+  return { kind: "hit", entries };
+}
+function diffComponents(stored, current) {
+  if (!stored || !current) return [];
+  const changed = [];
+  for (const name of ALL_COMPONENTS) {
+    if (stored[name] !== current[name]) changed.push(name);
+  }
+  return changed;
+}
+function wipeCacheDir(cacheDir) {
+  if (!fs5.existsSync(cacheDir)) return;
+  for (const name of fs5.readdirSync(cacheDir)) {
+    if (name === META_FILENAME || /^batch-\d+\.json$/.test(name)) {
+      fs5.rmSync(path6.join(cacheDir, name), { force: true });
+    }
+  }
+}
+function writeBatchEntry(cacheDir, batchNo, primary, retry = null) {
+  fs5.mkdirSync(cacheDir, { recursive: true });
+  const data = { primary };
+  if (retry !== null) data.retry = retry;
+  fs5.writeFileSync(
+    path6.join(cacheDir, batchFilename(batchNo)),
+    JSON.stringify(data, null, 2)
+  );
+}
+function commitMeta(cacheDir, key, numBatches, components, lastEventTs) {
+  fs5.mkdirSync(cacheDir, { recursive: true });
+  const data = { key, num_batches: numBatches };
+  if (components) data.components = components;
+  if (lastEventTs) data.last_event_ts = lastEventTs;
+  fs5.writeFileSync(
+    path6.join(cacheDir, META_FILENAME),
+    JSON.stringify(data, null, 2)
+  );
+}
+
+// src/llm-classifier/prompts.ts
+var CLASSIFY_SYSTEM_PROMPT = `I am reconstructing lost project state from Claude Code logs.
+You help me pick the right commands to restore it. It's critically important that you're very thorough
+and precise in your response.
+
+## Input format
+JSON list of events. Each event is a compact 3-tuple: [index, tool, input] where:
+- index: integer event identifier
+- tool: "Bash", "Write", "Edit", or "Read"
+- input: the Bash command (for "Bash") or the file path (for "Write" / "Edit" / "Read").
+
+
+## Decision
+All Write, Edit, Read events are ALWAYS replayed natively \u2014 you must not return entries for them.
+Your only job is to decide, per Bash event, what (if anything) should run.
+
+Runtime tolerance: Read events whose file is missing at checkpoint time are
+**silently skipped**, not halted. This means you can confidently cascade-OMIT
+a Bash chain when its sources are missing, without worrying that a downstream
+Read of the would-have-been-produced file will stop the replay. Cascade-omits
+are the correct, safe choice \u2014 the runtime has your back on the downstream
+Read side. (Bash subprocess failures STILL halt the replay, so the rule
+about omitting Bash events that read from missing files is unchanged.)
+
+For each Bash event, choose one of:
+  (a) Keep verbatim \u2192 emit \`[index, "#exact#"]\`.
+  (b) Rewrite \u2192 emit \`[index, "<subset of the chain>"]\` when only part of a chain should run.
+  (c) Skip \u2192 OMIT the index from your response entirely.
+
+The replay executes the returned \`command\` exactly as given, in event-index order.
+You're free to keep \`&&\`, \`||\`, \`;\`, \`|\`, redirects, heredocs \u2014 whatever is
+needed for the kept portion to be runnable on its own.
+
+## CWD Safety
+
+Why this matters: the replay runs every Bash event inside a single target
+directory derived from <source-roots>. If an event's command changes the
+working directory to a path NOT listed under <source-roots>, the rest of
+the chain escapes the target directory and operates against the real,
+present-day filesystem \u2014 usually with the wrong content. This is unsafe
+and silently corrupts the replay.
+
+THE RULE: For every Bash event you consider keeping, walk through its top-level
+subcommands. If ANY subcommand is \`cd <abs-path>\` or \`pushd <abs-path>\`
+AND <abs-path> is NOT equal to (or a subdirectory of) one of the paths
+listed inside <source-roots>, OMIT the whole event.
+Do NOT strip the \`cd\` and keep the rest of the chain \u2014 the remainder
+was written assuming that working directory; running it in the sandbox
+cwd produces silently wrong results.
+
+How to check, step by step:
+1. Split the command at top-level chain operators: \`&&\`, \`||\`, \`;\`, \`|\`, and newlines.
+2. For each subcommand that starts with \`cd \` or \`pushd \`, extract the target path.
+3. If the target is RELATIVE (\`cd src/\`, \`cd ..\`, \`cd .\`) \u2192 fine, the sandbox cwd is preserved.
+4. If the target is ABSOLUTE (starts with \`/\` or \`~/\`):
+  - Check if it equals OR is a subdirectory of any entry in
+    <source-roots>. If yes \u2192 in-scope, fine.
+  - If no \u2192 OMIT THE ENTIRE EVENT. Do not return any entry for it.
+5. Note: even one out-of-scope cd anywhere in the chain disqualifies the whole event.
+
+### CWD Safety Examples
+
+Source-roots in this example: ["/users/x/proj/orig"]; \`i\` = the event's index
+
+  original                                                                         \u2192 emit
+  \`cd /users/x/proj/orig && git add foo && git commit -m x\`                      \u2192 \`[i, "#exact#"]\`  (cd target IS a source root)
+  \`cd /users/x/proj/orig/internal && go test ./...\`                              \u2192 \`[i, "#exact#"]\`  (subdir of a source root)
+  \`cd /users/x/proj/old-name && git commit -m x\`                                 \u2192 OMIT              (old-name not in source-roots)
+  \`cd /users/x/proj/old-name && git add . && git commit -q -m foo\`               \u2192 OMIT              (do NOT strip the cd to keep \`git add && git commit\`)
+  \`cd /opt/scratch && ./build.sh\`                                                \u2192 OMIT              (/opt/scratch out of scope)
+  \`git status && cd /tmp/other && rm -rf .\`                                      \u2192 OMIT              (out-of-scope cd appears mid-chain \u2014 still OMIT)
+  \`pushd /var/log && tail -n 50 foo.log\`                                         \u2192 OMIT              (pushd treated like cd)
+  \`cd src/ && go build\`                                                          \u2192 (cd is relative; cwd-safety doesn't apply \u2014 apply normal REWRITE RULES below)
+  \`cd .. && ls\`                                                                  \u2192 (relative; cwd-safety doesn't apply)
+  \`go test ./...\`                                                                \u2192 (no cd; cwd-safety doesn't apply)
+
+## Rewrite Rules
+- Keep state-mutating subcommands: git history changes, codegen, package installs, heredoc/sed/awk/printf writes, scaffolding mkdirs, dependency syncs.
+- **Environment-setup commands MUST be kept** \u2014 they produce committable artifacts (lock files, version pins, generated sources) that later \`git add\`/\`git commit\` chains depend on. If you skip an environment-setup command, every subsequent commit that references its outputs will fail.
+  Common families (NON-exhaustive \u2014 extend the same reasoning to peers):
+  - **Python / uv**: \`uv sync\`, \`uv lock\`, \`uv add\`, \`uv remove\`, \`uv python pin\`, \`uv init\` \u2192 produce \`uv.lock\`, \`.python-version\`, populate \`.venv/\`.
+  - **Python / pip+venv**: \`python -m venv .venv\`, \`pip install -r requirements.txt\`, \`pip freeze > requirements.txt\` \u2192 produce \`requirements.txt\`, \`.venv/\`.
+  - **Python / poetry**: \`poetry install\`, \`poetry lock\`, \`poetry add\` \u2192 produce \`poetry.lock\`.
+  - **Node**: \`npm install\`, \`npm ci\`, \`yarn install\`, \`pnpm install\`, \`bun install\` \u2192 produce \`package-lock.json\`, \`yarn.lock\`, \`pnpm-lock.yaml\`, \`bun.lockb\`, \`node_modules/\`.
+  - **Go**: \`go mod init\`, \`go mod tidy\`, \`go mod download\`, \`go get \u2026\` \u2192 produce/update \`go.mod\`, \`go.sum\`.
+  - **Rust**: \`cargo init\`, \`cargo new\`, \`cargo add\`, \`cargo update\`, \`cargo generate-lockfile\` \u2192 produce \`Cargo.lock\`.
+  - **Ruby**: \`bundle install\`, \`bundle update\`, \`bundle add\` \u2192 produce \`Gemfile.lock\`.
+  - **Codegen**: \`make proto\`, \`protoc \u2026\`, \`buf generate\`, \`prisma generate\`, \`sqlc generate\`, \`openapi-generator \u2026\`, \`graphql-codegen\` \u2192 produce generated source files (often committed alongside the spec).
+  - **Init scripts**: \`scripts/bootstrap.sh\`, \`./setup\`, \`make setup\` \u2014 anything the project relies on to materialise lockfiles/configs before a commit captures them.
+  Rule of thumb: if an event creates or modifies a file that a LATER \`git add\` or \`git commit\` references, KEEP that event verbatim (with \`#exact#\`).
+- Drop subcommands that:
+  - Compile the project's own binary (\`go build\`, \`cargo build\`, \`tsc\` emit, bundler invocations).
+    If the ONLY mutating part of a chain is a build, OMIT the whole chain.
+    If other mutating subcommands exist alongside (e.g. \`git commit\`), keep just those and drop the build.
+    NOTE: do NOT confuse \`cargo build\` (drop) with \`cargo update\`/\`cargo add\` (KEEP \u2014 env setup, see above).
+    Similarly: \`go build\` (drop) vs \`go mod tidy\` (KEEP); \`tsc\` emit (drop) vs \`npm install\` (KEEP).
+  - Invoke the project's own built binary (\`./myserver \u2026\`, \`./mybinary \u2026\`, \`bin/cli \u2026\`).
+    Builds + runs do not affect git state.
+  - Read/inspect external state we cannot reproduce.
+  - Are purely read-only (\`ls\`, \`cat\`, \`find\` without \`-delete\`, \`grep\`, \`git status/log/diff\`, \`which\`, \`*\\\`--version\`).
+- Never invent commands the original didn't contain. The returned command MUST be an exact substring of the original command.
+- CWD-safety is a prerequisite \u2014 apply it BEFORE these rules. If cwd-safety says OMIT, the rewrite rules don't even get a vote.
+
+### Rewrite examples
+
+assume intent is "preserve git history; skip CLI build/run"; \`i\` = the event's index; cwd-safety already cleared)
+
+  original                                                            \u2192 emit
+  \`ls -la\`                                                          \u2192 OMIT
+  \`go mod init github.com/u/p\`                                      \u2192 \`[i, "#exact#"]\`
+  \`git init && git add . && git commit -m "init"\`                   \u2192 \`[i, "#exact#"]\`
+  \`go build -o myserver ./cmd/myserver && ./myserver run\`           \u2192 OMIT (both halves excluded)
+  \`make proto && git add gen/ && git commit -m "proto"\`             \u2192 \`[i, "#exact#"]\`
+  \`go test ./... && go build -o bin/cli ./cmd/cli\`                  \u2192 \`[i, "go test ./..."]\`
+  \`go build && go test ./...\`                                       \u2192 \`[i, "go test ./..."]\`
+  \`git status && git commit -am wip\`                                \u2192 \`[i, "git commit -am wip"]\`
+  \`find /etc -name '*.conf' && echo done\`                           \u2192 OMIT  (pure inspection)
+
+Environment-setup examples (KEEP these \u2014 they create committable artifacts):
+
+  original                                                            \u2192 emit
+  \`uv sync\`                                                          \u2192 \`[i, "#exact#"]\`  (creates .venv/, may write .python-version)
+  \`uv sync 2>&1 | tail -20\`                                          \u2192 \`[i, "#exact#"]\`  (tail is cosmetic; uv sync mutates)
+  \`uv add somepackage>=0.2.20\`                                       \u2192 \`[i, "#exact#"]\`  (updates pyproject.toml + uv.lock)
+  \`uv python pin 3.12\`                                               \u2192 \`[i, "#exact#"]\`  (writes .python-version)
+  \`rm uv.lock && uv sync && uv run pytest -v 2>&1 | tail -20\`        \u2192 \`[i, "rm uv.lock && uv sync"]\`  (drop pytest; keep the lock rebuild)
+  \`npm install\`                                                      \u2192 \`[i, "#exact#"]\`  (writes package-lock.json + node_modules/)
+  \`npm install lodash --save\`                                        \u2192 \`[i, "#exact#"]\`  (mutates package.json + lock)
+  \`pnpm install --frozen-lockfile\`                                   \u2192 \`[i, "#exact#"]\`
+  \`go mod tidy\`                                                      \u2192 \`[i, "#exact#"]\`  (writes go.sum)
+  \`go mod tidy && go test ./...\`                                     \u2192 \`[i, "go mod tidy"]\`  (drop tests; tidy mutates)
+  \`go get github.com/foo/bar@latest\`                                 \u2192 \`[i, "#exact#"]\`
+  \`cargo update\`                                                     \u2192 \`[i, "#exact#"]\`  (rewrites Cargo.lock)
+  \`cargo add serde\`                                                  \u2192 \`[i, "#exact#"]\`
+  \`bundle install\`                                                   \u2192 \`[i, "#exact#"]\`  (writes Gemfile.lock)
+  \`make proto && git add gen/ && git commit -m proto\`                \u2192 \`[i, "#exact#"]\`  (codegen + commit)
+  \`buf generate && git add gen/\`                                     \u2192 \`[i, "#exact#"]\`
+  \`./scripts/bootstrap.sh\`                                           \u2192 \`[i, "#exact#"]\`  (project-defined env setup)
+
+## File-dependency awareness
+
+A Bash event that reads from a file path will FAIL during replay if that
+file isn't on disk. Each user message starts with a
+<files-present></files-present> block listing every file guaranteed to be
+on disk at the start of that batch. Files in the block come from:
+
+  (a) the replay target's initial state (user-provided, if any); plus
+  (b) every Write or Edit event in PRIOR batches (Writes/Edits are
+      ALWAYS replayed natively, so their files materialise on disk).
+
+The block does NOT enumerate Bash outputs. If a Bash event YOU KEPT
+earlier obviously produces a file (e.g. \`mkdir <path>\`, \`touch <path>\`,
+\`cp <src> <path>\` from an available source, heredoc/redirect to
+<path>, codegen whose output lands at <path>), you may reason that the
+file is also available \u2014 but only when the production is unambiguous.
+When in doubt, treat the file as absent.
+
+<files-present> is GUARANTEED \u2014 these files are on disk at the start of this
+batch. <files-speculated> is CLAIMED \u2014 a prior batch's kept event was
+expected to produce them, but the replay has not verified the claim. Treat
+speculated entries as PROBABLY present when the producing chain is
+unambiguous (mkdir, simple heredoc, cp with both ends accounted for); treat
+them as UNCERTAIN when the producing event has failure modes the speculation
+cannot predict (network fetch, archive extraction with unknown contents,
+codegen with variable outputs). When uncertain \u2192 OMIT the reader.
+
+CRITICAL CLARIFICATION about source roots: "the path is inside
+<source-roots>" does NOT imply the file exists. <source-roots> governs
+CWD safety only; <files-present> is the authoritative list of
+guaranteed-present files. User-supplied binaries \u2014 \`.apk\`, \`.apkm\`,
+\`.zip\`, \`.tar.gz\`, downloaded fixtures, screenshots, data dumps \u2014 that
+the original session reads but no payload Write/Edit/kept-Bash produces
+are NEVER available in the replay, regardless of their path. Don't be
+fooled by their location.
+
+For each Bash event you are considering keeping, examine EVERY source
+path it reads from. If ANY source path is not in <files-present> AND
+not obviously produced by an earlier KEPT Bash event, OMIT the event.
+The replay would halt on it otherwise.
+
+Cascading rule: if you OMIT an event because its sources are missing,
+DO NOT count that event's outputs as available for later events. A
+chain whose first link is OMITted has ALL downstream links OMITted too
+(until a later event re-introduces the missing files via Write/Edit
+or a freshly-kept Bash event whose own sources are accounted for).
+
+This is a HEURISTIC, not a guarantee:
+- Be conservative on read sources. If you're unsure whether a file
+  exists by this point, OMIT.
+- Be permissive on write destinations. A Bash event that creates a NEW
+  file (e.g. \`mkdir\`, \`touch\`, \`cp\` whose source is in initial-state)
+  doesn't violate the rule even though the destination didn't exist
+  before \u2014 the event itself produces it.
+- INTENTS WIN. If the user's intent says to keep a category that this
+  rule would skip, keep it.
+
+Examples (assume <files-present> is empty unless noted; \`i\` = event index):
+
+  prior events                                                              | this event                                                  | decision
+  --------------------------------------------------------------------------+-------------------------------------------------------------+---------
+  <files-present> contains \`src/foo.go\`                                     | \`cp /src/foo.go /src/foo.bak\`                              \u2192 \`[i, "#exact#"]\`  (foo.go is listed as present)
+  <files-present> does NOT include \`src/codegen-out/Bar.java\`                  | \`cp /src/codegen-out/Bar.java /src/Bar.java\`                  \u2192 OMIT             (source not in <files-present> and not produced by a kept Bash)
+  Bash KEPT: \`codegen decompile foo.apk -o codegen-out/\` AND foo.apk in <files-present> | \`cp codegen-out/Bar.java Bar.java\`                            \u2192 \`[i, "#exact#"]\`  (the kept codegen run produces it)
+  Bash that would produce codegen-out/ was OMITted (cascading)                 | \`cp codegen-out/Bar.java Bar.java\`                            \u2192 OMIT             (cascade \u2014 producer omitted, so output absent)
+  Bash SKIPPED: \`codegen decompile foo.apk -o codegen-out/\` (per rewrite rules)   | \`cp codegen-out/Bar.java Bar.java\`                            \u2192 OMIT             (the producer was skipped)
+  <files-present> contains \`src/legacy.py\`                                  | \`sed -i 's/old/new/' src/legacy.py\`                        \u2192 \`[i, "#exact#"]\`  (file is listed)
+  <files-present> does NOT include \`src/lock.json\`                          | \`cat /src/lock.json\`                                       \u2192 OMIT             (pure inspection AND source-missing \u2014 drop either way)
+  <files-present> is EMPTY                                                    | \`unzip foo.apkm -d apkm-contents\`                          \u2192 OMIT             (foo.apkm not in <files-present>; do not be misled by the path looking project-local \u2014 empty means empty)
+
+Speculation entries only come from KEPT events. An omitted event contributes nothing \u2014 its outputs do not appear in <files-speculated> for later batches. Cascading OMITs are the correct behavior.
+
+### Worked example: user-supplied APK cascade
+
+The original session manually placed an \`.apkm\` file inside the project
+dir before running. The replay has NO knowledge of that binary \u2014 it's too
+large for a Write event and no Bash event in the payload produces it. So
+<files-present> will NEVER list it. The classifier must cascade omits:
+
+  event  | command (abridged)                                                | source reads                  | in <files-present>? | decision
+  -------+-------------------------------------------------------------------+-------------------------------+---------------------+---------
+  151    | \`brew install codegen apktool\`                                       | (system pkg manager)          | n/a                 | depends on rewrite rules (no source-roots reads)
+  154    | \`mkdir -p apkm-contents && unzip /src/foo.apkm -d apkm-contents\`  | \`/src/foo.apkm\`               | NO                  | OMIT
+  156    | \`codegen -d codegen-out apkm-contents/base.apk\`                         | \`apkm-contents/base.apk\`      | NO (154 cascaded)   | OMIT
+  160    | \`cp codegen-out/sources/.../BTBle.java .../BTBle.java && cp ...\`     | \`codegen-out/sources/...\`        | NO (156 cascaded)   | OMIT
+
+Even though the .apkm path is inside <source-roots>, it isn't in
+<files-present>. That alone is enough to OMIT event 154, and the cascade
+omits 156 and 160. Without this cascade, the replay halts at 160 on a
+missing source file.`;
+var OUTPUT_FORMAT = `## Output Format
+
+**CRITICAL**: Your response is a JSON 2-array \`[ [decisions...], [speculations...] ]\` \u2014 NOT a bare list of decisions. A response like \`[[10, "#exact#"]]\` is WRONG even when there are no speculations to declare; the correct form with no speculations is \`[[[10, "#exact#"]], []]\` (outer 2-array, decisions inside, empty speculations array).
+
+Your entire response is a JSON 2-array:
+
+\`\`\`
+[
+  [ ...decisions... ],
+  [ ...speculations... ]
+]
+\`\`\`
+
+Each decision is a 2-array \`[index, command]\` where \`command\` is EITHER the literal sentinel string \`"#exact#"\` OR a modified shell command string (substring of the original).
+
+- \`[index, "#exact#"]\`     \u2014 execute the event's ORIGINAL Bash command verbatim.
+- \`[index, "<command>"]\`   \u2014 execute the rewritten command (a substring of the original chain). Use this ONLY when part of the chain must be dropped.
+- omit the index entirely \u2192 skip.
+
+You must consciously CHOOSE one of these for every event you keep \u2014 \`"#exact#"\` is the verbatim-keep signal; everything else is a rewrite that runs literally. Every kept decision entry MUST have exactly 2 elements (\`[index, command]\`); 1-element arrays like \`[42]\` are INVALID. Decide first, then write \u2014 do not emit a draft and restart.
+
+Each speculation is a 2-array \`[path, producing_idx]\` where:
+- \`path\`: a project-relative file path (no leading "/", no leading "./", no ".." segments)
+- \`producing_idx\`: the index of an event in THIS BATCH'S payload that produces \`path\` on disk (Bash, Write, or Edit).
+
+Speculation rules:
+- Speculate only files that one of YOUR KEPT events in this batch will produce on disk.
+  Skipped events contribute nothing. (Write/Edit are always replayed natively, so
+  they always count as "kept" for speculation purposes.)
+- Prefer not to repeat paths already in <files-present> or <files-speculated> \u2014 they
+  are tracked already and will be normalized away. Repeats are not an error.
+- A single producing event can claim multiple paths \u2014 emit one [path, idx] entry per claim.
+- Do NOT speculate deletions. Speculation is additive only.
+- When production is uncertain (archive extraction with unknown contents, network fetch,
+  codegen with variable outputs), be conservative \u2014 claim only what is unambiguously created.
+
+Empty cases:
+- Nothing kept, nothing speculated: \`[[], []]\`
+- Decisions but no speculations:    \`[[[42, "#exact#"]], []]\`
+
+WRONG (bare list \u2014 old format, do not emit):
+  [[10, "#exact#"], [11, "git commit"]]
+  []
+
+RIGHT (always 2-array, even when speculations are empty):
+  [[[10, "#exact#"], [11, "git commit"]], []]
+  [[], []]
+
+The opening of your response is literally the characters \`[[\` (two left brackets \u2014 the outer 2-array and the start of the decisions list). The closing is \`]]\`.
+
+No preamble. No commentary. No markdown fences (no \`\`\`json). Compact JSON.
+`;
+var CLASSIFY_TAIL = `
+
+## Source roots
+Apply the CWD SAFETY rule from earlier in this prompt with
+these paths. The paths inside <source-roots></source-roots> are the
+ONLY absolute paths the replay treats as project-local. Every \`cd <abs>\`
+or \`pushd <abs>\` you keep MUST target one of these paths (or a subdir of
+one). Anything else \u2192 OMIT the event in full.
+
+<source-roots>
+</source-roots>
+
+# User intent
+Read carefully \u2014 the user's specific intents for THIS replay are inside <intents></intents>.
+Respect these rules even when the rules or supplements would otherwise suggest including X.
+Intent-stated exclusions are a HARD constraint, not a hint.
+
+
+<intents>
+</intents>
+
+## Multi-turn protocol
+
+Commands arrive one BATCH per user turn. Each user message contains:
+  - a \`Batch N/M\` header,
+  - a \`<files-present>...</files-present>\` block listing files that are
+    guaranteed to be on disk in the replay target at the start of this
+    batch (see "File-dependency awareness" above),
+  - a \`<files-speculated>...</files-speculated>\` block listing files
+    that a PRIOR batch's kept event claimed to produce, with provenance
+    \`(from idx N)\`. Apply the asymmetric-trust rule from the
+    "File-dependency awareness" section above when reading from these.
+  - a \`<commands>...</commands>\` block: a JSON list of [index, tool,
+    input] tuples for THIS batch.
+
+Respond with a JSON list per the output format above \u2014 decisions for THAT
+BATCH ONLY. Do not reference indices from prior or future batches.
+
+Some user messages will be retry follow-ups: they contain a
+\`<failures>...</failures>\` block listing entries from your previous response
+that failed substring validation. For retry turns, return a JSON list of
+corrected entries (same output format).
+`;
+var RESTORE_GIT_COMMITS_SUPPLEMENT = `## Additional Focus: Restore Git Commit History
+
+Beyond the general rules above, this run cares specifically about
+reconstructing the original session's git history on the replay target.
+Every commit, branch, tag, ref move, merge/rebase/revert result, and
+history rewrite must be reconstructible from the executed Bash events.
+
+Pay SPECIAL attention to these commands when they appear (non-exhaustive,
+extend the same reasoning to any equivalent command not listed below):
+- \`git init\` \u2014 repo creation
+- \`git add\` (any form: file list, \`-A\`, \`.\`, glob)
+- \`git commit\` (including \`--amend\`, \`-m\`, heredoc messages, \`--no-verify\`)
+- \`git branch\`, \`git checkout\`, \`git switch\` when they create or move a ref
+- \`git merge\`, \`git rebase\`, \`git cherry-pick\`, \`git revert\`
+- \`git reset\` when it moves HEAD or modifies the index
+- \`git tag\` (annotated or lightweight)
+- \`git stash push\` / \`pop\` / \`apply\` when working tree state matters
+- \`git filter-repo\`, \`git filter-branch\` \u2014 history rewrites
+- \`git apply\`, \`git am\`, \`patch\` when applying a stored diff
+- \`git remote add\`, \`git fetch\`, \`git pull\` when needed to make a ref local
+- \`git update-ref\`, \`git symbolic-ref\` \u2014 direct ref manipulation
+- \`git config\` writes used by subsequent commits (e.g. user.email)
+- heredoc / \`cat <<EOF\`, \`sed -i\`, \`awk\` redirects, \`printf > file\` that
+  produce content a later \`git commit\` captures
+
+When in doubt about whether a subcommand contributes to git state \u2014 KEEP IT.
+A spurious execute of git-adjacent work is recoverable; a missed mutation
+breaks the chain. Still drop CLI-build / CLI-run subcommands per the rewrite
+rules above.
+
+CRUCIAL EXCEPTION \u2014 git commands in OTHER directories must be IGNORED:
+The "preserve all git history" goal above applies ONLY to commands that
+operate on a repo INSIDE <source-roots>. A git command that runs in a
+different directory is editing a DIFFERENT REPO \u2014 replaying it against the
+replay target either silently corrupts our target (if the cd is stripped
+or rewritten) or executes against a real-world directory on disk
+(sandbox escape).
+
+Apply this AS PART of cwd-safety, not in spite of it:
+- If a Bash event begins with \`cd <path>\` (or contains \`&& cd <path>\`
+  mid-chain) AND <path> is NOT listed in <source-roots>, OMIT the event
+  in full \u2014 including any \`git init\`, \`git add\`, \`git commit\`,
+  \`git checkout\`, \`git branch\`, \`git merge\`, \`git rebase\`, \`git tag\`,
+  \`git filter-repo\` that follows on that chain. The "keep all git
+  mutations" rule does NOT override cwd-safety.
+- Do NOT strip the \`cd\` to recover the trailing git command. The
+  trailing git command was operating in the OTHER repo and would
+  fabricate a commit in our repo (wrong tree, wrong author state).
+
+Concrete examples (assume <source-roots> = [\`/u/x/proj/orig\`]):
+  \`cd /u/x/proj/orig && git init && git add . && git commit -m init\`           \u2192 \`[i, "#exact#"]\`  (cd is in-scope)
+  \`cd /u/x/proj/old-name && git init && git add . && git commit -m init\`       \u2192 OMIT             (different repo)
+  \`cd /u/x/proj/old-name && git commit -q -m "Initial old-name\u2026"\`              \u2192 OMIT             (different repo's commit chain)
+  \`cd /u/x/proj/old-name && git filter-repo --invert-paths --path .env\`        \u2192 OMIT             (history rewrite, but in a different repo)
+  \`git -C /u/x/proj/old-name commit -m foo\`                                   \u2192 OMIT             (\`-C <out-of-scope>\` is equivalent to cd-out-of-scope)
+  \`git add foo && git commit -m bar\`                                          \u2192 \`[i, "#exact#"]\`  (no cd; runs in sandbox cwd \u2014 fine)
+
+For "git -C <dir>" usage, apply the same rule as cd: the <dir> argument
+to \`-C\` must be inside <source-roots> or the event is OMITTED.`;
+var EXACT_SENTINEL = "#exact#";
+function buildBatchUserMessage(batchNo, totalBatches, filesPresent, filesSpeculated, commandsJson) {
+  const presentBody = filesPresent.length === 0 ? "(empty \u2014 target has no guaranteed files at the start of this batch)" : [...filesPresent].sort().map((p) => `- ${p}`).join("\n");
+  const specSorted = [...filesSpeculated].sort(
+    (a, b) => a.path.localeCompare(b.path)
+  );
+  const speculatedBody = specSorted.length === 0 ? "(empty \u2014 no prior-batch event has claimed file outputs)" : specSorted.map((s) => `- ${s.path} (from idx ${s.producingIdx})`).join("\n");
+  return `Batch ${batchNo}/${totalBatches}. Classify the commands below per the rules in the system prompt. Return the JSON response only \u2014 opening characters MUST be \`[[\` (the outer 2-array start), closing MUST be \`]]\`.
+
+<files-present>
+${presentBody}
+</files-present>
+
+<files-speculated>
+${speculatedBody}
+</files-speculated>
+
+<commands>
+${commandsJson}
+</commands>`;
+}
+function buildRetryUserMessage(failures) {
+  const failuresJson = JSON.stringify(
+    failures.map((f) => [f.idx, f.original, f.returned])
+  );
+  return `Retry. The entries below from your previous response failed validation: the \`command\` was NOT derivable from the original event's command.
+
+A valid rewrite is EITHER the literal sentinel \`"#exact#"\` OR an exact substring of the original's subcommands (joined with the same operators as the original \u2014 \`&&\`, \`||\`, \`;\`, \`|\`). You CANNOT introduce new tokens, new flags, new arguments, or new commands.
+
+If you cannot produce a valid rewrite for an entry, OMIT that index entirely.
+
+Each failure is a 3-tuple \`[index, original, your-prior-rewrite]\`:
+
+<failures>
+${failuresJson}
+</failures>
+
+Return the corrected response in the 2-array shape from the system prompt, with the speculations array empty: \`[[corrected_decisions...], []]\`. An empty corrections array \`[[], []]\` is valid if every failure should be omitted.`;
+}
+function composeMode(opts = {}) {
+  const labels = ["base"];
+  const systemPrompt = `${OUTPUT_FORMAT}
+${CLASSIFY_SYSTEM_PROMPT}
+
+---
+
+${RESTORE_GIT_COMMITS_SUPPLEMENT}${CLASSIFY_TAIL}`;
+  const intents = (opts.customIntents ?? []).map((s) => s.trim()).filter((s) => s.length > 0);
+  if (intents.length > 0) labels.push("custom-intent");
+  return { label: labels.join("+"), intents, systemPrompt };
+}
+function composeSystemPrompt(template, intents, sourceRoots) {
+  const intentsBody = intents.length === 0 ? "(none)" : intents.map((s) => `- ${s}`).join("\n");
+  const sourceRootsBody = sourceRoots.length === 0 ? "(none \u2014 treat every absolute path with skepticism)" : sourceRoots.map((s) => `- ${s}`).join("\n");
+  return template.replace(
+    /<source-roots>[\s\S]*?<\/source-roots>/,
+    `<source-roots>
+${sourceRootsBody}
+</source-roots>`
+  ).replace(/<intents>[\s\S]*?<\/intents>/, `<intents>
+${intentsBody}
+</intents>`);
+}
+
+// src/llm-classifier/parse.ts
+var ClassifierError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ClassifierError";
+  }
+};
+function validateSpeculationEntry(entry, payloadIdxs, bashKeptIdxs, nonBashPayloadIdxs) {
+  if (typeof entry.path !== "string" || entry.path.length === 0) {
+    return { ok: false, error: "path is empty" };
+  }
+  if (entry.path.startsWith("/")) {
+    return { ok: false, error: "path has leading '/' (must be project-relative)" };
+  }
+  if (entry.path.split("/").some((seg) => seg === "..")) {
+    return { ok: false, error: "path contains '..' segment" };
+  }
+  if (!payloadIdxs.has(entry.producingIdx)) {
+    return {
+      ok: false,
+      error: `producing_idx ${entry.producingIdx} is not in this batch's payload`
+    };
+  }
+  const isNonBash = nonBashPayloadIdxs?.has(entry.producingIdx) ?? false;
+  if (!isNonBash && !bashKeptIdxs.has(entry.producingIdx)) {
+    return {
+      ok: false,
+      error: `producing_idx ${entry.producingIdx} references a Bash event the classifier omitted (kept events only)`
+    };
+  }
+  return { ok: true };
+}
+var NON_VERB_CHARS_RE = /^[\s&|;]*$/;
+function isValidRewrite(rewritten, original) {
+  if (rewritten.length === 0) return false;
+  if (NON_VERB_CHARS_RE.test(rewritten)) return false;
+  return original.includes(rewritten);
+}
+function extractJson(text) {
+  const trimmed = text.trim();
+  const fence = /^```(?:json)?\s*([\s\S]*?)\s*```$/.exec(trimmed);
+  return fence ? fence[1].trim() : trimmed;
+}
+function parseEntry(entry, bashIdxs, originalByIdx) {
+  if (!Array.isArray(entry) || entry.length !== 2) {
+    return {
+      ok: false,
+      idx: null,
+      bad: {
+        raw: entry,
+        error: 'not a 2-element array [index, command] (use "#exact#" for verbatim)'
+      }
+    };
+  }
+  const idx = entry[0];
+  if (typeof idx !== "number" || !Number.isInteger(idx)) {
+    return {
+      ok: false,
+      idx: null,
+      bad: { raw: entry, error: "index is not int" }
+    };
+  }
+  if (!bashIdxs.has(idx)) {
+    return {
+      ok: false,
+      idx,
+      bad: {
+        raw: entry,
+        error: `idx ${idx} is not a Bash event in the input (fabricated)`
+      }
+    };
+  }
+  const command = entry[1];
+  if (typeof command !== "string" || command.trim() === "") {
+    return {
+      ok: false,
+      idx,
+      bad: { raw: entry, error: "command is missing or empty" }
+    };
+  }
+  const original = originalByIdx.get(idx) ?? "";
+  if (command === EXACT_SENTINEL) {
+    return {
+      ok: true,
+      idx,
+      decision: {
+        intent: "execute",
+        command: original,
+        reason: "execute (verbatim)"
+      }
+    };
+  }
+  if (!isValidRewrite(command, original)) {
+    return {
+      ok: false,
+      idx,
+      bad: {
+        raw: entry,
+        error: `rewrite at idx ${idx} is not a subset of the original command (fabricated)`,
+        retry: { idx, original, returned: command }
+      }
+    };
+  }
+  const rewritten = command !== original;
+  const reason = rewritten ? "execute (rewritten)" : "execute (verbatim)";
+  return {
+    ok: true,
+    idx,
+    decision: { intent: "execute", command, reason }
+  };
+}
+function detectResponseShape(top) {
+  if (!Array.isArray(top)) return "unknown";
+  if (top.length === 1 && Array.isArray(top[0]) && top[0].length === 2 && Array.isArray(top[0][0]) && Array.isArray(top[0][1])) {
+    return "wrapped";
+  }
+  if (top.length === 0) return "bare-list";
+  if (top.length === 2 && Array.isArray(top[0]) && Array.isArray(top[1])) {
+    const spec = top[1];
+    if (spec.length === 0) return "two-array";
+    const specHead = spec[0];
+    if (Array.isArray(specHead) || specHead !== null && typeof specHead === "object") {
+      return "two-array";
+    }
+  }
+  return "bare-list";
+}
+function parseBatchResponse(raw, bashPayloadIdxs, originalByIdx, payloadIdxs, nonBashPayloadIdxs, emit) {
+  const cleaned = extractJson(raw);
+  let top;
+  try {
+    top = JSON.parse(cleaned);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new ClassifierError(
+      `classifier returned non-JSON response: ${msg}
+raw response (first 500 chars):
+${raw.slice(0, 500)}`
+    );
+  }
+  const shape = detectResponseShape(top);
+  let decRaw;
+  let specRaw;
+  if (shape === "two-array") {
+    [decRaw, specRaw] = top;
+  } else if (shape === "wrapped") {
+    [decRaw, specRaw] = top[0];
+  } else if (shape === "bare-list") {
+    if (emit) {
+      emit(
+        "INFO classifier lenient parse: model returned bare decisions list (no speculations arm); treating as decisions-only"
+      );
+    }
+    decRaw = top;
+    specRaw = [];
+  } else {
+    throw new ClassifierError(
+      `classifier response is not a recognized shape (expected 2-array [decisions, speculations] or bare-list of decisions): ` + JSON.stringify(top).slice(0, 200)
+    );
+  }
+  if (!Array.isArray(decRaw)) {
+    throw new ClassifierError(
+      `decisions arm is not a list: ${JSON.stringify(decRaw).slice(0, 200)}`
+    );
+  }
+  if (!Array.isArray(specRaw)) {
+    throw new ClassifierError(
+      `speculations arm is not a list: ${JSON.stringify(specRaw).slice(0, 200)}`
+    );
+  }
+  const decisions = /* @__PURE__ */ new Map();
+  const bad = [];
+  const seenIdx = /* @__PURE__ */ new Set();
+  for (const entry of decRaw) {
+    const res = parseEntry(entry, bashPayloadIdxs, originalByIdx);
+    if (!res.ok) {
+      bad.push(res.bad);
+      continue;
+    }
+    if (seenIdx.has(res.idx)) {
+      bad.push({ raw: entry, error: `duplicate entry for idx ${res.idx}` });
+      continue;
+    }
+    seenIdx.add(res.idx);
+    decisions.set(res.idx, res.decision);
+  }
+  const bashKeptIdxs = /* @__PURE__ */ new Set();
+  for (const [idx, d] of decisions.entries()) {
+    if (d.intent === "execute") bashKeptIdxs.add(idx);
+  }
+  const speculations = [];
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const entry of specRaw) {
+    const parsed = parseSpeculationShape(entry);
+    if (parsed === null) {
+      bad.push({ raw: entry, error: "speculation entry has unexpected shape" });
+      continue;
+    }
+    const v = validateSpeculationEntry(
+      parsed,
+      payloadIdxs,
+      bashKeptIdxs,
+      nonBashPayloadIdxs
+    );
+    if (!v.ok) {
+      bad.push({ raw: entry, error: `speculation rejected: ${v.error}` });
+      continue;
+    }
+    if (seenPaths.has(parsed.path)) continue;
+    seenPaths.add(parsed.path);
+    speculations.push(parsed);
+  }
+  return { decisions, speculations, bad };
+}
+function parseSpeculationShape(entry) {
+  if (Array.isArray(entry) && entry.length === 2) {
+    const [p, i] = entry;
+    if (typeof p === "string" && typeof i === "number" && Number.isInteger(i)) {
+      return { path: p, producingIdx: i };
+    }
+    return null;
+  }
+  if (entry && typeof entry === "object") {
+    const o = entry;
+    if (typeof o.path === "string" && typeof o.producingIdx === "number" && Number.isInteger(o.producingIdx)) {
+      return { path: o.path, producingIdx: o.producingIdx };
+    }
+  }
+  return null;
+}
+
+// src/llm-classifier/sdk.ts
+var CLASSIFIER_MODEL = "claude-sonnet-4-6";
+var CLASSIFIER_RESPONSE_SCHEMA = {
+  type: "array",
+  minItems: 2,
+  maxItems: 2,
+  prefixItems: [
+    {
+      // Decisions arm: list of [idx, command] tuples.
+      type: "array",
+      items: {
+        type: "array",
+        prefixItems: [{ type: "integer" }, { type: "string", minLength: 1 }],
+        minItems: 2,
+        maxItems: 2
+      }
+    },
+    {
+      // Speculations arm: list of [path, producing_idx] tuples.
+      type: "array",
+      items: {
+        type: "array",
+        prefixItems: [
+          { type: "string", minLength: 1 },
+          { type: "integer" }
+        ],
+        minItems: 2,
+        maxItems: 2
+      }
+    }
+  ]
+};
+var sdkHooks = {
+  callClassifierMultiTurn: defaultCallClassifierMultiTurn
+};
+var UserMessageQueue = class {
+  resolvers = [];
+  pending = [];
+  closed = false;
+  push(msg) {
+    if (this.closed) return;
+    const r = this.resolvers.shift();
+    if (r) r(msg);
+    else this.pending.push(msg);
+  }
+  end() {
+    if (this.closed) return;
+    this.closed = true;
+    while (this.resolvers.length > 0) this.resolvers.shift()(null);
+  }
+  async *iterator() {
+    while (true) {
+      if (this.pending.length > 0) {
+        yield this.pending.shift();
+        continue;
+      }
+      if (this.closed) return;
+      const msg = await new Promise((r) => {
+        this.resolvers.push(r);
+      });
+      if (msg === null) return;
+      yield msg;
+    }
+  }
+};
+function makeUserMessage(text) {
+  return {
+    type: "user",
+    message: {
+      role: "user",
+      content: [{ type: "text", text }]
+    },
+    parent_tool_use_id: null,
+    session_id: ""
+  };
+}
+function collectAssistantText(message, out) {
+  const m = message;
+  if (m.type !== "assistant" && m.type !== "user") return;
+  const inner = m.message;
+  const content = inner?.content;
+  if (typeof content === "string") {
+    out.push(content);
+    return;
+  }
+  if (!Array.isArray(content)) return;
+  for (const block of content) {
+    if (block && typeof block === "object" && "text" in block) {
+      const t = block.text;
+      if (typeof t === "string") out.push(t);
+    }
+  }
+}
+function dumpMessageForDebug(message, msgCount, elapsed, emit) {
+  const m = message;
+  const msgType = typeof m.type === "string" ? String(m.type) : "unknown";
+  emit(`DEBUG[${elapsed.toFixed(1).padStart(6)}s] msg #${msgCount}: ${msgType}`);
+  for (const attr of [
+    "subtype",
+    "session_id",
+    "stop_reason",
+    "stop_sequence",
+    "duration_ms",
+    "duration_api_ms",
+    "num_turns",
+    "is_error",
+    "total_cost_usd",
+    "usage"
+  ]) {
+    const v = m[attr];
+    if (v !== void 0 && v !== null) {
+      let shown = JSON.stringify(v);
+      if (shown.length > 240) shown = shown.slice(0, 240) + "...(truncated)";
+      emit(`DEBUG          .${attr} = ${shown}`);
+    }
+  }
+}
+async function defaultCallClassifierMultiTurn(mode, sourceRoots, batches, perBatchFilesPresent, getFilesSpeculatedFor, decideRetry, opts) {
+  if (batches.length === 0) return [];
+  if (perBatchFilesPresent.length !== batches.length) {
+    throw new ClassifierError(
+      `internal: perBatchFilesPresent length (${perBatchFilesPresent.length}) must match batches length (${batches.length})`
+    );
+  }
+  const model = opts.model || CLASSIFIER_MODEL;
+  const debug = opts.debug ?? false;
+  const emit = opts.emit;
+  const systemPrompt = composeSystemPrompt(
+    mode.systemPrompt,
+    mode.intents,
+    sourceRoots
+  );
+  let query;
+  try {
+    ({ query } = await import("@anthropic-ai/claude-agent-sdk"));
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new ClassifierError(
+      `@anthropic-ai/claude-agent-sdk not installed: ${msg}. Try: npm install @anthropic-ai/claude-agent-sdk`
+    );
+  }
+  if (debug && emit) {
+    emit("DEBUG --- multi-turn classifier: pre-flight ---");
+    emit(`DEBUG model:           ${model}`);
+    emit(`DEBUG mode:            ${mode.label}`);
+    emit(
+      `DEBUG system prompt:   ${systemPrompt.length.toLocaleString()} chars (~${Math.floor(systemPrompt.length / 4).toLocaleString()} tokens)`
+    );
+    emit(`DEBUG batches:         ${batches.length}`);
+  }
+  const queue = new UserMessageQueue();
+  const enqueueBatch = (batchIdx2) => {
+    queue.push(
+      makeUserMessage(
+        buildBatchUserMessage(
+          batchIdx2 + 1,
+          batches.length,
+          perBatchFilesPresent[batchIdx2],
+          getFilesSpeculatedFor(batchIdx2),
+          JSON.stringify(batches[batchIdx2])
+        )
+      )
+    );
+  };
+  enqueueBatch(0);
+  const stderrCb = debug && emit ? (line) => emit(`DEBUG[sdk-stderr] ${line.replace(/\s+$/, "")}`) : void 0;
+  const q = query({
+    prompt: queue.iterator(),
+    options: {
+      model,
+      systemPrompt,
+      tools: [],
+      allowedTools: [],
+      settingSources: [],
+      thinking: { type: "enabled", budgetTokens: 8e3 },
+      outputFormat: {
+        type: "json_schema",
+        schema: CLASSIFIER_RESPONSE_SCHEMA
+      },
+      // Sessions are persisted to ~/.claude/projects/ by the SDK. We don't
+      // need cross-process resume (cached per-batch responses serve that
+      // role); within a single run, streaming input keeps the same
+      // subprocess + connection alive, so we don't depend on disk-resume.
+      env: {
+        ...process.env,
+        DISABLE_COMPACT: "1",
+        DISABLE_AUTO_COMPACT: "1",
+        CLAUDE_CODE_MAX_OUTPUT_TOKENS: "64000"
+      },
+      stderr: stderrCb
+    }
+  });
+  const results = batches.map(() => ({
+    primary: "",
+    retry: null
+  }));
+  let batchIdx = 0;
+  let inRetry = false;
+  let currentParts = [];
+  const overallStart = Date.now();
+  let turnStart = Date.now();
+  let msgCount = 0;
+  for await (const message of q) {
+    msgCount++;
+    if (debug && emit) {
+      const elapsed = (Date.now() - overallStart) / 1e3;
+      dumpMessageForDebug(message, msgCount, elapsed, emit);
+    }
+    collectAssistantText(message, currentParts);
+    const m = message;
+    if (m.type !== "result") continue;
+    const text = currentParts.join("");
+    currentParts = [];
+    const turnElapsed = (Date.now() - turnStart) / 1e3;
+    turnStart = Date.now();
+    if (!inRetry) {
+      results[batchIdx].primary = text;
+      if (emit) {
+        emit(
+          `INFO classifier batch ${batchIdx + 1}/${batches.length} primary done (${turnElapsed.toFixed(1)}s, ${text.length.toLocaleString()} chars)`
+        );
+      }
+      const failures = decideRetry(batchIdx + 1, text);
+      if (failures && failures.length > 0) {
+        if (emit) {
+          emit(
+            `INFO classifier batch ${batchIdx + 1}/${batches.length}: ${failures.length} rewrite(s) failed validation \u2014 retrying`
+          );
+        }
+        inRetry = true;
+        queue.push(makeUserMessage(buildRetryUserMessage(failures)));
+        continue;
+      }
+    } else {
+      results[batchIdx].retry = text;
+      if (emit) {
+        emit(
+          `INFO classifier batch ${batchIdx + 1}/${batches.length} retry done (${turnElapsed.toFixed(1)}s, ${text.length.toLocaleString()} chars)`
+        );
+      }
+      inRetry = false;
+    }
+    batchIdx++;
+    if (batchIdx >= batches.length) {
+      queue.end();
+      continue;
+    }
+    enqueueBatch(batchIdx);
+  }
+  if (batchIdx < batches.length) {
+    throw new ClassifierError(
+      `multi-turn classifier ended after ${batchIdx} of ${batches.length} batches; expected one result message per batch`
+    );
+  }
+  return results;
+}
+
+// src/llm-classifier/index.ts
+function batchIndices(batch) {
+  const bash = /* @__PURE__ */ new Set();
+  const payload = /* @__PURE__ */ new Set();
+  const nonBash = /* @__PURE__ */ new Set();
+  for (const [idx, tool] of batch) {
+    payload.add(idx);
+    if (tool === "Bash") bash.add(idx);
+    else nonBash.add(idx);
+  }
+  return { bash, payload, nonBash };
+}
+function parseBatchPrimary(primary, bashIdxs, originalByIdx, payloadIdxs, nonBashPayloadIdxs, emit) {
+  const parsed = parseBatchResponse(
+    primary,
+    bashIdxs,
+    originalByIdx,
+    payloadIdxs,
+    nonBashPayloadIdxs,
+    emit
+  );
+  const failures = [];
+  for (const b of parsed.bad) {
+    if (b.retry) failures.push(b.retry);
+  }
+  return {
+    decisions: parsed.decisions,
+    bad: parsed.bad,
+    failures,
+    speculations: parsed.speculations
+  };
+}
+function mergeRetryDecisions(primaryDecisions, bad, retryRaw, bashIdxs, originalByIdx, payloadIdxs, nonBashPayloadIdxs, emit) {
+  let retryParsed;
+  try {
+    const r = parseBatchResponse(
+      retryRaw,
+      bashIdxs,
+      originalByIdx,
+      payloadIdxs,
+      nonBashPayloadIdxs,
+      emit
+    );
+    retryParsed = { decisions: r.decisions, bad: r.bad };
+  } catch (e) {
+    if (emit) {
+      const msg = e instanceof Error ? e.message : String(e);
+      emit(
+        `WARN classifier retry response failed shape check (${msg}); dropping retry corrections for this batch`
+      );
+    }
+    return { decisions: primaryDecisions, bad };
+  }
+  const corrected = /* @__PURE__ */ new Set();
+  for (const [idx, decision] of retryParsed.decisions.entries()) {
+    primaryDecisions.set(idx, decision);
+    corrected.add(idx);
+  }
+  const finalBad = bad.filter((b) => {
+    if (b.retry && corrected.has(b.retry.idx)) return false;
+    return true;
+  });
+  for (const sb of retryParsed.bad) finalBad.push(sb);
+  return { decisions: primaryDecisions, bad: finalBad };
+}
+function revalidateSpeculationsAfterRetry(primarySpeculations, finalDecisions, payloadIdxs, nonBashPayloadIdxs) {
+  const surviving = [];
+  const dropped = [];
+  for (const s of primarySpeculations) {
+    if (!payloadIdxs.has(s.producingIdx)) {
+      dropped.push(s);
+      continue;
+    }
+    if (nonBashPayloadIdxs.has(s.producingIdx)) {
+      surviving.push(s);
+      continue;
+    }
+    const d = finalDecisions.get(s.producingIdx);
+    if (d && d.intent === "execute") {
+      surviving.push(s);
+    } else {
+      dropped.push(s);
+    }
+  }
+  return { surviving, dropped };
+}
+function computeDisplayedSpeculated(priorSpeculationsByBatch, guaranteed) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const batch of priorSpeculationsByBatch) {
+    for (const s of batch) {
+      if (seen.has(s.path)) continue;
+      seen.set(s.path, s.producingIdx);
+    }
+  }
+  const out = [];
+  for (const [path11, producingIdx] of seen.entries()) {
+    if (guaranteed.has(path11)) continue;
+    out.push({ path: path11, producingIdx });
+  }
+  return out;
+}
+async function getDecisions(cacheDir, mode, events, sourceRoots, opts = {}) {
+  const useCache = opts.useCache ?? true;
+  const overrideCache = opts.overrideCache ?? false;
+  const debug = opts.debug ?? false;
+  const emit = opts.emit;
+  const initialState = opts.initialState ?? [];
+  const payloadIdxs = payloadIndices(events);
+  const bashIdxs = bashIndices(events);
+  const nonBashIdxs = /* @__PURE__ */ new Set();
+  for (const i of payloadIdxs) if (!bashIdxs.has(i)) nonBashIdxs.add(i);
+  if (bashIdxs.size === 0) return /* @__PURE__ */ new Map();
+  const payload = buildPayload(events);
+  const batches = buildBatches(payload);
+  const originalByIdx = /* @__PURE__ */ new Map();
+  for (const [idx, tool, inp] of payload) {
+    if (tool === "Bash") originalByIdx.set(idx, inp);
+  }
+  const perBatchFilesPresent = [];
+  {
+    const cumulative = new Set(initialState);
+    for (let i = 0; i < batches.length; i++) {
+      perBatchFilesPresent.push(Array.from(cumulative).sort());
+      for (const [, tool, inp] of batches[i]) {
+        if (tool === "Write" || tool === "Edit") cumulative.add(inp);
+      }
+    }
+  }
+  if (emit) {
+    const sizes = batches.map((b) => b.length).join(",");
+    const bashPerBatch = batches.map(
+      (b) => b.filter((e) => e[1] === "Bash").length
+    );
+    emit(
+      `INFO classifier: ${batches.length} batch(es) over ${payload.length} payload events (${bashIdxs.size} Bash, ${nonBashIdxs.size} context); sizes=[${sizes}]; bash-per-batch=[${bashPerBatch.join(",")}]`
+    );
+    emit(
+      `INFO classifier model=${CLASSIFIER_MODEL}, mode=${mode.label}, source-roots=${sourceRoots.length}, initial-state-entries=${initialState.length}, cache-dir=${cacheDir}`
+    );
+  }
+  const { key, components } = cacheKeyComponents(
+    mode.systemPrompt,
+    mode.intents,
+    sourceRoots,
+    initialState,
+    payload
+  );
+  const cachedEntries = batches.map(() => null);
+  if (useCache && !overrideCache) {
+    const result = loadAllBatches(cacheDir, key, batches.length, components);
+    if (result.kind === "hit") {
+      for (let i = 0; i < batches.length; i++) cachedEntries[i] = result.entries[i];
+      if (emit)
+        emit(`INFO classifier cache hit: ${batches.length} batch(es) reused`);
+    } else if (emit) {
+      emit(`INFO classifier cache miss: ${describeMiss(result, batches.length)}`);
+    }
+  } else if (overrideCache && emit) {
+    emit(`INFO classifier cache override: recomputing all ${batches.length} batch(es)`);
+  }
+  if (opts.stats) {
+    opts.stats.totalBatches = batches.length;
+    opts.stats.cacheHits = cachedEntries.filter((e) => e !== null).length;
+  }
+  const firstMissIdx = cachedEntries.findIndex((e) => e === null);
+  const liveStart = firstMissIdx === -1 ? batches.length : firstMissIdx;
+  const liveBatches = batches.slice(liveStart);
+  const perBatchSpeculations = batches.map(() => []);
+  for (let i = 0; i < liveStart; i++) {
+    const entry = cachedEntries[i];
+    const { bash: batchBashIdxs, payload: batchPayloadIdxs, nonBash: nonBashPayloadIdxs } = batchIndices(batches[i]);
+    try {
+      const parsed = parseBatchResponse(
+        entry.primary,
+        batchBashIdxs,
+        originalByIdx,
+        batchPayloadIdxs,
+        nonBashPayloadIdxs,
+        emit
+      );
+      perBatchSpeculations[i] = parsed.speculations;
+    } catch (e) {
+      if (emit) {
+        const msg = e instanceof Error ? e.message : String(e);
+        emit(
+          `WARN classifier cached batch ${i + 1} failed reparse: ${msg}; treating speculations as empty`
+        );
+      }
+    }
+  }
+  const stagedPrimaryParses = batches.map(() => null);
+  const decideRetry = (batchNo, primaryText) => {
+    const i = liveStart + batchNo - 1;
+    const { bash: batchBashIdxs, payload: batchPayloadIdxs, nonBash: batchNonBashIdxs } = batchIndices(batches[i]);
+    let parsed;
+    try {
+      parsed = parseBatchPrimary(
+        primaryText,
+        batchBashIdxs,
+        originalByIdx,
+        batchPayloadIdxs,
+        batchNonBashIdxs,
+        emit
+      );
+    } catch (e) {
+      throw e;
+    }
+    stagedPrimaryParses[i] = { decisions: parsed.decisions, bad: parsed.bad };
+    perBatchSpeculations[i] = parsed.speculations;
+    if (parsed.failures.length > 0) {
+      return parsed.failures;
+    }
+    return null;
+  };
+  let liveResults = [];
+  if (liveBatches.length > 0) {
+    if (emit) {
+      emit(
+        `INFO classifier dispatching ${liveBatches.length} live batch(es) (cache hits for ${liveStart} batch(es) preceding)`
+      );
+    }
+    const liveFilesPresent = perBatchFilesPresent.slice(liveStart);
+    const getLiveFilesSpeculated = (liveIdx) => {
+      const absBatchIdx = liveStart + liveIdx;
+      const guaranteedSet = new Set(perBatchFilesPresent[absBatchIdx]);
+      return computeDisplayedSpeculated(
+        perBatchSpeculations.slice(0, absBatchIdx),
+        guaranteedSet
+      );
+    };
+    try {
+      liveResults = await sdkHooks.callClassifierMultiTurn(
+        mode,
+        sourceRoots,
+        liveBatches,
+        liveFilesPresent,
+        getLiveFilesSpeculated,
+        decideRetry,
+        { debug, emit }
+      );
+    } finally {
+      flushLiveBatchesToCache(cacheDir, liveStart, liveResults);
+    }
+  }
+  const allEntries = [];
+  for (let i = 0; i < batches.length; i++) {
+    if (i < liveStart) {
+      allEntries.push(cachedEntries[i]);
+    } else {
+      const lr = liveResults[i - liveStart];
+      if (!lr) {
+        throw new ClassifierError(
+          `internal: missing live result for batch ${i + 1}/${batches.length}`
+        );
+      }
+      allEntries.push({ primary: lr.primary, retry: lr.retry });
+    }
+  }
+  const good = /* @__PURE__ */ new Map();
+  const allBad = [];
+  for (let i = 0; i < batches.length; i++) {
+    const batch = batches[i];
+    const { bash: batchBashIdxs, payload: batchPayloadIdxs, nonBash: batchNonBashIdxs } = batchIndices(batch);
+    const entry = allEntries[i];
+    let parsed = parseBatchResponse(
+      entry.primary,
+      batchBashIdxs,
+      originalByIdx,
+      batchPayloadIdxs,
+      batchNonBashIdxs,
+      emit
+    );
+    if (entry.retry !== null) {
+      const merged = mergeRetryDecisions(
+        parsed.decisions,
+        parsed.bad,
+        entry.retry,
+        batchBashIdxs,
+        originalByIdx,
+        batchPayloadIdxs,
+        batchNonBashIdxs,
+        emit
+      );
+      const reval = revalidateSpeculationsAfterRetry(
+        parsed.speculations,
+        merged.decisions,
+        batchPayloadIdxs,
+        batchNonBashIdxs
+      );
+      if (emit && reval.dropped.length > 0) {
+        for (const d of reval.dropped) {
+          emit(
+            `WARN classifier dropped speculation after retry: ${d.path} (from idx ${d.producingIdx}) \u2014 producer omitted on retry`
+          );
+        }
+      }
+      parsed = {
+        decisions: merged.decisions,
+        bad: merged.bad,
+        speculations: reval.surviving
+      };
+      perBatchSpeculations[i] = reval.surviving;
+    }
+    if (debug && emit && parsed.speculations.length > 0) {
+      const sample = parsed.speculations.slice(0, 3).map((s) => `${s.path} (from ${s.producingIdx})`).join(", ");
+      const more = parsed.speculations.length > 3 ? `, +${parsed.speculations.length - 3} more` : "";
+      emit(
+        `DEBUG classifier batch ${i + 1}/${batches.length} speculated ${parsed.speculations.length} file(s): ${sample}${more}`
+      );
+    }
+    for (const [idx, d] of parsed.decisions.entries()) good.set(idx, d);
+    for (const b of parsed.bad) allBad.push(b);
+  }
+  for (const b of allBad) {
+    if (emit) {
+      emit(`WARN classifier dropped entry: ${JSON.stringify(b.raw)} \u2014 ${b.error}`);
+    }
+  }
+  for (const idx of bashIdxs) {
+    if (!good.has(idx)) {
+      good.set(idx, {
+        intent: "skip",
+        originalCommand: originalByIdx.get(idx) ?? "",
+        reason: "classifier omitted from replay list"
+      });
+    }
+  }
+  for (const idx of nonBashIdxs) {
+    good.set(idx, { intent: "execute", command: "", reason: "native" });
+  }
+  if (useCache && liveStart < batches.length) {
+    const lastEventTs = events[events.length - 1]?.timestamp;
+    commitMeta(cacheDir, key, batches.length, components, lastEventTs);
+    if (emit) emit(`INFO classifier cache meta committed at ${path7.join(cacheDir, "meta.json")}`);
+  }
+  if (debug && emit) {
+    const histo = { execute: 0, skip: 0, rewritten: 0 };
+    for (const idx of bashIdxs) {
+      const d = good.get(idx);
+      if (!d) continue;
+      histo[d.intent] = (histo[d.intent] || 0) + 1;
+      if (d.intent === "execute" && d.command !== (originalByIdx.get(idx) ?? "")) {
+        histo.rewritten++;
+      }
+    }
+    emit(`DEBUG bash decision histogram: ${JSON.stringify(histo)}`);
+    const sortedBash = Array.from(bashIdxs).sort((a, b) => a - b);
+    const sampled = [...sortedBash.slice(0, 5), ...sortedBash.slice(-5)];
+    for (const idx of sampled) {
+      const d = good.get(idx);
+      if (d) {
+        const cmd = d.intent === "execute" ? d.command : d.originalCommand;
+        emit(
+          `DEBUG   idx ${idx}: ${d.intent} \u2014 ${cmd.slice(0, 80)} (${d.reason})`
+        );
+      }
+    }
+  }
+  return good;
+}
+var COMPONENT_LABELS = {
+  systemPrompt: "classifier prompt",
+  intents: "custom intents",
+  sourceRoots: "source roots",
+  initialState: "initial-state file list",
+  events: "session logs"
+};
+function describeMiss(result, numBatches) {
+  switch (result.reason) {
+    case "no-meta":
+      return `no prior cache found; computing ${numBatches} batch(es) from scratch`;
+    case "key-mismatch": {
+      const { changedComponents } = result;
+      const tail = `wiping stale entries and recomputing ${numBatches} batch(es)`;
+      if (changedComponents.length === 0) {
+        return `cached run used a legacy meta with no component breakdown; ${tail}`;
+      }
+      const labels = changedComponents.map((c) => COMPONENT_LABELS[c]).join(", ");
+      return `inputs changed (${labels}); ${tail}`;
+    }
+    case "count-mismatch":
+      return `batch count differs (cached ${result.stored}, now ${result.expected}); wiping and recomputing ${numBatches} batch(es)`;
+    case "missing-batch":
+      return `meta said hit but batch ${result.batchNo} file is missing; wiping and recomputing ${numBatches} batch(es)`;
+  }
+}
+function flushLiveBatchesToCache(cacheDir, liveStart, liveResults) {
+  for (let i = 0; i < liveResults.length; i++) {
+    const lr = liveResults[i];
+    if (!lr || lr.primary === "") continue;
+    const batchPos = liveStart + i;
+    writeBatchEntry(cacheDir, batchPos + 1, lr.primary, lr.retry);
+  }
+}
+
+// src/bucketer.ts
+import * as path8 from "node:path";
+function classify(event, sourceRoots) {
+  if (event.isError) return "skip";
+  if (!event.cwd) return "skip";
+  if (!pathInsideAny(event.cwd, sourceRoots)) return "skip";
+  const ti = asToolInput(event);
+  if (ti === null) return "skip";
+  if (ti.tool === "Write" || ti.tool === "Edit") {
+    const target = ti.file_path;
+    if (!target || !path8.isAbsolute(target)) return "skip";
+    if (!pathInsideAny(target, sourceRoots)) return "skip";
+    return "action";
+  }
+  if (ti.tool === "Read") {
+    const target = ti.file_path;
+    if (!target || !path8.isAbsolute(target)) return "skip";
+    if (!pathInsideAny(target, sourceRoots)) return "skip";
+    return "checkpoint";
+  }
+  return "skip";
+}
+
+// src/snapshots.ts
+import * as fs6 from "node:fs";
+import * as os2 from "node:os";
+import * as path9 from "node:path";
+var DEFAULT_FILE_HISTORY_ROOT = path9.join(
+  os2.homedir(),
+  ".claude",
+  "file-history"
+);
+var SnapshotIndex = class _SnapshotIndex {
+  // Map: relative path → sorted list of [backupTime, backupFileName] (no dupes)
+  index;
+  fileHistoryRoot;
+  backupCache = /* @__PURE__ */ new Map();
+  // Dedupe warnings emitted from findAtOrBefore/resolveBackup so a single
+  // unreadable snapshot doesn't flood the log per Read event.
+  warnedKeys = /* @__PURE__ */ new Set();
+  warnEmit;
+  setEmit(emit) {
+    this.warnEmit = emit;
+  }
+  warnOnce(key, message) {
+    if (!this.warnEmit) return;
+    if (this.warnedKeys.has(key)) return;
+    this.warnedKeys.add(key);
+    this.warnEmit(`warn: ${message}`);
+  }
+  constructor(rawIndex, fileHistoryRoot = DEFAULT_FILE_HISTORY_ROOT) {
+    this.index = /* @__PURE__ */ new Map();
+    for (const [p, list] of rawIndex.entries()) {
+      const seen = /* @__PURE__ */ new Set();
+      const deduped = [];
+      for (const pair of list) {
+        const key = `${pair[0]}\0${pair[1]}`;
+        if (seen.has(key)) continue;
+        seen.add(key);
+        deduped.push([pair[0], pair[1]]);
+      }
+      deduped.sort((a, b) => {
+        if (a[0] < b[0]) return -1;
+        if (a[0] > b[0]) return 1;
+        if (a[1] < b[1]) return -1;
+        if (a[1] > b[1]) return 1;
+        return 0;
+      });
+      this.index.set(p, deduped);
+    }
+    this.fileHistoryRoot = fileHistoryRoot;
+  }
+  static fromLogsDir(logsDirs, fileHistoryRoot = DEFAULT_FILE_HISTORY_ROOT, emit) {
+    const dirs = typeof logsDirs === "string" ? [logsDirs] : logsDirs;
+    const raw = /* @__PURE__ */ new Map();
+    const seenPerPath = /* @__PURE__ */ new Map();
+    const jsonls = [];
+    for (const dir of dirs) {
+      for (const j of walkFiles(dir, {
+        filter: (e) => e.isFile() && e.name.endsWith(".jsonl"),
+        followSymlinks: true,
+        onError: (d, err) => emit?.(`warn: snapshot index readdir failed ${d}: ${err.message}`)
+      })) {
+        jsonls.push(j);
+      }
+    }
+    for (const j of jsonls) {
+      let data;
+      try {
+        data = fs6.readFileSync(j, "utf8");
+      } catch (e) {
+        if (emit) {
+          const msg = e instanceof Error ? e.message : String(e);
+          emit(`warn: snapshot index could not read ${j}: ${msg}`);
+        }
+        continue;
+      }
+      const lines = data.split("\n");
+      for (let lineNo = 0; lineNo < lines.length; lineNo++) {
+        const line = lines[lineNo];
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+        let obj;
+        try {
+          obj = JSON.parse(trimmed);
+        } catch (e) {
+          if (emit) {
+            const msg = e instanceof Error ? e.message : String(e);
+            emit(
+              `warn: snapshot index skipped malformed JSON ${path9.basename(j)}:${lineNo}: ${msg}`
+            );
+          }
+          continue;
+        }
+        if (!obj || typeof obj !== "object") continue;
+        const o = obj;
+        if (o.type !== "file-history-snapshot") continue;
+        const snapshot = o.snapshot;
+        const backups = snapshot?.trackedFileBackups ?? {};
+        for (const [p, info] of Object.entries(backups)) {
+          if (!info || typeof info !== "object") continue;
+          const ii = info;
+          const backupTime = ii.backupTime || "";
+          const backupFilename = ii.backupFileName || "";
+          if (!backupTime || !backupFilename) continue;
+          let seen = seenPerPath.get(p);
+          if (!seen) {
+            seen = /* @__PURE__ */ new Set();
+            seenPerPath.set(p, seen);
+          }
+          const key = `${backupTime}\0${backupFilename}`;
+          if (seen.has(key)) continue;
+          seen.add(key);
+          let list = raw.get(p);
+          if (!list) {
+            list = [];
+            raw.set(p, list);
+          }
+          list.push([backupTime, backupFilename]);
+        }
+      }
+    }
+    return new _SnapshotIndex(raw, fileHistoryRoot);
+  }
+  // Walks the file-history tree per *unique* filename (memoised in
+  // backupCache, so each filename is at most one walk per index instance).
+  // A first miss on a deep tree with thousands of sessions can be slow —
+  // if that ever becomes a problem, switch to an eager pass that builds a
+  // single filename → path map on first call.
+  resolveBackup(backupFilename) {
+    if (this.backupCache.has(backupFilename)) {
+      return this.backupCache.get(backupFilename);
+    }
+    let chosen = null;
+    const stack = [this.fileHistoryRoot];
+    while (stack.length > 0) {
+      const dir = stack.pop();
+      let entries;
+      try {
+        entries = fs6.readdirSync(dir, { withFileTypes: true });
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        this.warnOnce(
+          `readdir:${dir}`,
+          `file-history readdir failed ${dir}: ${msg} \u2014 snapshot resolution may miss entries under this directory`
+        );
+        continue;
+      }
+      for (const e of entries) {
+        const full = path9.join(dir, e.name);
+        if (e.isDirectory()) {
+          stack.push(full);
+        } else if (e.isFile() && e.name === backupFilename) {
+          chosen = full;
+          break;
+        }
+      }
+      if (chosen) break;
+    }
+    if (chosen === null) {
+      this.warnOnce(
+        `missing:${backupFilename}`,
+        `file-history backup '${backupFilename}' not found under ${this.fileHistoryRoot}`
+      );
+    }
+    this.backupCache.set(backupFilename, chosen);
+    return chosen;
+  }
+  findAtOrBefore(relativePath, ts) {
+    const entries = this.index.get(relativePath);
+    if (!entries || entries.length === 0) return null;
+    const atOrBefore = entries.filter((e) => e[0] <= ts);
+    if (atOrBefore.length === 0) return null;
+    for (let i = atOrBefore.length - 1; i >= 0; i--) {
+      const [, fname] = atOrBefore[i];
+      const backup = this.resolveBackup(fname);
+      if (backup === null) {
+        continue;
+      }
+      try {
+        return fs6.readFileSync(backup);
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        this.warnOnce(
+          `read:${backup}`,
+          `snapshot read failed ${backup}: ${msg} \u2014 falling through to next-oldest snapshot`
+        );
+        continue;
+      }
+    }
+    return null;
+  }
+};
+
+// src/logs.ts
+function formatClassify(opts) {
+  const { index, ts, session, tool, bucket, reason } = opts;
+  const bucketCell = reason ? `${bucket} (${reason})` : bucket;
+  return `CLASSIFY ${index} ${ts} | ${session} | ${tool} | ${bucketCell}`;
+}
+function formatApply(opts) {
+  const { index, ts, tool, summary } = opts;
+  return `APPLY ${index} ${ts} | ${tool} | ${summary}`;
+}
+function formatCheck(opts) {
+  const { index, ts, tool, target, status } = opts;
+  return `CHECK ${index} ${ts} | ${tool} | ${target} | ${status}`;
+}
+function formatHalt(opts) {
+  return `HALT ${opts.index} ${opts.reason}
+${opts.detail}`;
+}
+function formatInfo(msg) {
+  return `INFO ${msg}`;
+}
+
+// src/report.ts
+function newRunCounts(total) {
+  return {
+    total,
+    skipped: 0,
+    actions: { classified: 0, applied: 0 },
+    checkpoints: { classified: 0, passed: 0 },
+    reads: { applied: 0, snapshotApplied: 0, lenientlySkipped: 0 },
+    bash: {
+      classifiedExecute: 0,
+      classifiedSkip: 0,
+      executed: 0,
+      cwdFiltered: 0
+    },
+    overrides: { skips: 0, executes: 0 },
+    classifier: null,
+    elapsedSeconds: 0,
+    targetFiles: 0,
+    targetBytes: 0,
+    haltedAt: null,
+    haltReason: null
+  };
+}
+function formatSummary(c) {
+  const replayed = c.actions.applied + c.checkpoints.passed + c.reads.applied + c.reads.snapshotApplied + c.bash.executed;
+  const replayedOf = c.actions.classified + c.checkpoints.classified + c.bash.classifiedExecute;
+  const rows = [
+    { label: "events total", value: c.total },
+    { label: "replayed", value: `${replayed} (of ${replayedOf})`, indent: "  " },
+    { label: "skipped", value: c.skipped, indent: "  " }
+  ];
+  if (c.reads.snapshotApplied > 0) {
+    rows.push({ label: "reads from snapshot", value: c.reads.snapshotApplied });
+  }
+  if (c.reads.lenientlySkipped > 0) {
+    rows.push({
+      label: "reads leniently skipped",
+      value: c.reads.lenientlySkipped
+    });
+  }
+  const bashAny = c.bash.classifiedExecute + c.bash.classifiedSkip + c.bash.cwdFiltered > 0;
+  if (bashAny) {
+    rows.push({
+      label: "bash executed",
+      value: `${c.bash.executed} of ${c.bash.classifiedExecute}`
+    });
+    if (c.bash.cwdFiltered > 0) {
+      rows.push({ label: "bash cwd-filtered", value: c.bash.cwdFiltered });
+    }
+  }
+  if (c.classifier !== null) {
+    const { totalBatches, cacheHits } = c.classifier;
+    const live = totalBatches - cacheHits;
+    rows.push({
+      label: "classifier batches",
+      value: `${totalBatches} (${cacheHits} cached, ${live} live)`
+    });
+  }
+  if (c.overrides.skips + c.overrides.executes > 0) {
+    rows.push({
+      label: "overrides",
+      value: `skip=${c.overrides.skips} execute=${c.overrides.executes}`
+    });
+  }
+  rows.push({
+    label: "halted",
+    value: c.haltedAt !== null ? `at index ${c.haltedAt} (${c.haltReason})` : "no"
+  });
+  rows.push({ label: "elapsed", value: `${c.elapsedSeconds.toFixed(2)}s` });
+  rows.push({
+    label: "target files",
+    value: `${c.targetFiles}   (${c.targetBytes} bytes total)`
+  });
+  const colWidth = Math.max(...rows.map((r) => (r.indent ?? "").length + r.label.length + 1)) + 1;
+  const lines = rows.map((r) => {
+    const indent = r.indent ?? "";
+    const key = `${r.label}:`;
+    const pad = colWidth - indent.length - key.length;
+    return `${indent}${key}${" ".repeat(pad)}${r.value}`;
+  });
+  return ["=== claude-code-replay summary ===", ...lines].join("\n");
+}
+
+// src/cli.ts
+var HALT_EXIT = 10;
+function fail(msg) {
+  process.stderr.write(msg + "\n");
+  return 2;
+}
+function expandHome(p) {
+  if (p === "~") return os3.homedir();
+  if (p.startsWith("~/")) return path10.join(os3.homedir(), p.slice(2));
+  return p;
+}
+function inferLogsDirFromSourceRoot(absSourceRoot) {
+  const encoded = absSourceRoot.replace(/\//g, "-");
+  return path10.join(os3.homedir(), ".claude", "projects", encoded);
+}
+function countTarget(target) {
+  const paths = walkFiles(target, { filter: (e) => e.isFile() });
+  let totalBytes = 0;
+  for (const p of paths) {
+    try {
+      totalBytes += fs7.statSync(p).size;
+    } catch {
+    }
+  }
+  return [paths.length, totalBytes];
+}
+function pathIsInsideAnyResolved(p, roots) {
+  let absP;
+  try {
+    absP = fs7.realpathSync(p);
+  } catch {
+    absP = path10.resolve(p);
+  }
+  for (const root of roots) {
+    let absRoot;
+    try {
+      absRoot = fs7.realpathSync(root);
+    } catch {
+      absRoot = path10.resolve(root);
+    }
+    if (absP === absRoot) return true;
+    const rel = path10.relative(absRoot, absP);
+    if (rel !== "" && !rel.startsWith("..") && !path10.isAbsolute(rel)) return true;
+  }
+  return false;
+}
+function runEventLoop(events, counts, ctx) {
+  const {
+    target,
+    sourceRoots,
+    classifierDecisions,
+    overrides,
+    snapshotIndex,
+    applyReads,
+    dryRun,
+    lenientReads,
+    debug,
+    emit
+  } = ctx;
+  for (const ev of events) {
+    let bucket = classify(ev, sourceRoots);
+    let classifierSkipped = false;
+    let classifyReason;
+    let overrideCommand = null;
+    const override = overrides.get(ev.index);
+    if (override !== void 0) {
+      if (override.kind === "skip") {
+        bucket = "skip";
+        classifyReason = "override-skip";
+      } else {
+        bucket = "execute";
+        classifyReason = "override-execute";
+        overrideCommand = override.command;
+      }
+    } else if (bucket === "skip" && ev.toolName === "Bash" && classifierDecisions.has(ev.index)) {
+      const decision = classifierDecisions.get(ev.index);
+      if (decision.intent === "execute") {
+        bucket = "execute";
+      } else {
+        classifierSkipped = true;
+      }
+    }
+    if (debug) {
+      emit(
+        formatClassify({
+          index: ev.index,
+          ts: ev.timestamp,
+          session: ev.sessionFile,
+          tool: ev.toolName,
+          bucket,
+          reason: classifyReason
+        })
+      );
+    }
+    if (bucket === "skip") {
+      counts.skipped++;
+      if (override !== void 0 && override.kind === "skip") {
+        counts.overrides.skips++;
+      } else if (classifierSkipped) {
+        counts.bash.classifiedSkip++;
+      }
+      continue;
+    }
+    if (bucket === "action") {
+      counts.actions.classified++;
+      if (dryRun) continue;
+      let summary;
+      try {
+        summary = applyAction(ev, target, sourceRoots);
+      } catch (e) {
+        if (e instanceof ActionFailure) {
+          emit(formatHalt({ index: ev.index, reason: "ActionFailure", detail: e.message }));
+          counts.haltedAt = ev.index;
+          counts.haltReason = "ActionFailure";
+          return;
+        }
+        throw e;
+      }
+      if (debug) {
+        emit(formatApply({ index: ev.index, ts: ev.timestamp, tool: ev.toolName, summary }));
+      }
+      counts.actions.applied++;
+    } else if (bucket === "execute") {
+      const isOverride = override !== void 0 && override.kind === "execute";
+      if (isOverride) {
+        counts.overrides.executes++;
+      } else {
+        counts.bash.classifiedExecute++;
+      }
+      if (dryRun) continue;
+      const cwdOk = ev.cwd ? pathIsInsideAnyResolved(ev.cwd, sourceRoots) : false;
+      if (!cwdOk) {
+        counts.bash.cwdFiltered++;
+        const decisionReason = isOverride ? "user-supplied --override-execute" : classifierDecisions.get(ev.index)?.reason ?? "";
+        const label = isOverride ? "override-approved" : "classifier-approved";
+        const cwdDesc = ev.cwd ? `has cwd '${ev.cwd}' outside source roots` : `has no cwd (can't verify it's inside any source root)`;
+        emit(
+          formatInfo(
+            `warn: ${label} execute at index ${ev.index} ${cwdDesc}; skipping. reason: ${decisionReason}`
+          )
+        );
+        continue;
+      }
+      let decisionCommand;
+      if (isOverride) {
+        decisionCommand = overrideCommand ?? void 0;
+      } else {
+        const d = classifierDecisions.get(ev.index);
+        decisionCommand = d?.intent === "execute" ? d.command : void 0;
+      }
+      let summary;
+      try {
+        summary = executeBash(ev, target, sourceRoots, decisionCommand, emit);
+      } catch (e) {
+        if (e instanceof ExecuteFailure) {
+          emit(formatHalt({ index: ev.index, reason: "ExecuteFailure", detail: e.message }));
+          counts.haltedAt = ev.index;
+          counts.haltReason = "ExecuteFailure";
+          return;
+        }
+        throw e;
+      }
+      if (debug) {
+        emit(formatApply({ index: ev.index, ts: ev.timestamp, tool: ev.toolName, summary }));
+      }
+      counts.bash.executed++;
+    } else if (bucket === "checkpoint") {
+      counts.checkpoints.classified++;
+      if (dryRun) continue;
+      try {
+        const summary = runCheckpoint(ev, target, sourceRoots, {
+          applyReads,
+          snapshotIndex
+        });
+        if (debug) {
+          emit(
+            formatCheck({
+              index: ev.index,
+              ts: ev.timestamp,
+              tool: ev.toolName,
+              target: (() => {
+                const ti = asToolInput(ev);
+                return ti?.tool === "Read" ? ti.file_path : "";
+              })(),
+              status: summary
+            })
+          );
+        }
+        if (summary.includes("SNAPSHOT")) counts.reads.snapshotApplied++;
+        else if (summary.includes("APPLIED")) counts.reads.applied++;
+        else counts.checkpoints.passed++;
+      } catch (e) {
+        if (e instanceof CheckpointFailure) {
+          if (lenientReads && ev.toolName === "Read") {
+            emit(
+              formatInfo(
+                `lenient-reads: skipping failed Read checkpoint at index ${ev.index}: ${e.message}`
+              )
+            );
+            counts.reads.lenientlySkipped++;
+            continue;
+          }
+          emit(formatHalt({ index: ev.index, reason: "CheckpointFailure", detail: e.message }));
+          counts.haltedAt = ev.index;
+          counts.haltReason = "CheckpointFailure";
+          return;
+        }
+        throw e;
+      }
+    } else {
+      const _exhaustive = bucket;
+      throw new Error(`unreachable bucket: ${_exhaustive}`);
+    }
+  }
+}
+function collectStrings(value, prev) {
+  return [...prev, value];
+}
+function parseNonNegInt(raw) {
+  const t = raw.trim();
+  if (!/^\d+$/.test(t)) {
+    throw new InvalidArgumentError("must be a non-negative integer");
+  }
+  const n = Number.parseInt(t, 10);
+  if (!Number.isFinite(n) || n < 0) {
+    throw new InvalidArgumentError("must be a non-negative integer");
+  }
+  return n;
+}
+function parseIsoTimestamp(raw) {
+  if (Number.isNaN(Date.parse(raw))) {
+    throw new InvalidArgumentError(`could not parse timestamp '${raw}'`);
+  }
+  return raw;
+}
+function buildProgram() {
+  const program = new Command();
+  program.name("replay").description(
+    "Replay Claude Code session logs (*.jsonl) to reconstruct the filesystem state a session left behind."
+  ).showHelpAfterError("(run with --help for usage)").exitOverride();
+  program.optionsGroup("Required:").requiredOption(
+    "--target <dir>",
+    "directory the replay writes into; must be distinct from any logs dir"
+  ).requiredOption(
+    "--source-root <abs-path>",
+    "original absolute cwd from the session; compared verbatim against event.cwd. Repeatable.",
+    collectStrings,
+    []
+  );
+  program.optionsGroup("Replay window:").option(
+    "--logs-dir <dir>",
+    "directory containing session *.jsonl files. Repeatable. By default, one logs dir is inferred from each --source-root (~/.claude/projects/<encoded-source-root>); explicit --logs-dir values are added to the inferred set.",
+    collectStrings,
+    []
+  ).option("--cutoff <iso-ts>", "drop events at or after this ISO 8601 timestamp").option(
+    "--start <iso-ts>",
+    "start replay at the first event whose timestamp is at or after this",
+    parseIsoTimestamp
+  ).option(
+    "--from-index <N>",
+    "start replay at event index N (use to resume after a halt)",
+    parseNonNegInt,
+    0
+  );
+  program.optionsGroup("Verification:").option("--strict", "disable both snapshot and apply-reads heal layers").option("--strict-reads", "halt on the first failed Read checkpoint (default: log + continue)");
+  program.optionsGroup("Bash classifier (opt-in):").option("--enable-llm-classifier", "opt in to LLM calls (required for classifier)").option(
+    "--custom-intent <text>",
+    "append a natural-language intent to the classifier prompt. Repeatable.",
+    collectStrings,
+    []
+  ).option(
+    "--override-classifier-cache",
+    "force a fresh classifier call and overwrite the cache"
+  ).option(
+    "--skip-uncached-tail",
+    "if cached events form a prefix of current logs, drop the appended tail and reuse the cache (no classifier call for the new events)"
+  );
+  program.optionsGroup("Per-event overrides:").option(
+    "--override-skip <INDEX>",
+    "force event INDEX to skip. Repeatable.",
+    collectStrings,
+    []
+  ).option(
+    "--override-execute <INDEX[=CMD]>",
+    "force Bash event INDEX to execute. CMD must be a substring of the event's original command. Repeatable.",
+    collectStrings,
+    []
+  );
+  program.optionsGroup("Diagnostics:").option("--dry-run", "classify and log only; no filesystem mutation").option(
+    "--debug",
+    "per-event CLASSIFY/APPLY/CHECK trace plus classifier diagnostics"
+  );
+  program.addHelpText(
+    "after",
+    "\nExit codes: 0 success, 2 argv error, 10 halted on command failure.\n"
+  );
+  return program;
+}
+function parseCliArgs(argv) {
+  const program = buildProgram();
+  let opts;
+  try {
+    program.parse(argv, { from: "user" });
+    opts = program.opts();
+  } catch (e) {
+    if (e instanceof CommanderError) {
+      return e.exitCode === 0 ? 0 : 2;
+    }
+    throw e;
+  }
+  const customIntents = opts.customIntent;
+  if (customIntents.length > 0 && !opts.enableLlmClassifier) {
+    return fail(
+      "error: --custom-intent requires --enable-llm-classifier (opt-in to LLM calls)"
+    );
+  }
+  let classifierMode = null;
+  if (opts.enableLlmClassifier) {
+    classifierMode = composeMode({ customIntents });
+  }
+  const target = path10.resolve(expandHome(opts.target));
+  const sourceRoots = [];
+  for (const raw of opts.sourceRoot) {
+    const expanded = expandHome(raw);
+    if (!path10.isAbsolute(expanded)) {
+      return fail(
+        `error: --source-root must be absolute (got '${raw}'); source roots are compared verbatim against event.cwd in the logs.`
+      );
+    }
+    if (!sourceRoots.includes(expanded)) sourceRoots.push(expanded);
+  }
+  const logsDirs = [];
+  const seenLogsDirs = /* @__PURE__ */ new Set();
+  const pushLogsDir = (d) => {
+    if (seenLogsDirs.has(d)) return;
+    seenLogsDirs.add(d);
+    logsDirs.push(d);
+  };
+  for (const root of sourceRoots) {
+    const inferred = inferLogsDirFromSourceRoot(root);
+    if (fs7.existsSync(inferred) && fs7.statSync(inferred).isDirectory()) {
+      pushLogsDir(inferred);
+    }
+  }
+  for (const raw of opts.logsDir) {
+    const d = path10.resolve(expandHome(raw));
+    if (!fs7.existsSync(d) || !fs7.statSync(d).isDirectory()) {
+      return fail(`error: logs dir not found: ${d}`);
+    }
+    pushLogsDir(d);
+  }
+  if (logsDirs.length === 0) {
+    return fail(
+      "error: no logs dirs to read from; either pass --logs-dir explicitly or use a --source-root whose inferred logs dir (~/.claude/projects/<encoded-source-root>) exists."
+    );
+  }
+  for (const d of logsDirs) {
+    if (pathIsInsideOrEqual(target, d) || pathIsInsideOrEqual(d, target)) {
+      return fail(
+        `error: --target (${target}) must be distinct from logs dir (${d}); replayed commands could otherwise corrupt the logs.`
+      );
+    }
+  }
+  return {
+    logsDirs,
+    target,
+    sourceRoots,
+    classifierMode,
+    overrideClassifierCache: opts.overrideClassifierCache ?? false,
+    skipUncachedTail: opts.skipUncachedTail ?? false,
+    strict: opts.strict ?? false,
+    strictReads: opts.strictReads ?? false,
+    debug: opts.debug ?? false,
+    dryRun: opts.dryRun ?? false,
+    cutoff: opts.cutoff ?? null,
+    fromIndex: opts.fromIndex,
+    startTs: opts.start ?? null,
+    overrideSkipRaw: opts.overrideSkip,
+    overrideExecuteRaw: opts.overrideExecute
+  };
+}
+function parseOverrides(args, allEvents) {
+  const overrides = /* @__PURE__ */ new Map();
+  const parseIndex = (raw, flag) => {
+    const trimmed = raw.trim();
+    if (!/^-?\d+$/.test(trimmed)) {
+      fail(`error: ${flag} expects an integer event index (got '${raw}')`);
+      return null;
+    }
+    const n = Number.parseInt(trimmed, 10);
+    if (!Number.isFinite(n) || n < 0 || n >= allEvents.length) {
+      fail(`error: ${flag} index ${n} out of range [0, ${allEvents.length})`);
+      return null;
+    }
+    return n;
+  };
+  for (const raw of args.overrideSkipRaw) {
+    const idx = parseIndex(raw, "--override-skip");
+    if (idx === null) return 2;
+    if (overrides.has(idx)) {
+      return fail(
+        `error: duplicate override for index ${idx} (--override-skip / --override-execute may each appear once per index)`
+      );
+    }
+    overrides.set(idx, { kind: "skip", command: null });
+  }
+  for (const raw of args.overrideExecuteRaw) {
+    const eq = raw.indexOf("=");
+    const idxStr = eq === -1 ? raw : raw.slice(0, eq);
+    const cmd = eq === -1 ? null : raw.slice(eq + 1);
+    const idx = parseIndex(idxStr, "--override-execute");
+    if (idx === null) return 2;
+    if (overrides.has(idx)) {
+      return fail(
+        `error: duplicate override for index ${idx} (--override-skip / --override-execute may each appear once per index)`
+      );
+    }
+    const ev = allEvents[idx];
+    if (ev.toolName !== "Bash") {
+      return fail(
+        `error: --override-execute index ${idx} is a ${ev.toolName} event, not a Bash event; execute overrides only apply to Bash`
+      );
+    }
+    if (cmd !== null) {
+      const ti = asToolInput(ev);
+      const original = ti?.tool === "Bash" ? ti.command : "";
+      if (!original.includes(cmd)) {
+        return fail(
+          `error: --override-execute CMD for index ${idx} is not a substring of the event's original command.
+  original: ${JSON.stringify(original)}
+  cmd:      ${JSON.stringify(cmd)}`
+        );
+      }
+    }
+    overrides.set(idx, { kind: "execute", command: cmd });
+  }
+  return overrides;
+}
+function applyResumeWindow(allEvents, fromIndex, startTs, emit) {
+  let startArrayPos = 0;
+  if (startTs !== null) {
+    while (startArrayPos < allEvents.length && (allEvents[startArrayPos].timestamp || "") < startTs) {
+      startArrayPos++;
+    }
+  }
+  let fromIndexArrayPos = 0;
+  if (fromIndex > 0) {
+    while (fromIndexArrayPos < allEvents.length && allEvents[fromIndexArrayPos].index < fromIndex) {
+      fromIndexArrayPos++;
+    }
+  }
+  const effectiveStartPos = Math.max(startArrayPos, fromIndexArrayPos);
+  const events = allEvents.slice(effectiveStartPos);
+  if (effectiveStartPos > 0) {
+    const firstIdx = events.length > 0 ? events[0].index : allEvents[allEvents.length - 1]?.index ?? -1;
+    emit(
+      formatInfo(
+        `resume window: skipping ${effectiveStartPos} pre-start event(s) (fromIndex=${fromIndex}, start=${startTs ?? "-"}); replaying ${events.length} event(s)` + (events.length > 0 ? ` starting at event.index=${firstIdx}` : "")
+      )
+    );
+  }
+  return events;
+}
+async function main(argv) {
+  const args = parseCliArgs(argv);
+  if (args === 0 || args === 2) return args;
+  const {
+    logsDirs,
+    target,
+    sourceRoots,
+    classifierMode,
+    overrideClassifierCache,
+    skipUncachedTail,
+    strict,
+    strictReads,
+    debug,
+    dryRun,
+    cutoff,
+    fromIndex,
+    startTs
+  } = args;
+  const emit = (line) => {
+    process.stdout.write(line + "\n");
+  };
+  fs7.mkdirSync(target, { recursive: true });
+  emit(formatInfo(`collecting events from ${logsDirs.join(", ")}`));
+  if (cutoff) {
+    emit(formatInfo(`cutoff active: dropping events at/after '${cutoff}'`));
+  }
+  let allEvents = collect(logsDirs, cutoff);
+  emit(formatInfo(`collected ${allEvents.length} events`));
+  if (skipUncachedTail && classifierMode !== null) {
+    const cacheDir = cacheDirForTarget(target);
+    const cachedLastTs = readCachedLastEventTs(cacheDir);
+    if (cachedLastTs === null) {
+      emit(
+        formatInfo(
+          "--skip-uncached-tail: no prior cache found (or legacy meta without last_event_ts); proceeding without truncation"
+        )
+      );
+    } else {
+      const before = allEvents.length;
+      allEvents = allEvents.filter((e) => (e.timestamp ?? "") <= cachedLastTs);
+      const dropped = before - allEvents.length;
+      emit(
+        formatInfo(
+          `--skip-uncached-tail: capping at cached last_event_ts='${cachedLastTs}' (dropped ${dropped} appended event(s) past the cache)`
+        )
+      );
+    }
+  }
+  const events = applyResumeWindow(allEvents, fromIndex, startTs, emit);
+  const overrides = parseOverrides(args, allEvents);
+  if (overrides === 2) return 2;
+  if (overrides.size > 0) {
+    emit(
+      formatInfo(
+        `applying ${overrides.size} per-event override(s) (skip=${args.overrideSkipRaw.length}, execute=${args.overrideExecuteRaw.length})`
+      )
+    );
+  }
+  let snapshotIndex = null;
+  if (!strict) {
+    emit(formatInfo("building snapshot index from file-history-snapshot entries"));
+    snapshotIndex = SnapshotIndex.fromLogsDir(logsDirs, void 0, emit);
+    snapshotIndex.setEmit(emit);
+    emit(formatInfo(`snapshot index covers ${snapshotIndex.index.size} paths`));
+  }
+  const applyReads = !strict;
+  let classifierDecisions = /* @__PURE__ */ new Map();
+  const classifierStats = { totalBatches: 0, cacheHits: 0 };
+  if (classifierMode !== null) {
+    const cacheDir = cacheDirForTarget(target);
+    try {
+      classifierDecisions = await getDecisions(
+        cacheDir,
+        classifierMode,
+        allEvents,
+        sourceRoots,
+        {
+          useCache: true,
+          overrideCache: overrideClassifierCache,
+          debug,
+          emit,
+          stats: classifierStats
+        }
+      );
+    } catch (e) {
+      if (e instanceof ClassifierError) {
+        return fail(`error: classifier failed: ${e.message}`);
+      }
+      throw e;
+    }
+    emit(formatInfo(`classifier returned ${classifierDecisions.size} decisions`));
+  }
+  const counts = newRunCounts(events.length);
+  if (classifierMode !== null) {
+    counts.classifier = classifierStats;
+  }
+  const started = process.hrtime.bigint();
+  runEventLoop(events, counts, {
+    target,
+    sourceRoots,
+    classifierDecisions,
+    overrides,
+    snapshotIndex,
+    applyReads,
+    dryRun,
+    // Lenient-reads is the default: a failed Read checkpoint just records
+    // a skip and the replay continues. The classifier sometimes correctly
+    // omits a producing Bash chain, leaving downstream Reads with nothing
+    // to verify — halting at those would mask the cascade fix and stop
+    // every long replay short. Opt out with --strict-reads (or the broader
+    // --strict, which also disables the snapshot heal path).
+    lenientReads: !(strictReads || strict),
+    debug,
+    emit
+  });
+  const elapsedNs = process.hrtime.bigint() - started;
+  counts.elapsedSeconds = Number(elapsedNs) / 1e9;
+  const [files, bytes] = countTarget(target);
+  counts.targetFiles = files;
+  counts.targetBytes = bytes;
+  emit(formatSummary(counts));
+  return counts.haltedAt !== null ? HALT_EXIT : 0;
+}
+
+// src/main.ts
+var isDirectRun = !!process.argv[1] && import.meta.url === pathToFileURL(realpathSync3(process.argv[1])).href;
+if (isDirectRun) {
+  main(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (err) => {
+      console.error(err);
+      process.exit(1);
+    }
+  );
+}
+export {
+  main
+};