reasonix 0.0.5 → 0.2.0

package/dist/cli/index.js

@@ -783,6 +783,93 @@ function signature2(call) {
   return `${call.function?.name ?? ""}::${call.function?.arguments ?? ""}`;
 }
 
+// src/session.ts
+import {
+  appendFileSync,
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  readdirSync,
+  statSync,
+  unlinkSync
+} from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+function sessionsDir() {
+  return join(homedir(), ".reasonix", "sessions");
+}
+function sessionPath(name) {
+  return join(sessionsDir(), `${sanitizeName(name)}.jsonl`);
+}
+function sanitizeName(name) {
+  const cleaned = name.replace(/[^\w\-\u4e00-\u9fa5]/g, "_").slice(0, 64);
+  return cleaned || "default";
+}
+function loadSessionMessages(name) {
+  const path = sessionPath(name);
+  if (!existsSync(path)) return [];
+  try {
+    const raw = readFileSync(path, "utf8");
+    const out = [];
+    for (const line of raw.split(/\r?\n/)) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        const msg = JSON.parse(trimmed);
+        if (msg && typeof msg === "object" && "role" in msg) out.push(msg);
+      } catch {
+      }
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+function appendSessionMessage(name, message) {
+  const path = sessionPath(name);
+  mkdirSync(dirname(path), { recursive: true });
+  appendFileSync(path, `${JSON.stringify(message)}
+`, "utf8");
+  try {
+    chmodSync(path, 384);
+  } catch {
+  }
+}
+function listSessions() {
+  const dir = sessionsDir();
+  if (!existsSync(dir)) return [];
+  try {
+    const files = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+    return files.map((file) => {
+      const path = join(dir, file);
+      const stat = statSync(path);
+      const name = file.replace(/\.jsonl$/, "");
+      const messageCount = countLines(path);
+      return { name, path, size: stat.size, messageCount, mtime: stat.mtime };
+    }).sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+  } catch {
+    return [];
+  }
+}
+function deleteSession(name) {
+  const path = sessionPath(name);
+  try {
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function countLines(path) {
+  try {
+    const raw = readFileSync(path, "utf8");
+    return raw.split(/\r?\n/).filter((l) => l.trim()).length;
+  } catch {
+    return 0;
+  }
+}
+
 // src/telemetry.ts
 var DEEPSEEK_PRICING = {
   "deepseek-chat": { inputCacheHit: 0.07, inputCacheMiss: 0.27, output: 1.1 },
@@ -939,6 +1026,9 @@ var CacheFirstLoop = class {
   harvestOptions;
   branchEnabled;
   branchOptions;
+  sessionName;
+  /** Number of messages that were pre-loaded from the session file. */
+  resumedMessageCount;
   _turn = 0;
   _streamPreference;
   constructor(opts) {
@@ -962,6 +1052,23 @@ var CacheFirstLoop = class {
     this.stream = this.branchEnabled ? false : this._streamPreference;
     const allowedNames = /* @__PURE__ */ new Set([...this.prefix.toolSpecs.map((s) => s.function.name)]);
     this.repair = new ToolCallRepair({ allowedToolNames: allowedNames });
+    this.sessionName = opts.session ?? null;
+    if (this.sessionName) {
+      const prior = loadSessionMessages(this.sessionName);
+      for (const msg of prior) this.log.append(msg);
+      this.resumedMessageCount = prior.length;
+    } else {
+      this.resumedMessageCount = 0;
+    }
+  }
+  appendAndPersist(message) {
+    this.log.append(message);
+    if (this.sessionName) {
+      try {
+        appendSessionMessage(this.sessionName, message);
+      } catch {
+      }
+    }
   }
   /**
    * Reconfigure model/harvest/branch/stream mid-session. The loop's log,
@@ -1149,7 +1256,7 @@ var CacheFirstLoop = class {
       }
       const turnStats = this.stats.record(this._turn, this.model, usage ?? new Usage());
       if (pendingUser !== null) {
-        this.log.append({ role: "user", content: pendingUser });
+        this.appendAndPersist({ role: "user", content: pendingUser });
         pendingUser = null;
       }
       this.scratch.reasoning = reasoningContent || null;
@@ -1158,7 +1265,7 @@ var CacheFirstLoop = class {
         toolCalls,
         reasoningContent || null
       );
-      this.log.append(this.assistantMessage(assistantContent, repairedCalls));
+      this.appendAndPersist(this.assistantMessage(assistantContent, repairedCalls));
       yield {
         turn: this._turn,
         role: "assistant_final",
@@ -1176,13 +1283,19 @@ var CacheFirstLoop = class {
         const name = call.function?.name ?? "";
         const args = call.function?.arguments ?? "{}";
         const result = await this.tools.dispatch(name, args);
-        this.log.append({
+        this.appendAndPersist({
           role: "tool",
           tool_call_id: call.id ?? "",
           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]" };
@@ -1212,12 +1325,12 @@ function summarizeBranch(chosen, samples) {
 }
 
 // src/env.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 import { resolve } from "path";
 function loadDotenv(path = ".env") {
   let raw;
   try {
-    raw = readFileSync(resolve(process.cwd(), path), "utf8");
+    raw = readFileSync2(resolve(process.cwd(), path), "utf8");
   } catch {
     return;
   }
@@ -1235,16 +1348,439 @@ 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 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 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, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { homedir } from "os";
-import { dirname, join } from "path";
+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() {
-  return join(homedir(), ".reasonix", "config.json");
+  return join2(homedir2(), ".reasonix", "config.json");
 }
 function readConfig(path = defaultConfigPath()) {
   try {
-    const raw = readFileSync2(path, "utf8");
+    const raw = readFileSync4(path, "utf8");
     const parsed = JSON.parse(raw);
     if (parsed && typeof parsed === "object") return parsed;
   } catch {
@@ -1252,10 +1788,10 @@ function readConfig(path = defaultConfigPath()) {
   return {};
 }
 function writeConfig(cfg, path = defaultConfigPath()) {
-  mkdirSync(dirname(path), { recursive: true });
+  mkdirSync2(dirname2(path), { recursive: true });
   writeFileSync(path, JSON.stringify(cfg, null, 2), "utf8");
   try {
-    chmodSync(path, 384);
+    chmodSync2(path, 384);
   } catch {
   }
 }
@@ -1279,14 +1815,13 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.0.1";
+var VERSION = "0.2.0";
 
 // 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";
 
@@ -1494,7 +2029,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));
@@ -1543,8 +2078,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) : "";
@@ -1559,7 +2094,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)`;
 }
 
@@ -1629,15 +2164,51 @@ function handleSlash(cmd, args, loop) {
           "  /model <id>              deepseek-chat or deepseek-reasoner",
           "  /harvest [on|off]        Pillar 2: structured plan-state extraction",
           "  /branch <N|off>          run N parallel samples (N>=2), pick most confident",
-          "  /clear                   clear displayed history (log is kept)",
+          "  /sessions                list saved sessions (current is marked with \u25B8)",
+          "  /forget                  delete the current session from disk",
+          "  /clear                   clear displayed history (log + session kept)",
           "  /exit                    quit",
           "",
           "Presets:",
           "  fast   deepseek-chat   no harvest  no branch    ~1\xA2/100turns  \u2190 default",
           "  smart  reasoner        harvest                  ~10x cost, slower",
-          "  max    reasoner        harvest     branch 3     ~30x cost, slowest"
+          "  max    reasoner        harvest     branch 3     ~30x cost, slowest",
+          "",
+          "Sessions (auto-enabled by default, named 'default'):",
+          "  reasonix chat --session <name>   use a different named session",
+          "  reasonix chat --no-session       disable persistence for this run"
         ].join("\n")
       };
+    case "sessions": {
+      const items = listSessions();
+      if (items.length === 0) {
+        return {
+          info: "no saved sessions yet \u2014 chat normally and your messages will be saved automatically"
+        };
+      }
+      const lines = ["Saved sessions:"];
+      for (const s of items) {
+        const sizeKb = (s.size / 1024).toFixed(1);
+        const when = s.mtime.toISOString().replace("T", " ").slice(0, 16);
+        const marker = s.name === loop.sessionName ? "\u25B8" : " ";
+        lines.push(
+          `  ${marker} ${s.name.padEnd(22)} ${String(s.messageCount).padStart(5)} msgs  ${sizeKb.padStart(7)} KB  ${when}`
+        );
+      }
+      lines.push("");
+      lines.push("Resume with: reasonix chat --session <name>");
+      return { info: lines.join("\n") };
+    }
+    case "forget": {
+      if (!loop.sessionName) {
+        return { info: "not in a session \u2014 nothing to forget" };
+      }
+      const name = loop.sessionName;
+      const ok = deleteSession(name);
+      return {
+        info: ok ? `\u25B8 deleted session "${name}" \u2014 current screen still shows the conversation, but next launch starts fresh` : `could not delete session "${name}" (already gone?)`
+      };
+    }
     case "status": {
       const branchBudget = loop.branchOptions.budget ?? 1;
       return {
@@ -1697,7 +2268,7 @@ function handleSlash(cmd, args, loop) {
 
 // src/cli/ui/App.tsx
 var FLUSH_INTERVAL_MS = 60;
-function App({ model, system, transcript, harvest: harvest2, branch }) {
+function App({ model, system, transcript, harvest: harvest2, branch, session }) {
   const { exit } = useApp();
   const [historical, setHistorical] = useState2([]);
   const [streaming, setStreaming] = useState2(null);
@@ -1712,7 +2283,12 @@ function App({ model, system, transcript, harvest: harvest2, branch }) {
   });
   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 () => {
@@ -1724,23 +2300,52 @@ function App({ model, system, transcript, harvest: harvest2, branch }) {
     if (loopRef.current) return loopRef.current;
     const client = new DeepSeekClient();
     const prefix = new ImmutablePrefix({ system });
-    const l = new CacheFirstLoop({ client, prefix, model, harvest: harvest2, branch });
+    const l = new CacheFirstLoop({ client, prefix, model, harvest: harvest2, branch, session });
     loopRef.current = l;
     return l;
-  }, [model, system, harvest2, branch]);
+  }, [model, system, harvest2, branch, session]);
+  const sessionBannerShown = useRef(false);
+  useEffect2(() => {
+    if (sessionBannerShown.current) return;
+    sessionBannerShown.current = true;
+    if (!session) {
+      setHistorical((prev) => [
+        ...prev,
+        {
+          id: `sys-session-${Date.now()}`,
+          role: "info",
+          text: "\u25B8 ephemeral chat (no session persistence) \u2014 drop --no-session to enable"
+        }
+      ]);
+    } else if (loop.resumedMessageCount > 0) {
+      setHistorical((prev) => [
+        ...prev,
+        {
+          id: `sys-resume-${Date.now()}`,
+          role: "info",
+          text: `\u25B8 resumed session "${session}" with ${loop.resumedMessageCount} prior messages \xB7 /forget to start over \xB7 /sessions to list`
+        }
+      ]);
+    } else {
+      setHistorical((prev) => [
+        ...prev,
+        {
+          id: `sys-newsession-${Date.now()}`,
+          role: "info",
+          text: `\u25B8 session "${session}" (new) \u2014 auto-saved as you chat \xB7 /forget to delete \xB7 /sessions to list`
+        }
+      ]);
+    }
+  }, [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();
@@ -1873,7 +2478,7 @@ function App({ model, system, transcript, harvest: harvest2, branch }) {
   ), /* @__PURE__ */ React5.createElement(Static, { items: historical }, (item) => /* @__PURE__ */ React5.createElement(EventRow, { key: item.id, event: item })), streaming ? /* @__PURE__ */ React5.createElement(Box5, { marginY: 1 }, /* @__PURE__ */ React5.createElement(EventRow, { event: streaming })) : null, /* @__PURE__ */ React5.createElement(PromptInput, { value: input, onChange: setInput, onSubmit: handleSubmit, disabled: busy }), /* @__PURE__ */ React5.createElement(CommandStrip, null));
 }
 function CommandStrip() {
-  return /* @__PURE__ */ React5.createElement(Box5, { paddingX: 2 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /model \xB7 /harvest \xB7 /branch \xB7 /clear \xB7 /exit"));
+  return /* @__PURE__ */ React5.createElement(Box5, { paddingX: 2 }, /* @__PURE__ */ React5.createElement(Text5, { dimColor: true }, "/help \xB7 /preset ", "<fast|smart|max>", " \xB7 /sessions \xB7 /model \xB7 /harvest \xB7 /branch \xB7 /clear \xB7 /exit"));
 }
 function describeRepair(repair) {
   const parts = [];
@@ -1944,7 +2549,8 @@ function Root({ initialKey, ...appProps }) {
       system: appProps.system,
       transcript: appProps.transcript,
       harvest: appProps.harvest,
-      branch: appProps.branch
+      branch: appProps.branch,
+      session: appProps.session
     }
   );
 }
@@ -1957,6 +2563,93 @@ async function chatCommand(opts) {
   await waitUntilExit();
 }
 
+// src/cli/commands/diff.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { basename } from "path";
+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 }
+  );
+  console.log(renderSummaryTable(report));
+  if (opts.mdPath) {
+    const md = renderMarkdown(report);
+    writeFileSync2(opts.mdPath, md, "utf8");
+    console.log(`
+markdown report written to ${opts.mdPath}`);
+  }
+}
+
+// src/cli/commands/replay.ts
+function replayCommand(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";
@@ -2017,13 +2710,13 @@ async function runCommand(opts) {
 }
 
 // src/cli/commands/stats.ts
-import { existsSync, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync5 } from "fs";
 function statsCommand(opts) {
-  if (!existsSync(opts.transcript)) {
+  if (!existsSync2(opts.transcript)) {
     console.error(`no such transcript: ${opts.transcript}`);
     process.exit(1);
   }
-  const lines = readFileSync3(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;
@@ -2058,13 +2751,25 @@ program.command("chat").description("Interactive Ink TUI with live cache/cost pa
   "--branch <n>",
   "Self-consistency: run N parallel samples per turn and pick the most confident (disables streaming; enables harvest)",
   (v) => Number.parseInt(v, 10)
-).action(async (opts) => {
+).option(
+  "--session <name>",
+  "Use a named session (default: 'default'). Resume the same session next time."
+).option("--no-session", "Disable session persistence for this run (ephemeral chat)").action(async (opts) => {
+  let session;
+  if (opts.session === false) {
+    session = void 0;
+  } else if (typeof opts.session === "string" && opts.session.length > 0) {
+    session = opts.session;
+  } else {
+    session = "default";
+  }
   await chatCommand({
     model: opts.model,
     system: opts.system,
     transcript: opts.transcript,
     harvest: !!opts.harvest,
-    branch: Number.isFinite(opts.branch) && opts.branch > 1 ? opts.branch : void 0
+    branch: Number.isFinite(opts.branch) && opts.branch > 1 ? opts.branch : void 0,
+    session
   });
 });
 program.command("run <task>").description("Run a single task non-interactively, streaming output.").option("-m, --model <id>", "DeepSeek model id", "deepseek-chat").option("-s, --system <prompt>", "System prompt", DEFAULT_SYSTEM).action(async (task, opts) => {
@@ -2073,6 +2778,18 @@ 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(
+  "Pretty-print a transcript + rebuild its session summary (cost, cache, prefix stability). No API calls."
+).option("--head <n>", "Show only the first N records", (v) => Number.parseInt(v, 10)).option("--tail <n>", "Show only the last N records", (v) => Number.parseInt(v, 10)).action((transcript, opts) => {
+  replayCommand({
+    path: transcript,
+    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: aggregate deltas + first divergence.").option("--md <path>", "Also write a markdown report (blog-ready) to this path").option("--label-a <label>", "Display label for transcript A (default: filename)").option("--label-b <label>", "Display label for transcript B (default: filename)").action((a, b, opts) => {
+  diffCommand({ a, b, mdPath: opts.md, labelA: opts.labelA, labelB: opts.labelB });
+});
 program.command("version").description("Print Reasonix version.").action(versionCommand);
 program.parseAsync(process.argv).catch((err) => {
   console.error(err);