@clapecho233/pi-smart-fold 0.1.1 → 0.2.0

package/README.md

@@ -1,61 +1,68 @@
 # pi-smart-fold
 
-[pi](https://github.com/earendil-works/pi-mono) coding-agent 插件：保持会话记录紧凑，同时不丢失关键信息。
+A [pi](https://github.com/earendil-works/pi-mono) coding-agent extension that keeps the session transcript compact — without losing key information.
 
-## 功能
+| Without smart-fold | With smart-fold |
+| --- | --- |
+| Long thinking walls, verbose tool output, full file previews | One-line `Thought for 12.4s` summaries, folded tool output, `write src/index.ts +12 -3` headers |
 
-### 1. Thinking 折叠 + 计时（`smart` 默认）
+## Features
 
-- **思考中**：首行显示加粗的 **`Thinking… (8s)`**，换行后滚动显示思考文本的**结尾**（如 `tail -f`）。**点击一次 → 直接切换为完整显示至今全部思考内容**（持续跟随增长，加粗的实时计时行 **`Thinking… (8s)`** 固定在思考块**最底部**并持续更新）；**再点一次 → 回到滚动结尾**。没有中间标签状态，始终在 滚动结尾 ↔ 完整显示 间单击切换：
+### 1. Thinking fold + live timer (`smart` mode, default)
 
-  ```text
-  滚动显示（默认）              完整显示（点击后）
-  Thinking… (8s)               …前面的思考内容…
-  …正在进行的思考最新一行        正在进行的思考……
-                               Thinking… (9s)   ← 固定在底部、持续更新
-  ```
+**While the model thinks**, the block shows a bold **`Thinking… (8s)`** header line, followed by the scrolling *tail* of the thinking text (like `tail -f`). **One click toggles directly to the full text so far** (the ticking **`Thinking… (8s)`** line stays pinned at the bottom and keeps updating); **one more click toggles back** to the scrolling tail. There is no intermediate label state — a single click always switches between `scrolling tail ↔ full view`:
 
-- **思考结束后**：若该段思考当时正处于完整显示，会平滑过渡为底部 **`Thought for 12.4s`** 定格时长行；消息结束后默认完全折叠为一行加粗的 **`Thought for 12.4s`**。
-- **单击展开/收起单个思考块**：思考结束后默认进入隐藏态（由原型补丁预置），折叠行就是 **`Thought for 12.4s`** 标签（加粗、带实测时长）。**点击一次 → 该块展开为完整思考全文**（底部保留加粗的时长行，与斜体思考正文风格稍作区分）；**再点一次 → 收起**。没有中间状态，只影响被点击的块，同一消息里的其它思考块不受干扰。
-- **完全接管原生折叠**：pi 内置的思考隐藏标签（`Thinking...`）被替换为本插件按消息生成的 `Thought for …` 标签，点击与 ctrl+t 出现的都是我们的文本，而不是原生的 `Thinking...`（smart 模式下 ctrl+t 无额外效果，用点击或 `/fold expand` 展开）。
-- **点击识别是精确的**：通过对 pi 公开导出的 `AssistantMessageComponent` 打一个幂等的原型补丁，预置完成思考的隐藏态并观测其内部可见性映射的点击写入（区分 ctrl+t 的清空操作）；思考中的单击会被重定向（改回可见并切换插件自己的 滚动↔完整 模式），原生两态切换的中间“隐藏标签”态永远不会出现。主题切换 / 窗口缩放 / 布局重绘等全局重渲染绝不会误判为点击；若未来版本无法安装补丁，自动降级为 pi 原生显示（可用 `/fold expand` 兜底）。
-- **时长持久化**：每段思考的时长按内容哈希记录进会话文件（`smart-fold-thinking` 自定义条目，不进入 LLM 上下文），`/resume` 恢复会话后依旧显示；同一条消息内多段思考（工具调用之间）分别计时。
-- 截断按**终端显示宽度**计算（中文 / emoji 等宽字符占 2 列），超宽时保留行尾并加 `…` 前缀。
-- 折叠仅影响 TUI 显示，不改动会话文件中的原文与发送给模型的上下文。
+```text
+Scrolling tail (default)          Full view (after one click)
+Thinking… (8s)                    …earlier thinking text…
+…latest line of thinking          …thinking still streaming…
+                                  Thinking… (9s)   ← pinned at the bottom, live-updating
+```
+
+**After the thinking run finishes**, the block collapses to a single bold **`Thought for 12.4s`** line (measured duration). If the block was in full view at that moment, it transitions smoothly to the pinned duration footer first.
+
+**Single-click expand/collapse per block**: finished thinking starts hidden (seeded by a prototype patch). **One click → that block expands to its full text** (with the bold duration line kept at the bottom); **one more click → collapses back**. No intermediate states, and only the clicked block is affected — other thinking runs in the same message are untouched. The same one-click toggle works for a run that already finished *while its message is still streaming* (e.g. thinking done, answer text or a tool call still coming): the folded `Thought for …` line expands directly — never through pi's bare `Thought…` label middle state.
 
-其它模式：`tail`（始终单行显示结尾 + 加粗时长前缀）、`full`（结束后直接显示全文，底部同样附时长行）、`off`（关闭，并恢复 pi 默认的思考显示）。
+- **Fully takes over native folding**: pi's built-in hidden-thinking label (`Thinking...`) is replaced with per-message `Thought for …` labels generated by this extension. What you see after clicks or `ctrl+t` is always our text, never the native one. (In `smart` mode `ctrl+t` has no extra effect — use clicks or `/fold expand` instead.)
+- **Exact click detection**: an idempotent prototype patch on pi's publicly exported `AssistantMessageComponent` seeds the hidden state of finished thinking runs and observes writes to the component's internal visibility map (distinguishing `ctrl+t`'s clear operation). Clicks on runs of a still-streaming message — the live run as well as already-finished ones — are redirected so the native two-state toggle's hidden middle state never appears. Global re-renders — theme changes, window resizes, layout redraws — are never mistaken for clicks. If a future pi version can't be patched, the extension degrades gracefully to pi's native display (with `/fold expand` as a fallback).
+- **Persistent durations**: each thinking run's duration is recorded in the session file keyed by content hash (a `smart-fold-thinking` custom entry, never sent to the LLM context), so durations still show after `/resume`. Multiple thinking runs within one message (between tool calls) are timed individually.
+- **Code-block safe**: while a code fence streams through the thinking text, structural fence lines are skipped in the collapsed tail — the block never flashes fully open for a frame. In the expanded view an unclosed code fence is closed automatically so the `Thinking…/Thought for …` footer renders below it as bold text, never swallowed into the code block as literal `**asterisks**`.
+- Truncation is measured in **terminal display columns** (CJK characters / emoji count as 2), keeping the line ending with an `…` prefix when over-wide.
+- Folding is **display-only**: the session file and the context sent to the model are never modified.
 
-备用：`/fold expand on|off`（或设置面板中的"展开全部思考"）临时展开/折叠全部思考块 —— 日常操作直接点击单个思考块即可，新会话默认全部折叠。
+Other modes: `tail` (always one line — the text tail with a bold duration prefix), `full` (show full text after the run ends, with the duration footer), `off` (disable and restore pi's default thinking display).
 
-### 2. 工具输出折叠
+Fallback: `/fold expand on|off` (or "Expand all thinking" in the settings panel) temporarily expands/collapses *all* finished thinking blocks. Daily usage only needs single clicks on individual blocks; new sessions always start fully folded.
 
-每次 `session_start`（启动 / `/reload` / `/new` / `/resume` / `/fork`）自动调用 `ctx.ui.setToolsExpanded(false)`，工具输出保持折叠，`ctrl+o` 手动展开。
+### 2. Tool output folding
 
-### 3. 工具调用行截断 + Write/Edit 增删统计
+On every `session_start` (startup, `/reload`, `/new`, `/resume`, `/fork`) the extension calls `ctx.ui.setToolsExpanded(false)` so tool output stays collapsed; press `ctrl+o` to expand manually.
 
-- **调用命令过长时截断**：`bash`/`read`/`grep`/`find`/`ls` 等工具的调用行在折叠状态下截断为单行，超宽时以 `…` 结尾（pi 自带的 ANSI 感知 `truncateToWidth`），命令还有后续行时追加 ` …` 标记；点击或 `ctrl+o` 展开后与工具输出一起完整显示。
-- **write / edit 增删统计**：
-  - write：执行**前**读取原文件内容，与写入内容做行级 diff（公共前后缀裁剪 + LCS），首行追加 **绿色 `+新增` / 红色 `-删除`**，如 `write src/index.ts +12 -3`；新文件 `+N -0`；超大文件（>8MB）跳过。统计随工具结果**持久化进会话文件**，恢复历史会话后依旧显示（本版本之前产生的旧写入没有记录，不显示）。
-  - edit：直接对各 `edits` 的 `oldText → newText` 做行级 diff 并求和，如 `edit src/app.ts +2 -1`（参数流式传输时就实时更新）。
-- **write/edit 默认完全折叠，不显示任何代码内容/差异**：折叠时调用区和结果区都只剩一行头部（`writeCollapsed: header` 默认；pi 原生没有此能力，通过对 renderCall + renderResult 的双重包装实现 —— 结果区的 diff 在折叠时返回空组件，错误信息仍会显示）；点击 / `ctrl+o` 展开后显示完整差异 / 语法高亮内容，**头部行在折叠和展开时都保留 `+N -M` 统计**（edit 自带外壳的背景条完整保留，统计注入行尾填充、行宽不变）。可在设置中改回 `preview` 恢复 pi 原生预览。
-- 实现方式为对 pi 内置工具的渲染包装（执行逻辑完全复用各 `create*ToolDefinition`）。
+### 3. Tool call line truncation + write/edit diff stats
 
-## 设置界面
+- **Long call lines are truncated**: `bash` / `read` / `grep` / `find` / `ls` call lines collapse to a single line, cut to the terminal width with a trailing `…` (pi's ANSI-aware `truncateToWidth`). An extra ` …` marker is appended when the command has more lines. Click or `ctrl+o` to expand and see everything.
+- **write / edit line-diff stats**:
+  - `write`: reads the original file content *before* the write executes and computes a line-level diff (common prefix/suffix trimming + LCS). The header line gains a **green `+added` / red `-removed`** suffix, e.g. `write src/index.ts +12 -3`; new files show `+N -0`. Files larger than 8 MB are skipped. Stats are **persisted with the tool result in the session file**, so they still show in restored sessions (writes made before this version have no record and show nothing).
+  - `edit`: diffs each `edits[]` entry's `oldText → newText` directly and sums the result, e.g. `edit src/app.ts +2 -1` (updates live while arguments stream in).
+- **write/edit collapse to a header-only line by default** (`writeCollapsed: header`): collapsed rows show just the one-line header — no code content or diff preview (not natively possible in pi; implemented by wrapping both `renderCall` and `renderResult` — the result area renders an empty component while collapsed, and error messages remain visible). Click / `ctrl+o` expands to the full diff / syntax-highlighted content. The **`+N -M` stat stays in the header line in both states** (edit's native full-width background bar is preserved; the stat is injected into the trailing padding without changing the line width). Switch to `preview` in settings to restore pi's native preview.
+- Implemented as rendering wrappers around pi's built-in tools (execution logic is fully reused from each `create*ToolDefinition`).
+
+## Settings
 
 ```
-/fold        打开 /config 样式的选择式设置（Enter/Space 切换值，Esc 关闭）
+/fold        Open a /config-style interactive settings list (Enter/Space to change, Esc to close)
 ```
 
-也可带参数直接修改（含自动补全）：
+Or change values directly (with autocompletion):
 
 ```text
-/fold thinking smart|tail|full|off   # on=smart, off=off 兼容旧写法
-/fold tools on|off                   # 启动时是否折叠工具输出
-/fold writestat on|off               # write 增删统计开关
-/fold writecollapsed header|preview  # write 折叠时仅首行 / 保留预览
+/fold thinking smart|tail|full|off   # on=smart, off=off accepted for compatibility
+/fold tools on|off                   # fold tool output at session start
+/fold writestat on|off               # write/edit diff stats toggle
+/fold writecollapsed header|preview  # write rows: header-only / keep preview when collapsed
 ```
 
-配置文件 `smart-fold.config.json`（位于插件目录，可手工编辑；旧的 `thinkingFold` 布尔值会自动迁移）：
+Config file `smart-fold.config.json` (next to the extension entry; the legacy boolean `thinkingFold` is migrated automatically):
 
 ```json
 {
@@ -66,52 +73,69 @@
 }
 ```
 
-## 安装
+## Installation
 
-任选其一：
+Any one of these:
 
 ```bash
-# 方式 A：作为目录插件放入全局自动发现路径
+# Option A: clone into pi's global extension auto-discovery directory
 git clone <this-repo> ~/.pi/agent/extensions/smart-fold
 
-# 方式 B：通过 pi 包管理安装
+# Option B: install via the pi package manager
 pi install git:<repo-url>
 
-# 方式 C：加入 settings.json
+# Option C: add to settings.json
 # ~/.pi/agent/settings.json → { "extensions": ["/path/to/pi-smart-fold"] }
 
-# 临时测试
+# Try it temporarily
 pi -e /path/to/pi-smart-fold/index.ts
 ```
 
-> 插件无任何 npm 依赖，pi 通过 jiti 直接加载 TypeScript。
+> The extension has no npm dependencies — pi loads the TypeScript directly via jiti.
 
-## 开发
+## Development
 
 ```bash
-npm test          # 纯函数单元测试（Node ≥ 22.18 原生 TS 类型剥离，无需构建）
-npm run test:sim  # 点击周期仿真：驱动真实 pi AssistantMessageComponent
-                  # （需先把已安装的 pi 包符号链接到 node_modules/@earendil-works）
+npm install        # dev deps + relink node_modules/@earendil-works to the installed pi (postinstall)
+npm run link:pi    # re-point the type/runtime links after a pi upgrade — always current version
+npm run typecheck  # strict tsc against the installed pi's .d.ts (no emit)
+npm run check      # link + typecheck + jiti load-check + unit tests + click simulation
+npm test           # unit tests for the pure functions (native TS type stripping, Node ≥ 22.18, no build step)
+npm run test:sim   # click-cycle simulation against the real pi AssistantMessageComponent
 ```
 
-结构：
+The extension itself has no npm dependencies — pi loads the TypeScript directly via jiti.
+`typescript` / `@types/node` are dev-only, and `node_modules/@earendil-works/*` are symlinks into
+the pi installation that loads the extension (created by `scripts/link-pi.mjs`), so typecheck
+always runs against the exact pi version installed on the machine.
+
+Project layout:
 
 ```
-index.ts           插件入口（transformer / 事件 / write 渲染包装 / /fold 设置界面）
-lib/fold.ts        纯函数：显示宽度、行尾截断、时长格式化、行级 diff
-lib/thinking.ts    思考计时状态机（按内容哈希记录各段思考时长）
-lib/config.ts      配置读写（含旧配置迁移；缺失/损坏时回退默认值）
-test/fold.test.mjs 单元测试
-test/click-sim.mjs 点击周期仿真（真实 pi 组件 + 模拟点击，验证 滚动↔完整 切换）
+index.ts                Extension entry (transformer / events / write render wrappers / /fold settings UI)
+lib/fold.ts             Pure functions: display width, tail truncation, duration formatting, line diff
+lib/thinking.ts         Thinking timer state machine (per-run durations keyed by content hash)
+lib/config.ts           Config load/save (with legacy migration; falls back to defaults when missing/corrupt)
+scripts/link-pi.mjs     Symlink the installed pi runtime into node_modules (version-following)
+scripts/load-check.mjs  Smoke test: load the extension via pi's jiti and exercise registration
+test/fold.test.mjs      Unit tests
+test/click-sim.mjs      Click-cycle simulation (real pi component + simulated clicks, verifies tail ↔ full toggling)
 ```
 
-## 已知边界
+## Known limitations
+
+- Single-click toggling of thinking runs in a *live* message depends on the prototype patch's redirect; without the patch it degrades to pi's native two-state toggle (two clicks to expand).
+- Expand state is runtime-only: new sessions/reloads start folded again. Window resizes never collapse blocks you've expanded.
+- write diff stats only apply to writes executed in the current session (restored older sessions have no pre-execution snapshot to diff against).
+- When stacked with pi's native "Hide thinking blocks" (`ctrl+t` toggle): if thinking is hidden that way, the live scrolling line won't show — keep the native display at its default and let this extension handle folding.
 
-- 思考中的单击切换依赖原型补丁的重定向；补丁不可用时降级为 pi 原生两态切换（此时需两次点击展开）。
-- 展开状态为运行时状态，新会话/重载后恢复折叠；窗口缩放不会收起你已展开的块。
-- write 增删统计只对当前会话中的写入生效（恢复的旧会话没有执行前快照可对比）。
-- 与 pi 原生 "Hide thinking blocks"（`ctrl+t` 切换）叠加时，若隐藏了思考块，思考中不会显示滚动行 —— 建议保持默认的显示状态，由本插件负责折叠。
+## Compatibility
 
-## 兼容性
+Built and verified against pi **`0.86.1`** public extension APIs: `registerMarkdownTransformer`,
+`ctx.ui.setToolsExpanded` / `setHiddenThinkingLabel`, `create*ToolDefinition` (and friends),
+`registerTool` (`renderCall` / `renderResult` + `ToolRenderContext`), `registerCommand`, `appendEntry`,
+`SettingsList`, and the `AssistantMessageComponent` click-internals patch (`updateContent`,
+`thinkingVisibilityOverrides`, `hiddenThinkingLabel`).
 
-基于 pi `0.85.1` 的公开扩展 API（`registerMarkdownTransformer`、`ctx.ui.setToolsExpanded`、`createWriteToolDefinition`、`registerCommand`、`appendEntry`、`SettingsList`）。
+After upgrading pi, run `npm run link:pi && npm run check` — the links follow the newly installed
+version automatically, and the check verifies types, jiti loading, and behavior against it.

package/index.ts

@@ -73,6 +73,7 @@ import { Container, SettingsList, Text, truncateToWidth } from "@earendil-works/
 import type { Component, SettingItem } from "@earendil-works/pi-tui";
 
 import {
+  closeOpenFences,
   countEditsLineDiff,
   countLineDiff,
   displayWidth,
@@ -130,24 +131,29 @@ function resolveExtensionDir(): string | undefined {
 // (idempotently, shared across extension reloads via Symbol.for keys) to:
 //
 //   1. SEED every thinking run of a FINALIZED message with a hidden override
-//      when it has none yet. Finished thinking therefore starts collapsed in
-//      the hidden state — and since we also set the component's label text
-//      per message (`Thought for 12.4s`), the collapsed line keeps its
-//      duration. One click then flips the run to expanded (our transformer
-//      renders the full text), one click flips it back. Single click.
+//      when it has none yet (runs a streaming-era redirect left visible but
+//      folded are normalized into the seeded state as well). Finished
+//      thinking therefore starts collapsed in the hidden state — and since we
+//      also set the component's label text per message (`Thought for 12.4s`),
+//      the collapsed line keeps its duration. One click then flips the run to
+//      expanded (our transformer renders the full text), one click flips it
+//      back. Single click.
 //   2. CLEAR the overrides when expand-all is requested (mode "full" or the
 //      expand toggle), so every run renders expanded.
 //   3. DIFF the overrides map against a per-component snapshot to observe
 //      clicks exactly (seeding performed in the same pass is excluded, and
 //      clears are ignored) and record which block (content hash) was clicked
 //      plus a monotonic click sequence.
-//   4. REDIRECT clicks on the run that is still being written. pi's handler
-//      just toggled that run to the hidden-label state; we flip the override
-//      straight back to visible and toggle our own tail ↔ full mode instead,
-//      so one click switches between the scrolling tail and the full text
-//      (timing line pinned at the bottom) — the hidden middle state never
-//      shows. The MouseRegion click closure is rebuilt from the corrected
-//      map on every render, so each later click hits the same redirect.
+//   4. REDIRECT clicks on any thinking run of a STILL-STREAMING message.
+//      pi's handler just toggled that run to the hidden-label state; we flip
+//      the override straight back to visible and toggle our own mode
+//      instead. For the run still being written that switches between the
+//      scrolling tail and the full text (timing line pinned at the bottom);
+//      for a run that already finished while the message keeps streaming it
+//      switches between the folded duration line and the full text with its
+//      footer. The MouseRegion click closure is rebuilt from the corrected
+//      map on every render, so each later click hits the same redirect and
+//      the hidden middle state (the global `Thought…` label) never shows.
 //
 // The markdown transformer uses that click signal only to mark a block as
 // user-revealed (add-only), so unflagged re-renders of expanded blocks keep
@@ -167,8 +173,19 @@ interface SmartFoldGlobalState {
    * the tracker's open group (unlike `durationFor`).
    */
   isLiveRun(runText: string): boolean;
+  /**
+   * True when a FINISHED run of a still-streaming message currently renders
+   * expanded (revealed by a click, or matched by the streaming open prefix,
+   * or expand-all/full mode) — mirrors the transformer's `open` condition.
+   */
+  isFinishedRunOpen(runText: string): boolean;
   /** Called when the user collapses a live run back to the scrolling tail. */
   onLiveCollapse?(runText: string): void;
+  /**
+   * Called when the user collapses a finished run of a still-streaming
+   * message back to its folded duration line.
+   */
+  onFinishedCollapse?(runText: string): void;
 }
 
 type SmartFoldGlobal = typeof globalThis & { [SF_STATE]?: SmartFoldGlobalState };
@@ -213,7 +230,7 @@ function installThinkingDisplayPatch(): void {
     }
   ).prototype;
   const original = proto?.updateContent;
-  if (typeof original !== "function") return;
+  if (!proto || typeof original !== "function") return;
   if ("__smartFoldPatched" in original) return; // already installed by a previous load
   try {
     const patched = function (this: unknown, message: unknown, isStreaming?: boolean) {
@@ -229,6 +246,7 @@ function installThinkingDisplayPatch(): void {
         const overrides = self.thinkingVisibilityOverrides;
         if (state && state.behavior !== "inert" && overrides instanceof Map) {
           const previous = self[OVERRIDE_SNAPSHOT];
+          const previousMap = previous === undefined ? undefined : new Map(previous);
           const seeded = new Set<number>();
           const finalized =
             (isStreaming === undefined ? self.isStreaming !== true : isStreaming === false);
@@ -244,6 +262,21 @@ function installThinkingDisplayPatch(): void {
                 if (!overrides.has(run)) {
                   overrides.set(run, true);
                   seeded.add(run);
+                } else if (
+                  overrides.get(run) === false &&
+                  previousMap?.get(run) === false && // leftover, not a fresh click
+                  runs[run] !== undefined &&
+                  state.isFinishedRunOpen?.(runs[run]) !== true
+                ) {
+                  // A streaming-era redirect left this run visible but folded
+                  // (the user collapsed it again, or it was never opened).
+                  // Normalize it into the seeded hidden state — the folded
+                  // line and the per-message label read the same, so without
+                  // this the next click would appear to change nothing.
+                  // Marked seeded so the diff below does not mistake the
+                  // normalization for a click.
+                  overrides.set(run, true);
+                  seeded.add(run);
                 }
               }
               self.hiddenThinkingLabel = collapsedLabelText(runs, state);
@@ -263,24 +296,32 @@ function installThinkingDisplayPatch(): void {
             if (changedRun !== null) {
               const runText = thinkingRunText(self.lastMessage ?? message, changedRun);
               const clickedHidden = new Map(current).get(changedRun) === true;
-              if (
-                clickedHidden &&
-                !finalized &&
-                runText !== null &&
-                state.isLiveRun?.(runText) === true // live = no finalized duration yet
-              ) {
-                // Single-click tail ↔ full on the run still being written:
-                // pi just flipped it to the hidden-label state. Redirect —
-                // keep the run visible and switch our own mode instead. The
-                // click closure is rebuilt from the corrected map, so every
-                // later click lands here again: no hidden middle state.
-                const openPrefix = openStreamingPrefix();
-                if (openPrefix !== null && runText.startsWith(openPrefix)) {
-                  state.onLiveCollapse?.(runText); // drop any stale reveal mark
-                  setStreamingOpenPrefix(null); // full → scrolling tail
+              if (clickedHidden && !finalized && runText !== null) {
+                // A click on a thinking run of a still-streaming message just
+                // flipped it to pi's hidden-label state — which would show the
+                // global `Thought…` label (per-message labels are only set
+                // once finalized). Redirect: keep the run visible and toggle
+                // our own mode instead. The click closure is rebuilt from the
+                // corrected map, so every later click lands here again — one
+                // click per state change, no hidden middle state.
+                if (state.isLiveRun?.(runText) === true) {
+                  // Run still being written: scrolling tail ↔ full text so
+                  // far, timing line pinned at the bottom of the full view.
+                  const openPrefix = openStreamingPrefix();
+                  if (openPrefix !== null && runText.startsWith(openPrefix)) {
+                    state.onLiveCollapse?.(runText); // drop any stale reveal mark
+                    setStreamingOpenPrefix(null); // full → scrolling tail
+                  } else {
+                    recordRevealClick(runText); // tail → full text so far
+                    setStreamingOpenPrefix(runText);
+                  }
+                } else if (state.isFinishedRunOpen?.(runText) === true) {
+                  // Run already finished while the message keeps streaming:
+                  // full text → folded duration line.
+                  state.onFinishedCollapse?.(runText);
                 } else {
-                  recordRevealClick(runText); // tail → full text so far
-                  setStreamingOpenPrefix(runText);
+                  // Finished run, currently folded: → full text + footer.
+                  recordRevealClick(runText);
                 }
                 overrides.set(changedRun, false);
                 current = Array.from(overrides.entries());
@@ -391,6 +432,16 @@ function clearOpenStreamingPrefix(): void {
   (globalThis as ClickGlobal)[CLICK_OPEN_PREFIX] = null;
 }
 
+/**
+ * Forget the last recorded click so a re-render inside the click window
+ * cannot re-reveal a block the user just collapsed.
+ */
+function clearRevealClick(): void {
+  const clickGlobal = globalThis as ClickGlobal;
+  clickGlobal[CLICK_AT] = undefined;
+  clickGlobal[CLICK_HASH] = undefined;
+}
+
 /** How long after a click its re-render is expected (generous for slow frames). */
 const CLICK_WINDOW_MS = 250;
 
@@ -502,8 +553,23 @@ export default function smartFold(pi: ExtensionAPI): void {
       durationFor: (runText: string) =>
         tracker.finalizedMs(hashText(runText)) ?? tracker.finalizeIfMatches(runText),
       isLiveRun: (runText: string) => tracker.finalizedMs(hashText(runText)) === undefined,
+      isFinishedRunOpen: (runText: string) => {
+        if (revealedBlocks.has(hashText(runText))) return true;
+        const prefix = openStreamingPrefix();
+        if (prefix !== null && runText.startsWith(prefix)) return true;
+        return config.thinking === "full" || expandAllThinking;
+      },
       onLiveCollapse: (runText: string) => {
         revealedBlocks.delete(hashText(runText));
+        clearRevealClick();
+      },
+      onFinishedCollapse: (runText: string) => {
+        revealedBlocks.delete(hashText(runText));
+        const prefix = openStreamingPrefix();
+        if (prefix !== null && runText.startsWith(prefix)) {
+          setStreamingOpenPrefix(null); // that prefix was this run's text
+        }
+        clearRevealClick();
       },
     };
   };
@@ -596,7 +662,11 @@ export default function smartFold(pi: ExtensionAPI): void {
           mode === "full" ||
           expandAllThinking;
         if (open) {
-          return markdown.replace(/\s+$/, "") + expandedThinkingSuffix(ms);
+          // Close any unclosed code fence so the footer renders below the
+          // code block, not inside it as literal `**` characters.
+          return (
+            closeOpenFences(markdown.replace(/\s+$/, "")) + expandedThinkingSuffix(ms)
+          );
         }
         return foldedThinkingLine(markdown, ms, width, mode === "tail" ? "tail" : "smart");
       }
@@ -605,14 +675,20 @@ export default function smartFold(pi: ExtensionAPI): void {
       // run), with the ticking `Thinking… (Ns)` line pinned at the bottom.
       const openPrefix = openStreamingPrefix();
       if (openPrefix !== null && markdown.startsWith(openPrefix)) {
-        return markdown.replace(/\s+$/, "") + liveExpandedSuffix(tracker.liveElapsedMs());
+        // Close any unclosed code fence so the ticking footer stays outside
+        // the code block (otherwise it shows literal `**` asterisks).
+        return (
+          closeOpenFences(markdown.replace(/\s+$/, "")) +
+          liveExpandedSuffix(tracker.liveElapsedMs())
+        );
       }
       return liveThinkingLine(markdown, tracker.liveElapsedMs(), width);
     }
 
     if (mode === "full" || expandAllThinking || revealedBlocks.has(key)) {
-      // Fully expanded: original text, with the duration footer at the bottom.
-      return markdown.replace(/\s+$/, "") + expandedThinkingSuffix(ms);
+      // Fully expanded: original text, with the duration footer at the bottom
+      // (after closing any unclosed code fence so it renders as bold text).
+      return closeOpenFences(markdown.replace(/\s+$/, "")) + expandedThinkingSuffix(ms);
     }
     return foldedThinkingLine(markdown, ms, width, mode);
   });

package/lib/fold.ts

@@ -105,6 +105,28 @@ export function lastNonEmptyLine(markdown: string): string {
   return "";
 }
 
+/** A markdown code-fence line: up to 3 spaces indent, then ``` or ~~~. */
+const FENCE_LINE = /^\s{0,3}(?:`{3,}|~{3,})/;
+
+/**
+ * Last line of a markdown string worth showing as a one-line tail: blank
+ * lines and structural code-fence lines are skipped, and lines that strip
+ * down to nothing (bare block markers) are skipped too. Returns "" when
+ * there is no such line — e.g. while the model is right at a code fence
+ * being streamed.
+ */
+export function lastMeaningfulLine(markdown: string): string {
+  const lines = markdown.split(/\r?\n/);
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const raw = lines[i];
+    if (raw.trim() === "") continue;
+    if (FENCE_LINE.test(raw)) continue; // opening/closing fence — structural
+    const stripped = stripBlockMarkers(raw);
+    if (stripped !== "") return stripped;
+  }
+  return "";
+}
+
 /**
  * Strip common block-level markdown markers (`#`, `>`, `-`, `*`, `1.`)
  * so the collapsed line reads like prose. Runs a few passes for nesting
@@ -128,12 +150,13 @@ export function stripBlockMarkers(raw: string): string {
 
 /**
  * Collapse a thinking markdown block into a single line:
- * take its last non-empty line, strip block markers, and tail-truncate
+ * take its last meaningful line, strip block markers, and tail-truncate
  * to `availableWidth` display columns. Falls back to the original
  * markdown when there is nothing to show.
  */
 export function collapseThinking(markdown: string, availableWidth: number): string {
-  const line = stripBlockMarkers(lastNonEmptyLine(markdown));
+  if (lastNonEmptyLine(markdown) === "") return markdown; // nothing visible
+  const line = lastMeaningfulLine(markdown);
   if (!line) return markdown;
   return tailFit(line, sanitizeWidth(availableWidth));
 }
@@ -256,19 +279,22 @@ export function countLineDiff(
  * (supports the legacy single oldText/newText shape). Returns undefined when
  * there is nothing renderable.
  */
-export function countEditsLineDiff(
-  input: { edits?: unknown; oldText?: unknown; newText?: unknown } | undefined,
-): LineDiffStat | undefined {
+export function countEditsLineDiff(input: unknown): LineDiffStat | undefined {
   if (!input || typeof input !== "object") return undefined;
-  const edits = Array.isArray(input.edits)
-    ? input.edits
-    : typeof input.oldText === "string" && typeof input.newText === "string"
-      ? [{ oldText: input.oldText, newText: input.newText }]
+  const { edits, oldText, newText } = input as {
+    edits?: unknown;
+    oldText?: unknown;
+    newText?: unknown;
+  };
+  const editList = Array.isArray(edits)
+    ? edits
+    : typeof oldText === "string" && typeof newText === "string"
+      ? [{ oldText, newText }]
       : [];
   let added = 0;
   let removed = 0;
   let seen = false;
-  for (const edit of edits as Array<{ oldText?: unknown; newText?: unknown }>) {
+  for (const edit of editList as Array<{ oldText?: unknown; newText?: unknown }>) {
     if (!edit || typeof edit !== "object") continue;
     const oldText = typeof edit.oldText === "string" ? edit.oldText : undefined;
     const newText = typeof edit.newText === "string" ? edit.newText : undefined;
@@ -298,8 +324,16 @@ export function liveThinkingLine(
   elapsedMs: number | undefined,
   width: number,
 ): string {
-  const tail = stripBlockMarkers(lastNonEmptyLine(markdown));
-  if (!tail) return markdown;
+  if (lastNonEmptyLine(markdown) === "") return markdown; // nothing visible
+  const tail = lastMeaningfulLine(markdown);
+  if (!tail) {
+    // Only structural lines so far (e.g. a bare code fence being streamed):
+    // show the label alone — falling back to the full text would flash the
+    // whole block open for a frame (the fold "flicker").
+    return elapsedMs === undefined
+      ? ""
+      : `**Thinking… (${formatDuration(elapsedMs, "live")})**`;
+  }
   const fitted = tailFit(tail, sanitizeWidth(width));
   if (elapsedMs === undefined) return fitted;
   return `**Thinking… (${formatDuration(elapsedMs, "live")})**\n\n${fitted}`;
@@ -318,8 +352,15 @@ export function foldedThinkingLine(
 ): string {
   const w = sanitizeWidth(width);
   if (style === "tail") {
-    const tail = stripBlockMarkers(lastNonEmptyLine(markdown));
-    if (!tail) return markdown;
+    if (lastNonEmptyLine(markdown) === "") return markdown; // nothing visible
+    const tail = lastMeaningfulLine(markdown);
+    if (!tail) {
+      // Nothing textual (e.g. thinking ends right at a code fence): the
+      // duration line alone — never fall back to the full markdown.
+      return ms === undefined
+        ? "**Thought…**"
+        : `**Thought for ${formatDuration(ms, "final")}**`;
+    }
     const prefix = ms === undefined ? "" : `**${formatDuration(ms, "final")}** · `;
     return tailFit(prefix + tail, w);
   }
@@ -347,3 +388,28 @@ export function expandedThinkingSuffix(ms: number | undefined): string {
   return ms === undefined ? "" : `\n\n**Thought for ${formatDuration(ms, "final")}**`;
 }
 
+/**
+ * Close a trailing unclosed fenced code block (``` or ~~~) so text appended
+ * after `markdown` — e.g. the expanded-view footer — renders BELOW the code
+ * block instead of inside it as literal characters (visible `**` asterisks).
+ * A closing fence must match the opening fence's character, be at least as
+ * long, and carry no info string. Balanced input passes through unchanged.
+ */
+export function closeOpenFences(markdown: string): string {
+  let fence: string | null = null;
+  for (const line of markdown.split(/\r?\n/)) {
+    const match = /^\s{0,3}(`{3,}|~{3,})(.*)$/.exec(line);
+    if (!match) continue;
+    if (fence === null) {
+      fence = match[1];
+    } else if (
+      match[1][0] === fence[0] &&
+      match[1].length >= fence.length &&
+      match[2].trim() === ""
+    ) {
+      fence = null;
+    }
+  }
+  return fence === null ? markdown : `${markdown}\n${fence}`;
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clapecho233/pi-smart-fold",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "pi coding-agent extension: collapse tool output at startup and fold thinking blocks to a live last line",
   "type": "module",
   "license": "MIT",
@@ -16,10 +16,18 @@
     ]
   },
   "scripts": {
+    "postinstall": "node scripts/link-pi.mjs",
+    "link:pi": "node scripts/link-pi.mjs --required",
+    "typecheck": "tsc -p tsconfig.json",
+    "check": "node scripts/link-pi.mjs && tsc -p tsconfig.json && node scripts/load-check.mjs && node test/fold.test.mjs && node test/click-sim.mjs",
     "test": "node test/fold.test.mjs",
     "test:sim": "node test/click-sim.mjs"
   },
   "engines": {
     "node": ">=22.18"
+  },
+  "devDependencies": {
+    "@types/node": "^24.13.6",
+    "typescript": "5.9"
   }
 }

package/scripts/link-pi.mjs

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+/**
+ * Link the locally installed pi runtime into this project's node_modules so
+ * the extension typechecks and imports against the exact pi version that is
+ * installed on this machine (the same runtime that loads the extension).
+ *
+ * Creates:
+ *   node_modules/@earendil-works/pi-coding-agent -> <pi>/libexec/lib/node_modules/@earendil-works/pi-coding-agent
+ *   node_modules/@earendil-works/pi-tui          -> <pi>/.../pi-coding-agent/node_modules/@earendil-works/pi-tui
+ *
+ * Re-run after every pi upgrade (also wired up as the npm `postinstall` and
+ * `link:pi` scripts; pass --required to fail hard when pi is not found).
+ */
+import { execFileSync } from "node:child_process";
+import { mkdirSync, readlinkSync, rmSync, symlinkSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const projectRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+/** Resolve the pi installation root from the `pi` launcher on PATH. */
+function piRoot() {
+  for (const finder of [
+    () => process.env.PI_BIN,
+    () => execFileSync("which", ["pi"], { encoding: "utf8" }).trim(),
+  ]) {
+    try {
+      const bin = finder();
+      if (!bin) continue;
+      // /opt/homebrew/bin/pi -> ../Cellar/pi-coding-agent/<ver>/bin/pi
+      const real = execFileSync("realpath", [bin], { encoding: "utf8" }).trim();
+      return dirname(dirname(real)); // .../pi-coding-agent/<ver>
+    } catch {
+      // try next strategy
+    }
+  }
+  return undefined;
+}
+
+const root = piRoot();
+if (!root) {
+  const message = "link-pi: could not locate the pi installation (is `pi` on PATH?)";
+  if (process.argv.includes("--required")) {
+    console.error(message);
+    process.exit(1);
+  }
+  console.warn(`${message} — skipping (dev typecheck will not work until linked)`);
+  process.exit(0);
+}
+
+const agentPkg = resolve(root, "libexec/lib/node_modules/@earendil-works/pi-coding-agent");
+const tuiPkg = resolve(agentPkg, "node_modules/@earendil-works/pi-tui");
+
+const links = [
+  ["@earendil-works/pi-coding-agent", agentPkg],
+  ["@earendil-works/pi-tui", tuiPkg],
+];
+
+for (const [name, target] of links) {
+  const linkPath = resolve(projectRoot, "node_modules", name);
+  try {
+    const existing = readlinkSync(linkPath);
+    if (existing === target) {
+      console.log(`link-pi: ${name} already -> ${target}`);
+      continue;
+    }
+    rmSync(linkPath, { force: true, recursive: true });
+  } catch {
+    // no existing link (or a real directory — leave real dirs alone unless
+    // they are dangling symlinks, handled by rmSync above)
+  }
+  mkdirSync(dirname(linkPath), { recursive: true });
+  symlinkSync(target, linkPath);
+  console.log(`link-pi: linked ${name} -> ${target}`);
+}

package/scripts/load-check.mjs

@@ -0,0 +1,44 @@
+/**
+ * Load-test the extension against the installed pi runtime (jiti), the same
+ * loader pi uses for filesystem extensions. Exercises the default export
+ * with a stub ExtensionAPI and reports what got registered.
+ */
+import { createRequire } from "node:module";
+import { resolve } from "node:path";
+
+const root = resolve(import.meta.dirname, "..");
+// Resolve jiti from the linked pi package (extensions run inside pi's module
+// root, so this mirrors the real resolution environment).
+const require2 = createRequire(
+  resolve(root, "node_modules/@earendil-works/pi-coding-agent/package.json"),
+);
+const jitiPath = require2.resolve("jiti");
+const { createJiti } = await import(
+  jitiPath.startsWith("/") ? `file://${jitiPath}` : jitiPath,
+);
+const jiti = createJiti(import.meta.url);
+const mod = await jiti.import(resolve(root, "index.ts"), { default: true });
+
+console.log("default export:", typeof mod);
+if (typeof mod !== "function") process.exit(1);
+
+const registered = { transformers: 0, tools: [], commands: [], handlers: [] };
+const stub = {
+  registerMarkdownTransformer: () => registered.transformers++,
+  registerTool: (t) => registered.tools.push(t?.name),
+  registerCommand: (n) => registered.commands.push(n),
+  on: (e) => registered.handlers.push(e),
+  appendEntry: () => {},
+};
+mod(stub);
+console.log(
+  "transformers:", registered.transformers,
+  "| tools:", registered.tools.join(","),
+  "| commands:", registered.commands.join(","),
+  "| handlers:", registered.handlers.join(","),
+);
+if (registered.transformers !== 1 || registered.tools.length !== 7 || registered.commands[0] !== "fold") {
+  console.error("registration shape unexpected");
+  process.exit(1);
+}
+console.log("OK");

package/test/click-sim.mjs

@@ -7,7 +7,9 @@
  *   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.
+ *               appears. Same one-click toggle for a run that already
+ *               finished while the message keeps streaming (folded duration
+ *               line ↔ full text with footer).
  *   finalized:  seeded hidden `Thought for …` label →(click)→ full+footer
  *               →(click)→ label …
  *
@@ -205,20 +207,208 @@ 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);
+// clicking the finished run while the message still streams: ONE click
+// expands it directly — the global `Thought…` hidden-label middle state
+// must never appear (this was the reported bug)
+compB.thinkingVisibilityOverrides.set(0, true); // pi click handler for run 0
 compB.updateContent(compB.lastMessage);
-assert.equal(compB.thinkingVisibilityOverrides.get(0), true, "finished run toggles natively");
+assert.equal(compB.thinkingVisibilityOverrides.get(0), false, "finished-run click redirected to visible");
+assert.match(
+  render("first run", true),
+  /^first run\n\n\*\*Thought for /,
+  "one click expands the finished run with the footer",
+);
 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);
+// clicking it again folds the finished run back to the duration line
+compB.thinkingVisibilityOverrides.set(0, true);
 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");
+assert.equal(compB.thinkingVisibilityOverrides.get(0), false, "still visible after collapse");
+assert.match(
+  render("first run", true),
+  /^\*\*Thought for /,
+  "second click re-folds the finished run (no label middle state)",
+);
+assert.match(
+  render("second run", true),
+  /^second run\n\n\*\*Thinking… /,
+  "live run still expanded",
+);
+
+// third click expands again — a clean two-state toggle
+compB.thinkingVisibilityOverrides.set(0, true);
+compB.updateContent(compB.lastMessage);
+assert.match(
+  render("first run", true),
+  /^first run\n\n\*\*Thought for /,
+  "third click expands again",
+);
 
 console.log("✓ scenario B: finished-run clicks leave the live run's toggle intact");
+
+// ---- scenario C: the reported regression — single run finished, answer
+// text still streaming. `Thought for …` → click → full text, click → folded
+// again. Never the global `Thought…` label. --------------------------------
+const fireC = fire; // same handlers
+const msgC = (thinking, text) => ({
+  content: [
+    { type: "thinking", thinking },
+    { type: "text", text },
+  ],
+  stopReason: undefined,
+});
+const thinkOnly = (t) => ({ content: [{ type: "thinking", thinking: t }], stopReason: undefined });
+await fireC("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_start", contentIndex: 0, partial: thinkOnly("") },
+});
+await fireC("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: {
+    type: "thinking_delta",
+    contentIndex: 0,
+    delta: "plan the answer",
+    partial: thinkOnly("plan the answer"),
+  },
+});
+await fireC("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_end", contentIndex: 0, partial: thinkOnly("plan the answer") },
+});
+// the following text block closes the thinking run: it now has a finalized
+// duration while the message itself is still streaming
+await fireC("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: {
+    type: "text_start",
+    contentIndex: 1,
+    partial: msgC("plan the answer", ""),
+  },
+});
+
+const compC = new AssistantMessageComponent();
+compC.updateContent(msgC("plan the answer", "answering…"), true);
+assert.match(
+  render("plan the answer", true),
+  /^\*\*Thought for /,
+  "finished run folds while the answer still streams",
+);
+
+// click 1 → full text + footer (NOT the global `Thought…` label)
+compC.thinkingVisibilityOverrides.set(0, true);
+compC.updateContent(compC.lastMessage);
+assert.equal(compC.thinkingVisibilityOverrides.get(0), false, "click redirected to visible");
+assert.match(
+  render("plan the answer", true),
+  /^plan the answer\n\n\*\*Thought for /,
+  "one click expands to full text with the footer",
+);
+
+// click 2 → folded duration line again
+compC.thinkingVisibilityOverrides.set(0, true);
+compC.updateContent(compC.lastMessage);
+assert.equal(compC.thinkingVisibilityOverrides.get(0), false, "still visible after collapse");
+assert.match(
+  render("plan the answer", true),
+  /^\*\*Thought for /,
+  "second click re-folds to the duration line",
+);
+
+// message ends: the run left folded normalizes into the seeded hidden state
+// (label with duration) so the next click expands directly
+await fireC("message_end", {
+  message: { role: "assistant", ...msgC("plan the answer", "answering…"), stopReason: "stop" },
+});
+compC.updateContent(compC.lastMessage, false);
+assert.equal(compC.thinkingVisibilityOverrides.get(0), true, "collapsed run normalized to seeded hidden");
+assert.match(compC.hiddenThinkingLabel, /Thought for /, "label carries the duration");
+compC.thinkingVisibilityOverrides.set(0, false);
+compC.updateContent(compC.lastMessage);
+assert.match(
+  render("plan the answer", false),
+  /^plan the answer\n\n\*\*Thought for /,
+  "click after finalize expands in one step",
+);
+
+console.log("✓ scenario C: finished run in a streaming message toggles with one click");
+
+// ---- scenario D: code blocks inside thinking -------------------------------
+// Collapsed: when the last non-empty line is a bare code fence, the fold must
+// NOT fall back to the full markdown (that flash-open was the flicker).
+// Expanded: the footer must render OUTSIDE an unclosed fence — bold text, not
+// literal `**` asterisks (verified through pi's real Markdown renderer).
+import { Markdown } from "@earendil-works/pi-tui";
+import { getMarkdownTheme } from "@earendil-works/pi-coding-agent";
+
+const fireD = fire; // same handlers
+const md = (t) => ({ content: [{ type: "thinking", thinking: t }], stopReason: undefined });
+const streamD = (delta, partial) =>
+  fireD("message_update", {
+    message: { role: "assistant" },
+    assistantMessageEvent: { type: "thinking_delta", contentIndex: 0, delta, partial: md(partial) },
+  });
+
+// stream up to the opening fence: last non-empty line is the bare-ish fence
+await fireD("message_update", {
+  message: { role: "assistant" },
+  assistantMessageEvent: { type: "thinking_start", contentIndex: 0, partial: md("") },
+});
+await streamD("consider the snippet\n```ts", "consider the snippet\n```ts");
+const compD = new AssistantMessageComponent();
+compD.updateContent(md("consider the snippet\n```ts"), true);
+assert.match(
+  render("consider the snippet\n```ts", true),
+  /^\*\*Thinking… \(\d+s\)\*\*\n\nconsider the snippet$/,
+  "bare fence as last line does not unfold the tail view",
+);
+
+// code content streams in: it becomes the tail line
+await streamD("\nconst x = 1;", "consider the snippet\n```ts\nconst x = 1;");
+compD.updateContent(md("consider the snippet\n```ts\nconst x = 1;"), true);
+assert.match(
+  render("consider the snippet\n```ts\nconst x = 1;", true),
+  /^\*\*Thinking… \(\d+s\)\*\*\n\nconst x = 1;$/,
+  "code content line shows as the tail",
+);
+
+// expand while the fence is still unclosed → fence closed, footer outside it
+click(compD, 0);
+const expandedD = render("consider the snippet\n```ts\nconst x = 1;", true);
+assert.match(
+  expandedD,
+  /```ts\nconst x = 1;\n```\n\n\*\*Thinking… \(\d+s\)\*\*$/,
+  "unclosed fence gets closed and the footer lands below it",
+);
+
+// render through pi's REAL Markdown component: the footer line must be bold
+// "Thinking… (Ns)" — no literal asterisks from being swallowed by the fence
+const stripAnsi = (s) => s.replace(/\u001b\[[0-9;?]*[A-Za-z]/g, "");
+const renderedD = new Markdown(expandedD, 1, 0, getMarkdownTheme()).render(80).map(stripAnsi);
+const lastLineD = [...renderedD].reverse().find((l) => l.trim() !== "");
+assert.match(lastLineD.trim(), /^Thinking… \(\d+s\)$/, "footer renders bold without literal asterisks");
+assert.equal(
+  renderedD.some((l) => l.includes("**Thinking")),
+  false,
+  "no raw ** markers leak into the render",
+);
+assert.equal(
+  renderedD.some((l) => l.includes("const x = 1;")),
+  true,
+  "code content still rendered",
+);
+
+// and the pre-fix behavior really did swallow the footer: sanity-check that
+// an unclosed fence without our close would show literal asterisks
+const unclosedView = "consider the snippet\n```ts\nconst x = 1;\n\n**Thinking… (8s)**";
+const renderedU = new Markdown(unclosedView, 1, 0, getMarkdownTheme()).render(80).map(stripAnsi);
+assert.equal(
+  renderedU.some((l) => l.includes("**Thinking…")),
+  true,
+  "sanity: unclosed fence would have swallowed the footer (regression guard)",
+);
+
+console.log("✓ scenario D: code blocks — no fold flicker, footer renders outside the fence");

package/test/fold.test.mjs

@@ -12,8 +12,10 @@ import {
   displayWidth,
   tailFit,
   lastNonEmptyLine,
+  lastMeaningfulLine,
   stripBlockMarkers,
   collapseThinking,
+  closeOpenFences,
   formatDuration,
   hashText,
   countLineDiff,
@@ -100,6 +102,22 @@ check("lastNonEmptyLine: all empty → empty string", () => {
   assert.equal(lastNonEmptyLine("\n \n"), "");
 });
 
+// ---------------------------------------------------- lastMeaningfulLine ----
+check("lastMeaningfulLine: picks last strippable non-empty line", () => {
+  assert.equal(lastMeaningfulLine("first\nsecond\n\n"), "second");
+  assert.equal(lastMeaningfulLine("plan:\n- [ ] do it", ), "[ ] do it");
+});
+check("lastMeaningfulLine: skips bare code fences (no fold flicker)", () => {
+  assert.equal(lastMeaningfulLine("thinking text\n```"), "thinking text");
+  assert.equal(lastMeaningfulLine("```js\ncode()\n```"), "code()");
+  assert.equal(lastMeaningfulLine("~~~\nquoted\n~~~"), "quoted");
+});
+check("lastMeaningfulLine: only structural lines → empty", () => {
+  assert.equal(lastMeaningfulLine("```"), "");
+  assert.equal(lastMeaningfulLine("```js"), "");
+  assert.equal(lastMeaningfulLine("\n \n"), "");
+});
+
 // ---------------------------------------------------- stripBlockMarkers ----
 check("stripBlockMarkers: heading", () => {
   assert.equal(stripBlockMarkers("## Heading"), "Heading");
@@ -269,6 +287,23 @@ check("liveThinkingLine: truncates tail to width", () => {
 check("liveThinkingLine: empty content passes through", () => {
   assert.equal(liveThinkingLine("\n \n", 1_000, 80), "\n \n");
 });
+check("liveThinkingLine: bare fence last → label only, never the full text", () => {
+  // While a code block streams, the last non-empty line is often the bare
+  // fence — the fold must not flash open (the old fallback returned the full
+  // markdown, causing the flicker).
+  assert.equal(
+    liveThinkingLine("thought about code\n```", 8_000, 80),
+    "**Thinking… (8s)**\n\nthought about code",
+  );
+  assert.equal(liveThinkingLine("```", 8_000, 80), "**Thinking… (8s)**");
+  assert.equal(liveThinkingLine("```", undefined, 80), "");
+});
+check("liveThinkingLine: fence with info string is structural", () => {
+  assert.equal(
+    liveThinkingLine("before block\n```python", 3_000, 80),
+    "**Thinking… (3s)**\n\nbefore block",
+  );
+});
 check("foldedThinkingLine: smart shows bold Thought-for line", () => {
   assert.equal(
     foldedThinkingLine("anything at all", 12_340, 80, "smart"),
@@ -284,6 +319,16 @@ check("foldedThinkingLine: tail keeps the tail + bold duration", () => {
     "**12.3s** · last line",
   );
 });
+check("foldedThinkingLine: tail ending at a fence folds to the code line", () => {
+  // Thinking that ends with a code block ends with the closing fence —
+  // the fold must show the last code line, not unfold the whole block.
+  assert.equal(
+    foldedThinkingLine("intro\n```js\ncode()\n```", 12_340, 80, "tail"),
+    "**12.3s** · code()",
+  );
+  assert.equal(foldedThinkingLine("```", 12_340, 80, "tail"), "**Thought for 12.3s**");
+  assert.equal(foldedThinkingLine("```", undefined, 80, "tail"), "**Thought…**");
+});
 check("expandedThinkingSuffix: bold footer or empty", () => {
   assert.equal(expandedThinkingSuffix(61_500), "\n\n**Thought for 1m01s**");
   assert.equal(expandedThinkingSuffix(undefined), "");
@@ -297,6 +342,31 @@ check("liveExpandedSuffix: bold ticking footer at the bottom", () => {
   assert.equal(view.split("\n").at(-1), "**Thinking… (8s)**");
 });
 
+// ---------------------------------------------------------- closeOpenFences ----
+check("closeOpenFences: balanced fences pass through unchanged", () => {
+  assert.equal(closeOpenFences("text\n```js\ncode()\n```"), "text\n```js\ncode()\n```");
+  assert.equal(closeOpenFences("plain thinking"), "plain thinking");
+  assert.equal(closeOpenFences(""), "");
+});
+check("closeOpenFences: unclosed fence gets a matching close", () => {
+  assert.equal(closeOpenFences("text\n```js\ncode("), "text\n```js\ncode(\n```");
+  // longer opening fence needs an equally long close
+  assert.equal(closeOpenFences("````\ncode"), "````\ncode\n````");
+});
+check("closeOpenFences: tilde fences tracked separately", () => {
+  assert.equal(closeOpenFences("~~~\nquoted"), "~~~\nquoted\n~~~");
+  // a ``` line does not close a ~~~ fence (it is content), and vice versa
+  assert.equal(closeOpenFences("~~~\n```\nq"), "~~~\n```\nq\n~~~");
+});
+check("closeOpenFences: closing fence with info string does not close", () => {
+  assert.equal(closeOpenFences("```\ncode\n```js"), "```\ncode\n```js\n```");
+});
+check("closeOpenFences: footer appended after the close renders as bold", () => {
+  const view = closeOpenFences("thinking\n```js\ncode(") + "\n\n**Thinking… (8s)**";
+  assert.equal(view.split("\n").at(-1), "**Thinking… (8s)**");
+  assert.match(view, /```js\ncode\(\n```\n\n\*\*Thinking/);
+});
+
 // ------------------------------------------------------------ config ----
 check("config: defaults when file missing", () => {
   const dir = mkdtempSync(join(tmpdir(), "smart-fold-"));

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2023",
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "strict": true,
+    "noEmit": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": false,
+    "types": ["node"]
+  },
+  "include": ["index.ts", "lib/**/*.ts"]
+}