pi-minimalist 0.1.2 → 0.2.2

package/README.md

@@ -14,7 +14,11 @@ A quieter transcript for [Pi](https://pi.dev): turn bulky tool calls into one-li
 
 <img width="699" height="50" alt="after" src="https://github.com/user-attachments/assets/c0e8bca4-afa7-42c1-9bf0-69f267d18d9f" />
 
-Press **Ctrl+O** to expand tool output—including diffs and syntax highlighting. Nothing is removed from the session or hidden from the model; only the display changes.
+**Click** a folded line to open it into separate rows. Click one row to see only its output. Click the `▾ Expanded · click to fold` line above an opened run to fold it back.
+
+<img src="docs/click.png" width="600" alt="Clicking a folded line opens it into rows; clicking one row expands only that row">
+
+Press **Ctrl+O** to expand tool output—including diffs and syntax highlighting. Expanded rows also wrap long commands instead of cutting them off. Nothing is removed from the session or hidden from the model; only the display changes.
 
 ## Install
 
@@ -33,7 +37,25 @@ Run **`/minimalist`** to change settings live. Start with compact tool rows, or
 - **Compact thinking rows**, or keep thinking visible as it arrives.
 - **Keep running tools visible** while grouping other calls, with an elapsed timer to show how long they take.
 
-Compact tool rows and consecutive-call grouping are **on by default**. Activity folding and compact thinking are opt-in. Disable grouping if you prefer to see each call separately.
+A fresh install starts on the **`full`** preset (see below): compact tool rows, grouped calls and compact thinking. Activity folding is opt-in. Choose `lite` if you prefer to see each call separately.
+
+### Presets
+
+The **Preset** row at the top of `/minimalist` sets four options at once: **Compact tool rows**, **Combine consecutive tool calls**, **Collapse earlier activity** and **Compact thinking rows**.
+
+| Preset | What you get |
+| --- | --- |
+| `off` | Pi's native tool cards. |
+| `lite` | One-line tool rows, each call on its own line. |
+| `full` | `lite` plus combined consecutive calls and compact thinking rows. |
+| `max` | `full` plus collapsed earlier activity (`Worked for …`). |
+| `custom` | Your own values for those four options. |
+
+<img src="docs/presets.png" width="600" alt="Clicking a folded line opens it into rows; clicking one row expands only that row">
+
+A preset never overwrites your settings. While `off`, `lite`, `full` or `max` is selected, only those four rows are greyed out and show the preset's values; pressing Enter on one does nothing. Every other option (Left border, Elapsed timer, Symbols and so on) stays yours and stays editable. Your own values are kept and come back when you choose `custom`. The first time you choose `custom`, it starts from `lite`.
+
+**Upgrading:** if your settings already contain a `minimalist` block, you stay on `custom` and nothing changes. Only a user with no `minimalist` settings at all starts on `full`, which makes thinking rows compact. To pick another look, change **Preset**.
 
 ### Everyday controls
 
@@ -43,15 +65,14 @@ Compact tool rows and consecutive-call grouping are **on by default**. Activity
 | `/minimalist status` | Show current settings |
 | Ctrl+O | Expand or collapse tool output |
 | Ctrl+T | Expand or collapse thinking |
-| Restore defaults | Reset display settings in the editor |
 
 Settings apply to existing conversation history and are saved globally. If a symbol looks wrong in your terminal, choose **Symbols → ASCII**. No Nerd Font required.
 
 ## Go back to Pi's usual view
 
-Turn off **Compact tool rows** to restore native tool cards. Other folding options are independent; **Restore defaults** returns to the extension's initial settings, not native Pi.
+Turn off **Compact tool rows** to restore native tool cards. Or choose the `off` preset.
 
-To disable the extension completely, run `pi config`, disable pi-minimalist, and restart Pi. To uninstall:
+To disable the extension completely, run `pi config`, disable pi-minimalist, and restart Pi
 
 ## Compatibility
 

package/index.ts

@@ -22,8 +22,8 @@ import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
 // keybindings and colours, as Pi's own `/settings`.
 import { SettingsList } from "@earendil-works/pi-tui";
 import { installBridges, sharedState } from "./src/bridge.ts";
-import { BASIC_KEYS, DEFAULT_BASIC, type BasicKey, type BasicSettings, type Config } from "./src/config.ts";
-import { loadSettings, migratedQuiet, saveBasicSettings } from "./src/config-file.ts";
+import { type BasicKey, type BasicSettings, type Config } from "./src/config.ts";
+import { customSeed, loadSettings, saveBasicSettings } from "./src/config-file.ts";
 import { argumentCompletions, createConfigScreen, summary } from "./src/config-ui.ts";
 import { patchCore } from "./src/core-patch.ts";
 import { refreshMcpTools } from "./src/tools.ts";
@@ -34,15 +34,8 @@ export default function (pi: ExtensionAPI) {
   // strand every row on stale state.
   const { config, grouping } = sharedState(loadSettings());
 
-  // One-time migration of the preference written by the removed `/quiet`
-  // command. A session override, so the per-turn re-read below cannot revert it
-  // before the user has saved anything.
-  const migrated = migratedQuiet();
-  if (migrated !== undefined) config.setSessionOverride("groupToolRuns", migrated);
-
   installBridges({ config, grouping });
-  // Runtime replacement for editing Pi's compiled bundle. Idempotent, so a
-  // /reload only refreshes the bridge slots the wrappers read.
+  // Idempotent, so a /reload only refreshes the Bridge the wrappers read.
   patchCore(core);
 
   const refresh = () => {
@@ -82,7 +75,6 @@ export default function (pi: ExtensionAPI) {
           theme: getSettingsListTheme(),
           config,
           onChange: (key, value) => persist(ctx, config, key, value),
-          onReset: () => persistDefaults(ctx, config),
           onClose: () => done(),
         }),
       );
@@ -92,37 +84,23 @@ export default function (pi: ExtensionAPI) {
 
 type NotifyContext = { ui: { notify(message: string, type?: "info" | "warning" | "error"): void } };
 
-/**
- * Write only the changed key to the global agent settings, and be honest when that is impossible.
- *
- * The live value has already changed, so a silent failure would leave the UI and
- * the file disagreeing. Keeping it as a session override means the per-turn
- * re-read cannot revert what the message says was applied.
- */
-function persistDefaults(ctx: NotifyContext, config: Config): void {
-  const result = saveBasicSettings(DEFAULT_BASIC);
-  for (const key of BASIC_KEYS) {
-    if (result.ok) config.clearSessionOverride(key);
-    else config.setSessionOverride(key, config.get(key));
-  }
-  if (!result.ok) {
-    ctx.ui.notify(`Defaults applied for this session only; settings.json could not be written (${result.reason}).`, "warning");
-  }
-}
-
 function persist(
   ctx: NotifyContext,
   config: Config,
   key: BasicKey,
   value: BasicSettings[BasicKey],
 ): void {
-  const result = saveBasicSettings({ [key]: value });
-  if (result.ok) {
-    // The file now agrees, so it becomes the source of truth again.
-    config.clearSessionOverride(key);
-    return;
+  // The first switch to `custom` starts from the `lite` look (see customSeed).
+  const seed = key === "preset" && value === "custom" ? customSeed() : undefined;
+  const changes: Partial<Record<BasicKey, unknown>> = { ...seed, [key]: value };
+  const result = saveBasicSettings(changes as Partial<BasicSettings>);
+  for (const [k, v] of Object.entries(changes) as [BasicKey, never][]) {
+    config.set(k, v);
+    // On success the file agrees, so it becomes the source of truth again.
+    if (result.ok) config.clearSessionOverride(k);
+    else config.setSessionOverride(k, v);
   }
-  config.setSessionOverride(key, value);
+  if (result.ok) return;
   ctx.ui.notify(
     result.reason === "comments"
       ? `Applied for this session only. settings.json has comments, which JSON.stringify would delete — set "minimalist": { "${key}": ${JSON.stringify(value)} } by hand to persist.`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-minimalist",
-  "version": "0.1.2",
+  "version": "0.2.2",
   "description": "Compact one-line tool and thinking rows for Pi's interactive transcript",
   "keywords": ["pi-package"],
   "license": "MIT",

package/src/bridge.ts

@@ -2,56 +2,72 @@
  * The boundary between this extension and Pi's core components.
  *
  * Nothing on disk is patched. `core-patch.ts` wraps Pi's real component
- * prototypes at load time and READS the process-global slots below at CALL time,
- * so `/reload` swaps behavior without re-wrapping anything, and an unloaded
- * extension degrades to Pi's native rendering.
+ * prototypes at load time and READS ONE process-global object, the `Bridge`
+ * below, at CALL time. Every install replaces that object as a whole, so
+ * `/reload` swaps behavior without re-wrapping anything, and an unloaded
+ * extension (no object) degrades to Pi's native rendering.
  *
- * SINGLE SOURCE OF TRUTH for the symbol names, shared by the wrappers, the state
- * that must survive `/reload`, and the tests.
+ * SINGLE SOURCE OF TRUTH for the global key names, shared by the wrappers, the
+ * state that must survive `/reload`, and the tests.
  */
 
 import { Config } from "./config.ts";
 import { RunGrouping } from "./run-grouping.ts";
-import { Painter, type ThemeLike } from "./row.ts";
-import { createToolRenderer } from "./tool-renderer.ts";
-import { createThinkingPreview, singleHueThinkingTheme } from "./thinking.ts";
+import { Painter, type Row, type ThemeLike } from "./row.ts";
+import { createToolRenderer, type ToolRenderer } from "./tool-renderer.ts";
+import { createThinkingPreview, singleHueThinkingTheme, type ThinkingPreview } from "./thinking.ts";
 import type { Timers } from "./components.ts";
 
 export const BRIDGE_SYMBOLS = {
-  /** `{ renderShell, handles, renderCall, renderResult }` for every tool row. */
-  toolRenderer: "pi.defaultToolRenderer",
-  /** `(text, theme, pad, streaming, owner, runIndex) => Component`. */
-  thinkingPreview: "pi.thinkingPreview",
-  /** `(markdownTheme, theme) => markdownTheme` for expanded thinking. */
-  thinkingMarkdownTheme: "pi.thinkingMarkdownTheme",
-
+  /** The `Bridge` object: everything the prototype wrappers call. */
+  bridge: "pi.minimalist.bridge",
   /** Live settings, retained across a /reload. */
   config: "pi.minimalist.config",
   /** Run-grouping state, retained across a /reload. */
   grouping: "pi.minimalist.grouping",
+} as const;
+
+/**
+ * What the prototype wrappers may call. Functions, not values: the wrappers read
+ * the object on every call, so a settings toggle takes effect without
+ * reinstalling anything.
+ */
+export type Bridge = {
+  /** `{ renderShell, handles, renderCall, renderResult }` for every tool row. */
+  toolRenderer: ToolRenderer;
+  thinkingPreview: ThinkingPreview;
+  /** Expanded thinking: the Markdown theme with every token in the thinking hue. */
+  thinkingMarkdownTheme: (base: Record<string, unknown>, theme: ThemeLike) => Record<string, unknown>;
+  /** `thinkingAsToolCall`: do collapsed/expanded thinking rows belong to us? */
+  compactThinking: () => boolean;
+  /** Keep a STREAMING thinking block expanded. */
+  keepActiveThinkingExpanded: () => boolean;
 
   /** Chronology hooks that keep thinking and prose in transcript order. */
-  observeThinking: "pi.minimalist.observeThinking",
-  observeProse: "pi.minimalist.observeProse",
+  observeThinking: (owner: object, runIndex: number, streaming: boolean, hidden: boolean, timestamp?: number) => string;
+  observeProse: RunGrouping["observeProse"];
+  /** A visible row we do not fold (user message, excluded tool); it cuts runs. */
+  observeBarrier: (id: string) => void;
   /** `undefined` = native prose, `null` = hidden, Row = folded summary. */
-  proseView: "pi.minimalist.proseView",
-  /** `(toolCallId) => boolean`: omit core's separator before an activity summary. */
-  activitySummaryRow: "pi.minimalist.activitySummaryRow",
-  /** `(owner) => normal|hidden|summary`: normalize assistant host spacing. */
-  activityMessageView: "pi.minimalist.activityMessageView",
+  proseView: (id: string, theme: ThemeLike) => Row | null | undefined;
+  /** Header of an opened run, drawn by a prose/native-thinking host. */
+  proseHeader: (id: string, theme: ThemeLike) => Row | undefined;
+  /** A click on a summary or header; true when handled. */
+  click: (id: string, onHeader: boolean) => boolean;
+  /** Omit core's separator before an activity summary. */
+  activitySummaryRow: (id: string) => boolean;
+  /** Normalize assistant host spacing. */
+  activityMessageView: (owner: object) => "normal" | "hidden" | "summary";
   /**
    * Spacer suppression for a fully hidden assistant message.
    *
    * There is deliberately NO tool-row equivalent: a compact row uses
    * `renderShell: "self"`, and core's self-shell branch emits its separator
    * inline and returns ZERO lines when the row renders nothing — spacer
-   * included. An earlier `quietSpacer` bridge was compensating for a problem core
-   * already handles.
+   * included.
    */
-  messageSpacer: "pi.minimalist.messageSpacer",
-  /** `() => boolean`: keep a STREAMING thinking block expanded. */
-  keepActiveThinkingExpanded: "pi.minimalist.keepActiveThinkingExpanded",
-} as const;
+  messageSpacer: (owner: object) => boolean;
+};
 
 type Globals = Record<symbol, unknown>;
 
@@ -59,6 +75,11 @@ function slot(key: keyof typeof BRIDGE_SYMBOLS): symbol {
   return Symbol.for(BRIDGE_SYMBOLS[key]);
 }
 
+/** The installed bridge, or `undefined` when the extension is not loaded. */
+export function readBridge(): Bridge | undefined {
+  return (globalThis as Globals)[slot("bridge")] as Bridge | undefined;
+}
+
 /**
  * State that must survive `/reload`.
  *
@@ -85,40 +106,40 @@ export type InstallOptions = SharedState & {
 };
 
 /**
- * Install every bridge.
+ * Install the bridge.
  *
- * Each `/reload` overwrites these slots with fresh instances. Do NOT clear them
+ * Each `/reload` overwrites the slots with fresh instances. Do NOT clear them
  * from `session_shutdown`: reload ordering can let an old shutdown hook erase the
- * newly installed bridges. Process exit clears globalThis naturally.
+ * newly installed bridge. Process exit clears globalThis naturally.
  */
 export function installBridges({ config, grouping, timers }: InstallOptions): void {
   const globals = globalThis as Globals;
+  const painter = (theme: ThemeLike) => new Painter(theme, config);
 
-  globals[slot("config")] = config;
-  globals[slot("grouping")] = grouping;
-  globals[slot("toolRenderer")] = createToolRenderer({ config, grouping, timers });
-  globals[slot("thinkingPreview")] = createThinkingPreview({ config, grouping, timers });
-  globals[slot("thinkingMarkdownTheme")] = (base: Record<string, unknown>, theme: never) =>
-    singleHueThinkingTheme(base, theme, config);
+  const bridge: Bridge = {
+    toolRenderer: createToolRenderer({ config, grouping, timers }),
+    thinkingPreview: createThinkingPreview({ config, grouping, timers }),
+    thinkingMarkdownTheme: (base, theme) => singleHueThinkingTheme(base, theme, config),
+    compactThinking: () => config.get("thinkingAsToolCall") === true,
+    keepActiveThinkingExpanded: () => config.get("keepActiveThinkingExpanded"),
 
-  // Chronology: core walks message content in transcript order, and run folding
-  // depends on that order.
-  globals[slot("observeThinking")] = (owner: object, runIndex: number, streaming: boolean, hidden: boolean) => {
-    grouping.observeThinking(owner, runIndex, !streaming, !hidden);
-    return grouping.thinkingId(owner, runIndex);
+    // Chronology: core walks message content in transcript order, and run
+    // folding depends on that order.
+    observeThinking: (owner, runIndex, streaming, hidden, timestamp) => {
+      grouping.observeThinking(owner, runIndex, !streaming, !hidden, timestamp);
+      return grouping.thinkingId(owner, runIndex);
+    },
+    observeProse: (owner, contentIndex, signal) => grouping.observeProse(owner, contentIndex, signal),
+    observeBarrier: (id) => grouping.observeBarrier(id),
+    proseView: (id, theme) => grouping.proseView(id, painter(theme)),
+    proseHeader: (id, theme) => grouping.headerFor(id, painter(theme)),
+    click: (id, onHeader) => grouping.click(id, onHeader),
+    activitySummaryRow: (id) => grouping.isActivitySummary(id),
+    activityMessageView: (owner) => grouping.activityMessageView(owner),
+    messageSpacer: (owner) => grouping.showsMessageSpacer(owner),
   };
-  globals[slot("observeProse")] = (
-    owner: object,
-    contentIndex: number,
-    signal: Parameters<RunGrouping["observeProse"]>[2],
-  ) => grouping.observeProse(owner, contentIndex, signal);
-  globals[slot("proseView")] = (id: string, theme: ThemeLike) =>
-    grouping.proseView(id, new Painter(theme, config));
-  globals[slot("activitySummaryRow")] = (id: string) => grouping.isActivitySummary(id);
-  globals[slot("activityMessageView")] = (owner: object) => grouping.activityMessageView(owner);
-  globals[slot("messageSpacer")] = (owner: object) => grouping.showsMessageSpacer(owner);
 
-  // A function, not a value: the prototype wrapper reads it on every call, so a
-  // toggle takes effect without reinstalling anything.
-  globals[slot("keepActiveThinkingExpanded")] = () => config.get("keepActiveThinkingExpanded");
+  globals[slot("config")] = config;
+  globals[slot("grouping")] = grouping;
+  globals[slot("bridge")] = bridge;
 }

package/src/components.ts

@@ -6,7 +6,7 @@
  * production components without loading an extension runtime.
  */
 
-import { truncateToWidth } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import type { Component, TuiMouseEvent, TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { gutterWidth, type Row } from "./row.ts";
 
@@ -40,17 +40,57 @@ export const realTimers: Timers = {
  */
 export type ResolveRow = (width: number) => Row | null;
 
+/** Columns the details must keep on each line before wrapping is worth it. */
+const MIN_WRAP_COLUMNS = 10;
+
+/**
+ * An expanded row's details wrapped under themselves (a hanging indent below
+ * `glyph label`), or undefined when the terminal is too narrow to wrap
+ * usefully: the caller then truncates as usual. A body that fits wraps to a
+ * single line.
+ */
+function wrapped({ head, body }: { head: string; body: string }, room: number): string[] | undefined {
+  const indent = visibleWidth(head) + 1;
+  if (room - indent < MIN_WRAP_COLUMNS) return undefined;
+  const pad = " ".repeat(indent);
+  return wrapTextWithAnsi(body, room - indent).map((line, i) => (i === 0 ? `${head} ` : pad) + line);
+}
+
 /**
- * One physical terminal line with width-aware truncation and full-width color.
+ * Paint a resolved row at `width`; `null` renders ZERO lines.
+ *
+ * TUI pads each line to terminal width, so no manual trailing padding is
+ * needed. truncateToWidth understands ANSI codes and wide Unicode glyphs, so
+ * colored text truncates at VISIBLE columns. The gutter is a fixed-width
+ * prefix, so the content gets the remaining columns. Width comes from the
+ * row's OWN gutter text, so a disabled gutter reclaims those columns.
+ */
+function renderRow(row: Row | null, width: number): string[] {
+  if (row === null) return [];
+  const room = Math.max(1, width - gutterWidth(row.gutter));
+  const paint = (line: string) => row.gutter + line;
+  const lines = row.wrap ? wrapped(row.wrap, room) : undefined;
+  if (lines) return lines.map(paint);
+  return [paint(truncateToWidth(row.text, room, "…"))];
+}
+
+/**
+ * One physical terminal line (several for an expanded row) with width-aware
+ * truncation and full-width color.
  *
  * Pi's Text component wraps long strings. That is correct for prose but made a
- * long path spill onto a second line in a supposedly single-line renderer. TUI
+ * long path spill onto a second line in a renderer meant for one line. TUI
  * only supplies the real terminal width during render(), so truncating with a
  * fixed character count in the caller cannot solve this reliably.
+ *
+ * The one exception is an EXPANDED row (`row.wrap`): there the user asked to see
+ * everything, so a long command wraps under its own details instead.
  */
 export class CompactLine implements Component {
   private resolve: ResolveRow = () => null;
-  private click?: () => boolean;
+  private click?: (onHeader: boolean) => boolean;
+  /** Did the last render draw a header line at y=0? */
+  private headed = false;
   private ticker: unknown;
   private timers: Timers;
 
@@ -60,9 +100,10 @@ export class CompactLine implements Component {
 
   /**
    * Install the row resolver. Called on every updateDisplay with fresh state.
-   * `click` returning true stops Pi's own left-click (expand) handler.
+   * `click` returning true stops Pi's own left-click (expand) handler; its
+   * argument says whether the click landed on the row's header line.
    */
-  setRow(resolve: ResolveRow, click?: () => boolean): void {
+  setRow(resolve: ResolveRow, click?: (onHeader: boolean) => boolean): void {
     this.resolve = resolve;
     this.click = click;
   }
@@ -71,7 +112,8 @@ export class CompactLine implements Component {
   // the region's own expand/collapse toggle.
   handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
     if (event.type !== "click" || event.button !== "left") return undefined;
-    return this.click?.() ? { handled: true } : undefined;
+    // `y` is local to THIS component (Container subtracts earlier siblings).
+    return this.click?.(this.headed && event.y === 0) ? { handled: true } : undefined;
   }
 
   /**
@@ -91,22 +133,10 @@ export class CompactLine implements Component {
     }
   }
 
-  /** Test/inspection helper: is a repaint interval currently registered? */
-  isTicking(): boolean {
-    return this.ticker !== undefined;
-  }
-
   render(width: number): string[] {
     const row = this.resolve(width);
-    if (row === null) return [];
-
-    // TUI pads each line to terminal width, so no manual trailing padding is
-    // needed. truncateToWidth understands ANSI codes and wide Unicode glyphs,
-    // so colored text truncates at VISIBLE columns. The gutter is a fixed-width
-    // prefix, so the content gets the remaining columns. Width comes from the
-    // row's OWN gutter text, so a disabled gutter reclaims those columns.
-    const line = truncateToWidth(row.text, Math.max(1, width - gutterWidth(row.gutter)), "…");
-    return [row.gutter + (row.highlight ? row.highlight(line) : line)];
+    this.headed = row?.header !== undefined;
+    return [...(row?.header ? [...renderRow(row.header, width), ""] : []), ...renderRow(row, width)];
   }
 
   // Component contract allows cached components to be invalidated. This class
@@ -115,28 +145,55 @@ export class CompactLine implements Component {
 }
 
 /**
- * Collapsed results must render ZERO lines, not one blank line.
- *
- * Pi's Text component returns [""] for empty strings (one blank row), which
- * doubled the height of every collapsed tool call. This is the only safe way to
- * say "no content at all" while still returning a Component, as the
- * renderResult slot contract requires.
+ * Assistant prose or native thinking that a fold may take over: the resolver
+ * returns a Row to draw it instead, `null` to hide it (zero lines), or
+ * `undefined` to leave `inner` untouched (with an opened run's header line
+ * above it, when `header` supplies one). The header is followed by one blank line. Clicks on the summary or header go to
+ * `click`.
  */
 export class FoldableProse implements Component {
   private inner: Component;
   private resolve: (width: number) => Row | null | undefined;
+  private header: () => Row | undefined;
+  private click: (onHeader: boolean) => boolean;
+  /** What the last render drew: a folded summary, or a header line above native output. */
+  private summary = false;
+  private headed = false;
 
-  constructor(inner: Component, resolve: (width: number) => Row | null | undefined) {
+  /**
+   * `header` is the opened-run header to draw above the native output; `click`
+   * has the same contract as `CompactLine.setRow`'s: it gets whether the click
+   * landed on that header line.
+   */
+  constructor(
+    inner: Component,
+    resolve: (width: number) => Row | null | undefined,
+    header: () => Row | undefined,
+    click: (onHeader: boolean) => boolean,
+  ) {
     this.inner = inner;
     this.resolve = resolve;
+    this.header = header;
+    this.click = click;
   }
 
   render(width: number): string[] {
     const row = this.resolve(width);
-    if (row === undefined) return this.inner.render(width);
-    const line = new CompactLine();
-    line.setRow(() => row);
-    return line.render(width);
+    this.summary = row !== undefined && row !== null;
+    const header = row === undefined ? this.header() : undefined;
+    this.headed = header !== undefined;
+    if (row !== undefined) return renderRow(row, width);
+    return header ? [...renderRow(header, width), "", ...this.inner.render(width)] : this.inner.render(width);
+  }
+
+  // Only the summary or the header line is clickable; the native output below
+  // keeps whatever click behavior its own host (e.g. a thinking MouseRegion) has.
+  // `y` is local to THIS component, like CompactLine's.
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    if (event.type !== "click" || event.button !== "left") return undefined;
+    const onHeader = this.headed && event.y === 0;
+    if (!this.summary && !onHeader) return undefined;
+    return this.click(onHeader) ? { handled: true } : undefined;
   }
 
   invalidate(): void {
@@ -144,6 +201,14 @@ export class FoldableProse implements Component {
   }
 }
 
+/**
+ * Collapsed results must render ZERO lines, not one blank line.
+ *
+ * Pi's Text component returns [""] for empty strings (one blank row), which
+ * doubled the height of every collapsed tool call. This is the only safe way to
+ * say "no content at all" while still returning a Component, as the
+ * renderResult slot contract requires.
+ */
 export class EmptyComponent implements Component {
   render(): string[] {
     return [];