pi-thinking-header 0.3.3 → 0.4.0

package/README.md

@@ -4,12 +4,15 @@ dsh 风格的 pi thinking 显示插件：带 token 计数的单行标题 + 折
 
 ```
 展开时：                                        折叠时（ctrl+t / 点击标题行）：
-  Thinking (~2.50k tokens)                        流式中：Thinking (~2.50k tokens) · …尾随最新内容保持可见
-  模型思考全文…                                   结束后：Thinking (~2.50k tokens) · 第一行内容…
-  正式回复…                                       正式回复…
+  流式中：Thinking…                             流式中：Thinking (~2.50k tokens) · …尾随最新内容保持可见
+  结束后：Thinking (~2.50k tokens)               结束后：Thinking (~2.50k tokens) · 第一行内容…
+  模型思考全文…（流式中仅最后一行刷新）             正式回复…
+  正式回复…
 ```
 
-- token 数量为本地估算：`ceil(chars / 4)`，流式输出时实时增长
+- token 数量为本地估算：`ceil(chars / 4)`。折叠预览中流式实时增长；展开时标题行
+  在流式期间保持稳定（只显示 `Thinking…`），块结束后才显示最终计数——pi 按整行连续
+  区间重绘，标题行的计数若每个 chunk 都变化，会把前面的思考行与最新行一起擦除重绘
 - 小数点位数可配置（默认 2 位）：`/thinking-header decimals <0-6>`，或直接编辑
   配置文件 `~/.pi/agent/thinking-header.json`（`{"decimals": 2}`）。例如默认效果
   `2.50k`；`decimals: 0` → `3k`；`decimals: 4` → `2.5000k`。两种模式均实时读取
@@ -39,17 +42,26 @@ pi install ./pi-thinking-header
 所有功能的统一入口：
 
 ```
-/thinking-header                  # 状态总览（模式/补丁状态/decimals）+ 用法
+/thinking-header                  # 状态总览（模式/补丁状态/autoPatch/decimals）+ 用法
 /thinking-header patch           # 应用/修复完整模式补丁（确认后执行）
+/thinking-header autopatch       # 查看启动自动补丁状态
+/thinking-header autopatch on|off# 启动时自动检查并应用/迁移补丁（默认 on）
 /thinking-header decimals        # 查看当前小数位
 /thinking-header decimals <0-6>  # 设置小数位并持久化（默认 2）
 ```
 
+启动自动补丁（`autopatch`，默认开启）：每次会话启动（`session_start`）自动探测磁盘上的
+bundle——未打补丁时自动应用、检测到旧版本 patch 时自动迁移（installer 自带备份恢复逻辑），
+已是最新的则静默跳过。补丁写入磁盘后需重启 pi 才生效：当前会话仍用降级/旧渲染，notify
+会提示。因此 `pi update` 之后补丁丢失、或插件包更新带来新 patch 版本时，都无需手动
+处理，下次启动自动修复。关闭方式：`/thinking-header autopatch off`，或直接编辑配置文件
+（`{"autoPatch": false}`）。
+
 补丁安装（`patch` 子命令，内部运行 `node install-patch.mjs`）：
 
-- 已打补丁 → 提示 already applied（含当前 decimals）
-- 未打补丁（或补丁版本较旧）→ 确认后执行安装/迁移，输出结果并提醒重启 pi（当前会话仍是旧代码，重启后生效）
-- `pi update` 之后补丁丢失时，extension 自动进入降级模式，此时用该命令可一键修复
+- 已是当前版本 → 提示 already applied（含当前 decimals）
+- 未打补丁（或补丁版本较旧 → 迁移）→ 确认后执行安装/迁移，输出结果并提醒重启 pi（当前会话仍是旧代码，重启后生效）
+- `pi update` 之后补丁丢失时，extension 自动进入降级模式；启动自动补丁（默认开）会在下次会话开始时自动修复，也可用该命令立即修复
 
 小数位配置（`decimals` 子命令）：
 
@@ -64,7 +76,8 @@ pi install ./pi-thinking-header
 
 pi 的 extension API 无法接管内置 thinking 块的折叠渲染，完整效果需要附带
 的 bundle patch。推荐直接在 pi 会话内运行 `/thinking-header patch`
-（自动定位安装位置）；也可手动执行：
+（自动定位安装位置）；也可什么都不做——默认开启的启动自动补丁会在首次
+会话开始时自动应用。手动执行：
 
 ```bash
 # npm 安装：~/.pi/agent/npm/pi-thinking-header/install-patch.mjs
@@ -73,13 +86,17 @@ node <包目录>/install-patch.mjs
 ```
 
 - 每条消息独立的 token 计数与预览（含历史消息）
+- 展开态标题行流式期间字节级稳定（`Thinking…`）：折叠更新只重绘最后一行，
+  之前的思考行不会被一起擦除重绘；块结束后标题行才出现最终计数（回复流式时
+  已结束的思考块直接显示最终计数）
 - 折叠态严格单行、宽度感知截断、点击切换
 - 流式期间折叠预览滚动跟随最新行行尾（dsh 同款），结束后回到第一行
 - 小数点位数渲染时实时读取配置文件（mtime 缓存），与降级模式共享同一份配置
-- 幂等；自动从 v1/v2/v3/v3.1 patch 迁移（恢复原始备份后重新应用；早期 v3
+- 幂等；自动从 v1/v2/v3/v3.1/v3.2 patch 迁移（恢复原始备份后重新应用；早期 v3
   折叠组件缺 `invalidate()`、退出/切换模式时触发 `this.child.invalidate is not
-  a function` 崩溃且无备份时，会先原地热修复）；`pi update` 后重跑一次即可；
-  插件包更新后也建议重跑 `/thinking-header patch` 使 patch 与 extension 版本一致
+  a function` 崩溃且无备份时，会先原地热修复）；`pi update` 后无需手动处理——
+  启动自动补丁（默认开）会在下次会话开始时重新应用/迁移；插件包更新后同样如此
+  （patch 版本随插件更新时自动迁移到新版）
 - 回滚：
   ```bash
   cp <chunk路径>.pre-thinking-header.bak <chunk路径>
@@ -89,11 +106,13 @@ node <包目录>/install-patch.mjs
 ### 纯插件模式：extension 自动降级
 
 extension 启动时探测运行中的 pi bundle：**检测到任意版本的 patch 时**（含旧版本）
-extension 保持惰性（避免双标题），请运行 `/thinking-header patch` 迁移到当前 patch 版本；
-**未检测到 patch 时**自动进入降级模式：
+extension 保持惰性（避免双标题；旧版本会在下次会话启动时被自动迁移到当前版本，
+或运行 `/thinking-header patch` 立即迁移）；**未检测到 patch 时**自动进入降级模式，
+并在会话启动时自动应用补丁（默认行为，可关闭）：
 
 - 展开的 thinking：通过 markdown transformer 前置 `Thinking (~N tokens)` 标题行
-  （按块正确计数，`pi update` 后依然有效，无需维护）
+  （按块正确计数，`pi update` 后依然有效，无需维护）。流式期间同样保持稳定
+  （`Thinking…`），块结束后显示最终计数，避免正文旧行被一起重绘
 - 折叠的 thinking：pi 的 extension API 只暴露一个全局 label，插件会在每条
   assistant 消息结束后将其更新为最新消息的 `计数 · 预览`。局限：转录里更早的
   折叠块也会显示最新 label —— 需要按消息独立显示请打 bundle patch
@@ -104,7 +123,7 @@ extension 保持惰性（避免双标题），请运行 `/thinking-header patch`
 | 文件 | 说明 |
 |------|------|
 | `index.js` | pi extension（模式检测 + 降级实现，含流式行尾跟随 label） |
-| `install-patch.mjs` | 完整模式安装器（v3.2 bundle patch，渲染时读取 decimals 配置） |
+| `install-patch.mjs` | 完整模式安装器（v3.3 bundle patch，渲染时读取 decimals 配置） |
 | `package.json` | pi 包清单（`pi.extensions`） |
 
 ## License

package/index.js

@@ -7,7 +7,11 @@
  *
  *   Thinking (~2.50k tokens)
  *
- * - Expanded:  header line + full thinking text
+ * - Expanded:  header line + full thinking text; while the block streams the
+ *   header line stays byte-stable ("Thinking…") — pi's TUI redraws whole
+ *   lines over the contiguous changed range, so any header change would
+ *   redraw every earlier thinking line together with the latest one. The
+ *   token count appears once the block settles.
  * - Collapsed: single line — header + a preview of the thinking content that
  *   follows dsh's ReasoningRow: while streaming it shows the LATEST line with
  *   the window pinned to its tail (leading ellipsis — the line "scrolls" as
@@ -23,13 +27,23 @@
  * 2. FALLBACK MODE (pure extension API) — used when the bundle is unpatched:
  *    - Expanded thinking: prepends a `Thinking (~N tokens)` header via a
  *      markdown transformer (correct per-block counts, works everywhere,
- *      survives pi updates).
+ *      survives pi updates). Same streaming-stable header as full mode: while
+ *      `ctx.isStreaming` the header stays "Thinking…" and only the final
+ *      count is shown once the block settles.
  *    - Collapsed thinking: updates the global hidden-thinking label on each
  *      assistant message with the latest count + preview. Limitation: pi's
  *      extension API only exposes ONE global label, so collapsed blocks in
  *      older transcript messages will show the most recent label. Run
  *      /thinking-header patch for per-message fidelity.
  *
+ * Startup auto-patch (autoPatch, default on): every session_start re-probes
+ * the bundle — unpatched → apply the patch, older family version → migrate —
+ * so a lost patch after `pi update` (or a newer extension release) heals on
+ * the next launch with zero manual steps. The patched file matters for the
+ * NEXT restart; the running session keeps its fallback (or old-patch)
+ * renderer and a notify explains that. Disable: /thinking-header autopatch
+ * off, or {"autoPatch": false} in the config file.
+ *
  * Token counts are local estimates: ceil(chars / 4). The k-token decimal places
  * are configurable (default 2): /thinking-header decimals <0-6>, persisted to
  * <agentDir>/thinking-header.json ({"decimals": 2}). Both modes re-read the
@@ -50,9 +64,16 @@ const INSTALLER_PATH = fileURLToPath(new URL("./install-patch.mjs", import.meta.
 
 // Family-wide marker: ANY patch version owns header rendering end-to-end, so
 // the extension must stay inert for all of them (avoids double headers). The
-// /thinking-header patch migrates older patch versions to the current one.
+// /thinking-header patch (and the startup auto-patch) migrates older patch
+// versions to the current one.
 const MARKER = "pi-thinking-header";
 
+// Current patch version — keep in sync with CURRENT_MARKER in
+// install-patch.mjs. A disk bundle carrying only an older family version is
+// "patched" (extension stays inert) but not "current" (auto-migrates).
+const PATCH_VERSION = "v3.3";
+const CURRENT_MARKER = MARKER + ":" + PATCH_VERSION;
+
 // ---------------- decimals config (shared with the bundle patch) -------------
 // <agentDir>/thinking-header.json: { "decimals": 2 } — k-token decimal places.
 // The bundle patch reads the same file at render time (mtime-cached), so both
@@ -94,7 +115,10 @@ const getDecimals = () => {
   return typeof d === "number" && Number.isInteger(d) && d >= 0 && d <= 6 ? d : DEFAULT_DECIMALS;
 };
 
-function saveDecimals(n) {
+// Startup auto-patch: only an explicit `false` disables it (absent key = on).
+const getAutoPatch = () => loadConfig().autoPatch !== false;
+
+function saveConfigKey(key, value) {
   let cfg = {};
   try {
     const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
@@ -102,7 +126,7 @@ function saveDecimals(n) {
   } catch {
     // no/invalid config → start fresh, keep nothing
   }
-  cfg.decimals = n;
+  cfg[key] = value;
   mkdirSync(dirname(CONFIG_PATH), { recursive: true });
   writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
   configCache.mtime = -1n; // force re-read on next loadConfig()
@@ -113,7 +137,9 @@ const COMPONENT_ANCHOR =
 
 /**
  * Locate the running pi's bundle chunk that contains AssistantMessageComponent.
- * Returns { found: true, patched: boolean } or { found: false }.
+ * Returns { found: true, patched, current } or { found: false }:
+ *  - patched: ANY pi-thinking-header family version is on disk
+ *  - current: exactly the version this extension ships (PATCH_VERSION)
  */
 function probeBundle() {
   try {
@@ -128,7 +154,11 @@ function probeBundle() {
       const path = join(chunksDir, file);
       const src = readFileSync(path, "utf8");
       if (!src.includes(COMPONENT_ANCHOR)) continue;
-      return { found: true, patched: src.includes(MARKER) };
+      return {
+        found: true,
+        patched: src.includes(MARKER),
+        current: src.includes(CURRENT_MARKER),
+      };
     }
   } catch {
     // pi binary not resolvable — fall through
@@ -204,10 +234,58 @@ const thinkingLabel = (blocks, running) => {
   return label;
 };
 
+/**
+ * Startup auto-patch: on session_start, re-probe the bundle and run the
+ * installer when the disk is unpatched (apply) or carries an older family
+ * version (migrate). The patched file only matters for the NEXT pi start —
+ * the running session keeps whichever renderer it booted with — so the
+ * notify says so. Best-effort by design: failures degrade to the manual
+ * /thinking-header patch command, never to a broken startup.
+ */
+function registerAutoPatch(pi) {
+  pi.on("session_start", async (_event, ctx) => {
+    try {
+      if (!getAutoPatch()) return;
+      const before = probeBundle();
+      if (!before.found || before.current) return; // up to date / not resolvable
+      const migrating = before.patched; // older family version on disk
+      const { stdout, stderr } = await execFileAsync(
+        process.execPath,
+        [INSTALLER_PATH],
+        { timeout: 30_000, windowsHide: true, maxBuffer: 1024 * 1024 },
+      );
+      if (probeBundle().current) {
+        ctx.ui.notify(
+          `pi-thinking-header: bundle patch ${migrating ? "migrated to" : "applied"} (${PATCH_VERSION}) at startup — ` +
+            "effective after the next restart; this session keeps its current renderer.",
+          "info",
+        );
+      } else {
+        const out = (stdout + "\n" + stderr).trim();
+        ctx.ui.notify(
+          "pi-thinking-header: startup auto-patch had no effect.\n" +
+            (out || "(no installer output)") +
+            "\nRun /thinking-header patch for details.",
+          "warning",
+        );
+      }
+    } catch (err) {
+      const detail = [err?.message, err?.stdout, err?.stderr].filter(Boolean).join("\n");
+      ctx.ui.notify(
+        "pi-thinking-header: startup auto-patch failed.\n" +
+          detail +
+          "\nRun /thinking-header patch to apply manually.",
+        "warning",
+      );
+    }
+  });
+}
+
 export default function (pi) {
   // /thinking-header — single entry point for everything this package does:
   //   /thinking-header                    status overview + usage
   //   /thinking-header patch              apply/repair the full-mode bundle patch
+  //   /thinking-header autopatch on|off   startup auto-check+apply (default on)
   //   /thinking-header decimals           show the k-token decimal places
   //   /thinking-header decimals <0-6>     set + persist them (0-6, default 2)
   // Registered in BOTH modes. Fallback mode re-reads the config per label; the
@@ -217,21 +295,38 @@ export default function (pi) {
     "usage:\n" +
     "  /thinking-header                    status overview\n" +
     "  /thinking-header patch              apply/repair the full-mode patch\n" +
+    "  /thinking-header autopatch on|off   startup auto-check+apply (default on)\n" +
     "  /thinking-header decimals           show k-token decimal places\n" +
     "  /thinking-header decimals <0-6>     set them (persisted, applies live)";
 
   pi.registerCommand("thinking-header", {
-    description:
-      "pi-thinking-header: status / `patch` apply-repair full-mode patch / `decimals <0-6>` token-count decimals",
+    description: "Thinking display settings: status, patch, autopatch, decimals",
     getArgumentCompletions: (prefix) => {
       const p = (prefix ?? "").trimStart();
-      if (p.includes(" ")) return null;
-      const items = [
-        { value: "patch", label: "apply/repair the full-mode bundle patch" },
-        { value: "decimals", label: "k-token decimal places (0-6, default 2)" },
-      ];
-      const filtered = items.filter((i) => i.value.startsWith(p));
-      return filtered.length > 0 ? filtered : null;
+      const tokens = p.split(/\s+/);
+      // Fully typed token → close the menu so Enter SUBMITS the command:
+      // pi's editor consumes Enter to accept an open completion (argument
+      // prefixes don't start with "/", so accept-without-submit applies), and
+      // an exact-match item would re-open the menu on every re-query — Enter
+      // would be swallowed repeatedly and the command would never run.
+      if (tokens.length === 1) {
+        const items = [
+          { value: "patch", label: "apply/repair the full-mode bundle patch" },
+          { value: "autopatch", label: "startup auto-apply/migrate the patch (on/off)" },
+          { value: "decimals", label: "k-token decimal places (0-6, default 2)" },
+        ];
+        const filtered = items.filter((i) => i.value.startsWith(tokens[0]));
+        if (filtered.length === 0) return null;
+        if (filtered.length === 1 && filtered[0].value === tokens[0]) return null;
+        return filtered;
+      }
+      if (tokens.length === 2 && tokens[0] === "autopatch") {
+        const opts = ["on", "off"].filter((o) => o.startsWith(tokens[1]));
+        if (opts.length === 0) return null;
+        if (opts.length === 1 && opts[0] === tokens[1]) return null;
+        return opts.map((o) => ({ value: o, label: `startup auto-patch: ${o}` }));
+      }
+      return null; // decimals <0-6>: single-digit values never need completion
     },
     handler: async (args, ctx) => {
       const argv = (args ?? "").trim().split(/\s+/).filter(Boolean);
@@ -254,7 +349,7 @@ export default function (pi) {
           return;
         }
         try {
-          saveDecimals(n);
+          saveConfigKey("decimals", n);
         } catch (err) {
           ctx.ui.notify(`pi-thinking-header: failed to save ${CONFIG_PATH}: ${err?.message ?? err}`, "error");
           return;
@@ -267,6 +362,42 @@ export default function (pi) {
         return;
       }
 
+      // ---- autopatch subcommand: startup auto-check+apply toggle --------
+      if (argv[0] === "autopatch") {
+        const raw = argv[1];
+        if (raw === undefined) {
+          ctx.ui.notify(
+            `pi-thinking-header: autoPatch = ${getAutoPatch() ? "on" : "off"} (default on)\n` +
+              "session-start check: applies the patch when missing, migrates old versions\n" +
+              `config: ${CONFIG_PATH}\n` +
+              "usage: /thinking-header autopatch on|off",
+            "info",
+          );
+          return;
+        }
+        if (raw !== "on" && raw !== "off") {
+          ctx.ui.notify('pi-thinking-header: autopatch expects "on" or "off"', "error");
+          return;
+        }
+        try {
+          saveConfigKey("autoPatch", raw === "on");
+        } catch (err) {
+          ctx.ui.notify(
+            `pi-thinking-header: failed to save ${CONFIG_PATH}: ${err?.message ?? err}`,
+            "error",
+          );
+          return;
+        }
+        ctx.ui.notify(
+          `pi-thinking-header: autoPatch = ${raw} → saved to ${CONFIG_PATH}\n` +
+            (raw === "on"
+              ? "the next session start applies/migrates the patch automatically"
+              : "startup auto-patch disabled — use /thinking-header patch to apply manually"),
+          "info",
+        );
+        return;
+      }
+
       // ---- patch subcommand: apply/repair the full-mode bundle patch ----
       if (argv[0] === "patch") {
         try {
@@ -278,9 +409,9 @@ export default function (pi) {
             );
             return;
           }
-          if (state.patched) {
+          if (state.current) {
             ctx.ui.notify(
-              `pi-thinking-header: full-mode patch already applied (v3.2) — decimals = ${getDecimals()}`,
+              `pi-thinking-header: full-mode patch already applied (${PATCH_VERSION}) — decimals = ${getDecimals()}`,
               "info",
             );
             return;
@@ -316,12 +447,15 @@ export default function (pi) {
       const state = probeBundle();
       const mode = !state.found
         ? "fallback (pi installation not detected)"
-        : state.patched
-          ? "full (bundle patch v3.2 applied)"
-          : "fallback (bundle unpatched — /thinking-header patch enables full mode)";
+        : state.current
+          ? `full (bundle patch ${PATCH_VERSION} applied)`
+          : state.patched
+            ? "full (older patch on disk — auto-migrates at next session start, or /thinking-header patch now)"
+            : "fallback (bundle unpatched — auto-patches at next session start, or /thinking-header patch now)";
       ctx.ui.notify(
         "pi-thinking-header\n" +
           `mode: ${mode}\n` +
+          `autoPatch: ${getAutoPatch() ? "on" : "off"} (default on)\n` +
           `decimals: ${getDecimals()} (default ${DEFAULT_DECIMALS})\n` +
           `config: ${CONFIG_PATH}\n` +
           usage,
@@ -331,20 +465,37 @@ export default function (pi) {
   });
 
   const bundle = probeBundle();
+  if (bundle.found && bundle.current) {
+    // FULL MODE, up to date: the bundle patch owns rendering end-to-end
+    // (per-message labels, width-aware single-line previews). Stay inert — a
+    // global label update here would corrupt the patch's per-block counts.
+    return;
+  }
+
+  // Not current on disk (unpatched, or an older family version): register the
+  // startup auto-patch. It lands on disk for the NEXT restart; this session
+  // keeps whichever renderer it booted with.
+  registerAutoPatch(pi);
+
   if (bundle.found && bundle.patched) {
-    // FULL MODE: the bundle patch owns rendering end-to-end (per-message labels,
-    // width-aware single-line previews). Stay inert — a global label update here
-    // would corrupt the patch's per-block counts.
+    // An older family patch still owns rendering for THIS session → stay
+    // inert to avoid double headers; the auto-patch migrates it (above).
     return;
   }
 
   // ---------------- FALLBACK MODE (pure extension API) ----------------
 
-  // Expanded thinking: per-block header with token count.
+  // Expanded thinking: per-block header with token count. While the block is
+  // still streaming the header MUST stay byte-stable ("Thinking…"): pi's TUI
+  // diffs whole lines and rewrites the contiguous [firstChanged..lastChanged]
+  // range, so any header change on every chunk would erase+redraw every
+  // earlier thinking line together with the latest one. The token count
+  // appears once the block settles (isStreaming flips to false).
   pi.registerMarkdownTransformer((markdown, ctx) => {
     if (ctx?.messageType !== "assistant-thinking") return markdown;
     const text = markdown.trim();
     if (!text) return markdown;
+    if (ctx.isStreaming) return `*Thinking…*\n\n${markdown}`;
     return `*Thinking (~${formatTokens(Math.ceil(text.length / 4))} tokens)*\n\n${markdown}`;
   });
 
@@ -354,7 +505,10 @@ export default function (pi) {
   // once the message settles (message_end) it returns to the first line.
   // Limitation: pi's extension API only exposes ONE global label, so collapsed
   // blocks in older transcript messages will show the most recent label. Run
-  // /thinking-header patch for per-message fidelity.
+  // /thinking-header patch for per-message fidelity. Re-setting the SAME label
+  // is skipped: pi pushes the global label into every message component on
+  // each set, so a no-op set would still rebuild all of them.
+  let lastLabel = null;
   const updateLabel = async (message, ctx, running) => {
     try {
       if (!message || message.role !== "assistant") return;
@@ -362,7 +516,10 @@ export default function (pi) {
         (c) => c?.type === "thinking" && typeof c.thinking === "string" && c.thinking.trim(),
       );
       if (blocks.length === 0) return;
-      ctx.ui.setHiddenThinkingLabel(thinkingLabel(blocks, running));
+      const label = thinkingLabel(blocks, running);
+      if (label === lastLabel) return;
+      lastLabel = label;
+      ctx.ui.setHiddenThinkingLabel(label);
     } catch {
       // display-only; never break the session over a label
     }

package/install-patch.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * pi-thinking-header — FULL MODE installer (bundle patch, v3.2).
+ * pi-thinking-header — FULL MODE installer (bundle patch, v3.3).
  *
  * Patches pi's AssistantMessageComponent for dsh-style thinking rendering:
  *
@@ -46,8 +46,12 @@ const MD_TAIL =
   ",this.outputPad,0,this.markdownTheme,{color:text=>theme.fg(\"thinkingText\",text),italic:!0}," +
   '{transform:createMarkdownTransform("assistant-thinking",this.isStreaming,this.markdownTransformers)})';
 
+// hasVisibleContentAfter is in scope at the patch site (updateContent): a
+// thinking block is "still streaming" iff the message is streaming AND nothing
+// visible follows it — after the reply starts, earlier blocks show their final
+// count instead of staying on "Thinking…".
 const HEADER_TEXT =
-  'new Text(theme.italic(theme.fg("thinkingText",this.thinkingLabelText(thinkingBlocks))),this.outputPad,0)';
+  'new Text(theme.italic(theme.fg("thinkingText",this.thinkingHeaderLabel(thinkingBlocks,this.isStreaming&&!hasVisibleContentAfter))),this.outputPad,0)';
 
 const ANCHOR2 =
   'thinkingComponent=hidden?new Text(theme.italic(theme.fg("thinkingText",this.hiddenThinkingLabel)),this.outputPad,0):new Markdown(thinkingBlocks.' +
@@ -58,11 +62,11 @@ const ANCHOR2 =
 // ---------- injected code ----------
 // Current patch version; also the key for mode detection (family-wide) and
 // migration ("any older family member → restore pristine backup, re-apply").
-const CURRENT_MARKER = "pi-thinking-header:v3.2";
+const CURRENT_MARKER = "pi-thinking-header:v3.3";
 
 // Marker comment doubles as the extension's mode-detection key.
 const HELPER =
-  "/*pi-thinking-header:v3.2*/" +
+  "/*pi-thinking-header:v3.3*/" +
   // decimals config: per-instance cache keyed on the config file's mtime
   // (mtimeNs BigInt — ns precision beats same-ms collisions). Lazy ??= init
   // (no class fields needed) + a reader that resolves
@@ -73,14 +77,26 @@ const HELPER =
   'p=(process.env.PI_CODING_AGENT_DIR||os.homedir()+"/.pi/agent")+"/thinking-header.json",st=fs.statSync(p,{bigint:!0});' +
   'if(st.mtimeNs!==this._pthT){let c={};try{c=JSON.parse(fs.readFileSync(p,"utf8"))}catch{}' +
   "this._pthT=st.mtimeNs,this._pthC=c}}catch{this._pthC=null}return this._pthC||{}}" +
-  // One-line label: "Thinking (~2.50k tokens)" (prefix honours a custom label, minus trailing dots)
-  // Decimals come from _piCfg(): integer 0–6 wins, anything else → 2. No
-  // trailing-zero stripping: the setting is authoritative (2.50k stays 2.50k).
-  'thinkingLabelText(blocks){let chars=0;for(let b of blocks)chars+=b.length;' +
+  // Token count: local estimate ceil(chars / 4). Decimals come from _piCfg():
+  // integer 0–6 wins, anything else → 2. No trailing-zero stripping: the
+  // setting is authoritative (2.50k stays 2.50k).
+  '_tokensLabel(blocks){let chars=0;for(let b of blocks)chars+=b.length;' +
   "let tokens=Math.ceil(chars/4),c=this._piCfg()," +
-  'd=typeof c.decimals=="number"&&Number.isInteger(c.decimals)&&c.decimals>=0&&c.decimals<=6?c.decimals:2,' +
-  'count=tokens>=1000?(tokens/1000).toFixed(d)+"k":""+tokens;' +
-  'return this.hiddenThinkingLabel.replace(/\\.{3}$/,"")+" (~"+count+" tokens)"}' +
+  'd=typeof c.decimals=="number"&&Number.isInteger(c.decimals)&&c.decimals>=0&&c.decimals<=6?c.decimals:2;' +
+  'return(tokens>=1000?(tokens/1000).toFixed(d)+"k":""+tokens)+" tokens"}' +
+  // Live one-line label: "Thinking (~2.50k tokens)" (prefix honours a custom
+  // label, minus trailing dots). Used by the collapsed row ONLY — that row is
+  // a single screen line, so a live count redraws just that one line.
+  'thinkingLabelText(blocks){return this.hiddenThinkingLabel.replace(/\\.{3}$/,"")+" (~"+this._tokensLabel(blocks)+")"}' +
+  // Expanded header. While the block is ACTIVELY streaming (it is the message's
+  // last content and chunks still arrive) it renders the bare prefix + "…" and
+  // MUST stay byte-stable: pi's TUI diffs whole lines and rewrites the
+  // contiguous [firstChanged..lastChanged] range, so changing the header on
+  // every chunk would erase+redraw every earlier thinking line together with
+  // the latest one. The final count appears once the block settles (stream
+  // ends or later content starts), when the block no longer re-renders per
+  // chunk and no redraw cascade is possible.
+  'thinkingHeaderLabel(blocks,streaming){let p=this.hiddenThinkingLabel.replace(/\\.{3}$/,"");if(streaming)return p+"…";return p+" (~"+this._tokensLabel(blocks)+")"}' +
   // Collapsed state: plain-object component rendering ONE line:
   // label + " · " + preview, truncated to the render width (CJK-aware).
   // dsh ReasoningRow parity: running → latest non-empty line with the window
@@ -163,7 +179,7 @@ const TAIL_BROKEN = "padTotal)]}}}";
 const TAIL_FIXED = "padTotal)]},invalidate(){}}}";
 
 if (src.includes(CURRENT_MARKER) && src.includes(TAIL_FIXED)) {
-  console.log(`Already patched (v3.2): ${chunkPath}`);
+  console.log(`Already patched (v3.3): ${chunkPath}`);
   process.exit(0);
 }
 
@@ -181,7 +197,7 @@ if (src.includes("pi-thinking-header") || src.includes("thinkingLabelText(")) {
     writeFileSync(chunkPath, src);
     console.log("Hotfixed (early v3 → v3.1): added missing invalidate() to the collapsed-thinking component");
     console.log(`File:         ${chunkPath}`);
-    console.log("Re-run the installer to update the patch to v3.2 (configurable decimals).");
+    console.log("Re-run the installer to update the patch to the latest version.");
     process.exit(0);
   }
   if (!existsSync(backup)) {
@@ -205,6 +221,6 @@ if (!src.includes(CURRENT_MARKER) || !src.includes("piThinkingCollapsed(") || !s
 
 verifyESM(src);
 writeFileSync(chunkPath, src);
-console.log(`Patched (v3.2): ${chunkPath}`);
+console.log(`Patched (v3.3): ${chunkPath}`);
 console.log(`Backup:       ${backup}`);
 console.log("Revert with:  cp '" + backup + "' '" + chunkPath + "'");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-thinking-header",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "dsh-style thinking display for pi: one-line header with token count (configurable decimals, default 2); collapsed thinking shows a single-line content preview",
   "keywords": [
     "pi-package",