@runminton/pi-tidy-tools 0.1.2 → 0.2.0

package/README.md

@@ -2,31 +2,55 @@
 
 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).
+
+## 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 |
 
-Collapsed summaries are single-line (bash shows one preview line plus a count row).
+Switching modes clears per-tool manual toggles and 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.
 
-`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
+
+Use these commands when terminal shortcuts conflict or are not delivered:
+
+| Command | Tool |
+|---|---|
+| `/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
 
@@ -61,6 +85,22 @@ If a shortcut still does nothing on your machine, check:
 1. **Terminal or input method swallows the key.** Some terminals and IMEs (e.g. Chinese input methods, Windows Alt-menu accelerators) intercept `Ctrl+Alt+...` before Pi ever sees it. Try a different combination or a different terminal.
 2. **tmux / screen.** If Pi runs inside tmux with the default configuration, tmux's own key handling may interfere.
 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.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
 

package/README.zh-CN.md

@@ -2,31 +2,55 @@
 
 为 [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 行（计数后缀内联在输出行尾）。
+
+## 模式
+
+| 模式 | 行为 |
+|---|---|
+| compact（默认） | 三工具全折叠 |
+| markdown（`/tidy-markdown` 切换） | Markdown 文件（`.md`、`.mdx`、`.markdown`）的 `edit`/`write` 展开全文，其余照样折叠 |
 
-折叠摘要为单行样式（bash 额外保留一行输出预览 + 一行计数）。
+切换模式会清空各工具的手动钉选并重渲染已有行。模式不持久化，重启后回到 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` 对这三个工具均无效。
+
+## 命令
+
+终端快捷键冲突或无法传入 Pi 时，使用这些命令：
+
+| 命令 | 工具 |
+|---|---|
+| `/tidy-bash` | 切换 `bash` 输出 |
+| `/tidy-edit` | 切换 `edit` 输出 |
+| `/tidy-write` | 切换 `write` 输出 |
+| `/tidy-markdown` | 切换 Markdown 模式（Markdown 文件的 edit/write 展开） |
 
 ## 使用方法
 
@@ -61,6 +85,22 @@ Pi 会在终端支持时协商 [Kitty 键盘协议](https://sw.kovidgoyal.net/ki
 1. **终端或输入法吞掉了按键。** 有些终端和输入法（例如中文输入法、Windows 的 Alt 菜单加速键）会在 Pi 收到按键之前把它拦截。换一个组合键或换一个终端试试。
 2. **tmux / screen。** 如果 Pi 运行在 tmux 默认配置里，tmux 自己的按键处理可能干扰。
 3. **自定义按键。** 绑定在 `tidy-tools.ts` 里通过 `pi.registerShortcut(...)` 注册——改那里的按键字符串即可重新绑定。Pi 内置的全局展开（`Ctrl+O`，即 `app.tools.expand`）则单独通过 `~/.pi/agent/keybindings.json` 配置。
+4. **检查输入。** 执行 `/tidy-key-debug`，再按一次目标快捷键。Pi 会显示收到的字节和改写结果。若没有通知，终端或输入法在 Pi 收到按键前已拦截它。
+
+## 更新日志
+
+### 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` + 控制字符形式的快捷键归一化
 
 ## 开发
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runminton/pi-tidy-tools",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "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",

package/tidy-tools.ts

@@ -7,6 +7,9 @@
  * - Expanded: Ctrl+Alt+E (edit), Ctrl+Alt+W (write), Ctrl+Alt+B (bash)
  *   toggle each tool between 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
@@ -32,8 +35,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 +68,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 +130,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 +211,37 @@ 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>();
+
+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;
+}
+
+function isToolExpanded(name: string, args: any): boolean {
+    return manualExpanded.get(name) ?? modeDefaultExpanded(name, args);
+}
 
 // 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
@@ -180,8 +255,17 @@ const CTRL_CODE_TO_KEY: Record<number, string> = {
     2: "b", // Ctrl+B
 };
 const ALT_MODIFIER = 2;
+let debugNextTerminalInput = false;
 
 function convertCtrlAltSequence(data: string): string | undefined {
+    // Legacy terminals send Ctrl+Alt+letter as ESC followed by the Ctrl
+    // character. Pi deliberately ignores this form after Kitty negotiation,
+    // so normalize it before Pi's key matcher sees it.
+    if (data.length === 2 && data[0] === "\x1b") {
+        const key = CTRL_CODE_TO_KEY[data.charCodeAt(1)];
+        if (key) return `\x1b[${key.charCodeAt(0)};7u`; // 7 = Ctrl|Alt (1-indexed)
+    }
+
     const match = data.match(/^\x1b\[(\d+);(\d+)(?::(\d+))?u$/);
     if (!match) return undefined;
     const code = Number(match[1]);
@@ -192,14 +276,18 @@ 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)));
+    refreshToolRows(ctx);
+    ctx.ui.notify(`${name}: ${manualExpanded.get(name) ? "expanded" : "collapsed"}`, "info");
 }
 
 // Cache the official tool implementation by working directory, as pi may run
@@ -235,6 +323,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";
@@ -247,8 +338,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);
@@ -256,11 +350,17 @@ function registerCollapsibleTool(
 
         renderCall(args, theme, context) {
             const def = getDef(context.cwd);
-            if (toolExpanded.get(def.name) && def.renderCall) {
+            if (isToolExpanded(def.name, args) && def.renderCall) {
                 return 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,
                 );
             }
             const component = collapsedCall(args, theme);
@@ -277,10 +377,10 @@ function registerCollapsibleTool(
 
         renderResult(result, options, theme, context) {
             const def = getDef(context.cwd);
-            if (toolExpanded.get(def.name) && def.renderResult) {
+            if (isToolExpanded(def.name, context.args) && def.renderResult) {
                 return def.renderResult(
                     result as never,
-                    options as never,
+                    { ...options, ...(forceFullExpansion ? { expanded: true } : {}) } as never,
                     theme as never,
                     { ...context, lastComponent: undefined } as never,
                 );
@@ -336,7 +436,7 @@ export default function (pi: ExtensionAPI) {
         },
 
         renderCall(args, theme, context) {
-            if (toolExpanded.get("bash")) {
+            if (isToolExpanded("bash", args)) {
                 const def = getBashDef(context.cwd);
                 if (def.renderCall) {
                     return def.renderCall(
@@ -349,7 +449,8 @@ export default function (pi: ExtensionAPI) {
                 }
             }
 
-            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;
@@ -362,7 +463,7 @@ export default function (pi: ExtensionAPI) {
         },
 
         renderResult(result, options, theme, context) {
-            if (toolExpanded.get("bash")) {
+            if (isToolExpanded("bash", context.args)) {
                 const def = getBashDef(context.cwd);
                 if (def.renderResult) {
                     return def.renderResult(
@@ -376,26 +477,40 @@ export default function (pi: ExtensionAPI) {
                 }
             }
 
-            const output = errorText(result).trim().replace(/\r/g, "");
+            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 new CollapsedBashOutput(
+                        theme.fg("error", "failed"),
+                        "",
+                        theme.fg("muted", "..."),
+                    );
+                }
+                return 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 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 new CollapsedBashOutput(
+                theme.fg("toolOutput", first),
+                moreSuffix,
                 theme.fg("muted", "..."),
             );
         },
@@ -453,8 +568,39 @@ export default function (pi: ExtensionAPI) {
             }
             return new Text(theme.fg("success", "done"), 0, 0);
         },
+        // 展开即全文，跳过官方 10 行预览：三工具统一两档，Ctrl+O 彻底失效。
+        true,
     );
 
+    pi.registerCommand("tidy-bash", {
+        description: "Toggle bash output expansion",
+        handler: async (_args, ctx) => toggleToolExpanded(ctx, "bash"),
+    });
+    pi.registerCommand("tidy-edit", {
+        description: "Toggle edit output expansion",
+        handler: async (_args, ctx) => toggleToolExpanded(ctx, "edit"),
+    });
+    pi.registerCommand("tidy-write", {
+        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();
+            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) => {
+            debugNextTerminalInput = true;
+            ctx.ui.notify("Press one key to inspect its terminal sequence.", "info");
+        },
+    });
+
     // --- Per-tool expansion shortcuts, independent of the global Ctrl+O ---
     pi.registerShortcut("ctrl+alt+e", {
         description: "Toggle edit expansion",
@@ -472,8 +618,16 @@ export default function (pi: ExtensionAPI) {
     // Some terminals encode Ctrl+Alt+letter as a control-character CSI-u
     // sequence. Rewrite those three sequences before they reach the editor.
     pi.on("session_start", (_event, ctx) => {
-        ctx.ui.onTerminalInput?.((data) => {
+        ctx.ui.onTerminalInput((data) => {
             const converted = convertCtrlAltSequence(data);
+            if (debugNextTerminalInput) {
+                debugNextTerminalInput = false;
+                const bytes = [...data].map((char) => char.charCodeAt(0)).join(", ");
+                ctx.ui.notify(
+                    `raw: ${JSON.stringify(data)} [${bytes}]${converted ? ` → ${JSON.stringify(converted)}` : ""}`,
+                    "info",
+                );
+            }
             return converted ? { data: converted } : undefined;
         });
     });