agent-polygraph 0.0.0-stage → 0.1.0

package/src/report/terminal.js

@@ -0,0 +1,160 @@
+import os from "node:os";
+import { AGENT_NAMES, ROWS, TESTED, columns, day, duration, pct, range, versionRange } from "./format.js";
+
+const useColor = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+const bold = paint("1");
+const dim = paint("2");
+const red = paint("31");
+const green = paint("32");
+const yellow = paint("33");
+const cyan = paint("36");
+
+const VERDICT_LABEL = {
+  "no-run": "no test run in the session",
+  stale: "code edited after the last run",
+  failed: "the last test run had failed",
+};
+
+export function renderTerminal({ sessions, groups, seconds, by = "agent", examples = 5, demo = false }) {
+  const out = [];
+  const cols = columns(groups, by);
+  const all = groups.all;
+  const W = 44;
+  const CW = Math.max(12, ...cols.map((c) => c.label.length + 2));
+
+  const header = (title, sub) => {
+    out.push("");
+    out.push(bold(title) + (sub ? dim("  " + sub) : ""));
+    out.push(dim(" ".repeat(W) + cols.map((c) => c.label.padStart(CW)).join("")));
+  };
+  const row = (label, fn, colorize) => {
+    const cells = cols.map((c) => {
+      const v = fn(c.g);
+      const s = String(v).padStart(CW);
+      return colorize ? colorize(v, s) : s;
+    });
+    const padded = label.padEnd(W - 2);
+    out.push("  " + (label.startsWith("…") ? dim(padded) : padded) + cells.join(""));
+  };
+  const warnIfPositive = (v, s) => (typeof v === "number" && v > 0 ? yellow(s) : s);
+
+  out.push("");
+  if (!all.activeSessions) {
+    out.push(bold("agent-polygraph"));
+    out.push("");
+    out.push("No Claude Code or Codex sessions with commands or edits found.");
+    out.push(dim("Looked in ~/.claude/projects and ~/.codex/sessions (override with --claude-dir / --codex-dir)."));
+    return out.join("\n");
+  }
+  out.push(bold("agent-polygraph") + dim(`  ${all.activeSessions} working sessions · ${range(all)} · ${seconds.toFixed(1)}s`));
+  if (demo) out.push(yellow("DEMO DATA: generated sessions, invented numbers. Run without --demo to check your own."));
+
+  header('"Tests pass" claims', "was there a passing run after the last code edit?");
+  ROWS.claims.forEach(([label, fn], i) => row(label, fn, i === 0 ? (v, s) => green(s) : i < 4 ? warnIfPositive : null));
+  // say why, instead of hiding unclear claims behind the receipt rate
+  ROWS.unclear.forEach(([label, fn]) => cols.some((c) => fn(c.g) > 0) && row(label, fn, (v, s) => dim(s)));
+  row(
+    bold("Receipt rate"),
+    (g) => pct(g.receiptRate),
+    (v, s) => bold(v === "–" ? s : parseInt(v) >= 95 ? green(s) : parseInt(v) >= 80 ? yellow(s) : red(s)),
+  );
+  // evidence that came from outside the agents' logs (record, --ci)
+  const ev = all.evidence || {};
+  const used = [
+    [ev.snapshot, "settled by working-tree snapshots"],
+    [ev.recorded, "read from recorded test output"],
+    [ev.terminal, "judged by test runs in your terminal"],
+    [ev.ci, "judged with GitHub Actions"],
+  ].filter(([n]) => n > 0);
+  if (used.length) out.push(dim("  Beyond the logs: " + used.map(([n, what]) => `${n} ${what}`).join(" · ")));
+
+  header("Test integrity", "worth a second look, not proof of cheating");
+  ROWS.integrity.forEach(([label, fn]) => row(label, fn, warnIfPositive));
+
+  header("Where the time went");
+  ROWS.time.forEach(([label, fn]) => row(label, fn));
+
+  header("You and the agent");
+  ROWS.you.forEach(([label, fn]) => row(label, fn));
+
+  if (sessions.unrecognized?.length) {
+    out.push("");
+    out.push(yellow(`${sessions.unrecognized.length} session file(s) are in a log format this version doesn't recognize and are not included.`) + dim(" Please report it, with your agent's version."));
+  }
+  if (sessions.skipped?.length) {
+    out.push("");
+    out.push(yellow(`${sessions.skipped.length} session file(s) couldn't be read and are not included.`) + dim(" Set POLYGRAPH_DEBUG=1 to see why."));
+  }
+
+  if (examples > 0) {
+    const all = sessions.flatMap((s) => s.findings);
+    const pick = (type) => all.filter((f) => f.type === type).sort((a, b) => b.ts - a.ts).slice(0, examples);
+    const claims = pick("claim");
+    const fixes = pick("test-only-fix");
+    const weak = pick("weakened-test");
+    const loops = pick("retry-loop");
+    const risky = pick("risky");
+    if (claims.length + fixes.length + weak.length + loops.length + risky.length) {
+      out.push("");
+      out.push(bold("Most recent examples") + dim("  (stays on your machine; --html never includes these)"));
+    }
+    for (const f of claims) {
+      out.push("");
+      out.push(`  ${red("✗")} ${bold(VERDICT_LABEL[f.detail.verdict] + (f.detail.ci ? " (CI claim)" : ""))} ${where(f)}`);
+      out.push(`    ${cyan("“" + f.detail.claim + "”")}`);
+      const lt = f.detail.lastTest;
+      if (lt) out.push(dim(`    last test: ${lt.cmd} → ${lt.outcome ?? "?"}, ${duration(lt.ago)} earlier`));
+      if (f.detail.editedAfter) out.push(dim(`    then edited: ${f.detail.editedAfter}`));
+      out.push(dim(`    ${tilde(f.file)}`));
+    }
+    for (const f of fixes) {
+      out.push("");
+      out.push(`  ${yellow("!")} ${bold("failing test made to pass by editing only tests")} ${where(f)}`);
+      out.push(dim(`    edited: ${f.detail.tests.join(", ")}`));
+      out.push(dim(`    then passed: ${f.detail.cmd}`));
+      out.push(dim(`    ${tilde(f.file)}`));
+    }
+    for (const f of weak) {
+      out.push("");
+      out.push(`  ${yellow("!")} ${bold(f.detail.reasons.join(", "))}: ${f.detail.path} ${where(f)}`);
+      if (f.detail.removed?.length) out.push(dim(`    - ${f.detail.removed.slice(0, 2).join("\n    - ")}`));
+      out.push(dim(`    ${tilde(f.file)}`));
+    }
+    for (const f of loops) {
+      out.push("");
+      out.push(`  ${yellow("↻")} ${bold("same failing command, 3+ times, nothing changed in between")} ${where(f)}`);
+      out.push(dim(`    ${f.detail.cmd}`));
+    }
+    for (const f of risky) {
+      out.push("");
+      out.push(`  ${yellow("!")} ${bold(f.detail.label)} ${where(f)}`);
+      out.push(dim(`    ${f.detail.cmd}`));
+    }
+  }
+
+  const seen = ["claude", "codex"].map((a) => [a, versionRange(a, groups[`agent:${a}`]?.versions)]).filter(([, r]) => r);
+  if (seen.length) {
+    out.push("");
+    out.push(dim("Log versions: " + seen.map(([a, r]) => `${AGENT_NAMES[a]} ${r.text}`).join(" · ")));
+    for (const [a, r] of seen) if (r.newer) out.push(yellow(`${AGENT_NAMES[a]} logs are newer than the versions this release was tested with (up to ${TESTED[a]}). If numbers look off, please report it.`));
+  }
+  out.push("");
+  out.push(dim("How each number is measured: https://github.com/EleChon-pixel/agent-polygraph#how-it-decides"));
+  out.push(dim("A verdict looks wrong? Report it (redacted): https://github.com/EleChon-pixel/agent-polygraph/issues/new/choose"));
+  out.push(dim("Share a numbers-only card: npx agent-polygraph --html"));
+  out.push(dim("Catch these as they happen: npx agent-polygraph guard --install"));
+  if (!used.length) out.push(dim("See what the logs miss: npx agent-polygraph record --install (stays offline), or --ci (asks GitHub)"));
+  out.push("");
+  return out.join("\n");
+}
+
+function where(f) {
+  const project = f.cwd ? f.cwd.split("/").filter(Boolean).pop() : "";
+  return dim(`· ${AGENT_NAMES[f.agent]} · ${day(f.ts)}${project ? " · " + project : ""}`);
+}
+
+function tilde(p) {
+  const home = os.homedir();
+  return p && p.startsWith(home) ? "~" + p.slice(home.length) : p;
+}

package/src/scan.js

@@ -0,0 +1,60 @@
+import * as claude from "./sources/claude.js";
+import * as codex from "./sources/codex.js";
+import { analyzeSession } from "./analyze.js";
+import { applyRecords } from "./record.js";
+
+export const SOURCES = { claude, codex };
+
+/**
+ * Discover, parse and analyze sessions.
+ * opts: { agents: ["claude","codex"], since: ms timestamp, project: substring, exclude: [id prefix or cwd substring],
+ *         roots: {claude, codex}, records: false to ignore `record` data, enrich: async (session) => void,
+ *         onProgress }
+ */
+export async function scan(opts = {}) {
+  const agents = opts.agents?.length ? opts.agents : Object.keys(SOURCES);
+  let entries = [];
+  for (const a of agents) {
+    const src = SOURCES[a];
+    entries.push(...src.discover(opts.roots?.[a] || src.defaultRoot()));
+  }
+  if (opts.since) entries = entries.filter((e) => e.mtime >= opts.since);
+
+  const results = [];
+  results.skipped = []; // session files we couldn't read: a quiet gap would look like a full audit
+  results.unrecognized = []; // files with content in a format we don't know (a new agent version?)
+  let done = 0;
+  const queue = [...entries];
+  const worker = async () => {
+    while (queue.length) {
+      const entry = queue.shift();
+      try {
+        const session = await SOURCES[entry.agent].parse(entry);
+        if (opts.project && !(session.cwd || "").includes(opts.project)) continue;
+        // --exclude: a session id prefix or a piece of its working directory
+        if (opts.exclude?.some((x) => entry.id.startsWith(x) || (session.cwd || "").includes(x))) continue;
+        if (opts.since && session.end && session.end < opts.since) continue;
+        if (session.unrecognized) {
+          results.unrecognized.push({ file: entry.files[0], agent: entry.agent });
+          continue;
+        }
+        if (!session.events.length) continue;
+        // evidence outside the logs: `record` snapshots and terminal runs (local files),
+        // then --ci (GitHub) when asked for
+        if (opts.records !== false) applyRecords(session);
+        if (opts.enrich) await opts.enrich(session);
+        results.push(analyzeSession(session));
+      } catch (err) {
+        results.skipped.push({ file: entry.files[0], error: err.message });
+        if (process.env.POLYGRAPH_DEBUG) console.error(`skip ${entry.files[0]}: ${err.message}`);
+      } finally {
+        opts.onProgress?.(++done, entries.length);
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(8, entries.length || 1) }, worker));
+  const { skipped, unrecognized } = results;
+  results.sort((a, b) => (a.start ?? 0) - (b.start ?? 0));
+  Object.assign(results, { skipped, unrecognized });
+  return results;
+}

package/src/shell/record.sh

@@ -0,0 +1,61 @@
+# agent-polygraph record: logs test commands you run in this terminal (folder, start and end
+# time, exit code; never their output) to ~/.agent-polygraph/records/terminal.jsonl, so a
+# test you ran yourself counts as evidence. Stays on this machine.
+# Remove with: agent-polygraph record --uninstall --shell
+case $- in *i*) ;; *) return 0 2>/dev/null ;; esac
+# not inside coding agents' own shells: their commands are in their logs already
+[ -n "${CLAUDECODE:-}${CODEX_SANDBOX:-}${CODEX_THREAD_ID:-}${CODEX_MANAGED_BY_NPM:-}" ] && return 0 2>/dev/null
+
+__apg_file="${AGENT_POLYGRAPH_HOME:-$HOME/.agent-polygraph}/records/terminal.jsonl"
+# a cheap prefilter; agent-polygraph applies its real test-command rules when it reads the log
+__apg_re='(test|spec|pytest|jest|vitest|mocha|rspec|phpunit|ctest|tox|nox|check|verify)'
+__apg_cmd=
+
+__apg_now() {
+  if [ -n "${EPOCHREALTIME:-}" ]; then printf '%s' "${EPOCHREALTIME/,/.}"; else date +%s; fi
+}
+__apg_esc() {
+  local s=$1
+  s=${s//\\/\\\\}; s=${s//\"/\\\"}; s=${s//$'\n'/\\n}; s=${s//$'\t'/\\t}; s=${s//$'\r'/}
+  printf '%s' "$s"
+}
+__apg_pre() {
+  __apg_cmd=
+  [[ $1 =~ $__apg_re ]] || return 0
+  __apg_cmd=$1
+  __apg_dir=$PWD
+  __apg_t0=$(__apg_now)
+}
+__apg_post() {
+  local s=$?
+  if [ -n "$__apg_cmd" ]; then
+    printf '{"v":1,"kind":"terminal","start":%s,"end":%s,"exit":%s,"cwd":"%s","cmd":"%s"}\n' \
+      "$__apg_t0" "$(__apg_now)" "$s" "$(__apg_esc "$__apg_dir")" "$(__apg_esc "$__apg_cmd")" >>"$__apg_file" 2>/dev/null
+    __apg_cmd=
+  fi
+  return $s
+}
+
+if [ -n "${ZSH_VERSION:-}" ]; then
+  autoload -Uz add-zsh-hook && add-zsh-hook preexec __apg_pre && add-zsh-hook precmd __apg_post
+elif [ -n "${BASH_VERSION:-}" ]; then
+  if [ -n "${bash_preexec_imported:-}${__bp_imported:-}" ]; then
+    # bash-preexec is loaded: use its hooks instead of a DEBUG trap of our own
+    preexec_functions+=(__apg_pre)
+    precmd_functions=(__apg_post "${precmd_functions[@]}")
+  elif [ -z "$(trap -p DEBUG)" ]; then
+    # one DEBUG trap call per command line: $HISTCMD changes only when a new line is entered
+    __apg_last=$HISTCMD
+    __apg_debug() {
+      [[ ${BASH_COMMAND:-} == __apg_* ]] && return
+      [ -n "${COMP_LINE:-}" ] && return
+      [ "$HISTCMD" = "$__apg_last" ] && return
+      __apg_last=$HISTCMD
+      local h
+      h=$(HISTTIMEFORMAT= builtin history 1)
+      [[ $h =~ ^[[:space:]]*[0-9]+[*]?[[:space:]]+(.*)$ ]] && __apg_pre "${BASH_REMATCH[1]}"
+    }
+    trap '__apg_debug' DEBUG
+    PROMPT_COMMAND="__apg_post${PROMPT_COMMAND:+;$PROMPT_COMMAND}"
+  fi
+fi

package/src/sources/claude.js

@@ -0,0 +1,300 @@
+// Claude Code transcripts: ~/.claude/projects/<project>/<session>.jsonl
+// Subagent transcripts live in <session>/subagents/*.jsonl and are merged into the parent.
+
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { readJsonl } from "../jsonl.js";
+
+export const name = "claude";
+
+export function defaultRoot() {
+  return path.join(process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), ".claude"), "projects");
+}
+
+/** List sessions as { id, files: [main, ...subagents], mtime }. */
+export function discover(root = defaultRoot()) {
+  const out = [];
+  let projects = [];
+  try {
+    projects = fs.readdirSync(root, { withFileTypes: true }).filter((d) => d.isDirectory());
+  } catch {
+    return out;
+  }
+  for (const proj of projects) {
+    const dir = path.join(root, proj.name);
+    for (const f of safeReaddir(dir)) {
+      if (!f.endsWith(".jsonl")) continue;
+      const id = f.slice(0, -6);
+      const main = path.join(dir, f);
+      const subDir = path.join(dir, id, "subagents");
+      const subs = safeReaddir(subDir)
+        .filter((s) => s.endsWith(".jsonl"))
+        .map((s) => path.join(subDir, s));
+      out.push({ agent: name, id, files: [main, ...subs], mtime: mtime(main) });
+    }
+  }
+  return out;
+}
+
+// Cheap prefilter before JSON.parse. Whitespace-tolerant: anonymizers and exporters often
+// re-serialize transcripts as `"type": "user"`.
+// Hook runs are recorded as attachments carrying the command, its output and exit code.
+const WANTED = /"type"\s*:\s*"(?:user|assistant|hook_success|hook_non_blocking_error|hook_blocking_error)"/;
+
+// Event model (shared with codex.js): a command's start (`cmd`) and what was learned about
+// it (`result`) are separate events, placed where they were observed. Edits are only
+// emitted once their tool result confirms them. Analysis relies on event order.
+export async function parse(entry) {
+  const session = { agent: name, id: entry.id, file: entry.files[0], cwd: null, models: new Set(), versions: new Set(), events: [], start: null, end: null };
+  const stats = { lines: 0, kept: 0 };
+  let userCmd = null; // a command you typed with `!`, waiting for its output
+  const pendingCmds = new Map(); // tool_use id -> cmd event awaiting its result
+  const pendingEdits = new Map(); // tool_use id -> edit events awaiting confirmation
+  const background = new Map(); // tool_use id -> backgrounded cmd event
+  const outputFiles = new Map(); // background output file -> cmd event
+  const reads = new Map(); // Read tool_use id -> cmd event whose output file it reads
+  // seq breaks timestamp ties in the order things were requested or observed
+  let seq = 0;
+  const push = (ev) => {
+    ev.seq ??= seq++;
+    session.events.push(ev);
+  };
+  const result = (of, ts, fields) => push({ kind: "result", of, ts, ...fields });
+
+  for (const [i, file] of entry.files.entries()) {
+    const isSub = i > 0;
+    for await (const rec of readJsonl(file, (line) => WANTED.test(line), stats)) {
+      const ts = Date.parse(rec.timestamp) || null;
+      if (rec.version && !isSub) session.versions.add(rec.version);
+      if (ts) {
+        session.start = Math.min(session.start ?? ts, ts);
+        session.end = Math.max(session.end ?? ts, ts);
+      }
+      if (!session.cwd && rec.cwd && !isSub) session.cwd = rec.cwd;
+      if (rec.gitBranch && rec.gitBranch !== "HEAD" && !isSub) session.branch = rec.gitBranch;
+      const msg = rec.message || {};
+      const content = msg.content;
+
+      // a hook (PostToolUse, Stop, …) that ran a command: tests run by hooks count too
+      if (rec.type === "attachment") {
+        const a = rec.attachment || {};
+        if (a.command) {
+          const ev = { kind: "cmd", ts, cmd: String(a.command), sub: isSub, hook: a.hookEvent || true };
+          push(ev);
+          result(ev, ts, { exitCode: typeof a.exitCode === "number" ? a.exitCode : null, isError: null, output: (String(a.stdout ?? "") + "\n" + String(a.stderr ?? "")).slice(-6000), ms: a.durationMs ?? null });
+        }
+        continue;
+      }
+
+      if (rec.type === "assistant") {
+        if (msg.model && !msg.model.startsWith("<")) session.models.add(msg.model);
+        if (!Array.isArray(content)) continue;
+        for (const block of content) {
+          if (block.type === "text" && !isSub) {
+            push({ kind: "say", ts, text: block.text });
+          } else if (block.type === "tool_use") {
+            if (block.name === "Read" && outputFiles.has(block.input?.file_path)) reads.set(block.id, outputFiles.get(block.input.file_path));
+            const evs = toolEvents(block, ts, isSub);
+            if (evs.length && evs[0].kind === "cmd") {
+              evs[0].id = block.id;
+              if (rec.gitBranch && rec.gitBranch !== "HEAD") evs[0].branch = rec.gitBranch;
+              // `tail -5 …/tasks/x.output` through the shell reads a background run's output too
+              const read = [...outputFiles.keys()].find((f) => evs[0].cmd.includes(f));
+              if (read) reads.set(block.id, outputFiles.get(read));
+              push(evs[0]);
+              pendingCmds.set(block.id, evs[0]);
+            } else if (evs.length) {
+              // an edit takes effect in request order, before any later tool call runs;
+              // it is only emitted if its result confirms it
+              for (const e of evs) e.seq = seq++;
+              pendingEdits.set(block.id, evs);
+            }
+          }
+        }
+      } else if (rec.type === "user") {
+        if (Array.isArray(content)) {
+          for (const block of content) {
+            if (block.type === "tool_result") {
+              const text = fullText(resultText(block.content));
+              const readOf = reads.get(block.tool_use_id);
+              if (readOf) {
+                // the agent reading a background run's output file: evidence about that run
+                reads.delete(block.tool_use_id);
+                result(readOf, ts, { exitCode: null, isError: null, output: text.slice(-6000), partial: true });
+                if (!pendingCmds.has(block.tool_use_id)) continue; // a Read; a shell read also gets its own result
+              }
+              const edits = pendingEdits.get(block.tool_use_id);
+              if (edits) {
+                pendingEdits.delete(block.tool_use_id);
+                if (block.is_error === true) continue; // rejected or failed: nothing changed
+                for (const e of edits) {
+                  // Write overwrites as happily as it creates; only its result says which
+                  if (e.write) e.op = /created successfully/i.test(text) ? "add" : /updated|overwr/i.test(text) ? "update" : "unknown";
+                  push(e);
+                }
+                continue;
+              }
+              const ev = pendingCmds.get(block.tool_use_id);
+              if (!ev) continue;
+              pendingCmds.delete(block.tool_use_id);
+              // refused by a permission prompt, the auto-mode classifier or a hook: it never ran
+              if (block.is_error === true && DENIED.test(text)) {
+                result(ev, ts, { denied: true, exitCode: null, isError: true, output: "" });
+                continue;
+              }
+              if (/running in background|backgrounded command/i.test(text) && !/^Exit code/.test(text)) {
+                // result arrives later through a <task-notification> or a Read of the output file
+                background.set(block.tool_use_id, ev);
+                const file = /(\/\S+\.output)\b/.exec(text)?.[1];
+                if (file) outputFiles.set(file, ev);
+                continue;
+              }
+              const m = /^Exit code (-?\d+)/.exec(text);
+              const isError = block.is_error === true;
+              result(ev, ts, { exitCode: m ? Number(m[1]) : isError ? null : 0, isError, output: text.slice(-6000), ms: ts && ev.ts ? ts - ev.ts : null });
+            } else if (block.type === "text" && !isSub && /^\[Request interrupted by user/.test(block.text || "")) {
+              push({ kind: "interrupt", ts });
+            }
+          }
+        }
+        if (typeof content === "string" && content.startsWith("<task-notification")) {
+          const id = /<tool-use-id>([^<]+)</.exec(content)?.[1];
+          const ev = background.get(id);
+          if (ev) {
+            const code = /exit code (-?\d+)/i.exec(content);
+            const status = /<status>(\w+)</.exec(content)?.[1];
+            const file = /<output-file>([^<]+)</.exec(content)?.[1];
+            if (file) outputFiles.set(file, ev);
+            result(ev, ts, {
+              exitCode: code ? Number(code[1]) : status === "completed" ? 0 : status === "failed" ? 1 : null,
+              isError: null,
+              output: "",
+              ms: ts && ev.ts ? ts - ev.ts : null,
+            });
+          }
+        }
+        // commands you typed yourself with `!`: <bash-input>, then <bash-stdout>/<bash-stderr>
+        if (typeof content === "string" && /^\s*<bash-input>/.test(content)) {
+          const cmd = unescape(/<bash-input>([\s\S]*?)<\/bash-input>/.exec(content)?.[1] ?? "").trim();
+          if (cmd) {
+            userCmd = { kind: "cmd", ts, cmd, sub: false, byUser: true };
+            push(userCmd);
+          }
+          continue;
+        }
+        if (typeof content === "string" && /^\s*<bash-std(?:out|err)>/.test(content) && userCmd) {
+          const out = [...content.matchAll(/<bash-std(?:out|err)>([\s\S]*?)<\/bash-std(?:out|err)>/g)].map((m) => unescape(m[1])).join("\n");
+          result(userCmd, ts, { exitCode: null, isError: null, output: out.slice(-6000), ms: ts && userCmd.ts ? ts - userCmd.ts : null });
+          userCmd = null;
+          continue;
+        }
+        if (!isSub && isHumanPrompt(rec)) {
+          push({ kind: "user", ts, text: typeof content === "string" ? content : textOf(content) });
+        }
+      }
+    }
+  }
+  // Edits whose outcome never arrived may or may not have happened.
+  for (const evs of pendingEdits.values()) push({ kind: "uncertain", ts: evs[0].ts, seq: evs[0].seq, reason: "edit with no result" });
+  session.versions = [...session.versions];
+  // lines in the file but none we recognize: probably a log format we don't know yet
+  session.unrecognized = stats.lines > 5 && stats.kept === 0;
+  // stable: events with equal timestamps keep the order they were observed in
+  session.events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0) || a.seq - b.seq);
+  session.models = [...session.models];
+  return session;
+}
+
+// Answers the agent gets instead of a command's output when it wasn't allowed to run
+const DENIED = /^(?:Permission for this action was denied|Permission to use \S+ (?:with command .* )?has been denied|The user doesn't want to proceed with this tool use|\S+ operation blocked by hook|.{0,40}hook (?:blocked|denied)|User rejected)/is;
+
+/**
+ * Output too large for the transcript is saved to a file, and the transcript keeps only
+ * a preview (`<persisted-output>… Full output saved to: /path …`). The runner's summary is
+ * at the end, so read the end of the saved file when it still exists.
+ */
+function fullText(text) {
+  if (!text.includes("<persisted-output>")) return text;
+  const file = /Full output saved to: (\S+?\.txt)\b/.exec(text)?.[1];
+  if (!file) return text;
+  try {
+    const fd = fs.openSync(file, "r");
+    try {
+      const size = fs.fstatSync(fd).size;
+      const n = Math.min(size, 16384);
+      const buf = Buffer.alloc(n);
+      fs.readSync(fd, buf, 0, n, size - n);
+      return text + "\n" + buf.toString("utf8");
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch {
+    return text;
+  }
+}
+
+function isHumanPrompt(rec) {
+  if (rec.isMeta || rec.isSidechain) return false;
+  const kind = rec.origin?.kind;
+  if (kind) return kind === "human";
+  const c = rec.message?.content;
+  const text = typeof c === "string" ? c : Array.isArray(c) && c.every((b) => b.type === "text") ? textOf(c) : null;
+  if (!text) return false;
+  return !/^\s*(?:<[a-z_-]+[\s>]|\[(?:Request interrupted|Image)|Caveat:)/.test(text);
+}
+
+function toolEvents(block, ts, isSub) {
+  const input = block.input || {};
+  switch (block.name) {
+    case "Bash":
+    case "bash":
+    case "PowerShell": // Claude Code on Windows; same result format as Bash
+    case "powershell":
+      return input.command ? [{ kind: "cmd", ts, cmd: String(input.command), sub: isSub }] : [];
+    case "Edit":
+      return [edit(input.file_path, input.old_string, input.new_string, ts)];
+    case "MultiEdit":
+      return (input.edits || []).map((e) => edit(input.file_path, e.old_string, e.new_string, ts));
+    case "Write":
+      return [{ kind: "edit", ts, path: input.file_path || "", removed: null, added: lines(input.content), write: true }];
+    case "NotebookEdit":
+      return [{ kind: "edit", ts, path: input.notebook_path || "", removed: [], added: lines(input.new_source) }];
+    default:
+      return [];
+  }
+}
+
+function edit(p, oldS, newS, ts) {
+  return { kind: "edit", ts, path: p || "", removed: lines(oldS), added: lines(newS) };
+}
+
+const lines = (s) => (typeof s === "string" && s.length ? s.split("\n") : []);
+
+function resultText(c) {
+  if (typeof c === "string") return c;
+  if (Array.isArray(c)) return c.map((b) => (typeof b === "string" ? b : b.text || "")).join("\n");
+  return "";
+}
+
+const unescape = (s) => s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+
+function textOf(content) {
+  return Array.isArray(content) ? content.filter((b) => b.type === "text").map((b) => b.text).join("\n") : "";
+}
+
+function safeReaddir(d) {
+  try {
+    return fs.readdirSync(d);
+  } catch {
+    return [];
+  }
+}
+
+function mtime(f) {
+  try {
+    return fs.statSync(f).mtimeMs;
+  } catch {
+    return 0;
+  }
+}