@mingozhou/dsh-replay 0.3.3

package/lib/core.js

@@ -0,0 +1,720 @@
+// src/core/decode.ts
+var CHUNK_ROW_TYPES = /* @__PURE__ */ new Set(["text-chunks", "reasoning-chunks", "tool-call-chunks"]);
+function isChunkRow(record) {
+  return CHUNK_ROW_TYPES.has(record.type);
+}
+function expandChunkRow(row) {
+  const { seq0, time0, data } = row;
+  const { turn, step, index, dt } = data;
+  const events = [];
+  const count = (row.type === "tool-call-chunks" ? data.args?.length : data.texts?.length) ?? 0;
+  let time = time0;
+  for (let k = 0; k < count; k++) {
+    if (k > 0) time += dt[k - 1] ?? 0;
+    let chunk;
+    if (row.type === "text-chunks") {
+      chunk = { type: "text-delta", index, text: data.texts[k] };
+    } else if (row.type === "reasoning-chunks") {
+      chunk = { type: "reasoning-delta", index, text: data.texts[k] };
+    } else {
+      chunk = {
+        type: "tool-call-delta",
+        index,
+        id: data.id,
+        ...k === 0 && data.name !== void 0 ? { name: data.name } : {},
+        args: data.args[k]
+      };
+    }
+    events.push({
+      type: "assistant/chunk",
+      seq: seq0 + k,
+      time,
+      data: { turn, step, chunk }
+    });
+  }
+  return events;
+}
+function decodeStorageRecord(record) {
+  if (isChunkRow(record)) return expandChunkRow(record);
+  return [record];
+}
+function isHeaderLine(value) {
+  return value["type"] === "session" && typeof value["id"] === "string";
+}
+function parseSessionJsonl(text) {
+  const lines = text.split("\n");
+  const malformed = [];
+  let header;
+  const events = [];
+  const endsWithNewline = text.endsWith("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    if (raw.trim() === "") continue;
+    const isLastLine = i === lines.length - 1;
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch (error) {
+      if (isLastLine && !endsWithNewline) {
+        malformed.push({ line: i + 1, raw, error: "torn tail (uncommitted final record)" });
+      } else {
+        malformed.push({ line: i + 1, raw, error: String(error) });
+      }
+      continue;
+    }
+    if (header === void 0) {
+      if (!isHeaderLine(value)) {
+        malformed.push({ line: i + 1, raw, error: "expected session header line" });
+        continue;
+      }
+      header = value;
+      continue;
+    }
+    try {
+      events.push(...decodeStorageRecord(value));
+    } catch (error) {
+      malformed.push({ line: i + 1, raw, error: String(error) });
+    }
+  }
+  if (header === void 0) {
+    throw new Error("session log has no header line");
+  }
+  events.sort((a, b) => a.seq - b.seq);
+  return { header, events, malformed };
+}
+function fromInspection(header, records) {
+  const events = records.flatMap(decodeStorageRecord).sort((a, b) => a.seq - b.seq);
+  return { header, events, malformed: [] };
+}
+
+// src/core/timeline.ts
+function contentText(message) {
+  if (!message?.content) return "";
+  return message.content.filter((b) => typeof b.text === "string").map((b) => b.text).join("");
+}
+function truncate(text, max = 96) {
+  const oneLine = text.replaceAll(/\s+/gu, " ").trim();
+  return oneLine.length > max ? `${oneLine.slice(0, max - 1)}\u2026` : oneLine;
+}
+function tryPretty(raw) {
+  try {
+    return JSON.stringify(JSON.parse(raw), null, 2);
+  } catch {
+    return void 0;
+  }
+}
+function get(obj, key) {
+  return typeof obj === "object" && obj !== null ? obj[key] : void 0;
+}
+var HIDDEN_TYPES = /* @__PURE__ */ new Set(["assistant/chunk", "step/start", "step/end", "turn/start"]);
+function metaLabel(event) {
+  const d = event.data;
+  switch (event.type) {
+    case "turn/end": {
+      const reason = get(get(d, "reason"), "kind");
+      return reason === "completed" ? void 0 : `turn ended: ${String(reason)}`;
+    }
+    case "compaction/summary":
+      return "context compacted (summary)";
+    case "compaction/prune":
+      return "context pruned";
+    case "approval/asked":
+      return `approval requested: ${String(get(d, "toolName") ?? "")}`;
+    case "approval/decided": {
+      const outcome = get(d, "outcome") ?? get(d, "decision");
+      return `approval decided: ${typeof outcome === "string" ? outcome : JSON.stringify(outcome)}`;
+    }
+    case "sandbox/mode":
+      return `sandbox mode \u2192 ${JSON.stringify(d)}`;
+    case "permission/preset":
+      return `permission preset \u2192 ${JSON.stringify(d)}`;
+    case "plan/mode":
+      return `plan mode change`;
+    case "subagent/descriptor":
+      return `subagent spawned (${String(get(d, "mode") ?? "")})`;
+    case "session/end-seed":
+      return "seed boundary (fork/resume point)";
+    case "llm/retry":
+    case "llm/retry-started":
+      return "model request retried";
+    case "command/run":
+      return `command: ${truncate(JSON.stringify(d), 60)}`;
+    case "goal/change":
+      return "goal changed";
+    case "session/title":
+      return void 0;
+    default:
+      return void 0;
+  }
+}
+function shadowedSeqs(events) {
+  const surfaceOrder = [];
+  const shadowed = /* @__PURE__ */ new Set();
+  for (const event of events) {
+    const op = event.surfaceOp;
+    if (op === void 0) continue;
+    if (op === "append") {
+      surfaceOrder.push(event.seq);
+    } else if (typeof op === "object" && op.op === "replace") {
+      const removed = surfaceOrder.splice(op.start, op.end - op.start + 1, event.seq);
+      for (const seq of removed) shadowed.add(seq);
+    }
+  }
+  return shadowed;
+}
+function buildTimeline(session) {
+  const { events } = session;
+  const turns = /* @__PURE__ */ new Map();
+  const items = [];
+  const usageSamples = [];
+  const toolCallsBySeq = /* @__PURE__ */ new Map();
+  const toolCalls = [];
+  const usageByStep = /* @__PURE__ */ new Map();
+  const models = /* @__PURE__ */ new Set();
+  const shadowed = shadowedSeqs(events);
+  let seedBoundarySeq;
+  let activeTurn;
+  let sessionTitle;
+  const ensureTurn = (turn, event) => {
+    let model = turns.get(turn);
+    if (model === void 0) {
+      model = { turn, startSeq: event.seq, startTime: event.time, steps: [], items: [] };
+      turns.set(turn, model);
+    }
+    return model;
+  };
+  const ensureStep = (turnModel, step, event) => {
+    let model = turnModel.steps.find((s) => s.step === step);
+    if (model === void 0) {
+      model = { turn: turnModel.turn, step, startSeq: event.seq, startTime: event.time, items: [] };
+      turnModel.steps.push(model);
+    }
+    return model;
+  };
+  const push = (item) => {
+    if (shadowed.has(item.seq)) item.shadowed = true;
+    items.push(item);
+    if (item.turn !== void 0) {
+      const turnModel = ensureTurn(item.turn, item.event);
+      turnModel.items.push(item);
+      if (item.step !== void 0) ensureStep(turnModel, item.step, item.event).items.push(item);
+    }
+  };
+  for (const event of events) {
+    const d = event.data;
+    const turn = get(d, "turn");
+    const step = get(d, "step");
+    switch (event.type) {
+      case "turn/start":
+        activeTurn = turn;
+        ensureTurn(activeTurn, event);
+        break;
+      case "turn/end": {
+        const model = ensureTurn(turn, event);
+        model.endSeq = event.seq;
+        model.endTime = event.time;
+        model.endReason = String(get(get(d, "reason"), "kind") ?? "completed");
+        activeTurn = void 0;
+        break;
+      }
+      case "step/start":
+        ensureStep(ensureTurn(turn, event), step, event);
+        break;
+      case "step/end": {
+        const stepModel = ensureStep(ensureTurn(turn, event), step, event);
+        stepModel.endSeq = event.seq;
+        stepModel.endTime = event.time;
+        break;
+      }
+      case "user/message": {
+        const message = d;
+        const text = contentText(message);
+        push({
+          kind: "user",
+          seq: event.seq,
+          time: event.time,
+          type: event.type,
+          turn: activeTurn,
+          label: truncate(text) || "(user message)",
+          text,
+          event
+        });
+        break;
+      }
+      case "assistant/message": {
+        const message = get(d, "message");
+        const usage = get(d, "usage");
+        const text = contentText(message);
+        const source = message?.source;
+        if (typeof source?.["model"] === "string") models.add(source["model"]);
+        if (usage) {
+          usageByStep.set(`${String(turn)}/${String(step)}`, usage);
+        }
+        push({
+          kind: "assistant",
+          seq: event.seq,
+          time: event.time,
+          turn,
+          step,
+          type: event.type,
+          label: truncate(text) || "(assistant message)",
+          text,
+          usage,
+          event
+        });
+        break;
+      }
+      case "assistant/chunk": {
+        const chunk = get(d, "chunk");
+        if (get(chunk, "type") === "usage") {
+          const usage = get(chunk, "usage");
+          usageByStep.set(`${String(turn)}/${String(step)}`, usage);
+        }
+        break;
+      }
+      case "tool/call": {
+        const info = {
+          callId: String(get(d, "callId") ?? ""),
+          name: String(get(d, "name") ?? ""),
+          argumentsRaw: String(get(d, "arguments") ?? ""),
+          argumentsPretty: tryPretty(String(get(d, "arguments") ?? "")),
+          callSeq: event.seq,
+          callTime: event.time
+        };
+        toolCallsBySeq.set(info.callId, info);
+        toolCalls.push(info);
+        push({
+          kind: "tool",
+          seq: event.seq,
+          time: event.time,
+          turn,
+          step,
+          type: event.type,
+          label: `${info.name}(${truncate(info.argumentsRaw, 48)})`,
+          toolCall: info,
+          event
+        });
+        break;
+      }
+      case "tool/result": {
+        const message = get(d, "message");
+        const source = message?.source;
+        const callId = String(source?.["callId"] ?? "");
+        const info = toolCallsBySeq.get(callId);
+        const block = message?.content?.[0];
+        const resultText = typeof get(block, "text") === "string" ? get(block, "text") : contentText({ content: get(block, "content") });
+        const error = get(d, "error");
+        if (info) {
+          info.resultSeq = event.seq;
+          info.resultTime = event.time;
+          info.durationMs = event.time - info.callTime;
+          info.resultText = resultText;
+          info.error = error;
+        }
+        break;
+      }
+      case "session/end-seed":
+        seedBoundarySeq = event.seq;
+        push({
+          kind: "meta",
+          seq: event.seq,
+          time: event.time,
+          type: event.type,
+          label: "seed boundary (fork/resume point)",
+          event
+        });
+        break;
+      case "request/context": {
+        const model = get(d, "model");
+        if (typeof model === "string") models.add(model);
+        break;
+      }
+      case "session/title": {
+        const title = get(d, "title");
+        if (typeof title === "string" && title !== "") sessionTitle = title;
+        break;
+      }
+      default: {
+        if (HIDDEN_TYPES.has(event.type)) break;
+        const label = metaLabel(event);
+        if (label !== void 0) {
+          push({
+            kind: "meta",
+            seq: event.seq,
+            time: event.time,
+            turn: typeof turn === "number" ? turn : void 0,
+            step: typeof step === "number" ? step : void 0,
+            type: event.type,
+            label,
+            event
+          });
+        }
+      }
+    }
+  }
+  const totals = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0, billedInput: 0 };
+  for (const [key, usage] of usageByStep) {
+    const [turnStr, stepStr] = key.split("/");
+    totals.input += usage.inputTokens;
+    totals.output += usage.outputTokens;
+    totals.cacheRead += usage.cacheReadTokens ?? 0;
+    totals.cacheWrite += usage.cacheWriteTokens ?? 0;
+    totals.reasoning += usage.reasoningTokens ?? 0;
+    const turnModel = turns.get(Number(turnStr));
+    const stepModel = turnModel?.steps.find((s) => s.step === Number(stepStr));
+    if (stepModel) stepModel.usage = usage;
+    const anchor = stepModel?.items.find((i) => i.kind === "assistant");
+    usageSamples.push({
+      seq: anchor?.seq ?? stepModel?.startSeq ?? 0,
+      turn: Number(turnStr),
+      step: Number(stepStr),
+      usage
+    });
+  }
+  usageSamples.sort((a, b) => a.seq - b.seq);
+  totals.billedInput = totals.input + totals.cacheRead + totals.cacheWrite;
+  const orderedTurns = [...turns.values()].sort((a, b) => a.turn - b.turn);
+  for (const t of orderedTurns) t.steps.sort((a, b) => a.step - b.step);
+  const startTime = events[0]?.time ?? session.header.createdAt;
+  const endTime = events.at(-1)?.time ?? startTime;
+  return {
+    turns: orderedTurns,
+    items,
+    totals,
+    usageSamples,
+    toolCalls,
+    durationMs: endTime - startTime,
+    startTime,
+    endTime,
+    eventCount: events.length,
+    seedBoundarySeq,
+    models: [...models],
+    title: sessionTitle
+  };
+}
+
+// src/core/audit.ts
+function get2(obj, key) {
+  return typeof obj === "object" && obj !== null ? obj[key] : void 0;
+}
+function str(value) {
+  return typeof value === "string" ? value : JSON.stringify(value) ?? "";
+}
+var SHELL_TOOLS = /^(bash|shell|exec|run_command|terminal|subprocess)/iu;
+var WRITE_TOOLS = /^(write|edit|create_file|str_replace|apply_patch|notebook_edit|fs_write|mv|rm|delete)/iu;
+var NETWORK_TOOLS = /^(fetch|web_fetch|http|curl|download|web_search|browser)/iu;
+var DANGEROUS_SHELL = [
+  { re: /\brm\s+(-[a-z]*[rf][a-z]*\s+)+/iu, why: "recursive/forced delete", key: "rm-rf" },
+  { re: /\bsudo\b/u, why: "privilege escalation", key: "sudo" },
+  { re: /\bchmod\s+([0-7]{3,4}|\+x)/u, why: "permission change", key: "chmod" },
+  { re: /\b(curl|wget)\b[^|;&]*\|\s*(ba)?sh\b/iu, why: "pipe remote script to shell", key: "curl-pipe" },
+  { re: /\bgit\s+push\s+.*--force/iu, why: "force push", key: "force-push" },
+  { re: /\b(dd|mkfs|fdisk)\b/u, why: "raw disk operation", key: "disk" },
+  { re: /(\bssh\b|\bscp\b|\brsync\b.*@)/u, why: "remote host access", key: "remote" },
+  { re: /\b(export|echo)\b.*\b(API_?KEY|TOKEN|SECRET|PASSWORD)\b/iu, why: "credential material in command", key: "creds" }
+];
+var SENSITIVE_PATH = /(\.env\b|\.ssh\/|id_rsa|\.aws\/|credentials|\.npmrc|\.netrc|secrets?\.|\.pem\b)/iu;
+var DEFAULT_RULES = [
+  {
+    id: "shell-exec",
+    severity: (event) => {
+      const args = str(get2(event.data, "arguments"));
+      return DANGEROUS_SHELL.some((p) => p.re.test(args)) ? "critical" : "warning";
+    },
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name = str(get2(event.data, "name"));
+      if (!SHELL_TOOLS.test(name)) return void 0;
+      const args = str(get2(event.data, "arguments"));
+      const hit = DANGEROUS_SHELL.find((p) => p.re.test(args));
+      return {
+        title: hit ? `shell: ${hit.why}` : `shell command via ${name}`,
+        detail: args.slice(0, 400),
+        messageKey: hit ? "f.shell.dangerous" : "f.shell.plain",
+        params: hit ? { whyKey: hit.key, why: hit.why } : { name }
+      };
+    }
+  },
+  {
+    id: "file-write",
+    severity: (event) => SENSITIVE_PATH.test(str(get2(event.data, "arguments"))) ? "critical" : "info",
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name = str(get2(event.data, "name"));
+      if (!WRITE_TOOLS.test(name)) return void 0;
+      const args = str(get2(event.data, "arguments"));
+      const sensitive = SENSITIVE_PATH.test(args);
+      return {
+        title: sensitive ? `file write touches sensitive path` : `file mutation via ${name}`,
+        detail: args.slice(0, 400),
+        messageKey: sensitive ? "f.file.sensitive" : "f.file.write",
+        params: { name }
+      };
+    }
+  },
+  {
+    id: "sensitive-read",
+    severity: "serious",
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const args = str(get2(event.data, "arguments"));
+      const name = str(get2(event.data, "name"));
+      if (WRITE_TOOLS.test(name) || SHELL_TOOLS.test(name)) return void 0;
+      if (!SENSITIVE_PATH.test(args)) return void 0;
+      return {
+        title: `access to sensitive path via ${name}`,
+        detail: args.slice(0, 400),
+        messageKey: "f.read.sensitive",
+        params: { name }
+      };
+    }
+  },
+  {
+    id: "network",
+    severity: "info",
+    match: (event) => {
+      if (event.type !== "tool/call") return void 0;
+      const name = str(get2(event.data, "name"));
+      if (!NETWORK_TOOLS.test(name)) return void 0;
+      return {
+        title: `network access via ${name}`,
+        detail: str(get2(event.data, "arguments")).slice(0, 400),
+        messageKey: "f.network",
+        params: { name }
+      };
+    }
+  },
+  {
+    id: "approval-denied",
+    severity: "warning",
+    match: (event) => {
+      if (event.type !== "approval/decided") return void 0;
+      const outcome = str(get2(event.data, "outcome") ?? get2(event.data, "decision"));
+      if (!/den|reject|refus/iu.test(outcome)) return void 0;
+      return { title: "user denied an approval", detail: outcome, messageKey: "f.approval.denied" };
+    }
+  },
+  {
+    id: "sandbox-change",
+    severity: "serious",
+    match: (event) => event.type === "sandbox/mode" ? { title: "sandbox mode changed", detail: JSON.stringify(event.data), messageKey: "f.sandbox.change" } : void 0
+  },
+  {
+    id: "permission-change",
+    severity: "serious",
+    match: (event) => event.type === "permission/preset" ? { title: "permission preset changed", detail: JSON.stringify(event.data), messageKey: "f.permission.change" } : void 0
+  },
+  {
+    id: "subagent",
+    severity: "info",
+    match: (event) => event.type === "subagent/descriptor" ? {
+      title: `subagent spawned (${str(get2(event.data, "mode"))})`,
+      detail: str(get2(event.data, "persona") ?? get2(event.data, "label") ?? ""),
+      messageKey: "f.subagent",
+      params: { mode: str(get2(event.data, "mode")) }
+    } : void 0
+  },
+  {
+    id: "tool-error",
+    severity: "warning",
+    match: (event) => {
+      if (event.type !== "tool/result") return void 0;
+      const error = get2(event.data, "error");
+      if (error === void 0) return void 0;
+      return {
+        title: `tool failed: ${str(get2(error, "name"))}`,
+        detail: str(get2(error, "code")),
+        messageKey: "f.tool.error",
+        params: { name: str(get2(error, "name")) }
+      };
+    }
+  },
+  {
+    id: "turn-error",
+    severity: "warning",
+    match: (event) => {
+      if (event.type !== "turn/end") return void 0;
+      const kind = str(get2(get2(event.data, "reason"), "kind"));
+      if (kind === "completed" || kind === "") return void 0;
+      return { title: `turn ended abnormally: ${kind}`, messageKey: "f.turn.error", params: { kind } };
+    }
+  }
+];
+var SEVERITY_ORDER = ["critical", "serious", "warning", "info"];
+function auditSession(session, rules = DEFAULT_RULES) {
+  const findings = [];
+  for (const event of session.events) {
+    for (const rule of rules) {
+      const hit = rule.match(event);
+      if (hit === void 0) continue;
+      const severity = typeof rule.severity === "function" ? rule.severity(event) : rule.severity;
+      findings.push({ ruleId: rule.id, severity, seq: event.seq, time: event.time, ...hit });
+    }
+  }
+  findings.sort(
+    (a, b) => SEVERITY_ORDER.indexOf(a.severity) - SEVERITY_ORDER.indexOf(b.severity) || a.seq - b.seq
+  );
+  const counts = { critical: 0, serious: 0, warning: 0, info: 0 };
+  for (const finding of findings) counts[finding.severity]++;
+  return { findings, counts };
+}
+
+// src/core/forktree.ts
+function buildForkForest(entries) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const { header, title } of entries) {
+    nodes.set(header.id, {
+      id: header.id,
+      header,
+      title,
+      children: [],
+      seedLength: header.seedLength,
+      depth: 0,
+      row: 0
+    });
+  }
+  const roots = [];
+  for (const node of nodes.values()) {
+    const parentId = node.header.parentSession;
+    if (parentId === void 0) {
+      roots.push(node);
+      continue;
+    }
+    const parent = nodes.get(parentId);
+    if (parent === void 0) {
+      node.orphan = true;
+      roots.push(node);
+    } else {
+      parent.children.push(node);
+    }
+  }
+  const byCreated = (a, b) => a.header.createdAt - b.header.createdAt || a.id.localeCompare(b.id);
+  roots.sort(byCreated);
+  for (const node of nodes.values()) node.children.sort(byCreated);
+  let row = 0;
+  let maxDepth = 0;
+  const visited = /* @__PURE__ */ new Set();
+  const assign = (node, depth) => {
+    if (visited.has(node.id)) return;
+    visited.add(node.id);
+    node.depth = depth;
+    node.row = row++;
+    maxDepth = Math.max(maxDepth, depth);
+    for (const child of node.children) assign(child, depth + 1);
+  };
+  for (const root of roots) assign(root, 0);
+  for (const node of nodes.values()) {
+    if (!visited.has(node.id)) {
+      node.orphan = true;
+      roots.push(node);
+      assign(node, 0);
+    }
+  }
+  return { roots, nodes, rowCount: row, maxDepth };
+}
+function lineageOf(forest, id) {
+  const path = [];
+  let current = forest.nodes.get(id);
+  const guard = /* @__PURE__ */ new Set();
+  while (current !== void 0 && !guard.has(current.id)) {
+    guard.add(current.id);
+    path.unshift(current);
+    const parentId = current.header.parentSession;
+    current = parentId === void 0 ? void 0 : forest.nodes.get(parentId);
+  }
+  return path;
+}
+
+// src/core/compare.ts
+function stats(session, timeline, title) {
+  const toolMix = {};
+  let toolErrors = 0;
+  for (const call of timeline.toolCalls) {
+    toolMix[call.name] = (toolMix[call.name] ?? 0) + 1;
+    if (call.error !== void 0) toolErrors++;
+  }
+  const steps = timeline.turns.reduce((n, t) => n + t.steps.length, 0);
+  return {
+    id: session.header.id,
+    title,
+    turns: timeline.turns.length,
+    steps,
+    events: timeline.eventCount,
+    toolCallCount: timeline.toolCalls.length,
+    toolErrors,
+    inputTokens: timeline.totals.input,
+    billedInputTokens: timeline.totals.billedInput,
+    outputTokens: timeline.totals.output,
+    cacheReadTokens: timeline.totals.cacheRead,
+    durationMs: timeline.durationMs,
+    models: timeline.models,
+    toolMix
+  };
+}
+function eventFingerprint(event) {
+  return `${event.type}\0${JSON.stringify(event.data)}`;
+}
+function compareSessions(a, b, titles) {
+  const timelineA = buildTimeline(a);
+  const timelineB = buildTimeline(b);
+  const statsA = stats(a, timelineA, titles?.a);
+  const statsB = stats(b, timelineB, titles?.b);
+  const toolNames = [.../* @__PURE__ */ new Set([...Object.keys(statsA.toolMix), ...Object.keys(statsB.toolMix)])].sort();
+  const related = a.header.parentSession === b.header.id || b.header.parentSession === a.header.id || a.header.parentSession !== void 0 && a.header.parentSession === b.header.parentSession;
+  let divergenceSeq;
+  const shared = Math.min(a.events.length, b.events.length);
+  for (let i = 0; i < shared; i++) {
+    if (a.events[i].type === "session/end-seed" || b.events[i].type === "session/end-seed") {
+      if (a.events[i].type !== b.events[i].type) {
+        divergenceSeq = Math.min(a.events[i].seq, b.events[i].seq);
+        break;
+      }
+      continue;
+    }
+    if (eventFingerprint(a.events[i]) !== eventFingerprint(b.events[i])) {
+      divergenceSeq = a.events[i].seq;
+      break;
+    }
+  }
+  if (divergenceSeq === void 0 && a.events.length !== b.events.length) {
+    divergenceSeq = shared > 0 ? (a.events[shared - 1]?.seq ?? 0) + 1 : 0;
+  }
+  return { a: statsA, b: statsB, toolNames, divergenceSeq, related };
+}
+
+// src/core/cost.ts
+var DEFAULT_PRICING = [
+  { match: /deepseek.*pro/iu, rate: { input: 1.1, cacheRead: 0.27, output: 4.4 }, label: "DeepSeek Pro" },
+  { match: /deepseek/iu, rate: { input: 0.27, cacheRead: 0.07, output: 1.1 }, label: "DeepSeek" },
+  { match: /claude|anthropic/iu, rate: { input: 3, cacheRead: 0.3, cacheWrite: 3.75, output: 15 }, label: "Claude" },
+  { match: /gpt|^o\d|openai|codex/iu, rate: { input: 2.5, cacheRead: 1.25, output: 10 }, label: "OpenAI" },
+  { match: /gemini/iu, rate: { input: 1.25, cacheRead: 0.31, output: 10 }, label: "Gemini" }
+];
+function estimateCost(totals, models, pricing = DEFAULT_PRICING) {
+  const entry = pricing.find((p) => models.some((m) => p.match.test(m)));
+  if (entry === void 0) return void 0;
+  const { rate } = entry;
+  const usd = (totals.input * rate.input + totals.cacheRead * rate.cacheRead + totals.cacheWrite * (rate.cacheWrite ?? rate.input) + totals.output * rate.output) / 1e6;
+  return { usd, label: entry.label };
+}
+function formatUsd(usd) {
+  if (usd >= 1) return `$${usd.toFixed(2)}`;
+  if (usd >= 0.01) return `$${usd.toFixed(3)}`;
+  return `$${usd.toFixed(4)}`;
+}
+export {
+  DEFAULT_PRICING,
+  DEFAULT_RULES,
+  auditSession,
+  buildForkForest,
+  buildTimeline,
+  compareSessions,
+  decodeStorageRecord,
+  estimateCost,
+  expandChunkRow,
+  formatUsd,
+  fromInspection,
+  isChunkRow,
+  lineageOf,
+  parseSessionJsonl
+};