@clapecho233/pi-smart-fold 0.1.0 → 0.1.1

package/test/click-sim.mjs

@@ -0,0 +1,224 @@
+/**
+ * Click-cycle simulation against the REAL pi AssistantMessageComponent.
+ *
+ * Drives the patched updateContent + pi's exact MouseRegion click semantics
+ (copied from pi's assistant-message.js) and asserts the user-facing toggle:
+ *
+ *   streaming:  tail →(click)→ full →(click)→ tail →(click)→ full …
+ *               full view keeps the ticking `Thinking… (Ns)` line at the
+ *               BOTTOM of the block; the hidden-label middle state never
+ *               appears.
+ *   finalized:  seeded hidden `Thought for …` label →(click)→ full+footer
+ *               →(click)→ label …
+ *
+ * Requires ./node_modules/@earendil-works symlinks to the installed pi
+ * packages (see README dev section). Not part of `npm test`.
+ */
+import assert from "node:assert/strict";
+import { AssistantMessageComponent, initTheme } from "@earendil-works/pi-coding-agent";
+import smartFold from "../index.ts";
+
+initTheme("default", false); // headless: the component's render path needs a theme
+
+// ---- mock pi ExtensionAPI --------------------------------------------------
+let transformer;
+const handlers = {};
+const mockPi = {
+  registerMarkdownTransformer: (fn) => {
+    transformer = fn;
+  },
+  on: (name, fn) => {
+    (handlers[name] ??= []).push(fn);
+  },
+  registerTool: () => {},
+  registerCommand: () => {},
+  appendEntry: () => {},
+};
+smartFold(mockPi);
+assert.equal(typeof transformer, "function", "transformer registered");
+
+const fire = (name, event) => {
+  let done = Promise.resolve();
+  for (const fn of handlers[name] ?? []) done = done.then(() => fn(event));
+  return done;
+};
+
+/** Invoke the transformer the way pi's Markdown component would. */
+const render = (markdown, isStreaming) =>
+  transformer(markdown, {
+    messageType: "assistant-thinking",
+    isStreaming,
+    availableWidth: 100,
+  });
+
+/** pi's MouseRegion click handler, verbatim semantics. */
+const click = (comp, runIndex) => {
+  const hidden = comp.thinkingVisibilityOverrides.get(runIndex) ?? comp.hideThinkingBlock;
+  comp.thinkingVisibilityOverrides.set(runIndex, !hidden);
+  comp.updateContent(comp.lastMessage);
+};
+
+const msg = (thinking) => ({
+  content: [{ type: "thinking", thinking }],
+  stopReason: undefined,
+});
+const update = (partial, delta) =>
+  fire("message_update", {
+    message: { role: "assistant" },
+    assistantMessageEvent: { type: "thinking_delta", contentIndex: 0, delta, partial },
+  });
+
+// ---- streaming: tail ↔ full with a single click -----------------------------
+await fire("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_start", contentIndex: 0, partial: msg("") },
+});
+await update(msg("alpha thoughts"), "alpha thoughts");
+
+const comp = new AssistantMessageComponent();
+comp.updateContent(msg("alpha thoughts"), true);
+assert.equal(comp.thinkingVisibilityOverrides.size, 0, "no overrides before any click");
+
+// default: scrolling tail — label line on TOP, only the last text line
+assert.match(
+  render("alpha thoughts", true),
+  /^\*\*Thinking… \(\d+[smh][0-9]*\)\*\*\n\nalpha thoughts$/,
+  "default streaming view is the live tail",
+);
+
+// click 1 → full text so far, timing line pinned at the BOTTOM
+click(comp, 0);
+assert.equal(comp.thinkingVisibilityOverrides.get(0), false, "click redirected to visible");
+assert.match(
+  render("alpha thoughts", true),
+  /^alpha thoughts\n\n\*\*Thinking… \(\d+[smh][0-9]*\)\*\*$/,
+  "first click expands to full view with the timing line last",
+);
+
+// text keeps growing while open → full view follows, timing stays at the bottom
+await update(msg("alpha thoughts\nbeta continues"), "beta continues");
+comp.updateContent(msg("alpha thoughts\nbeta continues"), true);
+assert.match(
+  render("alpha thoughts\nbeta continues", true),
+  /^alpha thoughts\nbeta continues\n\n\*\*Thinking… \(\d+[smh][0-9]*\)\*\*$/,
+  "full view follows growth",
+);
+
+// click 2 → back to the scrolling tail (no hidden-label middle state)
+click(comp, 0);
+assert.equal(comp.thinkingVisibilityOverrides.get(0), false, "still visible after collapse");
+assert.match(
+  render("alpha thoughts\nbeta continues", true),
+  /^\*\*Thinking… \(\d+[smh][0-9]*\)\*\*\n\nbeta continues$/,
+  "second click returns to the live tail",
+);
+
+// click 3 → full again — a clean two-state toggle
+click(comp, 0);
+assert.equal(comp.thinkingVisibilityOverrides.get(0), false);
+assert.match(
+  render("alpha thoughts\nbeta continues", true),
+  /^alpha thoughts\nbeta continues\n\n\*\*Thinking… \(\d+[smh][0-9]*\)\*\*$/,
+  "third click expands again",
+);
+
+// ---- message end: open run keeps full text, now with the final footer -------
+await fire("message_end", {
+  message: { role: "assistant", content: msg("alpha thoughts\nbeta continues").content, stopReason: "stop" },
+});
+comp.updateContent(msg("alpha thoughts\nbeta continues"), false); // finalized render
+assert.match(
+  render("alpha thoughts\nbeta continues", false),
+  /^alpha thoughts\nbeta continues\n\n\*\*Thought for [\d.]+s\*\*$/,
+  "run left open at message end shows full text + Thought-for footer",
+);
+
+// ---- fresh message: seeded hidden label, single click expands ---------------
+const comp2 = new AssistantMessageComponent();
+comp2.updateContent(msg("alpha thoughts\nbeta continues"), false);
+assert.equal(comp2.thinkingVisibilityOverrides.get(0), true, "finalized runs seeded hidden");
+assert.match(comp2.hiddenThinkingLabel, /Thought for /, "hidden label carries the duration");
+
+click(comp2, 0);
+assert.equal(comp2.thinkingVisibilityOverrides.get(0), false, "one click expands");
+assert.match(
+  render("alpha thoughts\nbeta continues", false),
+  /\n\n\*\*Thought for [\d.]+s\*\*$/,
+  "expanded finalized run shows the footer",
+);
+click(comp2, 0);
+assert.equal(comp2.thinkingVisibilityOverrides.get(0), true, "one more click collapses");
+
+console.log("✓ scenario A: tail ↔ full while streaming; seeded toggle after");
+
+// ---- scenario B: finished run + live run in one streaming message ----------
+// Clicks on the finished run must not disturb the live run's open state.
+const fireB = fire; // same handlers
+const mk = (a, b) => ({
+  content: [
+    { type: "thinking", thinking: a },
+    { type: "toolCall", id: "t1", name: "bash", arguments: {} },
+    { type: "thinking", thinking: b },
+  ],
+  stopReason: undefined,
+});
+/** Partial as it exists at run A's thinking_end: just the thinking block. */
+const endPartial = (a) => ({ content: [{ type: "thinking", thinking: a }], stopReason: undefined });
+/** Partial at run B's thinking_start: run A's block followed by the tool call. */
+const toolPartial = (a) => ({
+  content: [
+    { type: "thinking", thinking: a },
+    { type: "toolCall", id: "t1", name: "bash", arguments: {} },
+  ],
+  stopReason: undefined,
+});
+await fireB("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_start", contentIndex: 0, partial: mk("", "") },
+});
+await fireB("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_end", contentIndex: 0, partial: endPartial("first run") },
+});
+await fireB("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "toolcall_start", contentIndex: 1, partial: toolPartial("first run") },
+});
+await fireB("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_start", contentIndex: 2, partial: toolPartial("first run") },
+});
+await fireB("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_delta", contentIndex: 2, delta: "second run", partial: mk("first run", "second run") },
+});
+
+const compB = new AssistantMessageComponent();
+compB.updateContent(mk("first run", "second run"), true);
+// run 0 finished → folded duration line; run 1 live → tail
+assert.match(render("first run", true), /^\*\*Thought for /, "finished run folds while message streams");
+assert.match(render("second run", true), /^\*\*Thinking… /, "live run shows the tail");
+
+// open the live run (run 1) to full view
+compB.thinkingVisibilityOverrides.set(1, true); // pi click handler for run 1
+compB.updateContent(compB.lastMessage);
+assert.equal(compB.thinkingVisibilityOverrides.get(1), false, "live-run click redirected");
+assert.match(render("second run", true), /^second run\n\n\*\*Thinking… /, "live run expanded");
+
+// clicking the finished run (hidden toggle) must not collapse the live run
+compB.thinkingVisibilityOverrides.set(0, true);
+compB.updateContent(compB.lastMessage);
+assert.equal(compB.thinkingVisibilityOverrides.get(0), true, "finished run toggles natively");
+assert.match(
+  render("second run", true),
+  /^second run\n\n\*\*Thinking… /,
+  "finished-run click does not clobber the live run's open state",
+);
+
+// clicking it back open reveals the finished run, live run still untouched
+compB.thinkingVisibilityOverrides.set(0, false);
+compB.updateContent(compB.lastMessage);
+assert.match(render("first run", true), /^first run\n\n\*\*Thought for /, "finished run expands with footer");
+assert.match(render("second run", true), /^second run\n\n\*\*Thinking… /, "live run still expanded");
+
+console.log("✓ scenario B: finished-run clicks leave the live run's toggle intact");

package/test/fold.test.mjs

@@ -14,8 +14,17 @@ import {
   lastNonEmptyLine,
   stripBlockMarkers,
   collapseThinking,
+  formatDuration,
+  hashText,
+  countLineDiff,
+  countEditsLineDiff,
+  expandedThinkingSuffix,
+  foldedThinkingLine,
+  liveExpandedSuffix,
+  liveThinkingLine,
 } from "../lib/fold.ts";
 import { defaultConfig, loadConfig, saveConfig } from "../lib/config.ts";
+import { ThinkingTracker, trailingThinkingText } from "../lib/thinking.ts";
 
 let passed = 0;
 const check = (name, fn) => {
@@ -40,6 +49,10 @@ check("codePointWidth: CJK is 2", () => {
 check("codePointWidth: emoji is 2", () => {
   assert.equal(codePointWidth("😀".codePointAt(0)), 2);
 });
+check("codePointWidth: stopwatch emoji is 2", () => {
+  assert.equal(codePointWidth("⏱".codePointAt(0)), 2);
+  assert.equal(displayWidth("⏱ 8s"), 5); // 2 + 1 + 2
+});
 check("codePointWidth: combining mark is 0", () => {
   assert.equal(codePointWidth(0x0301), 0);
 });
@@ -141,7 +154,212 @@ check("collapseThinking: non-finite width degrades to default 80", () => {
   assert.equal(collapseThinking("a\nb", undefined), "b");
 });
 
-// -------------------------------------------------------------- config ----
+// --------------------------------------------------------- formatDuration ----
+check("formatDuration: live style uses whole seconds", () => {
+  assert.equal(formatDuration(0, "live"), "0s");
+  assert.equal(formatDuration(8_400, "live"), "8s");
+  assert.equal(formatDuration(91_000, "live"), "1m31s");
+  assert.equal(formatDuration(3_723_000, "live"), "1h02m");
+});
+check("formatDuration: final style uses one decimal under a minute", () => {
+  assert.equal(formatDuration(12_350), "12.3s"); // toFixed(1) rounds
+  assert.equal(formatDuration(940), "0.9s");
+  assert.equal(formatDuration(59_999), "60.0s"); // just under the boundary
+});
+check("formatDuration: final style switches to m/h", () => {
+  assert.equal(formatDuration(61_500), "1m01s");
+  assert.equal(formatDuration(3_723_000), "1h02m");
+});
+check("formatDuration: tolerates garbage", () => {
+  assert.equal(formatDuration(Number.NaN), "0.0s");
+  assert.equal(formatDuration(-5, "live"), "0s");
+});
+
+// -------------------------------------------------------------- hashText ----
+check("hashText: deterministic and distinguishing", () => {
+  assert.equal(hashText("hello"), hashText("hello"));
+  assert.notEqual(hashText("hello"), hashText("hello!"));
+  assert.notEqual(hashText("ab"), hashText("ba")); // same length, different hash
+});
+check("hashText: encodes length", () => {
+  assert.equal(hashText(""), "0:811c9dc5"); // FNV offset basis, length 0
+});
+
+// ---------------------------------------------------------- countLineDiff ----
+check("countLineDiff: new file → all added", () => {
+  assert.deepEqual(countLineDiff(undefined, "a\nb\nc"), { added: 3, removed: 0 });
+});
+check("countLineDiff: identical → zeros (trailing newline tolerant)", () => {
+  assert.deepEqual(countLineDiff("a\nb\n", "a\nb\n"), { added: 0, removed: 0 });
+  assert.deepEqual(countLineDiff("a\nb", "a\nb\n"), { added: 0, removed: 0 });
+});
+check("countLineDiff: pure append", () => {
+  assert.deepEqual(countLineDiff("a\nb", "a\nb\nc\nd"), { added: 2, removed: 0 });
+});
+check("countLineDiff: pure removal", () => {
+  assert.deepEqual(countLineDiff("a\nb\nc", "a"), { added: 0, removed: 2 });
+});
+check("countLineDiff: modify one middle line", () => {
+  assert.deepEqual(countLineDiff("a\nb\nc", "a\nX\nc"), { added: 1, removed: 1 });
+});
+check("countLineDiff: full rewrite", () => {
+  assert.deepEqual(countLineDiff("a\nb\nc", "x\ny\nz"), { added: 3, removed: 3 });
+});
+check("countLineDiff: LCS detects moved/matching middle lines", () => {
+  // "b" is kept as a common subsequence
+  assert.deepEqual(countLineDiff("a\nb\nc", "x\nb\nz"), { added: 2, removed: 2 });
+});
+check("countLineDiff: oversized middle falls back to replacement", () => {
+  const a = Array.from({ length: 100 }, (_, i) => `old-${i}`);
+  const b = Array.from({ length: 100 }, (_, i) => `new-${i}`);
+  // maxCells=1 forces the fallback path instead of LCS
+  assert.deepEqual(countLineDiff(a.join("\n"), b.join("\n"), 1), {
+    added: 100,
+    removed: 100,
+  });
+});
+check("countLineDiff: prefix/suffix trim keeps LCS small", () => {
+  const head = Array.from({ length: 500 }, (_, i) => `h${i}`);
+  const tail = Array.from({ length: 500 }, (_, i) => `t${i}`);
+  const oldText = [...head, "MID", ...tail].join("\n");
+  const newText = [...head, "NEW", ...tail].join("\n");
+  assert.deepEqual(countLineDiff(oldText, newText), { added: 1, removed: 1 });
+});
+
+// -------------------------------------------------- countEditsLineDiff ----
+check("countEditsLineDiff: sums over the edits array", () => {
+  const stat = countEditsLineDiff({
+    edits: [
+      { oldText: "a\nb\nc", newText: "a\nX\nc" }, // +1 -1
+      { oldText: "tail", newText: "tail\nextra" }, // +1 -0
+    ],
+  });
+  assert.deepEqual(stat, { added: 2, removed: 1 });
+});
+check("countEditsLineDiff: legacy single oldText/newText shape", () => {
+  assert.deepEqual(countEditsLineDiff({ oldText: "x", newText: "y\nz" }), { added: 2, removed: 1 });
+});
+check("countEditsLineDiff: garbage input yields undefined", () => {
+  assert.equal(countEditsLineDiff(undefined), undefined);
+  assert.equal(countEditsLineDiff({}), undefined);
+  assert.equal(countEditsLineDiff({ edits: "nope" }), undefined);
+  assert.equal(countEditsLineDiff({ edits: [{ oldText: 5 }] }), undefined);
+});
+check("countEditsLineDiff: new-content-only edit counts as additions", () => {
+  assert.deepEqual(countEditsLineDiff({ edits: [{ newText: "a\nb" }] }), { added: 2, removed: 0 });
+});
+
+// -------------------------------------------------- thinking line renderers ----
+check("liveThinkingLine: bold label line above the tail", () => {
+  assert.equal(
+    liveThinkingLine("first\nlast line", 8_000, 80),
+    "**Thinking… (8s)**\n\nlast line",
+  );
+});
+check("liveThinkingLine: unknown duration → bare tail", () => {
+  assert.equal(liveThinkingLine("first\nlast line", undefined, 80), "last line");
+});
+check("liveThinkingLine: truncates tail to width", () => {
+  const out = liveThinkingLine("short\n" + "x".repeat(100), 5_000, 20);
+  const [label, , tail] = out.split("\n");
+  assert.equal(label, "**Thinking… (5s)**");
+  assert.equal(displayWidth(tail) <= 20, true);
+  assert.equal(tail.startsWith("…"), true);
+});
+check("liveThinkingLine: empty content passes through", () => {
+  assert.equal(liveThinkingLine("\n \n", 1_000, 80), "\n \n");
+});
+check("foldedThinkingLine: smart shows bold Thought-for line", () => {
+  assert.equal(
+    foldedThinkingLine("anything at all", 12_340, 80, "smart"),
+    "**Thought for 12.3s**",
+  );
+});
+check("foldedThinkingLine: smart without duration", () => {
+  assert.equal(foldedThinkingLine("anything", undefined, 80, "smart"), "**Thought…**");
+});
+check("foldedThinkingLine: tail keeps the tail + bold duration", () => {
+  assert.equal(
+    foldedThinkingLine("first\nlast line", 12_340, 80, "tail"),
+    "**12.3s** · last line",
+  );
+});
+check("expandedThinkingSuffix: bold footer or empty", () => {
+  assert.equal(expandedThinkingSuffix(61_500), "\n\n**Thought for 1m01s**");
+  assert.equal(expandedThinkingSuffix(undefined), "");
+});
+check("liveExpandedSuffix: bold ticking footer at the bottom", () => {
+  assert.equal(liveExpandedSuffix(8_000), "\n\n**Thinking… (8s)**");
+  assert.equal(liveExpandedSuffix(91_000), "\n\n**Thinking… (1m31s)**");
+  assert.equal(liveExpandedSuffix(undefined), "");
+  // appended after the full text, the timing line ends up as the last line
+  const view = "first thought\nsecond thought" + liveExpandedSuffix(8_000);
+  assert.equal(view.split("\n").at(-1), "**Thinking… (8s)**");
+});
+
+// ------------------------------------------------------------ config ----
+check("config: defaults when file missing", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    assert.deepEqual(loadConfig(dir), defaultConfig);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: save/load roundtrip with new fields", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    const next = {
+      toolsFold: false,
+      thinking: "tail",
+      writeStat: false,
+      writeCollapsed: "preview",
+    };
+    assert.equal(saveConfig(dir, next), true);
+    assert.deepEqual(loadConfig(dir), next);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: migrates legacy thinkingFold boolean", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    writeFileSync(join(dir, "smart-fold.config.json"), '{"thinkingFold": false}', "utf8");
+    assert.deepEqual(loadConfig(dir).thinking, "off");
+    writeFileSync(join(dir, "smart-fold.config.json"), '{"thinkingFold": true}', "utf8");
+    assert.deepEqual(loadConfig(dir).thinking, "smart");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: invalid values fall back to defaults", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    writeFileSync(
+      join(dir, "smart-fold.config.json"),
+      '{"thinking": "bogus", "writeCollapsed": 42, "writeStat": "yes", "toolsFold": 1}',
+      "utf8",
+    );
+    const loaded = loadConfig(dir);
+    assert.deepEqual(loaded.thinking, "smart");
+    assert.deepEqual(loaded.writeCollapsed, "header");
+    assert.deepEqual(loaded.writeStat, true);
+    assert.deepEqual(loaded.toolsFold, true);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: broken JSON falls back to defaults", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    writeFileSync(join(dir, "smart-fold.config.json"), "{oops", "utf8");
+    assert.deepEqual(loadConfig(dir), defaultConfig);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+// ------------------------------------------------------------ config ----
 check("config: defaults when file missing", () => {
   const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
   try {
@@ -150,14 +368,45 @@ check("config: defaults when file missing", () => {
     rmSync(dir, { recursive: true, force: true });
   }
 });
-check("config: save/load roundtrip and partial merge", () => {
+check("config: save/load roundtrip with new fields", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    const next = {
+      toolsFold: false,
+      thinking: "tail",
+      writeStat: false,
+      writeCollapsed: "preview",
+    };
+    assert.equal(saveConfig(dir, next), true);
+    assert.deepEqual(loadConfig(dir), next);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: migrates legacy thinkingFold boolean", () => {
   const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
   try {
-    assert.equal(saveConfig(dir, { toolsFold: false, thinkingFold: true }), true);
-    assert.deepEqual(loadConfig(dir), { toolsFold: false, thinkingFold: true });
-    // partial file merges over defaults
     writeFileSync(join(dir, "smart-fold.config.json"), '{"thinkingFold": false}', "utf8");
-    assert.deepEqual(loadConfig(dir), { toolsFold: true, thinkingFold: false });
+    assert.deepEqual(loadConfig(dir).thinking, "off");
+    writeFileSync(join(dir, "smart-fold.config.json"), '{"thinkingFold": true}', "utf8");
+    assert.deepEqual(loadConfig(dir).thinking, "smart");
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+check("config: invalid values fall back to defaults", () => {
+  const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));
+  try {
+    writeFileSync(
+      join(dir, "smart-fold.config.json"),
+      '{"thinking": "bogus", "writeCollapsed": 42, "writeStat": "yes", "toolsFold": 1}',
+      "utf8",
+    );
+    const loaded = loadConfig(dir);
+    assert.deepEqual(loaded.thinking, "smart");
+    assert.deepEqual(loaded.writeCollapsed, "header");
+    assert.deepEqual(loaded.writeStat, true);
+    assert.deepEqual(loaded.toolsFold, true);
   } finally {
     rmSync(dir, { recursive: true, force: true });
   }
@@ -172,4 +421,162 @@ check("config: broken JSON falls back to defaults", () => {
   }
 });
 
+// ------------------------------------------------------ ThinkingTracker ----
+const msg = (content) => ({ content });
+
+check("ThinkingTracker: single run lifecycle", () => {
+  let t = 1_000;
+  const tracker = new ThinkingTracker(() => t);
+  tracker.handleUpdate({ type: "thinking_start", contentIndex: 0, partial: msg([]) });
+  t = 3_000;
+  tracker.handleUpdate({ type: "thinking_delta", contentIndex: 0, delta: "hmm ", partial: msg([{ type: "thinking", thinking: "hmm " }]) });
+  t = 5_200;
+  tracker.handleUpdate({
+    type: "thinking_end",
+    contentIndex: 0,
+    partial: msg([{ type: "thinking", thinking: "hmm let me think" }]),
+  });
+  // live elapsed while open
+  t = 6_000;
+  assert.equal(tracker.liveElapsedMs(), 5_000);
+  // text followed → closes the run
+  t = 7_000;
+  tracker.handleUpdate({
+    type: "text_start",
+    contentIndex: 1,
+    partial: msg([{ type: "thinking", thinking: "hmm let me think" }, { type: "text", text: "" }]),
+  });
+  assert.equal(tracker.liveElapsedMs(), undefined);
+  const hash = hashText("hmm let me think");
+  assert.equal(tracker.finalizedMs(hash), 4_200); // 5200 - 1000
+  const runs = tracker.drainPending();
+  assert.deepEqual(runs, [{ hash, ms: 4_200 }]);
+  assert.deepEqual(tracker.drainPending(), []);
+});
+
+check("ThinkingTracker: consecutive thinking blocks form one group", () => {
+  let t = 100;
+  const tracker = new ThinkingTracker(() => t);
+  tracker.handleUpdate({ type: "thinking_start", contentIndex: 0, partial: msg([]) });
+  t = 200;
+  tracker.handleUpdate({ type: "thinking_delta", contentIndex: 0, delta: "part one", partial: msg([{ type: "thinking", thinking: "part one" }]) });
+  t = 300;
+  tracker.handleUpdate({
+    type: "thinking_end",
+    contentIndex: 0,
+    partial: msg([{ type: "thinking", thinking: "part one" }]),
+  });
+  // second thinking block immediately after → same group, no close
+  tracker.handleUpdate({
+    type: "thinking_start",
+    contentIndex: 1,
+    partial: msg([{ type: "thinking", thinking: "part one" }]),
+  });
+  t = 400;
+  tracker.handleUpdate({
+    type: "thinking_end",
+    contentIndex: 1,
+    partial: msg([{ type: "thinking", thinking: "part one" }, { type: "thinking", thinking: "part two" }]),
+  });
+  const runs = tracker.handleMessageEnd(
+    msg([{ type: "thinking", thinking: "part one" }, { type: "thinking", thinking: "part two" }]),
+  );
+  assert.equal(runs.length, 1);
+  assert.deepEqual(runs[0], { hash: hashText("part one\n\npart two"), ms: 300 }); // 400 - 100
+});
+
+check("ThinkingTracker: tool call between thinking blocks splits groups", () => {
+  let t = 0;
+  const tracker = new ThinkingTracker(() => t);
+  t = 100;
+  tracker.handleUpdate({ type: "thinking_start", contentIndex: 0, partial: msg([]) });
+  t = 200;
+  tracker.handleUpdate({
+    type: "thinking_end",
+    contentIndex: 0,
+    partial: msg([{ type: "thinking", thinking: "before tool" }]),
+  });
+  t = 900;
+  tracker.handleUpdate({
+    type: "toolcall_start",
+    contentIndex: 1,
+    partial: msg([{ type: "thinking", thinking: "before tool" }, { type: "toolCall" }]),
+  });
+  // group 1's thinking ended at its last activity (t=200) → 100ms of thinking
+  assert.equal(tracker.finalizedMs(hashText("before tool")), 100);
+  // second group after the tool
+  tracker.handleUpdate({
+    type: "thinking_start",
+    contentIndex: 2,
+    partial: msg([{ type: "toolCall" }]),
+  });
+  t = 1_500;
+  const runs = tracker.handleMessageEnd(msg([{ type: "toolCall" }, { type: "thinking", thinking: "after tool" }]));
+  // both runs of the message are drained together
+  assert.equal(runs.length, 2);
+  assert.deepEqual(runs[0], { hash: hashText("before tool"), ms: 100 });
+  assert.deepEqual(runs[1], { hash: hashText("after tool"), ms: 600 }); // 1500 - 900
+  assert.equal(tracker.finalizedMs(hashText("after tool")), 600);
+});
+
+check("ThinkingTracker: finalizeIfMatches closes on exact text", () => {
+  let t = 10_000;
+  const tracker = new ThinkingTracker(() => t);
+  tracker.handleUpdate({ type: "thinking_start", contentIndex: 0, partial: msg([]) });
+  t = 12_500;
+  tracker.handleUpdate({
+    type: "thinking_end",
+    contentIndex: 0,
+    partial: msg([{ type: "thinking", thinking: "exact text" }]),
+  });
+  assert.equal(tracker.finalizeIfMatches("exact text"), 2_500);
+  assert.equal(tracker.liveElapsedMs(), undefined);
+  assert.equal(tracker.finalizeIfMatches("exact text"), undefined); // already closed
+  assert.equal(tracker.finalizedMs(hashText("exact text")), 2_500);
+});
+
+check("ThinkingTracker: restore merges persisted durations", () => {
+  const tracker = new ThinkingTracker(() => 0);
+  const hash = hashText("restored thought");
+  tracker.restore([{ hash, ms: 3_000 }]);
+  assert.equal(tracker.finalizedMs(hash), 3_000);
+  // invalid entries are ignored
+  tracker.restore([{ hash: 42, ms: "x" }, { hash: "ok", ms: 5 }]);
+  assert.equal(tracker.finalizedMs("ok"), 5);
+});
+
+check("ThinkingTracker: delta-only fallback when no thinking_end seen", () => {
+  let t = 0;
+  const tracker = new ThinkingTracker(() => t);
+  t = 100;
+  tracker.handleUpdate({ type: "thinking_start", contentIndex: 0, partial: msg([]) });
+  t = 250;
+  tracker.handleUpdate({ type: "thinking_delta", contentIndex: 0, delta: "partial", partial: msg([]) });
+  const runs = tracker.handleMessageEnd(undefined);
+  assert.equal(runs.length, 1);
+  assert.deepEqual(runs[0], { hash: hashText("partial"), ms: 150 });
+});
+
+// ------------------------------------------------------ trailingThinkingText ----
+check("trailingThinkingText: joins and trims trailing thinking blocks", () => {
+  assert.equal(
+    trailingThinkingText(
+      msg([{ type: "text", text: "hi" }, { type: "thinking", thinking: " one " }, { type: "thinking", thinking: "two" }]),
+    ),
+    "one\n\ntwo",
+  );
+});
+check("trailingThinkingText: stops at non-thinking block", () => {
+  assert.equal(
+    trailingThinkingText(msg([{ type: "thinking", thinking: "x" }, { type: "text", text: "hi" }])),
+    null,
+  );
+});
+check("trailingThinkingText: skips empty thinking blocks at the end", () => {
+  assert.equal(
+    trailingThinkingText(msg([{ type: "thinking", thinking: "x" }, { type: "thinking", thinking: "  " }])),
+    "x",
+  );
+});
+
 console.log(`✓ ${passed} test groups passed`);