@runminton/pi-tidy-tools 0.1.3 → 0.2.1

package/README.md

@@ -2,31 +2,46 @@
 
 A tidy tool-rendering extension for [Pi](https://github.com/earendil-works/pi-mono) (the pi-coding-agent TUI). It overrides the rendering of `bash`, `edit` and `write`: compact summaries by default, full official rendering when you need it.
 
+> Display layer only. Tool execution is fully delegated to Pi's official implementations — parameters, behavior and results are untouched; the extension only decides how many rows to draw and in which colors.
+
 [中文版](README.zh-CN.md)
 
 ## Default view
 
-Each tool starts in one of two states:
+All three tools start **Collapsed**:
 
-| Tool | Default | What you see |
+| Tool | Collapsed summary | Expanded |
 |---|---|---|
-| `bash` | **Collapsed** | `$ command`, one output line, and `... (N more lines)` if there is more output |
-| `edit` | **Expanded** | Pi's official renderer: path, block count, live diff preview, native layout |
-| `write` | **Expanded** | Pi's official renderer: path, line count, syntax-highlighted content |
+| `bash` | `$ command` plus one output line, with an inline `... (N more lines)` suffix when truncated | complete output |
+| `edit` | `edit path (N blocks)` + `applied +a -b` | Pi's official renderer: path, block count, live diff preview, native layout |
+| `write` | `write path (N lines)` + `done` | Pi's official renderer: path, line count, syntax-highlighted content |
+
+Collapsed summaries are single-line per slot: one command line plus one output line (the count suffix is inline at the end of the output line).
 
-Collapsed summaries are single-line (bash shows one preview line plus a count row).
+In Pi's fullscreen mode, left-click any tool block to toggle that row between its compact summary and full rendering. Click it again to collapse it. Each tool has only these two states; `bash` and `write` skip Pi's intermediate previews.
+
+## Modes
+
+| Mode | Behavior |
+|---|---|
+| compact (default) | all three tools collapsed |
+| markdown (`/tidy-markdown` toggles) | `edit`/`write` on Markdown files (`.md`, `.mdx`, `.markdown`) expand to full content; everything else stays collapsed |
+
+Switching modes clears shortcut state and row-local click state, then re-renders existing rows. The mode is not persisted across restarts.
 
 ## Shortcuts
 
-| Shortcut | Tool | Toggles between |
+On Mac press `Command+Option+letter` (verified; maps to the registered `Ctrl+Alt+letter`. Other platforms press `Ctrl+Alt+letter`):
+
+| Shortcut (Mac) | Tool | Toggles between |
 |---|---|---|
-| `Ctrl+Alt+B` | `bash` | collapsed summary ↔ **one-key full output** |
-| `Ctrl+Alt+E` | `edit` | official rendering ↔ collapsed summary |
-| `Ctrl+Alt+W` | `write` | official rendering ↔ collapsed summary |
+| `Command+Option+B` | `bash` | collapsed summary ↔ **one-key full output** |
+| `Command+Option+E` | `edit` | official rendering ↔ collapsed summary |
+| `Command+Option+W` | `write` | official rendering ↔ collapsed summary |
 
-A notification shows the current state on each toggle; press again to switch back.
+A shortcut toggles all existing rows of that tool type and clears their prior row-local click state. A notification shows the new state; press again to switch back.
 
-`bash` expands to the **complete output** in one keypress — it skips Pi's built-in 5-line tail preview. `edit` and `write` expand to Pi's **official default rendering**: they delegate to the official renderers, and whether the content itself is further expanded is still controlled by the global `Ctrl+O`, exactly as without this extension. Only `bash` ignores `Ctrl+O` in its expanded state.
+`bash` and `write` expand to the **complete output** in one keypress — they skip Pi's built-in previews (bash's 5-line tail preview, write's 10-line preview). `edit` expands to Pi's **official rendering** (it has no preview state). The global `Ctrl+O` tool expansion does not affect these three tools.
 
 ## Commands
 
@@ -37,6 +52,7 @@ Use these commands when terminal shortcuts conflict or are not delivered:
 | `/tidy-bash` | Toggle `bash` output |
 | `/tidy-edit` | Toggle `edit` output |
 | `/tidy-write` | Toggle `write` output |
+| `/tidy-markdown` | Toggle markdown mode (edit/write expand for Markdown files) |
 
 ## Usage
 
@@ -73,6 +89,26 @@ If a shortcut still does nothing on your machine, check:
 3. **Custom keys.** The bindings are registered in `tidy-tools.ts` via `pi.registerShortcut(...)` — edit the key strings there to rebind. Pi's built-in global expansion (`Ctrl+O`, `app.tools.expand`) is configured separately via `~/.pi/agent/keybindings.json`.
 4. **Inspect the input.** Run `/tidy-key-debug`, then press one target shortcut. Pi shows the received bytes and any rewrite. If no notification appears, the terminal or input method consumed the key before Pi received it.
 
+## Changelog
+
+### 0.2.1
+
+- Added per-block fullscreen clicking for bash/edit/write, toggling between compact and full rendering
+- Kept tool-wide shortcuts; a shortcut applies one state to all rows of that tool type
+
+### 0.2.0
+
+- All three tools collapsed by default (edit/write used to expand)
+- New `/tidy-markdown`: edit/write on Markdown files auto-expand to full content, the rest stays collapsed; switching modes clears manual toggles
+- Write expansion skips the official 10-line preview and shows full content; global `Ctrl+O` no longer affects any of the three tools
+- Bash collapsed output is 2 rows with the count suffix inline, including error output
+- Fixed tab-width overflow wrapping collapsed bash output on narrow terminals; fixed doubled edit padding from a nested render shell
+
+### 0.1.3
+
+- New `/tidy-bash`, `/tidy-edit`, `/tidy-write`, `/tidy-key-debug` commands
+- Normalized the legacy `ESC` + control-character shortcut form
+
 ## Development
 
 ```bash

package/README.zh-CN.md

@@ -2,31 +2,46 @@
 
 为 [Pi](https://github.com/earendil-works/pi-mono)（pi-coding-agent 的 TUI）打造的工具渲染精简扩展。它覆盖了 `bash`、`edit`、`write` 的渲染：默认呈现紧凑摘要，需要时切换为官方完整渲染。
 
+> 只动显示层，不动执行层。三个工具的执行完全委托 Pi 官方实现，参数、行为、结果一字不差；插件只决定屏幕上画几行、用什么颜色。
+
 [English](README.md)
 
 ## 默认视图
 
-每个工具启动时处于两种状态之一：
+三个工具默认**全部折叠**：
 
-| 工具 | 默认状态 | 显示内容 |
+| 工具 | 折叠摘要 | 展开 |
 |---|---|---|
-| `bash` | **折叠** | `$ command`、一行输出预览、有更多输出时加 `... (N more lines)` 计数行 |
-| `edit` | **展开** | Pi 官方渲染：路径、修改块数、实时 diff 预览、原生布局 |
-| `write` | **展开** | Pi 官方渲染：路径、行数、语法高亮内容 |
+| `bash` | `$ command` 加一行输出预览，计数后缀 `... (N more lines)` 内联在行尾 | 完整输出 |
+| `edit` | `edit 路径（N blocks）` + `applied +a -b` | Pi 官方渲染：路径、修改块数、实时 diff 预览、原生布局 |
+| `write` | `write 路径（N lines）` + `done` | Pi 官方渲染：路径、行数、语法高亮内容 |
+
+折叠摘要每槽单行：命令 1 行加输出 1 行（计数后缀内联在输出行尾）。
 
-折叠摘要为单行样式（bash 额外保留一行输出预览 + 一行计数）。
+在 Pi 的 fullscreen 模式下，左键点击任意一个工具块，可单独在紧凑摘要和完整渲染之间切换。再次点击即收起。三个工具都只有这两种状态；`bash` 和 `write` 不经过官方中间预览。
+
+## 模式
+
+| 模式 | 行为 |
+|---|---|
+| compact（默认） | 三工具全折叠 |
+| markdown（`/tidy-markdown` 切换） | Markdown 文件（`.md`、`.mdx`、`.markdown`）的 `edit`/`write` 展开全文，其余照样折叠 |
+
+切换模式会清空快捷键状态和各工具块的点击状态，并重渲染已有行。模式不持久化，重启后回到 compact。
 
 ## 快捷键
 
-| 快捷键 | 工具 | 切换内容 |
+Mac 上按 `Command+Option+字母`（实测有效，对应插件注册的 `Ctrl+Alt+字母`；其他平台按 `Ctrl+Alt+字母`）：
+
+| 快捷键（Mac） | 工具 | 切换内容 |
 |---|---|---|
-| `Ctrl+Alt+B` | `bash` | 折叠摘要 ↔ **一键完整输出** |
-| `Ctrl+Alt+E` | `edit` | 官方渲染 ↔ 折叠摘要 |
-| `Ctrl+Alt+W` | `write` | 官方渲染 ↔ 折叠摘要 |
+| `Command+Option+B` | `bash` | 折叠摘要 ↔ **一键完整输出** |
+| `Command+Option+E` | `edit` | 官方渲染 ↔ 折叠摘要 |
+| `Command+Option+W` | `write` | 官方渲染 ↔ 折叠摘要 |
 
-每次切换会弹出通知提示当前状态；再按一次切回。
+快捷键按工具类型切换所有已有工具块，并清除该工具之前的逐块点击状态。每次切换会弹出通知；再按一次切回。
 
-`bash` 展开时**一次按键直接显示完整输出**——跳过 Pi 内置的 5 行尾部预览。`edit` 和 `write` 展开时使用 Pi **官方默认渲染**：委托给官方渲染器，内容本身是否进一步展开仍由全局 `Ctrl+O` 控制，与不装本扩展时完全一致。只有 `bash` 在展开状态下不受 `Ctrl+O` 影响。
+`bash` 和 `write` 展开时**一次按键直接显示完整输出**——跳过 Pi 内置预览（bash 的 5 行尾部预览、write 的 10 行预览）。`edit` 展开时使用 Pi **官方渲染**（它没有预览态）。全局 `Ctrl+O` 对这三个工具均无效。
 
 ## 命令
 
@@ -37,6 +52,7 @@
 | `/tidy-bash` | 切换 `bash` 输出 |
 | `/tidy-edit` | 切换 `edit` 输出 |
 | `/tidy-write` | 切换 `write` 输出 |
+| `/tidy-markdown` | 切换 Markdown 模式（Markdown 文件的 edit/write 展开） |
 
 ## 使用方法
 
@@ -73,6 +89,26 @@ Pi 会在终端支持时协商 [Kitty 键盘协议](https://sw.kovidgoyal.net/ki
 3. **自定义按键。** 绑定在 `tidy-tools.ts` 里通过 `pi.registerShortcut(...)` 注册——改那里的按键字符串即可重新绑定。Pi 内置的全局展开（`Ctrl+O`，即 `app.tools.expand`）则单独通过 `~/.pi/agent/keybindings.json` 配置。
 4. **检查输入。** 执行 `/tidy-key-debug`，再按一次目标快捷键。Pi 会显示收到的字节和改写结果。若没有通知，终端或输入法在 Pi 收到按键前已拦截它。
 
+## 更新日志
+
+### 0.2.1
+
+- 支持在 Pi fullscreen 模式下点击单个 bash/edit/write 工具块，在紧凑摘要和完整渲染之间切换
+- 保留工具级快捷键；快捷键会统一设置同类工具块
+
+### 0.2.0 - 2026-09-05
+
+- 默认三工具全折叠（edit/write 原默认展开）
+- 新增 `/tidy-markdown`：Markdown 文件的 edit/write 自动展开全文，其余照样折叠；切模式清空手动钉选
+- write 展开跳过官方 10 行预览，直接全文；全局 `Ctrl+O` 对三工具失效
+- bash 折叠压成 2 行：计数后缀内联到输出行尾，失败输出（红色）同样单行
+- 修 tab 宽度导致的窄终端折行；修 edit 双层外框多出的 padding
+
+### 0.1.3
+
+- 新增 `/tidy-bash`、`/tidy-edit`、`/tidy-write`、`/tidy-key-debug` 命令
+- 修传统 `ESC` + 控制字符形式的快捷键归一化
+
 ## 开发
 
 ```bash

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@runminton/pi-tidy-tools",
-  "version": "0.1.3",
+  "version": "0.2.1",
   "description": "Collapse bash/edit/write into one-line summaries in the pi TUI; expand the official rendering per tool with Ctrl+Alt+B/W/E.",
   "license": "MIT",
   "type": "module",
   "files": [
     "tidy-tools.ts",
     "README.md",
-    "README.zh-CN.md",
-    "CHANGELOG.md"
+    "README.zh-CN.md"
   ],
   "pi": {
     "extensions": [

package/tidy-tools.ts

@@ -4,9 +4,13 @@
  * Overrides the TUI rendering of bash, edit and write while delegating
  * execution to the official implementations:
  * - Collapsed: show a small summary with an ellipsis for long content.
- * - Expanded: Ctrl+Alt+E (edit), Ctrl+Alt+W (write), Ctrl+Alt+B (bash)
- *   toggle each tool between collapsed and fully expanded rendering.
+ * - Expanded: click an individual tool block in fullscreen mode, or use
+ *   Ctrl+Alt+E (edit), Ctrl+Alt+W (write), Ctrl+Alt+B (bash) for all rows
+ *   of that tool, to toggle collapsed and fully expanded rendering.
  * - The global Ctrl+O tool expansion does not affect these three tools.
+ * - Modes: compact (default, all three collapsed) and markdown
+ *   (`/tidy-markdown` toggles; edit/write on Markdown files expand,
+ *   the rest stays collapsed). Not persisted across restarts.
  *
  * Usage:
  *   pi -e ./tidy-tools.ts
@@ -23,6 +27,7 @@ import type { EditToolDetails } from "@earendil-works/pi-coding-agent";
 import {
     Box,
     Container,
+    MouseRegion,
     Text,
     type Component,
     sliceByColumn,
@@ -32,8 +37,8 @@ import {
 
 const MAX_COLLAPSED_COMMAND_LINES = 1;
 const MAX_COLLAPSED_CONTENT_LINES = 3;
-// bash 折叠输出：1 行预览 + 1 行计数提示（共 2 行）。
-const MAX_COLLAPSED_BASH_OUTPUT_LINES = 2;
+// bash 折叠输出：预览与计数后缀合并为 1 行（命令 1 行 + 输出 1 行）。
+const MAX_COLLAPSED_BASH_OUTPUT_LINES = 1;
 
 /**
  * Truncate rendered rows to at most maxLines, keeping the beginning.
@@ -65,6 +70,14 @@ function firstLine(text: string | undefined): string {
     return line.length > 80 ? `${line.slice(0, 77)}...` : line;
 }
 
+// 终端 tab 按 8 的倍数对齐，pi-tui 按 3 列计算。不展开 tab 会导致
+// 行宽估算小于终端实际渲染，窄终端下折成两行。与官方 replaceTabs
+// 保持一致：tab 展开为 3 个空格。
+
+function expandTabs(text: string): string {
+    return text.replace(/\t/g, "   ");
+}
+
 function errorText(result: { content: { type: string; text?: string }[] }): string {
     return result.content
         .filter((c) => c.type === "text")
@@ -119,6 +132,46 @@ class LimitedLinesText implements Component {
     }
 }
 
+class CollapsedBashOutput implements Component {
+    // 首行预览 + 计数后缀合并为 1 行，后缀常显。预览放不下时截断并加省略标记。
+    constructor(
+        private readonly preview: string,
+        private readonly suffix: string,
+        private readonly truncatedMarker: string,
+    ) {}
+
+    render(width: number): string[] {
+        if (!this.suffix) {
+            return truncateRows(
+                wrapTextWithAnsi(this.preview, Math.max(1, width)),
+                MAX_COLLAPSED_BASH_OUTPUT_LINES,
+                this.truncatedMarker,
+                width,
+            );
+        }
+        const suffixWidth = visibleWidth(this.suffix);
+        if (suffixWidth >= width) {
+            return [sliceByColumn(this.suffix, 0, Math.max(1, width), true)];
+        }
+        const previewBudget = width - suffixWidth - 1;
+        if (visibleWidth(this.preview) <= previewBudget) {
+            return [`${this.preview} ${this.suffix}`];
+        }
+        const markerWidth = visibleWidth(this.truncatedMarker);
+        const preview = sliceByColumn(
+            this.preview,
+            0,
+            Math.max(0, previewBudget - markerWidth),
+            true,
+        );
+        const row = `${preview}${this.truncatedMarker} ${this.suffix}`;
+        // 极窄宽度下省略标记本身都放不下时做最终钳制，保证恒为 1 行。
+        return [visibleWidth(row) > width ? sliceByColumn(row, 0, width, true) : row];
+    }
+
+    invalidate(): void {}
+}
+
 class CollapsedToolShell extends Box {
     private callComponent?: Component;
     private resultComponent?: Component;
@@ -160,13 +213,66 @@ function getCollapsedBackground(isPartial: boolean, isError: boolean): string {
     return isError ? "toolErrorBg" : "toolSuccessBg";
 }
 
-// Per-tool expansion state, toggled by Ctrl+Alt+E/W/B. Independent of the
-// global tool-output expansion (Ctrl+O).
-const toolExpanded = new Map<string, boolean>([
-    ["bash", false],
-    ["edit", true],
-    ["write", true],
-]);
+// 显示模式：compact 下三工具默认全折叠；markdown 模式下 edit/write 遇到
+// Markdown 文件默认展开全文，其余照样折叠。默认 compact，不持久化。
+let markdownMode = false;
+// 手动钉选：Ctrl+Alt+? 或 /tidy-<tool> 设置，优先于模式默认；切换模式时清空。
+const manualExpanded = new Map<string, boolean>();
+// Per-tool revisions let a mode or tool-wide toggle replace row-local clicks
+// without disturbing clicked rows belonging to the other tools.
+const expansionRevisions = new Map<string, number>();
+
+function isMarkdownPath(value: unknown): boolean {
+    if (typeof value !== "string") return false;
+    return /\.(md|mdx|markdown)$/i.test(value.trim());
+}
+
+function toolArgsMarkdown(args: any): boolean {
+    return isMarkdownPath(args?.path) || isMarkdownPath(args?.file_path);
+}
+
+// 不带文件上下文的工具级基准（用于翻转手动钉选）：compact 下全 false；
+// markdown 模式下 edit/write 为 true（具体到文件时再按后缀细化）。
+function modeBaseExpanded(name: string): boolean {
+    if (!markdownMode) return false;
+    return name === "edit" || name === "write";
+}
+
+function modeDefaultExpanded(name: string, args: any): boolean {
+    if (!markdownMode) return false;
+    if (name === "edit" || name === "write") return toolArgsMarkdown(args);
+    return false;
+}
+
+interface RowExpansionState {
+    revision: number;
+    override?: boolean;
+}
+
+function getRowExpansionState(name: string, context: any): RowExpansionState {
+    const revision = expansionRevisions.get(name) ?? 0;
+    let state = context.state.tidyExpansion as RowExpansionState | undefined;
+    if (!state || state.revision !== revision) {
+        state = { revision };
+        context.state.tidyExpansion = state;
+    }
+    return state;
+}
+
+function isToolExpanded(name: string, args: any, context: any): boolean {
+    const rowState = getRowExpansionState(name, context);
+    return rowState.override ?? manualExpanded.get(name) ?? modeDefaultExpanded(name, args);
+}
+
+function makeToolClickable(component: Component, name: string, args: any, context: any): Component {
+    return new MouseRegion(component, (event) => {
+        if (event.type !== "click" || event.button !== "left") return undefined;
+        const rowState = getRowExpansionState(name, context);
+        rowState.override = !isToolExpanded(name, args, context);
+        context.invalidate();
+        return { handled: true };
+    });
+}
 
 // Some terminals (Kitty keyboard protocol flag-1 mode) encode Ctrl+letter as
 // a CSI-u sequence using the control character code without a Ctrl modifier
@@ -201,14 +307,19 @@ function convertCtrlAltSequence(data: string): string | undefined {
     return `\x1b[${key.charCodeAt(0)};7${eventSuffix}u`; // 7 = Ctrl|Alt (1-indexed)
 }
 
-function toggleToolExpanded(ctx: ExtensionContext, name: string): void {
-    toolExpanded.set(name, !(toolExpanded.get(name) ?? false));
+function refreshToolRows(ctx: ExtensionContext): void {
     const globalExpanded = ctx.ui.getToolsExpanded();
     // Force every tool row to re-render. The global value is restored
     // immediately, so only the rows' renderers refresh, not the global state.
     ctx.ui.setToolsExpanded(!globalExpanded);
     ctx.ui.setToolsExpanded(globalExpanded);
-    ctx.ui.notify(`${name}: ${toolExpanded.get(name) ? "expanded" : "collapsed"}`, "info");
+}
+
+function toggleToolExpanded(ctx: ExtensionContext, name: string): void {
+    manualExpanded.set(name, !(manualExpanded.get(name) ?? modeBaseExpanded(name)));
+    expansionRevisions.set(name, (expansionRevisions.get(name) ?? 0) + 1);
+    refreshToolRows(ctx);
+    ctx.ui.notify(`${name}: ${manualExpanded.get(name) ? "expanded" : "collapsed"}`, "info");
 }
 
 // Cache the official tool implementation by working directory, as pi may run
@@ -244,6 +355,9 @@ function registerCollapsibleTool(
     getDef: (cwd: string) => ToolDefinition<any, any, any>,
     collapsedCall: (args: any, theme: any) => Component,
     collapsedResult: (result: any, options: any, theme: any, context: any) => Component,
+    // 跳过官方预览态，展开即全文（bash 行为）。为 false 时保留官方默认视图，
+    // 其内部预览 / 全文仍由全局 Ctrl+O 决定。
+    forceFullExpansion = false,
 ) {
     const def = getDef(process.cwd());
     const usesSelfShell = def.renderShell === "self";
@@ -256,8 +370,11 @@ function registerCollapsibleTool(
         parameters: def.parameters,
         prepareArguments: def.prepareArguments,
         constrainedSampling: def.constrainedSampling,
-        // Omit renderShell so Pi inherits each built-in tool's native shell.
-        // In particular, edit uses "self" for its original expanded layout.
+        // Mirror the official renderShell. Omitting it falls back to
+        // "default", which double-wraps "self" tools like edit in an
+        // extra Box: one extra padding line on top and bottom when
+        // expanded, and a Box-in-Box when collapsed.
+        ...(usesSelfShell ? { renderShell: "self" as const } : {}),
 
         async execute(toolCallId, params, signal, onUpdate, ctx) {
             return getDef(ctx.cwd).execute(toolCallId, params, signal, onUpdate, ctx);
@@ -265,15 +382,22 @@ function registerCollapsibleTool(
 
         renderCall(args, theme, context) {
             const def = getDef(context.cwd);
-            if (toolExpanded.get(def.name) && def.renderCall) {
-                return def.renderCall(
+            if (isToolExpanded(def.name, args, context) && def.renderCall) {
+                const component = def.renderCall(
                     args as never,
                     theme as never,
-                    { ...context, lastComponent: undefined } as never,
+                    // One-key full expansion: skip the official preview so
+                    // the per-tool shortcut always shows complete output.
+                    {
+                        ...context,
+                        ...(forceFullExpansion ? { expanded: true } : {}),
+                        lastComponent: undefined,
+                    } as never,
                 );
+                return makeToolClickable(component, def.name, args, context);
             }
             const component = collapsedCall(args, theme);
-            if (!usesSelfShell) return component;
+            if (!usesSelfShell) return makeToolClickable(component, def.name, args, context);
 
             const shell = getCollapsedToolShell(
                 context.state,
@@ -281,21 +405,22 @@ function registerCollapsibleTool(
                 getCollapsedBackground(context.isPartial, context.isError),
             );
             shell.setCall(component);
-            return shell;
+            return makeToolClickable(shell, def.name, args, context);
         },
 
         renderResult(result, options, theme, context) {
             const def = getDef(context.cwd);
-            if (toolExpanded.get(def.name) && def.renderResult) {
-                return def.renderResult(
+            if (isToolExpanded(def.name, context.args, context) && def.renderResult) {
+                const component = def.renderResult(
                     result as never,
-                    options as never,
+                    { ...options, ...(forceFullExpansion ? { expanded: true } : {}) } as never,
                     theme as never,
                     { ...context, lastComponent: undefined } as never,
                 );
+                return makeToolClickable(component, def.name, context.args, context);
             }
             const component = collapsedResult(result, options, theme, context);
-            if (!usesSelfShell) return component;
+            if (!usesSelfShell) return makeToolClickable(component, def.name, context.args, context);
 
             const shell = getCollapsedToolShell(
                 context.state,
@@ -345,36 +470,38 @@ export default function (pi: ExtensionAPI) {
         },
 
         renderCall(args, theme, context) {
-            if (toolExpanded.get("bash")) {
+            if (isToolExpanded("bash", args, context)) {
                 const def = getBashDef(context.cwd);
                 if (def.renderCall) {
-                    return def.renderCall(
+                    const component = def.renderCall(
                         args as never,
                         theme as never,
                         // One-key full expansion for bash: skip the official
                         // preview so Ctrl+Alt+B shows the complete output.
                         { ...context, expanded: true, lastComponent: undefined } as never,
                     );
+                    return makeToolClickable(component, "bash", args, context);
                 }
             }
 
-            const command = args.command || "...";
+            const rawCommand = args.command || "...";
+            const command = typeof rawCommand === "string" ? expandTabs(rawCommand) : "...";
             const timeout = args.timeout as number | undefined;
             const timeoutSuffix = timeout ? theme.fg("muted", ` (timeout ${timeout}s)`) : "";
             const renderedCommand = theme.fg("toolTitle", theme.bold(`$ ${command}`)) + timeoutSuffix;
 
-            return new LimitedLinesText(
+            return makeToolClickable(new LimitedLinesText(
                 renderedCommand,
                 MAX_COLLAPSED_COMMAND_LINES,
                 theme.fg("muted", "..."),
-            );
+            ), "bash", args, context);
         },
 
         renderResult(result, options, theme, context) {
-            if (toolExpanded.get("bash")) {
+            if (isToolExpanded("bash", context.args, context)) {
                 const def = getBashDef(context.cwd);
                 if (def.renderResult) {
-                    return def.renderResult(
+                    const component = def.renderResult(
                         result as never,
                         // One-key full expansion for bash: skip the official
                         // preview so Ctrl+Alt+B shows the complete output.
@@ -382,31 +509,47 @@ export default function (pi: ExtensionAPI) {
                         theme as never,
                         { ...context, lastComponent: undefined } as never,
                     );
+                    return makeToolClickable(component, "bash", context.args, context);
                 }
             }
 
-            const output = errorText(result).trim().replace(/\r/g, "");
+            const clickable = (component: Component) => makeToolClickable(component, "bash", context.args, context);
+            const output = expandTabs(errorText(result).trim().replace(/\r/g, ""));
+            const allLines = output.split("\n");
+            const first = allLines[0] ?? "";
+            const moreSuffix =
+                allLines.length > 1
+                    ? theme.fg("muted", `... (${allLines.length - 1} more lines)`)
+                    : "";
+            // 失败输出同样压成 1 行：红色首行 + 内联计数，与成功态同形。
             if (context.isError) {
-                return new LimitedLinesText(
-                    theme.fg("error", firstLine(output) || "failed"),
-                    MAX_COLLAPSED_CONTENT_LINES,
+                if (!first) {
+                    return clickable(new CollapsedBashOutput(
+                        theme.fg("error", "failed"),
+                        "",
+                        theme.fg("muted", "..."),
+                    ));
+                }
+                return clickable(new CollapsedBashOutput(
+                    theme.fg("error", first),
+                    moreSuffix,
                     theme.fg("muted", "..."),
-                );
+                ));
             }
             // Preview only the first line. Wrapping the full output on every
             // frame is what made the TUI lag with large outputs.
-            const allLines = output.split("\n");
-            const previewLines = allLines.slice(0, 1).map((line) => theme.fg("toolOutput", line));
-            if (allLines.length > 1) {
-                previewLines.push(
-                    theme.fg("muted", `... (${allLines.length - 1} more lines)`),
-                );
+            if (!first) {
+                return clickable(new CollapsedBashOutput(
+                    theme.fg("muted", "(no output)"),
+                    "",
+                    theme.fg("muted", "..."),
+                ));
             }
-            return new LimitedLinesText(
-                previewLines.join("\n") || theme.fg("muted", "(no output)"),
-                MAX_COLLAPSED_BASH_OUTPUT_LINES,
+            return clickable(new CollapsedBashOutput(
+                theme.fg("toolOutput", first),
+                moreSuffix,
                 theme.fg("muted", "..."),
-            );
+            ));
         },
     });
 
@@ -462,6 +605,8 @@ export default function (pi: ExtensionAPI) {
             }
             return new Text(theme.fg("success", "done"), 0, 0);
         },
+        // 展开即全文，跳过官方 10 行预览：三工具统一两档，Ctrl+O 彻底失效。
+        true,
     );
 
     pi.registerCommand("tidy-bash", {
@@ -476,6 +621,18 @@ export default function (pi: ExtensionAPI) {
         description: "Toggle write output expansion",
         handler: async (_args, ctx) => toggleToolExpanded(ctx, "write"),
     });
+    pi.registerCommand("tidy-markdown", {
+        description: "Toggle markdown mode (edit/write expand for Markdown files)",
+        handler: async (_args, ctx) => {
+            markdownMode = !markdownMode;
+            manualExpanded.clear();
+            for (const name of ["bash", "edit", "write"]) {
+                expansionRevisions.set(name, (expansionRevisions.get(name) ?? 0) + 1);
+            }
+            refreshToolRows(ctx);
+            ctx.ui.notify(`markdown mode: ${markdownMode ? "on" : "off"}`, "info");
+        },
+    });
     pi.registerCommand("tidy-key-debug", {
         description: "Show the next raw terminal key sequence",
         handler: async (_args, ctx) => {

package/CHANGELOG.md

@@ -1,16 +0,0 @@
-# Changelog
-
-## [0.1.3] - 2026-08-27
-
-### Added
-
-- Added `/tidy-bash`, `/tidy-edit`, and `/tidy-write` commands for toggling tool output.
-- Added `/tidy-key-debug` to inspect the next terminal key sequence.
-
-### Fixed
-
-- Normalized the legacy `ESC` + control-character form of `Ctrl+Alt+letter` shortcuts.
-
-### Documentation
-
-- Documented the new commands and keyboard input debugging steps.