pi-thinking-header 0.3.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 focksor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,112 @@
+# pi-thinking-header
+
+dsh 风格的 pi thinking 显示插件：带 token 计数的单行标题 + 折叠时单行内容预览（参考 dsh `ReasoningRow` 的滚动跟随）。
+
+```
+展开时：                                        折叠时（ctrl+t / 点击标题行）：
+  Thinking (~2.50k tokens)                        流式中：Thinking (~2.50k tokens) · …尾随最新内容保持可见
+  模型思考全文…                                   结束后：Thinking (~2.50k tokens) · 第一行内容…
+  正式回复…                                       正式回复…
+```
+
+- token 数量为本地估算：`ceil(chars / 4)`，流式输出时实时增长
+- 小数点位数可配置（默认 2 位）：`/thinking-header decimals <0-6>`，或直接编辑
+  配置文件 `~/.pi/agent/thinking-header.json`（`{"decimals": 2}`）。例如默认效果
+  `2.50k`；`decimals: 0` → `3k`；`decimals: 4` → `2.5000k`。两种模式均实时读取
+  该文件（mtime 缓存），修改后无需重启 pi
+- 折叠预览与 dsh `ReasoningRow` 对齐：**流式期间**显示最新一行的**行尾**（前导省略号，
+  相当于 `scrollLeft = scrollWidth - clientWidth`），多行内容在单行内持续滚动跟随；
+  **结束后**回到第一行开头（尾部省略号，相当于 `scrollLeft = 0`）
+- 截断按终端宽度计算（CJK 全角字符按 2 列计宽），保证严格单行
+- 点击标题行或 `Ctrl+T` 切换展开/折叠
+
+## 安装
+
+```bash
+# 从 npm 安装（写入 ~/.pi/agent/settings.json）
+pi install npm:pi-thinking-header
+```
+
+本地开发调试：
+
+```bash
+git clone https://github.com/focksor/pi-thinking-header
+pi install ./pi-thinking-header
+```
+
+## 会话内命令：`/thinking-header`
+
+所有功能的统一入口：
+
+```
+/thinking-header                  # 状态总览（模式/补丁状态/decimals）+ 用法
+/thinking-header patch           # 应用/修复完整模式补丁（确认后执行）
+/thinking-header decimals        # 查看当前小数位
+/thinking-header decimals <0-6>  # 设置小数位并持久化（默认 2）
+```
+
+补丁安装（`patch` 子命令，内部运行 `node install-patch.mjs`）：
+
+- 已打补丁 → 提示 already applied（含当前 decimals）
+- 未打补丁（或补丁版本较旧）→ 确认后执行安装/迁移，输出结果并提醒重启 pi（当前会话仍是旧代码，重启后生效）
+- `pi update` 之后补丁丢失时，extension 自动进入降级模式，此时用该命令可一键修复
+
+小数位配置（`decimals` 子命令）：
+
+- 有效范围 0–6 的整数，其它输入会报错且不修改配置
+- 写入 `~/.pi/agent/thinking-header.json`（也可直接编辑该文件）；降级模式立即生效，
+  完整模式下 patch 在每次渲染时读取该文件（mtime 缓存），同样无需重启
+- 尊重 `PI_CODING_AGENT_DIR` 环境变量（支持 `~/...` 形式）
+
+## 两种模式（自动检测）
+
+### 完整模式（推荐）：bundle patch
+
+pi 的 extension API 无法接管内置 thinking 块的折叠渲染，完整效果需要附带
+的 bundle patch。推荐直接在 pi 会话内运行 `/thinking-header patch`
+（自动定位安装位置）；也可手动执行：
+
+```bash
+# npm 安装：~/.pi/agent/npm/pi-thinking-header/install-patch.mjs
+# 本地安装：<仓库路径>/install-patch.mjs
+node <包目录>/install-patch.mjs
+```
+
+- 每条消息独立的 token 计数与预览（含历史消息）
+- 折叠态严格单行、宽度感知截断、点击切换
+- 流式期间折叠预览滚动跟随最新行行尾（dsh 同款），结束后回到第一行
+- 小数点位数渲染时实时读取配置文件（mtime 缓存），与降级模式共享同一份配置
+- 幂等；自动从 v1/v2/v3/v3.1 patch 迁移（恢复原始备份后重新应用；早期 v3
+  折叠组件缺 `invalidate()`、退出/切换模式时触发 `this.child.invalidate is not
+  a function` 崩溃且无备份时，会先原地热修复）；`pi update` 后重跑一次即可；
+  插件包更新后也建议重跑 `/thinking-header patch` 使 patch 与 extension 版本一致
+- 回滚：
+  ```bash
+  cp <chunk路径>.pre-thinking-header.bak <chunk路径>
+  # 路径见 install-patch.mjs 的输出
+  ```
+
+### 纯插件模式：extension 自动降级
+
+extension 启动时探测运行中的 pi bundle：**检测到任意版本的 patch 时**（含旧版本）
+extension 保持惰性（避免双标题），请运行 `/thinking-header patch` 迁移到当前 patch 版本；
+**未检测到 patch 时**自动进入降级模式：
+
+- 展开的 thinking：通过 markdown transformer 前置 `Thinking (~N tokens)` 标题行
+  （按块正确计数，`pi update` 后依然有效，无需维护）
+- 折叠的 thinking：pi 的 extension API 只暴露一个全局 label，插件会在每条
+  assistant 消息结束后将其更新为最新消息的 `计数 · 预览`。局限：转录里更早的
+  折叠块也会显示最新 label —— 需要按消息独立显示请打 bundle patch
+- bundle 已打 patch 时 extension 完全惰性，不会产生双标题
+
+## 文件
+
+| 文件 | 说明 |
+|------|------|
+| `index.js` | pi extension（模式检测 + 降级实现，含流式行尾跟随 label） |
+| `install-patch.mjs` | 完整模式安装器（v3.2 bundle patch，渲染时读取 decimals 配置） |
+| `package.json` | pi 包清单（`pi.extensions`） |
+
+## License
+
+MIT © focksor

package/index.js

@@ -0,0 +1,373 @@
+/**
+ * pi-thinking-header — dsh-style thinking display for pi.
+ *
+ * What it does
+ * ------------
+ * Thinking blocks get a one-line header with an estimated token count:
+ *
+ *   Thinking (~2.50k tokens)
+ *
+ * - Expanded:  header line + full thinking text
+ * - 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
+ *   content arrives); when done it shows the FIRST line from its start
+ *
+ * Two modes (auto-detected at load time)
+ * --------------------------------------
+ * 1. FULL MODE — the companion bundle patch (install-patch.mjs) has patched the
+ *    running pi installation. The patch implements everything per-message with
+ *    width-aware truncation and click-to-toggle. This extension then stays
+ *    completely inert to avoid double headers.
+ *
+ * 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).
+ *    - 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.
+ *
+ * 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
+ * file, so changes apply without restarting pi.
+ */
+
+import { execFile, execSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+// Companion installer (same package directory), executed by /thinking-header patch.
+const INSTALLER_PATH = fileURLToPath(new URL("./install-patch.mjs", import.meta.url));
+
+// 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.
+const MARKER = "pi-thinking-header";
+
+// ---------------- 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
+// modes react to changes without restarting pi.
+const DEFAULT_DECIMALS = 2;
+const AGENT_DIR = process.env.PI_CODING_AGENT_DIR
+  ? process.env.PI_CODING_AGENT_DIR.replace(/^~(?=\/|$)/, () => homedir())
+  : join(homedir(), ".pi", "agent");
+const CONFIG_PATH = join(AGENT_DIR, "thinking-header.json");
+
+const configCache = { mtime: -1n, value: {} };
+
+function loadConfig() {
+  try {
+    // mtimeNs (BigInt) as cache key: ms-precision mtime can collide when a
+    // config write lands in the same millisecond as the previous read.
+    const st = statSync(CONFIG_PATH, { bigint: true });
+    if (st.mtimeNs !== configCache.mtime) {
+      let value = {};
+      try {
+        const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) value = parsed;
+      } catch {
+        // unparsable config → treat as empty
+      }
+      configCache.mtime = st.mtimeNs;
+      configCache.value = value;
+    }
+  } catch {
+    // file missing → defaults (also drops cache entries for deleted files)
+    configCache.mtime = -1n;
+    configCache.value = {};
+  }
+  return configCache.value;
+}
+
+const getDecimals = () => {
+  const d = loadConfig().decimals;
+  return typeof d === "number" && Number.isInteger(d) && d >= 0 && d <= 6 ? d : DEFAULT_DECIMALS;
+};
+
+function saveDecimals(n) {
+  let cfg = {};
+  try {
+    const parsed = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
+    if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) cfg = parsed;
+  } catch {
+    // no/invalid config → start fresh, keep nothing
+  }
+  cfg.decimals = n;
+  mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+  writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2) + "\n");
+  configCache.mtime = -1n; // force re-read on next loadConfig()
+}
+// Unique fragment of AssistantMessageComponent#setHiddenThinkingLabel in the bundle
+const COMPONENT_ANCHOR =
+  "setHiddenThinkingLabel(label){this.hiddenThinkingLabel=label,this.lastMessage&&this.updateContent(this.lastMessage)}";
+
+/**
+ * Locate the running pi's bundle chunk that contains AssistantMessageComponent.
+ * Returns { found: true, patched: boolean } or { found: false }.
+ */
+function probeBundle() {
+  try {
+    const bin = execSync("readlink -f $(which pi)", { stdio: ["ignore", "pipe", "ignore"] })
+      .toString()
+      .trim();
+    if (!bin.endsWith(join("dist", "bundle", "cli.js"))) return { found: false };
+    const chunksDir = join(dirname(bin), "chunks");
+    if (!existsSync(chunksDir)) return { found: false };
+    for (const file of readdirSync(chunksDir)) {
+      if (!file.endsWith(".js")) continue;
+      const path = join(chunksDir, file);
+      const src = readFileSync(path, "utf8");
+      if (!src.includes(COMPONENT_ANCHOR)) continue;
+      return { found: true, patched: src.includes(MARKER) };
+    }
+  } catch {
+    // pi binary not resolvable — fall through
+  }
+  return { found: false };
+}
+
+// decimals: 0–6 (invalid values fall back to DEFAULT_DECIMALS); the setting is
+// authoritative — no trailing-zero stripping, so decimals=2 renders 2.50k.
+const formatTokens = (n, decimals = getDecimals()) =>
+  n >= 1000 ? (n / 1000).toFixed(decimals) + "k" : String(n);
+
+const firstLine = (text) => {
+  for (const line of text.split("\n")) {
+    if (line.trim()) return line.trim();
+  }
+  return "";
+};
+
+const lastLine = (text) => {
+  const lines = text.trimEnd().split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].trim()) return lines[i].trim();
+  }
+  return "";
+};
+
+/** Visible-length estimate that counts CJK-wide chars as 2 columns. */
+const visibleLength = (s) => {
+  let n = 0;
+  for (const ch of s) n += ch.codePointAt(0) >= 0x2e80 ? 2 : 1;
+  return n;
+};
+
+/** Truncate a preview so it fits `max` columns, appending an ellipsis when cut. */
+const truncatePreview = (text, max) => {
+  if (visibleLength(text) <= max) return text;
+  let out = "";
+  let width = 0;
+  for (const ch of text) {
+    const w = ch.codePointAt(0) >= 0x2e80 ? 2 : 1;
+    if (width + w > max - 1) break;
+    out += ch;
+    width += w;
+  }
+  return out + "…";
+};
+
+/** Tail variant: keep the END visible, prepending an ellipsis when cut
+ *  (terminal equivalent of dsh's scrollLeft = scrollWidth - clientWidth). */
+const tailPreview = (text, max) => {
+  if (visibleLength(text) <= max) return text;
+  const out = [];
+  let width = 0;
+  const chars = [...text];
+  for (let i = chars.length - 1; i >= 0; i--) {
+    const w = chars[i].codePointAt(0) >= 0x2e80 ? 2 : 1;
+    if (width + w > max - 1) break;
+    out.push(chars[i]);
+    width += w;
+  }
+  return "…" + out.reverse().join("");
+};
+
+/** Hidden-thinking label: count + preview (tail-following while streaming). */
+const thinkingLabel = (blocks, running) => {
+  const chars = blocks.reduce((n, c) => n + c.thinking.length, 0);
+  let label = `Thinking (~${formatTokens(Math.ceil(chars / 4))} tokens)`;
+  const text = running
+    ? lastLine(blocks[blocks.length - 1].thinking)
+    : firstLine(blocks[blocks.length - 1].thinking);
+  if (text) label += " · " + (running ? tailPreview(text, 80) : truncatePreview(text, 80));
+  return label;
+};
+
+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 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
+  // bundle patch re-reads it per render (mtime-cached), so decimal changes
+  // apply without restarting pi.
+  const usage =
+    "usage:\n" +
+    "  /thinking-header                    status overview\n" +
+    "  /thinking-header patch              apply/repair the full-mode patch\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",
+    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;
+    },
+    handler: async (args, ctx) => {
+      const argv = (args ?? "").trim().split(/\s+/).filter(Boolean);
+
+      // ---- decimals subcommand -------------------------------------
+      if (argv[0] === "decimals") {
+        const raw = argv[1];
+        if (raw === undefined) {
+          ctx.ui.notify(
+            `pi-thinking-header: decimals = ${getDecimals()} (default ${DEFAULT_DECIMALS})\n` +
+              `config: ${CONFIG_PATH}\n` +
+              "usage: /thinking-header decimals <0-6>",
+            "info",
+          );
+          return;
+        }
+        const n = Number(raw);
+        if (!Number.isInteger(n) || n < 0 || n > 6) {
+          ctx.ui.notify("pi-thinking-header: decimals must be an integer between 0 and 6", "error");
+          return;
+        }
+        try {
+          saveDecimals(n);
+        } catch (err) {
+          ctx.ui.notify(`pi-thinking-header: failed to save ${CONFIG_PATH}: ${err?.message ?? err}`, "error");
+          return;
+        }
+        ctx.ui.notify(
+          `pi-thinking-header: decimals = ${n} → saved to ${CONFIG_PATH}\n` +
+            `e.g. Thinking (~${formatTokens(2500)} tokens)`,
+          "info",
+        );
+        return;
+      }
+
+      // ---- patch subcommand: apply/repair the full-mode bundle patch ----
+      if (argv[0] === "patch") {
+        try {
+          const state = probeBundle();
+          if (!state.found) {
+            ctx.ui.notify(
+              "pi-thinking-header: could not locate the running pi installation (readlink -f $(which pi))",
+              "error",
+            );
+            return;
+          }
+          if (state.patched) {
+            ctx.ui.notify(
+              `pi-thinking-header: full-mode patch already applied (v3.2) — decimals = ${getDecimals()}`,
+              "info",
+            );
+            return;
+          }
+          const ok = await ctx.ui.confirm(
+            "pi-thinking-header",
+            "Apply the full-mode bundle patch to the running pi installation?\n" +
+              "Modifies the installed bundle (a .bak backup is kept). Restart pi afterwards.",
+          );
+          if (!ok) return;
+          const { stdout, stderr } = await execFileAsync(
+            process.execPath,
+            [INSTALLER_PATH],
+            { timeout: 30_000, windowsHide: true, maxBuffer: 1024 * 1024 },
+          );
+          const out = (stdout + "\n" + stderr).trim();
+          ctx.ui.notify("pi-thinking-header: patch applied.\n" + out, "info");
+          ctx.ui.notify("pi-thinking-header: restart pi to load the patched renderer.", "warning");
+        } catch (err) {
+          const detail = [err?.message, err?.stdout, err?.stderr].filter(Boolean).join("\n");
+          ctx.ui.notify("pi-thinking-header: patch failed.\n" + detail, "error");
+        }
+        return;
+      }
+
+      // ---- unknown arg → usage -------------------------------------
+      if (argv.length > 0) {
+        ctx.ui.notify("pi-thinking-header: unknown argument.\n" + usage, "error");
+        return;
+      }
+
+      // ---- no args → status overview + usage ----
+      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)";
+      ctx.ui.notify(
+        "pi-thinking-header\n" +
+          `mode: ${mode}\n` +
+          `decimals: ${getDecimals()} (default ${DEFAULT_DECIMALS})\n` +
+          `config: ${CONFIG_PATH}\n` +
+          usage,
+        "info",
+      );
+    },
+  });
+
+  const bundle = probeBundle();
+  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.
+    return;
+  }
+
+  // ---------------- FALLBACK MODE (pure extension API) ----------------
+
+  // Expanded thinking: per-block header with token count.
+  pi.registerMarkdownTransformer((markdown, ctx) => {
+    if (ctx?.messageType !== "assistant-thinking") return markdown;
+    const text = markdown.trim();
+    if (!text) return markdown;
+    return `*Thinking (~${formatTokens(Math.ceil(text.length / 4))} tokens)*\n\n${markdown}`;
+  });
+
+  // Collapsed thinking: pi exposes a single global label; keep it in sync with
+  // the latest assistant message (count + one-line preview). While streaming
+  // (message_update) the preview is the latest line tail-following dsh-style;
+  // 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.
+  const updateLabel = async (message, ctx, running) => {
+    try {
+      if (!message || message.role !== "assistant") return;
+      const blocks = (message.content ?? []).filter(
+        (c) => c?.type === "thinking" && typeof c.thinking === "string" && c.thinking.trim(),
+      );
+      if (blocks.length === 0) return;
+      ctx.ui.setHiddenThinkingLabel(thinkingLabel(blocks, running));
+    } catch {
+      // display-only; never break the session over a label
+    }
+  };
+
+  pi.on("message_update", (event, ctx) => updateLabel(event?.message, ctx, true));
+  pi.on("message_end", (event, ctx) => updateLabel(event?.message, ctx, false));
+}

package/install-patch.mjs

@@ -0,0 +1,210 @@
+#!/usr/bin/env node
+/**
+ * pi-thinking-header — FULL MODE installer (bundle patch, v3.2).
+ *
+ * Patches pi's AssistantMessageComponent for dsh-style thinking rendering:
+ *
+ *   Thinking (~2.50k tokens) · preview of the thinking content…
+ *
+ * - Expanded:  one-line header (token count) + full thinking text
+ * - Collapsed: single line — header + content preview, truncated to the
+ *              terminal width (CJK-aware); click or ctrl+t toggles
+ * - Collapsed preview follows dsh's ReasoningRow: while streaming it shows
+ *   the LATEST line with the window pinned to its tail (leading ellipsis —
+ *   the single line "scrolls" as content arrives); when done it shows the
+ *   FIRST line from its start (trailing ellipsis)
+ * - Token count: local estimate ceil(chars / 4); live during streaming
+ * - Decimals: k-token decimal places configurable (0–6, default 2) via
+ *   <agentDir>/thinking-header.json {"decimals": 2}; read per render with an
+ *   mtime cache, so changes apply without restarting pi. Same file the
+ *   extension uses in fallback mode.
+ *
+ * The extension (index.js) detects this patch and stays inert while it is
+ * applied; if pi is updated and the patch is gone, the extension's pure-API
+ * fallback takes over automatically.
+ *
+ * Idempotent. Migrates a v1 patch automatically (restores the pristine
+ * backup first). Re-run after `pi update` / `npm update -g`.
+ *
+ * Usage: node install-patch.mjs [path/to/chunk-*.js]
+ */
+import { readdirSync, readFileSync, writeFileSync, copyFileSync, existsSync } from "node:fs";
+import { execSync, spawnSync } from "node:child_process";
+import { dirname, join } from "node:path";
+
+// ---------- anchors (verified against pi 0.85.1 minified bundle) ----------
+// AssistantMessageComponent#setHiddenThinkingLabel — unique: InteractiveMode's
+// version references defaultHiddenThinkingLabel; RPC's takes _label.
+const ANCHOR1 =
+  "setHiddenThinkingLabel(label){this.hiddenThinkingLabel=label,this.lastMessage&&this.updateContent(this.lastMessage)}";
+
+// The minified bundle contains REAL newline bytes inside this template literal.
+const NL = "\n";
+const JOIN_TPL = "join(`" + NL + NL + "`)";
+
+const MD_TAIL =
+  ",this.outputPad,0,this.markdownTheme,{color:text=>theme.fg(\"thinkingText\",text),italic:!0}," +
+  '{transform:createMarkdownTransform("assistant-thinking",this.isStreaming,this.markdownTransformers)})';
+
+const HEADER_TEXT =
+  'new Text(theme.italic(theme.fg("thinkingText",this.thinkingLabelText(thinkingBlocks))),this.outputPad,0)';
+
+const ANCHOR2 =
+  'thinkingComponent=hidden?new Text(theme.italic(theme.fg("thinkingText",this.hiddenThinkingLabel)),this.outputPad,0):new Markdown(thinkingBlocks.' +
+  JOIN_TPL +
+  MD_TAIL +
+  ";";
+
+// ---------- 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";
+
+// Marker comment doubles as the extension's mode-detection key.
+const HELPER =
+  "/*pi-thinking-header:v3.2*/" +
+  // 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
+  // <agentDir>/thinking-header.json without any imports:
+  // process.getBuiltinModule works inside ESM (Node >= 22.3; on older runtimes
+  // the try/catch degrades to {} → default decimals).
+  '_piCfg(){this._pthT??=0n,this._pthC??=null;try{let fs=process.getBuiltinModule("node:fs"),os=process.getBuiltinModule("node:os"),' +
+  '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;' +
+  "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)"}' +
+  // 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
+  // pinned to its tail (leading "…", i.e. scrollLeft=scrollWidth-clientWidth);
+  // done → first non-empty line from its start (trailing "…", scrollLeft=0).
+  "piThinkingCollapsed(blocks,running){let label=this.thinkingLabelText(blocks),self=this,text=\"\";" +
+  'if(running){for(let i=blocks.length-1;i>=0&&!text;i--){let ls=blocks[i].split("\\n");for(let j=ls.length-1;j>=0;j--){let l=ls[j].trim();if(l){text=l;break}}}}' +
+  'else{for(let b of blocks){let line=b.split("\\n").find(l=>l.trim());if(line){text=line.trim();break}}}' +
+  "let vlen=s=>{let n=0;for(let ch of s)n+=ch.codePointAt(0)>=0x2e80?2:1;return n};" +
+  "return {render(w){let inner=Math.max(8,w-self.outputPad*2),max=inner-vlen(label)-3;" +
+  "if(max<1){let padTotal=inner-vlen(label);if(padTotal<0)padTotal=0;" +
+  'return [" ".repeat(self.outputPad)+theme.italic(theme.fg("thinkingText",label))+" ".repeat(self.outputPad+padTotal)]}' +
+  "let prev=text;" +
+  "if(vlen(prev)>max){if(running){let out=[],n=0,cs=[...prev];for(let i=cs.length-1;i>=0;i--){let cw=cs[i].codePointAt(0)>=0x2e80?2:1;if(n+cw>max-1)break;out.push(cs[i]);n+=cw}prev=\"…\"+out.reverse().join(\"\")}" +
+  "else{let out=\"\",n=0;for(let ch of prev){let cw=ch.codePointAt(0)>=0x2e80?2:1;if(n+cw>max-1)break;out+=ch;n+=cw}prev=out+\"…\"}}" +
+  'let line=label+" · "+prev;let padTotal=inner-vlen(line);if(padTotal<0)padTotal=0;' +
+  // v3.1: the returned plain object MUST implement invalidate() — MouseRegion
+  // forwards lifecycle unconditionally (invalidate(){this.child.invalidate()}),
+  // so a render-only object crashed pi on exit/mode-switch with
+  // "this.child.invalidate is not a function". The object is stateless (render
+  // output is computed fresh on every call), so a no-op invalidate is correct.
+  'return [" ".repeat(self.outputPad)+theme.italic(theme.fg("thinkingText",line))+" ".repeat(self.outputPad+padTotal)]},invalidate(){}}}';
+
+const PATCH2 =
+  "thinkingComponent=hidden?this.piThinkingCollapsed(thinkingBlocks,this.isStreaming):" +
+  "(()=>{let body=new Markdown(thinkingBlocks." +
+  JOIN_TPL +
+  MD_TAIL +
+  ",box=new Container;" +
+  "return box.addChild(" +
+  HEADER_TEXT +
+  "),box.addChild(body),box})();";
+
+// ---------- safety net: parse-check before writing ----------
+// Same ESM parser pi's loader uses (vm.SourceTextModule), never executes the
+// code. A brace-counting mistake must abort the install, not brick pi.
+function verifyESM(src) {
+  const probe =
+    'const vm=require("node:vm");let d="";' +
+    'process.stdin.on("data",(c)=>d+=c).on("end",()=>{' +
+    'try{new vm.SourceTextModule(d,{identifier:"candidate"});process.exit(0)}' +
+    'catch(e){console.error(e.message);process.exit(1)}});';
+  const r = spawnSync(process.execPath, ["--experimental-vm-modules", "-e", probe], {
+    input: src,
+    encoding: "utf8",
+    timeout: 30_000,
+  });
+  if (r.error) throw r.error;
+  if (r.status !== 0) {
+    throw new Error("Candidate bundle failed ESM parse check: " + (r.stderr || "unknown").trim());
+  }
+}
+
+// ---------- locate target chunk ----------
+function locateChunk() {
+  if (process.argv[2]) return process.argv[2];
+  const bin = execSync("readlink -f $(which pi)").toString().trim(); // <pkg>/dist/bundle/cli.js
+  const chunksDir = join(dirname(bin), "chunks");
+  for (const f of readdirSync(chunksDir)) {
+    if (!f.endsWith(".js")) continue;
+    const p = join(chunksDir, f);
+    if (readFileSync(p, "utf8").includes(ANCHOR1)) return p;
+  }
+  throw new Error(`Could not find the AssistantMessageComponent chunk under ${chunksDir}`);
+}
+
+// ---------- apply (with v1 migration) ----------
+const chunkPath = locateChunk();
+const backup = chunkPath + ".pre-thinking-header.bak";
+let src = readFileSync(chunkPath, "utf8");
+
+// Distinctive tail of piThinkingCollapsed's returned object, with and without
+// the v3.1 invalidate() fix. `padTotal)]}}}` can only match the final return —
+// the max<1 branch ends with a single `}` before `let prev=text;` — and it
+// does NOT occur inside TAIL_FIXED (there `)]` is followed by a single `}`
+// then `,`). TAIL_FIXED closes, in order: render fn, the invalidate method
+// body (inside its own `(){}`), the object literal, and finally the
+// piThinkingCollapsed class method itself — four `}` after `]` in total.
+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}`);
+  process.exit(0);
+}
+
+// Any older member of the patch family (v1/v2/v3/v3.1, detected via the family
+// string or the v1/v2 helper name) → restore pristine, then re-apply fresh.
+if (src.includes("pi-thinking-header") || src.includes("thinkingLabelText(")) {
+  // Early v3 (pre-3.1) shipped a render-only collapsed component: MouseRegion
+  // .invalidate crashed pi on exit/mode-switch ("this.child.invalidate is not
+  // a function"). Without a pristine backup we cannot re-apply, so hotfix that
+  // one shape in place; a later installer run (with a backup) migrates fully.
+  if (src.includes(TAIL_BROKEN) && !existsSync(backup)) {
+    src = src.replace(TAIL_BROKEN, TAIL_FIXED);
+    if (!src.includes(TAIL_FIXED)) throw new Error("v3 → v3.1 hotfix failed");
+    verifyESM(src);
+    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).");
+    process.exit(0);
+  }
+  if (!existsSync(backup)) {
+    throw new Error("Older pi-thinking-header patch found but no pristine backup; reinstall pi, then re-run.");
+  }
+  src = readFileSync(backup, "utf8");
+  console.log("Migrating: older pi-thinking-header patch detected, restored pristine bundle from backup.");
+} else if (!existsSync(backup)) {
+  copyFileSync(chunkPath, backup);
+}
+
+if (!src.includes(ANCHOR1)) throw new Error("ANCHOR1 not found (pi version changed?)");
+if (!src.includes(ANCHOR2)) throw new Error("ANCHOR2 not found (pi version changed?)");
+
+src = src.replace(ANCHOR1, ANCHOR1 + HELPER);
+src = src.replace(ANCHOR2, PATCH2);
+
+if (!src.includes(CURRENT_MARKER) || !src.includes("piThinkingCollapsed(") || !src.includes(TAIL_FIXED)) {
+  throw new Error("Patch did not apply");
+}
+
+verifyESM(src);
+writeFileSync(chunkPath, src);
+console.log(`Patched (v3.2): ${chunkPath}`);
+console.log(`Backup:       ${backup}`);
+console.log("Revert with:  cp '" + backup + "' '" + chunkPath + "'");

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "pi-thinking-header",
+  "version": "0.3.2",
+  "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",
+    "pi-extension",
+    "thinking",
+    "tui"
+  ],
+  "license": "MIT",
+  "author": "focksor <focksor@outlook.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/focksor/pi-thinking-header.git"
+  },
+  "bugs": {
+    "url": "https://github.com/focksor/pi-thinking-header/issues"
+  },
+  "homepage": "https://github.com/focksor/pi-thinking-header#readme",
+  "type": "module",
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "files": [
+    "index.js",
+    "install-patch.mjs"
+  ],
+  "pi": {
+    "extensions": ["./index.js"]
+  }
+}