reasonix 0.0.6 → 0.2.2

package/dist/cli/index.js

@@ -1289,7 +1289,13 @@ var CacheFirstLoop = class {
           name,
           content: result
         });
-        yield { turn: this._turn, role: "tool", content: result, toolName: name };
+        yield {
+          turn: this._turn,
+          role: "tool",
+          content: result,
+          toolName: name,
+          toolArgs: args
+        };
       }
     }
     yield { turn: this._turn, role: "done", content: "[max_tool_iters reached]" };
@@ -1342,8 +1348,462 @@ function loadDotenv(path = ".env") {
   }
 }
 
+// src/transcript.ts
+import { createWriteStream, readFileSync as readFileSync3 } from "fs";
+function recordFromLoopEvent(ev, extra) {
+  const rec = {
+    ts: (/* @__PURE__ */ new Date()).toISOString(),
+    turn: ev.turn,
+    role: ev.role,
+    content: ev.content
+  };
+  if (ev.toolName !== void 0) rec.tool = ev.toolName;
+  if (ev.toolArgs !== void 0) rec.args = ev.toolArgs;
+  if (ev.error !== void 0) rec.error = ev.error;
+  if (ev.stats) {
+    rec.usage = {
+      prompt_tokens: ev.stats.usage.promptTokens,
+      completion_tokens: ev.stats.usage.completionTokens,
+      total_tokens: ev.stats.usage.totalTokens,
+      prompt_cache_hit_tokens: ev.stats.usage.promptCacheHitTokens,
+      prompt_cache_miss_tokens: ev.stats.usage.promptCacheMissTokens
+    };
+    rec.cost = ev.stats.cost;
+    rec.model = ev.stats.model;
+    rec.prefixHash = extra.prefixHash;
+  } else if (ev.role === "assistant_final") {
+    rec.model = extra.model;
+    rec.prefixHash = extra.prefixHash;
+  }
+  return rec;
+}
+function writeRecord(stream, record) {
+  stream.write(`${JSON.stringify(record)}
+`);
+}
+function writeMeta(stream, meta) {
+  const line = { role: "_meta", meta };
+  stream.write(`${JSON.stringify(line)}
+`);
+}
+function openTranscriptFile(path, meta) {
+  const stream = createWriteStream(path, { flags: "a" });
+  writeMeta(stream, meta);
+  return stream;
+}
+function readTranscript(path) {
+  const raw = readFileSync3(path, "utf8");
+  return parseTranscript(raw);
+}
+function parseTranscript(raw) {
+  const out = { meta: null, records: [] };
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    let obj;
+    try {
+      obj = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (!obj || typeof obj !== "object") continue;
+    const rec = obj;
+    if (rec.role === "_meta" && rec.meta && typeof rec.meta === "object") {
+      out.meta = rec.meta;
+      continue;
+    }
+    if (typeof rec.ts === "string" && typeof rec.turn === "number" && typeof rec.role === "string" && typeof rec.content === "string") {
+      out.records.push(rec);
+    }
+  }
+  return out;
+}
+
+// src/replay.ts
+function groupRecordsByTurn(records) {
+  const byTurn = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    const list = byTurn.get(rec.turn);
+    if (list) list.push(rec);
+    else byTurn.set(rec.turn, [rec]);
+  }
+  return [...byTurn.entries()].sort(([a], [b]) => a - b).map(([turn, records2]) => ({ turn, records: records2 }));
+}
+function computeCumulativeStats(pages, upToIdx) {
+  if (upToIdx < 0) return computeReplayStats([]);
+  const flat = [];
+  for (let i = 0; i <= upToIdx && i < pages.length; i++) {
+    const records = pages[i]?.records;
+    if (records) flat.push(...records);
+  }
+  return computeReplayStats(flat);
+}
+function replayFromFile(path) {
+  const parsed = readTranscript(path);
+  return { parsed, stats: computeReplayStats(parsed.records) };
+}
+function computeReplayStats(records) {
+  const turns = [];
+  const models = /* @__PURE__ */ new Set();
+  const prefixHashes = /* @__PURE__ */ new Set();
+  let userTurns = 0;
+  let toolCalls = 0;
+  for (const rec of records) {
+    if (rec.role === "user") userTurns++;
+    else if (rec.role === "tool") toolCalls++;
+    else if (rec.role === "assistant_final") {
+      if (rec.model) models.add(rec.model);
+      if (rec.prefixHash) prefixHashes.add(rec.prefixHash);
+      if (rec.usage && rec.model) {
+        const u = new Usage(
+          rec.usage.prompt_tokens ?? 0,
+          rec.usage.completion_tokens ?? 0,
+          rec.usage.total_tokens ?? 0,
+          rec.usage.prompt_cache_hit_tokens ?? 0,
+          rec.usage.prompt_cache_miss_tokens ?? 0
+        );
+        turns.push({
+          turn: rec.turn,
+          model: rec.model,
+          usage: u,
+          // `rec.cost` wins when present — honors whatever the writer computed
+          // even if pricing tables have since changed. Only recompute when
+          // the transcript didn't record it (old format).
+          cost: rec.cost ?? costUsd(rec.model, u),
+          cacheHitRatio: u.cacheHitRatio
+        });
+      }
+    }
+  }
+  return {
+    perTurn: turns,
+    models: [...models],
+    prefixHashes: [...prefixHashes],
+    userTurns,
+    toolCalls,
+    ...summarizeTurns(turns)
+  };
+}
+function summarizeTurns(turns) {
+  const totalCost = turns.reduce((s, t) => s + t.cost, 0);
+  const totalClaude = turns.reduce((s, t) => s + claudeEquivalentCost(t.usage), 0);
+  let hit = 0;
+  let miss = 0;
+  for (const t of turns) {
+    hit += t.usage.promptCacheHitTokens;
+    miss += t.usage.promptCacheMissTokens;
+  }
+  const cacheHitRatio = hit + miss > 0 ? hit / (hit + miss) : 0;
+  const savingsVsClaude = totalClaude > 0 ? 1 - totalCost / totalClaude : 0;
+  return {
+    turns: turns.length,
+    totalCostUsd: round2(totalCost, 6),
+    claudeEquivalentUsd: round2(totalClaude, 6),
+    savingsVsClaudePct: round2(savingsVsClaude * 100, 2),
+    cacheHitRatio: round2(cacheHitRatio, 4)
+  };
+}
+function round2(n, digits) {
+  const f = 10 ** digits;
+  return Math.round(n * f) / f;
+}
+
+// src/diff.ts
+function findNextDivergence(pairs, fromIdx) {
+  for (let i = fromIdx + 1; i < pairs.length; i++) {
+    if (pairs[i].kind !== "match") return i;
+  }
+  return -1;
+}
+function findPrevDivergence(pairs, fromIdx) {
+  const start = Math.min(fromIdx - 1, pairs.length - 1);
+  for (let i = start; i >= 0; i--) {
+    if (pairs[i].kind !== "match") return i;
+  }
+  return -1;
+}
+function diffTranscripts(a, b) {
+  const aSide = {
+    label: a.label,
+    meta: a.parsed.meta,
+    records: a.parsed.records,
+    stats: computeReplayStats(a.parsed.records)
+  };
+  const bSide = {
+    label: b.label,
+    meta: b.parsed.meta,
+    records: b.parsed.records,
+    stats: computeReplayStats(b.parsed.records)
+  };
+  const aByTurn = groupByTurn(a.parsed.records);
+  const bByTurn = groupByTurn(b.parsed.records);
+  const turns = [.../* @__PURE__ */ new Set([...aByTurn.keys(), ...bByTurn.keys()])].sort((x, y) => x - y);
+  const pairs = [];
+  let firstDivergenceTurn = null;
+  for (const turn of turns) {
+    const aGroup = aByTurn.get(turn) ?? { assistant: void 0, tools: [] };
+    const bGroup = bByTurn.get(turn) ?? { assistant: void 0, tools: [] };
+    const aAssistant = aGroup.assistant;
+    const bAssistant = bGroup.assistant;
+    const aTools = aGroup.tools;
+    const bTools = bGroup.tools;
+    let kind;
+    let divergenceNote;
+    if (!aAssistant && bAssistant) kind = "only_in_b";
+    else if (aAssistant && !bAssistant) kind = "only_in_a";
+    else if (!aAssistant && !bAssistant)
+      kind = "diverge";
+    else {
+      divergenceNote = classifyDivergence(aAssistant, bAssistant, aTools, bTools);
+      kind = divergenceNote ? "diverge" : "match";
+    }
+    if (kind !== "match" && firstDivergenceTurn === null) firstDivergenceTurn = turn;
+    pairs.push({ turn, aAssistant, bAssistant, aTools, bTools, kind, divergenceNote });
+  }
+  return { a: aSide, b: bSide, pairs, firstDivergenceTurn };
+}
+function classifyDivergence(a, b, aTools, bTools) {
+  const aNames = aTools.map((t) => t.tool ?? "").sort();
+  const bNames = bTools.map((t) => t.tool ?? "").sort();
+  if (aNames.join(",") !== bNames.join(",")) {
+    return `tool calls differ: A=[${aNames.join(",") || "\u2014"}] B=[${bNames.join(",") || "\u2014"}]`;
+  }
+  for (let i = 0; i < aTools.length; i++) {
+    const at = aTools[i];
+    const bt = bTools[i];
+    if (at.tool !== bt.tool) continue;
+    if ((at.args ?? "") !== (bt.args ?? "")) {
+      return `"${at.tool}" args differ`;
+    }
+  }
+  const simRatio = similarity(a.content, b.content);
+  if (simRatio < 0.75) return `text similarity ${(simRatio * 100).toFixed(0)}%`;
+  return void 0;
+}
+function similarity(a, b) {
+  if (a === b) return 1;
+  if (!a && !b) return 1;
+  if (!a || !b) return 0;
+  const maxLen = Math.max(a.length, b.length);
+  if (maxLen > 2e3) return tokenOverlap(a, b);
+  const dist = levenshtein(a, b);
+  return 1 - dist / maxLen;
+}
+function tokenOverlap(a, b) {
+  const ta = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const tb = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  if (ta.size === 0 && tb.size === 0) return 1;
+  let shared = 0;
+  for (const t of ta) if (tb.has(t)) shared++;
+  return 2 * shared / (ta.size + tb.size);
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let curr = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+    }
+    [prev, curr] = [curr, prev];
+  }
+  return prev[n];
+}
+function groupByTurn(records) {
+  const out = /* @__PURE__ */ new Map();
+  for (const rec of records) {
+    if (rec.role === "user") continue;
+    const g = out.get(rec.turn) ?? { tools: [] };
+    if (rec.role === "assistant_final") g.assistant = rec;
+    else if (rec.role === "tool") g.tools.push(rec);
+    out.set(rec.turn, g);
+  }
+  return out;
+}
+function renderSummaryTable(report, _opts = {}) {
+  const a = report.a;
+  const b = report.b;
+  const lines = [];
+  lines.push("Comparing:");
+  lines.push(`  A  ${a.label}`);
+  lines.push(`  B  ${b.label}`);
+  lines.push("");
+  lines.push(row(["", "A", "B", "\u0394"], [20, 14, 14, 14]));
+  lines.push(
+    row(["\u2500".repeat(20), "\u2500".repeat(14), "\u2500".repeat(14), "\u2500".repeat(14)], [20, 14, 14, 14])
+  );
+  lines.push(statRow("model calls", a.stats.turns, b.stats.turns));
+  lines.push(statRow("user turns", a.stats.userTurns, b.stats.userTurns));
+  lines.push(statRow("tool calls", a.stats.toolCalls, b.stats.toolCalls));
+  lines.push(
+    row(
+      [
+        "cache hit",
+        `${pct(a.stats.cacheHitRatio)}`,
+        `${pct(b.stats.cacheHitRatio)}`,
+        signPct(b.stats.cacheHitRatio - a.stats.cacheHitRatio)
+      ],
+      [20, 14, 14, 14]
+    )
+  );
+  lines.push(
+    row(
+      [
+        "cost (USD)",
+        `$${a.stats.totalCostUsd.toFixed(6)}`,
+        `$${b.stats.totalCostUsd.toFixed(6)}`,
+        costDelta(a.stats.totalCostUsd, b.stats.totalCostUsd)
+      ],
+      [20, 14, 14, 14]
+    )
+  );
+  lines.push(statRow("prefix hashes", a.stats.prefixHashes.length, b.stats.prefixHashes.length));
+  lines.push("");
+  const aPrefixStable = a.stats.prefixHashes.length <= 1;
+  const bPrefixStable = b.stats.prefixHashes.length <= 1;
+  if (aPrefixStable !== bPrefixStable) {
+    const stable = aPrefixStable ? "A" : "B";
+    const churn = aPrefixStable ? "B" : "A";
+    const churnCount = aPrefixStable ? b.stats.prefixHashes.length : a.stats.prefixHashes.length;
+    lines.push(
+      `prefix stability: ${stable} stayed byte-stable across ${Math.max(
+        a.stats.turns,
+        b.stats.turns
+      )} turns; ${churn} churned ${churnCount} distinct prefixes.`
+    );
+    lines.push("");
+  } else if (a.stats.prefixHashes[0] && a.stats.prefixHashes[0] === b.stats.prefixHashes[0]) {
+    lines.push(
+      `prefix: A and B share the same prefix hash (${a.stats.prefixHashes[0].slice(0, 12)}\u2026) \u2014 cache delta is attributable to log stability, not prompt change.`
+    );
+    lines.push("");
+  }
+  if (report.firstDivergenceTurn !== null) {
+    const p = report.pairs.find((p2) => p2.turn === report.firstDivergenceTurn);
+    lines.push(
+      `first divergence: turn ${report.firstDivergenceTurn} \u2014 ${p?.divergenceNote ?? "?"}`
+    );
+    if (p?.aAssistant) lines.push(`  A \u2192 ${truncate(p.aAssistant.content, 100)}`);
+    if (p?.bAssistant) lines.push(`  B \u2192 ${truncate(p.bAssistant.content, 100)}`);
+  } else {
+    lines.push("no material divergence detected (texts within similarity threshold).");
+  }
+  return lines.join("\n");
+}
+function renderMarkdown(report) {
+  const a = report.a;
+  const b = report.b;
+  const out = [];
+  out.push(`# Transcript diff: ${a.label} vs ${b.label}`);
+  out.push("");
+  if (a.meta || b.meta) {
+    out.push("## Meta");
+    out.push("");
+    out.push(`| | ${a.label} | ${b.label} |`);
+    out.push("|---|---|---|");
+    out.push(`| source | ${a.meta?.source ?? "\u2014"} | ${b.meta?.source ?? "\u2014"} |`);
+    out.push(`| model | ${a.meta?.model ?? "\u2014"} | ${b.meta?.model ?? "\u2014"} |`);
+    out.push(`| task | ${a.meta?.task ?? "\u2014"} | ${b.meta?.task ?? "\u2014"} |`);
+    out.push(`| startedAt | ${a.meta?.startedAt ?? "\u2014"} | ${b.meta?.startedAt ?? "\u2014"} |`);
+    out.push("");
+  }
+  out.push("## Summary");
+  out.push("");
+  out.push(`| metric | ${a.label} | ${b.label} | delta |`);
+  out.push("|---|---:|---:|---:|");
+  out.push(
+    `| model calls | ${a.stats.turns} | ${b.stats.turns} | ${signed(b.stats.turns - a.stats.turns)} |`
+  );
+  out.push(
+    `| user turns | ${a.stats.userTurns} | ${b.stats.userTurns} | ${signed(b.stats.userTurns - a.stats.userTurns)} |`
+  );
+  out.push(
+    `| tool calls | ${a.stats.toolCalls} | ${b.stats.toolCalls} | ${signed(b.stats.toolCalls - a.stats.toolCalls)} |`
+  );
+  out.push(
+    `| cache hit | ${pct(a.stats.cacheHitRatio)} | ${pct(b.stats.cacheHitRatio)} | **${signPct(b.stats.cacheHitRatio - a.stats.cacheHitRatio)}** |`
+  );
+  out.push(
+    `| cost (USD) | $${a.stats.totalCostUsd.toFixed(6)} | $${b.stats.totalCostUsd.toFixed(6)} | ${costDelta(a.stats.totalCostUsd, b.stats.totalCostUsd)} |`
+  );
+  out.push(
+    `| prefix hashes | ${a.stats.prefixHashes.length} | ${b.stats.prefixHashes.length} | \u2014 |`
+  );
+  out.push("");
+  out.push("## Turn-by-turn");
+  out.push("");
+  out.push(`| turn | kind | ${a.label} tool calls | ${b.label} tool calls | note |`);
+  out.push("|---:|:---:|---|---|---|");
+  for (const p of report.pairs) {
+    const aTools = p.aTools.map((t) => t.tool).filter(Boolean).join(", ") || "\u2014";
+    const bTools = p.bTools.map((t) => t.tool).filter(Boolean).join(", ") || "\u2014";
+    out.push(`| ${p.turn} | ${p.kind} | ${aTools} | ${bTools} | ${p.divergenceNote ?? ""} |`);
+  }
+  out.push("");
+  if (report.firstDivergenceTurn !== null) {
+    const p = report.pairs.find((x) => x.turn === report.firstDivergenceTurn);
+    out.push(`## First divergence (turn ${report.firstDivergenceTurn})`);
+    out.push("");
+    out.push(p?.divergenceNote ?? "");
+    out.push("");
+    if (p?.aAssistant) {
+      out.push(`**${a.label}:**`);
+      out.push("");
+      out.push("```");
+      out.push(p.aAssistant.content);
+      out.push("```");
+      out.push("");
+    }
+    if (p?.bAssistant) {
+      out.push(`**${b.label}:**`);
+      out.push("");
+      out.push("```");
+      out.push(p.bAssistant.content);
+      out.push("```");
+      out.push("");
+    }
+  }
+  return out.join("\n");
+}
+function row(cols, widths) {
+  return cols.map((c, i) => padRight(c, widths[i] ?? c.length)).join(" ");
+}
+function statRow(label, av, bv) {
+  return row([label, `${av}`, `${bv}`, signed(bv - av)], [20, 14, 14, 14]);
+}
+function padRight(s, w) {
+  return s.length >= w ? s : s + " ".repeat(w - s.length);
+}
+function signed(n) {
+  if (n === 0) return "0";
+  return `${n > 0 ? "+" : ""}${n}`;
+}
+function signPct(diff) {
+  if (diff === 0) return "0pp";
+  const s = (diff * 100).toFixed(1);
+  return `${diff > 0 ? "+" : ""}${s}pp`;
+}
+function pct(x) {
+  return `${(x * 100).toFixed(1)}%`;
+}
+function costDelta(a, b) {
+  if (a === 0 && b === 0) return "\u2014";
+  if (a === 0) return "new";
+  const pctChange = (b - a) / a * 100;
+  return `${pctChange > 0 ? "+" : ""}${pctChange.toFixed(1)}%`;
+}
+function truncate(s, n) {
+  return s.length > n ? `${s.slice(0, n)}\u2026` : s;
+}
+
 // src/config.ts
-import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { chmodSync as chmodSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync4, writeFileSync } from "fs";
 import { homedir as homedir2 } from "os";
 import { dirname as dirname2, join as join2 } from "path";
 function defaultConfigPath() {
@@ -1351,7 +1811,7 @@ function defaultConfigPath() {
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync3(path, "utf8");
+    const raw = readFileSync4(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -1386,14 +1846,13 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.0.1";
+var VERSION = "0.2.2";
 
 // src/cli/commands/chat.tsx
 import { render } from "ink";
 import React7, { useState as useState4 } from "react";
 
 // src/cli/ui/App.tsx
-import { createWriteStream } from "fs";
 import { Box as Box5, Static, Text as Text5, useApp } from "ink";
 import React5, { useCallback, useEffect as useEffect2, useMemo, useRef, useState as useState2 } from "react";
 
@@ -1601,7 +2060,7 @@ var EventRow = React2.memo(function EventRow2({ event }) {
     return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant")), event.branch ? /* @__PURE__ */ React2.createElement(BranchBlock, { branch: event.branch }) : null, event.reasoning ? /* @__PURE__ */ React2.createElement(ReasoningBlock, { reasoning: event.reasoning }) : null, !isPlanStateEmpty(event.planState) ? /* @__PURE__ */ React2.createElement(PlanStateBlock, { planState: event.planState }) : null, event.text ? /* @__PURE__ */ React2.createElement(Markdown, { text: event.text }) : /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "(no content)"), event.stats ? /* @__PURE__ */ React2.createElement(StatsLine, { stats: event.stats }) : null, event.repair ? /* @__PURE__ */ React2.createElement(Text2, { color: "magenta" }, event.repair) : null);
   }
   if (event.role === "tool") {
-    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, `tool<${event.toolName ?? "?"}>  \u2192`), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " ", truncate(event.text, 400)));
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "yellow" }, `tool<${event.toolName ?? "?"}>  \u2192`), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, " ", truncate2(event.text, 400)));
   }
   if (event.role === "error") {
     return /* @__PURE__ */ React2.createElement(Box2, { marginTop: 1 }, /* @__PURE__ */ React2.createElement(Text2, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "red" }, event.text));
@@ -1650,8 +2109,8 @@ function StreamingAssistant({ event }) {
     if (p.completed === 0) {
       return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "\u{1F500} launching ", p.total, " parallel samples (R1 thinking in parallel)\u2026", " "), /* @__PURE__ */ React2.createElement(Elapsed, null)), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  ", "spread across T=0.0/0.5/1.0 \xB7 typical wait 30-90s for reasoner"));
     }
-    const pct = Math.round(p.completed / p.total * 100);
-    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "\u{1F500} branching ", p.completed, "/", p.total, " (", pct, "%)", " "), /* @__PURE__ */ React2.createElement(Elapsed, null)), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
+    const pct2 = Math.round(p.completed / p.total * 100);
+    return /* @__PURE__ */ React2.createElement(Box2, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React2.createElement(Box2, null, /* @__PURE__ */ React2.createElement(Text2, { bold: true, color: "green" }, "assistant", " "), /* @__PURE__ */ React2.createElement(Text2, { color: "blue" }, "\u{1F500} branching ", p.completed, "/", p.total, " (", pct2, "%)", " "), /* @__PURE__ */ React2.createElement(Elapsed, null)), /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  latest #", p.latestIndex, " T=", p.latestTemperature.toFixed(1), " u=", p.latestUncertainties, p.completed < p.total ? "  \xB7 waiting for other samples\u2026" : "  \xB7 selecting winner\u2026"));
   }
   const tail = lastLine(event.text, 140);
   const reasoningTail = event.reasoning ? lastLine(event.reasoning, 120) : "";
@@ -1666,7 +2125,7 @@ function StatsLine({ stats }) {
   const hit = (stats.cacheHitRatio * 100).toFixed(1);
   return /* @__PURE__ */ React2.createElement(Text2, { dimColor: true }, "  \u21B3 cache ", hit, "% \xB7 tokens ", stats.usage.promptTokens, "\u2192", stats.usage.completionTokens, " \xB7 $", stats.cost.toFixed(6));
 }
-function truncate(s, max) {
+function truncate2(s, max) {
   return s.length <= max ? s : `${s.slice(0, max)}\u2026 (+${s.length - max} chars)`;
 }
 
@@ -1855,7 +2314,12 @@ function App({ model, system, transcript, harvest: harvest2, branch, session })
   });
   const transcriptRef = useRef(null);
   if (transcript && !transcriptRef.current) {
-    transcriptRef.current = createWriteStream(transcript, { flags: "a" });
+    transcriptRef.current = openTranscriptFile(transcript, {
+      version: 1,
+      source: "reasonix chat",
+      model,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
   }
   useEffect2(() => {
     return () => {
@@ -1905,18 +2369,14 @@ function App({ model, system, transcript, harvest: harvest2, branch, session })
     }
   }, [session, loop]);
   const prefixHash = loop.prefix.fingerprint;
-  const writeTranscript = useCallback((ev) => {
-    transcriptRef.current?.write(
-      `${JSON.stringify({
-        ts: (/* @__PURE__ */ new Date()).toISOString(),
-        turn: ev.turn,
-        role: ev.role,
-        content: ev.content,
-        tool: ev.toolName
-      })}
-`
-    );
-  }, []);
+  const writeTranscript = useCallback(
+    (ev) => {
+      const stream = transcriptRef.current;
+      if (!stream) return;
+      writeRecord(stream, recordFromLoopEvent(ev, { model, prefixHash }));
+    },
+    [model, prefixHash]
+  );
   const handleSubmit = useCallback(
     async (raw) => {
       const text = raw.trim();
@@ -2134,6 +2594,300 @@ async function chatCommand(opts) {
   await waitUntilExit();
 }
 
+// src/cli/commands/diff.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { basename } from "path";
+import { render as render2 } from "ink";
+import React10 from "react";
+
+// src/cli/ui/DiffApp.tsx
+import { Box as Box8, Static as Static2, Text as Text8, useApp as useApp3, useInput } from "ink";
+import React9, { useState as useState5 } from "react";
+
+// src/cli/ui/RecordView.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import React8 from "react";
+function RecordView({ rec, compact = false }) {
+  const toolArgsMax = compact ? 120 : 200;
+  const toolContentMax = compact ? 200 : 400;
+  if (rec.role === "user") {
+    return /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "cyan" }, "you \u203A", " "), /* @__PURE__ */ React8.createElement(Text7, null, rec.content));
+  }
+  if (rec.role === "assistant_final") {
+    return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { bold: true, color: "green" }, "assistant"), rec.cost !== void 0 ? /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "  $", rec.cost.toFixed(6)) : null, rec.usage ? /* @__PURE__ */ React8.createElement(CacheBadge, { usage: rec.usage }) : null), rec.content ? /* @__PURE__ */ React8.createElement(Text7, null, rec.content) : /* @__PURE__ */ React8.createElement(Text7, { dimColor: true, italic: true }, "(tool-call response only)"));
+  }
+  if (rec.role === "tool") {
+    return /* @__PURE__ */ React8.createElement(Box7, { flexDirection: "column", marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "yellow" }, "tool<", rec.tool ?? "?", ">"), rec.args ? /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "  args: ", truncate3(rec.args, toolArgsMax)) : null, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "  \u2192 ", truncate3(rec.content, toolContentMax)));
+  }
+  if (rec.role === "error") {
+    return /* @__PURE__ */ React8.createElement(Box7, { marginTop: 1 }, /* @__PURE__ */ React8.createElement(Text7, { color: "red", bold: true }, "error", " "), /* @__PURE__ */ React8.createElement(Text7, { color: "red" }, rec.error ?? rec.content));
+  }
+  if (rec.role === "done" || rec.role === "assistant_delta") {
+    return null;
+  }
+  return /* @__PURE__ */ React8.createElement(Box7, null, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "[", rec.role, "] ", rec.content));
+}
+function CacheBadge({ usage }) {
+  const hit = usage.prompt_cache_hit_tokens ?? 0;
+  const miss = usage.prompt_cache_miss_tokens ?? 0;
+  const total = hit + miss;
+  if (total === 0) return null;
+  const pct2 = hit / total * 100;
+  const color = pct2 >= 70 ? "green" : pct2 >= 40 ? "yellow" : "red";
+  return /* @__PURE__ */ React8.createElement(Text7, null, /* @__PURE__ */ React8.createElement(Text7, { dimColor: true }, "  \xB7 cache "), /* @__PURE__ */ React8.createElement(Text7, { color }, pct2.toFixed(1), "%"));
+}
+function truncate3(s, max) {
+  return s.length <= max ? s : `${s.slice(0, max)}\u2026 (+${s.length - max} chars)`;
+}
+
+// src/cli/ui/DiffApp.tsx
+function DiffApp({ report }) {
+  const { exit } = useApp3();
+  const maxIdx = Math.max(0, report.pairs.length - 1);
+  const initialIdx = report.firstDivergenceTurn ? report.pairs.findIndex((p) => p.turn === report.firstDivergenceTurn) : 0;
+  const [idx, setIdx] = useState5(Math.max(0, initialIdx));
+  useInput((input, key) => {
+    if (input === "q" || key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (input === "j" || key.downArrow || input === " " || key.return) {
+      setIdx((i) => Math.min(maxIdx, i + 1));
+    } else if (input === "k" || key.upArrow) {
+      setIdx((i) => Math.max(0, i - 1));
+    } else if (input === "g") {
+      setIdx(0);
+    } else if (input === "G") {
+      setIdx(maxIdx);
+    } else if (input === "n") {
+      const next = findNextDivergence(report.pairs, idx);
+      if (next !== -1) setIdx(next);
+    } else if (input === "N" || input === "p") {
+      const prev = findPrevDivergence(report.pairs, idx);
+      if (prev !== -1) setIdx(prev);
+    }
+  });
+  const pair = report.pairs[idx];
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column" }, /* @__PURE__ */ React9.createElement(DiffHeader, { report }), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, paddingX: 1, justifyContent: "space-between" }, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan", bold: true }, "turn ", pair?.turn ?? "?", " (", idx + 1, " / ", report.pairs.length, ")"), /* @__PURE__ */ React9.createElement(Text8, null, pair ? /* @__PURE__ */ React9.createElement(KindBadge, { kind: pair.kind }) : null)), /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "row", marginTop: 1 }, /* @__PURE__ */ React9.createElement(Pane, { label: report.a.label, headerColor: "blue", records: paneRecords(pair, "a") }), /* @__PURE__ */ React9.createElement(Pane, { label: report.b.label, headerColor: "magenta", records: paneRecords(pair, "b") })), pair?.divergenceNote ? /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u2605 "), /* @__PURE__ */ React9.createElement(Text8, null, pair.divergenceNote)) : null, /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "j"), "/", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "\u2193"), " next \xB7 ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "k"), "/", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "\u2191"), " ", "prev \xB7 ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "n"), " next-diverge \xB7 ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "N"), "/", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "p"), " ", "prev-diverge \xB7 ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "g"), "/", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "G"), " first/last \xB7 ", /* @__PURE__ */ React9.createElement(Text8, { bold: true }, "q"), " ", "quit")));
+}
+function DiffHeader({ report }) {
+  const a = report.a;
+  const b = report.b;
+  const cacheDelta = b.stats.cacheHitRatio - a.stats.cacheHitRatio;
+  const costDelta2 = a.stats.totalCostUsd > 0 ? (b.stats.totalCostUsd - a.stats.totalCostUsd) / a.stats.totalCostUsd * 100 : 0;
+  const aStable = a.stats.prefixHashes.length <= 1;
+  const bStable = b.stats.prefixHashes.length <= 1;
+  let prefixLine = null;
+  if (aStable !== bStable) {
+    const stableLabel = aStable ? report.a.label : report.b.label;
+    const churnLabel = aStable ? report.b.label : report.a.label;
+    const churnCount = aStable ? b.stats.prefixHashes.length : a.stats.prefixHashes.length;
+    prefixLine = `${stableLabel} stayed byte-stable; ${churnLabel} churned ${churnCount} distinct prefixes.`;
+  } else if (a.stats.prefixHashes[0] && a.stats.prefixHashes[0] === b.stats.prefixHashes[0]) {
+    prefixLine = `shared prefix hash ${a.stats.prefixHashes[0].slice(0, 12)}\u2026 \u2014 cache delta attributable to log stability, not prompt change.`;
+  }
+  return /* @__PURE__ */ React9.createElement(Box8, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1 }, /* @__PURE__ */ React9.createElement(Box8, { justifyContent: "space-between" }, /* @__PURE__ */ React9.createElement(Text8, null, /* @__PURE__ */ React9.createElement(Text8, { color: "cyan", bold: true }, "reasonix diff"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " \xB7 A="), /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, a.label), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " vs B="), /* @__PURE__ */ React9.createElement(Text8, { color: "magenta" }, b.label)), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, report.pairs.length, " turns aligned")), /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1, gap: 3 }, /* @__PURE__ */ React9.createElement(Text8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "cache "), /* @__PURE__ */ React9.createElement(Text8, null, (a.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React9.createElement(Text8, null, (b.stats.cacheHitRatio * 100).toFixed(1), "%"), /* @__PURE__ */ React9.createElement(Text8, { color: cacheDelta >= 0 ? "green" : "red", bold: true }, "  ", cacheDelta >= 0 ? "+" : "", (cacheDelta * 100).toFixed(1), "pp")), /* @__PURE__ */ React9.createElement(Text8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "cost "), /* @__PURE__ */ React9.createElement(Text8, null, "$", a.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, " \u2192 "), /* @__PURE__ */ React9.createElement(Text8, null, "$", b.stats.totalCostUsd.toFixed(6)), /* @__PURE__ */ React9.createElement(Text8, { color: costDelta2 <= 0 ? "green" : "red", bold: true }, "  ", costDelta2 >= 0 ? "+" : "", costDelta2.toFixed(1), "%")), /* @__PURE__ */ React9.createElement(Text8, null, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true }, "model calls "), /* @__PURE__ */ React9.createElement(Text8, null, a.stats.turns, " \u2192 ", b.stats.turns))), prefixLine ? /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, italic: true }, prefixLine)) : null);
+}
+function Pane({
+  label,
+  headerColor,
+  records
+}) {
+  return /* @__PURE__ */ React9.createElement(
+    Box8,
+    {
+      flexDirection: "column",
+      flexGrow: 1,
+      paddingX: 1,
+      borderStyle: "single",
+      borderColor: headerColor
+    },
+    /* @__PURE__ */ React9.createElement(Text8, { color: headerColor, bold: true }, label),
+    records.length === 0 ? /* @__PURE__ */ React9.createElement(Box8, { marginTop: 1 }, /* @__PURE__ */ React9.createElement(Text8, { dimColor: true, italic: true }, "(no records on this side for this turn)")) : /* @__PURE__ */ React9.createElement(Static2, { items: records.map((rec, i) => ({ key: `${label}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React9.createElement(RecordView, { key, rec, compact: true }))
+  );
+}
+function KindBadge({ kind }) {
+  if (kind === "match") {
+    return /* @__PURE__ */ React9.createElement(Text8, { color: "green" }, "\u2713 match");
+  }
+  if (kind === "diverge") {
+    return /* @__PURE__ */ React9.createElement(Text8, { color: "yellow" }, "\u2605 diverge");
+  }
+  if (kind === "only_in_a") {
+    return /* @__PURE__ */ React9.createElement(Text8, { color: "blue" }, "\u2190 only in A");
+  }
+  return /* @__PURE__ */ React9.createElement(Text8, { color: "magenta" }, "\u2192 only in B");
+}
+function paneRecords(pair, side) {
+  if (!pair) return [];
+  const tools = side === "a" ? pair.aTools : pair.bTools;
+  const assistant = side === "a" ? pair.aAssistant : pair.bAssistant;
+  const out = [...tools];
+  if (assistant) out.push(assistant);
+  return out;
+}
+
+// src/cli/commands/diff.ts
+async function diffCommand(opts) {
+  const aParsed = readTranscript(opts.a);
+  const bParsed = readTranscript(opts.b);
+  const report = diffTranscripts(
+    { label: opts.labelA ?? basename(opts.a), parsed: aParsed },
+    { label: opts.labelB ?? basename(opts.b), parsed: bParsed }
+  );
+  const wantMarkdown = !!opts.mdPath;
+  const wantPrint = opts.print || !process.stdout.isTTY;
+  const wantTui = opts.tui || !wantPrint && !wantMarkdown;
+  if (wantMarkdown) {
+    console.log(renderSummaryTable(report));
+    const md = renderMarkdown(report);
+    writeFileSync2(opts.mdPath, md, "utf8");
+    console.log(`
+markdown report written to ${opts.mdPath}`);
+    return;
+  }
+  if (wantTui) {
+    const { waitUntilExit } = render2(React10.createElement(DiffApp, { report }), {
+      exitOnCtrlC: true
+    });
+    await waitUntilExit();
+    return;
+  }
+  console.log(renderSummaryTable(report));
+}
+
+// src/cli/commands/replay.ts
+import { render as render3 } from "ink";
+import React12 from "react";
+
+// src/cli/ui/ReplayApp.tsx
+import { Box as Box9, Static as Static3, Text as Text9, useApp as useApp4, useInput as useInput2 } from "ink";
+import React11, { useMemo as useMemo2, useState as useState6 } from "react";
+function ReplayApp({ meta, pages }) {
+  const { exit } = useApp4();
+  const maxIdx = Math.max(0, pages.length - 1);
+  const [idx, setIdx] = useState6(maxIdx);
+  useInput2((input, key) => {
+    if (input === "q" || key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (input === "j" || key.downArrow || input === " " || key.return) {
+      setIdx((i) => Math.min(maxIdx, i + 1));
+    } else if (input === "k" || key.upArrow) {
+      setIdx((i) => Math.max(0, i - 1));
+    } else if (input === "g") {
+      setIdx(0);
+    } else if (input === "G") {
+      setIdx(maxIdx);
+    } else if (input === "h" || key.leftArrow) {
+      setIdx(0);
+    } else if (input === "l" || key.rightArrow) {
+      setIdx(maxIdx);
+    }
+  });
+  const cumStats = useMemo2(() => computeCumulativeStats(pages, idx), [pages, idx]);
+  const summary = {
+    turns: cumStats.turns,
+    totalCostUsd: cumStats.totalCostUsd,
+    claudeEquivalentUsd: cumStats.claudeEquivalentUsd,
+    savingsVsClaudePct: cumStats.savingsVsClaudePct,
+    cacheHitRatio: cumStats.cacheHitRatio
+  };
+  const prefixHash = cumStats.prefixHashes.length === 1 ? cumStats.prefixHashes[0].slice(0, 16) : cumStats.prefixHashes.length === 0 ? "(untracked)" : `(churned \xD7${cumStats.prefixHashes.length})`;
+  const currentPage = pages[idx];
+  const progressLabel = pages.length === 0 ? "empty transcript" : `turn ${idx + 1} / ${pages.length}`;
+  return /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column" }, /* @__PURE__ */ React11.createElement(
+    StatsPanel,
+    {
+      summary,
+      model: cumStats.models[0] ?? meta?.model ?? "?",
+      prefixHash
+    }
+  ), /* @__PURE__ */ React11.createElement(Box9, { flexDirection: "column", marginTop: 1, paddingX: 1 }, /* @__PURE__ */ React11.createElement(Box9, { justifyContent: "space-between" }, /* @__PURE__ */ React11.createElement(Text9, { color: "cyan", bold: true }, progressLabel), meta ? /* @__PURE__ */ React11.createElement(Text9, { dimColor: true }, meta.source, meta.task ? ` \xB7 ${meta.task}` : "", meta.mode ? ` \xB7 ${meta.mode}` : "") : null), currentPage ? /* @__PURE__ */ React11.createElement(Static3, { items: currentPage.records.map((rec, i) => ({ key: `${idx}-${i}`, rec })) }, ({ key, rec }) => /* @__PURE__ */ React11.createElement(RecordView, { key, rec })) : /* @__PURE__ */ React11.createElement(Text9, { dimColor: true, italic: true }, "no records")), /* @__PURE__ */ React11.createElement(Box9, { marginTop: 1, paddingX: 1, borderStyle: "single", borderColor: "gray" }, /* @__PURE__ */ React11.createElement(Text9, { dimColor: true }, /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "j"), "/", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "\u2193"), "/", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "space"), " next \xB7 ", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "k"), "/", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "\u2191"), " prev \xB7 ", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "g"), " first \xB7 ", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "G"), " last \xB7", " ", /* @__PURE__ */ React11.createElement(Text9, { bold: true }, "q"), " quit")));
+}
+
+// src/cli/commands/replay.ts
+async function replayCommand(opts) {
+  const wantPrint = opts.print || !process.stdout.isTTY || opts.head !== void 0 || opts.tail !== void 0;
+  if (wantPrint) {
+    printReplay(opts);
+    return;
+  }
+  const { parsed } = replayFromFile(opts.path);
+  const pages = groupRecordsByTurn(parsed.records);
+  const { waitUntilExit } = render3(React12.createElement(ReplayApp, { meta: parsed.meta, pages }), {
+    exitOnCtrlC: true
+  });
+  await waitUntilExit();
+}
+function printReplay(opts) {
+  const { parsed, stats } = replayFromFile(opts.path);
+  if (parsed.meta) {
+    const m = parsed.meta;
+    const bits = [`source=${m.source}`];
+    if (m.model) bits.push(`model=${m.model}`);
+    if (m.task) bits.push(`task=${m.task}`);
+    if (m.mode) bits.push(`mode=${m.mode}`);
+    if (m.repeat !== void 0) bits.push(`repeat=${m.repeat}`);
+    bits.push(`started=${m.startedAt}`);
+    console.log(`[meta] ${bits.join(" ")}`);
+    console.log("");
+  }
+  const records = sliceRecords(parsed.records, opts);
+  for (const rec of records) {
+    renderRecord(rec);
+  }
+  console.log("");
+  console.log("\u2500\u2500 summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  console.log(`model calls:         ${stats.turns}`);
+  console.log(`user turns:          ${stats.userTurns}`);
+  console.log(`tool calls:          ${stats.toolCalls}`);
+  console.log(`cache hit:           ${(stats.cacheHitRatio * 100).toFixed(1)}%`);
+  console.log(`cost:                $${stats.totalCostUsd.toFixed(6)}`);
+  console.log(`claude equivalent:   $${stats.claudeEquivalentUsd.toFixed(6)}`);
+  console.log(`savings vs claude:   ${stats.savingsVsClaudePct.toFixed(1)}%`);
+  console.log(`models:              ${stats.models.join(", ") || "\u2014"}`);
+  console.log(`prefix hashes:       ${stats.prefixHashes.length} distinct`);
+  if (stats.prefixHashes.length === 1) {
+    console.log(`  (byte-stable prefix: ${stats.prefixHashes[0]?.slice(0, 16)}\u2026)`);
+  } else if (stats.prefixHashes.length > 1) {
+    console.log("  (prefix churned \u2014 cache-hostile session)");
+  }
+}
+function sliceRecords(records, opts) {
+  if (opts.head !== void 0 && opts.head > 0) return records.slice(0, opts.head);
+  if (opts.tail !== void 0 && opts.tail > 0) return records.slice(-opts.tail);
+  return records;
+}
+function renderRecord(rec) {
+  const turn = `[t${rec.turn}]`;
+  if (rec.role === "user") {
+    console.log(`${turn} USER: ${oneLine(rec.content)}`);
+  } else if (rec.role === "assistant_final") {
+    const cost = rec.cost !== void 0 ? ` $${rec.cost.toFixed(6)}` : "";
+    const cache = rec.usage && (rec.usage.prompt_cache_hit_tokens !== void 0 || rec.usage.prompt_cache_miss_tokens !== void 0) ? (() => {
+      const hit = rec.usage.prompt_cache_hit_tokens ?? 0;
+      const miss = rec.usage.prompt_cache_miss_tokens ?? 0;
+      const total = hit + miss;
+      return total > 0 ? ` cache=${(hit / total * 100).toFixed(1)}%` : "";
+    })() : "";
+    console.log(`${turn} AGENT:${cost}${cache} ${oneLine(rec.content)}`);
+  } else if (rec.role === "tool") {
+    const args = rec.args ? ` args=${oneLine(rec.args, 80)}` : "";
+    console.log(`${turn} TOOL ${rec.tool ?? "?"}:${args} \u2192 ${oneLine(rec.content, 120)}`);
+  } else if (rec.role === "error") {
+    console.log(`${turn} ERROR: ${rec.error ?? rec.content}`);
+  } else if (rec.role === "done") {
+  } else {
+    console.log(`${turn} ${rec.role}: ${oneLine(rec.content)}`);
+  }
+}
+function oneLine(s, max = 200) {
+  const collapsed = s.replace(/\s+/g, " ").trim();
+  return collapsed.length > max ? `${collapsed.slice(0, max)}\u2026` : collapsed;
+}
+
 // src/cli/commands/run.ts
 import { stdin, stdout } from "process";
 import { createInterface } from "readline/promises";
@@ -2194,13 +2948,13 @@ async function runCommand(opts) {
 }
 
 // src/cli/commands/stats.ts
-import { existsSync as existsSync2, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
 function statsCommand(opts) {
   if (!existsSync2(opts.transcript)) {
     console.error(`no such transcript: ${opts.transcript}`);
     process.exit(1);
   }
-  const lines = readFileSync4(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
+  const lines = readFileSync5(opts.transcript, "utf8").split(/\r?\n/).filter(Boolean);
   let assistantTurns = 0;
   let toolCalls = 0;
   let lastTurn = 0;
@@ -2262,6 +3016,29 @@ program.command("run <task>").description("Run a single task non-interactively,
 program.command("stats <transcript>").description("Summarize a JSONL transcript produced by `reasonix chat --transcript`.").action((transcript) => {
   statsCommand({ transcript });
 });
+program.command("replay <transcript>").description(
+  "Interactive Ink TUI to scrub through a transcript + rebuild its session summary (cost, cache, prefix stability). No API calls."
+).option("--print", "Dump to stdout instead of mounting the TUI (auto when piped)").option("--head <n>", "stdout mode only \u2014 show first N records", (v) => Number.parseInt(v, 10)).option("--tail <n>", "stdout mode only \u2014 show last N records", (v) => Number.parseInt(v, 10)).action(async (transcript, opts) => {
+  await replayCommand({
+    path: transcript,
+    print: !!opts.print,
+    head: Number.isFinite(opts.head) ? opts.head : void 0,
+    tail: Number.isFinite(opts.tail) ? opts.tail : void 0
+  });
+});
+program.command("diff <a> <b>").description(
+  "Compare two transcripts in a split-pane Ink TUI (default) or stdout table. Use n/N to jump across divergences."
+).option("--md <path>", "Write a markdown report (blog-ready) to this path").option("--print", "Force stdout table instead of the TUI (auto when piped)").option("--tui", "Force the TUI even when piped (rare)").option("--label-a <label>", "Display label for transcript A (default: filename)").option("--label-b <label>", "Display label for transcript B (default: filename)").action(async (a, b, opts) => {
+  await diffCommand({
+    a,
+    b,
+    mdPath: opts.md,
+    labelA: opts.labelA,
+    labelB: opts.labelB,
+    print: !!opts.print,
+    tui: !!opts.tui
+  });
+});
 program.command("version").description("Print Reasonix version.").action(versionCommand);
 program.parseAsync(process.argv).catch((err) => {
   console.error(err);