reasonix 0.0.5 → 0.2.0

package/dist/index.js

@@ -778,6 +778,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 },
@@ -934,6 +1021,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) {
@@ -957,6 +1047,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,
@@ -1144,7 +1251,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;
@@ -1153,7 +1260,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",
@@ -1171,13 +1278,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]" };
@@ -1207,12 +1320,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;
   }
@@ -1230,16 +1343,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 {
@@ -1247,10 +1783,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 {
   }
 }
@@ -1274,7 +1810,7 @@ function redactKey(key) {
 }
 
 // src/index.ts
-var VERSION = "0.0.1";
+var VERSION = "0.2.0";
 export {
   AppendOnlyLog,
   CacheFirstLoop,
@@ -1289,25 +1825,44 @@ export {
   VolatileScratch,
   aggregateBranchUsage,
   analyzeSchema,
+  appendSessionMessage,
   claudeEquivalentCost,
+  computeReplayStats,
   costUsd,
   defaultConfigPath,
   defaultSelector,
+  deleteSession,
+  diffTranscripts,
   emptyPlanState,
   fetchWithRetry,
   flattenSchema,
   harvest,
   isPlanStateEmpty,
   isPlausibleKey,
+  listSessions,
   loadApiKey,
   loadDotenv,
+  loadSessionMessages,
   nestArguments,
+  openTranscriptFile,
+  parseTranscript,
   readConfig,
+  readTranscript,
+  recordFromLoopEvent,
   redactKey,
+  renderMarkdown as renderDiffMarkdown,
+  renderSummaryTable as renderDiffSummary,
   repairTruncatedJson,
+  replayFromFile,
   runBranches,
+  sanitizeName as sanitizeSessionName,
   saveApiKey,
   scavengeToolCalls,
-  writeConfig
+  sessionPath,
+  sessionsDir,
+  similarity,
+  writeConfig,
+  writeMeta,
+  writeRecord
 };
 //# sourceMappingURL=index.js.map