pi-minimalist 0.1.1 → 0.2.0

package/README.md

@@ -14,6 +14,10 @@ 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" />
 
+**Click** a folded line to open it into separate rows. Click one row to see only its output.
+
+<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. 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,13 +65,12 @@ 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:
 

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, migratedQuiet, 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";
@@ -82,7 +82,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 +91,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.1",
+  "version": "0.2.0",
   "description": "Compact one-line tool and thinking rows for Pi's interactive transcript",
   "keywords": ["pi-package"],
   "license": "MIT",

package/src/components.ts

@@ -7,7 +7,7 @@
  */
 
 import { truncateToWidth } from "@earendil-works/pi-tui";
-import type { Component } from "@earendil-works/pi-tui";
+import type { Component, TuiMouseEvent, TuiMouseEventResult } from "@earendil-works/pi-tui";
 import { gutterWidth, type Row } from "./row.ts";
 
 /**
@@ -50,6 +50,7 @@ export type ResolveRow = (width: number) => Row | null;
  */
 export class CompactLine implements Component {
   private resolve: ResolveRow = () => null;
+  private click?: () => boolean;
   private ticker: unknown;
   private timers: Timers;
 
@@ -57,9 +58,20 @@ export class CompactLine implements Component {
     this.timers = timers;
   }
 
-  /** Install the row resolver. Called on every updateDisplay with fresh state. */
-  setRow(resolve: ResolveRow): void {
+  /**
+   * Install the row resolver. Called on every updateDisplay with fresh state.
+   * `click` returning true stops Pi's own left-click (expand) handler.
+   */
+  setRow(resolve: ResolveRow, click?: () => boolean): void {
     this.resolve = resolve;
+    this.click = click;
+  }
+
+  // Pi's MouseRegion asks its child first, so a handled click never reaches
+  // 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;
   }
 
   /**

package/src/config-file.ts

@@ -29,6 +29,11 @@ import {
   DEFAULTS,
   DEFAULT_TOKENS,
   GLYPH_PRESETS,
+  FRESH_PRESET,
+  LOOK_KEYS,
+  PRESETS,
+  isFresh,
+  isPreset,
   SETTINGS_KEY,
   type BasicSettings,
   type Glyphs,
@@ -153,8 +158,10 @@ function readSettingsFile(path: string): Json {
  * this is hand-edited input.
  */
 function coerce(raw: unknown, into: Settings): Settings {
-  if (!isRecord(raw)) return into;
   const out = { ...into };
+  // A user with no basic key has never configured anything: they get the default preset.
+  if (isFresh(raw)) out.preset = FRESH_PRESET;
+  if (!isRecord(raw)) return out;
 
   for (const key of BASIC_KEYS) {
     if (typeof DEFAULT_BASIC[key] === "boolean" && typeof raw[key] === "boolean") {
@@ -169,6 +176,7 @@ function coerce(raw: unknown, into: Settings): Settings {
   if (Array.isArray(raw.excludeTools)) {
     out.excludeTools = raw.excludeTools.filter((name): name is string => typeof name === "string");
   }
+  if (isPreset(raw.preset)) out.preset = raw.preset;
   if (raw.glyphStyle === "unicode" || raw.glyphStyle === "ascii") {
     out.glyphStyle = raw.glyphStyle;
   }
@@ -204,6 +212,17 @@ export function loadSettings(env = process.env): Settings {
   return coerce(global[SETTINGS_KEY], DEFAULTS);
 }
 
+/**
+ * Look keys to write when the user switches to `custom` for the first time: the
+ * `lite` look, so "custom" starts from something known. Undefined when the file
+ * already holds any of the user's own look keys (they are kept untouched).
+ */
+export function customSeed(env = process.env): Record<string, boolean> | undefined {
+  const block = readSettingsFile(globalSettingsPath(env))[SETTINGS_KEY];
+  const own = isRecord(block) && LOOK_KEYS.some((key) => key in block);
+  return own ? undefined : PRESETS.lite;
+}
+
 /**
  * One-time migration of the old `/quiet` preference.
  *
@@ -232,7 +251,7 @@ export type SaveResult =
 
 /**
  * Persist only the supplied editor-managed settings into the global agent file.
- * A normal edit passes one key; Restore defaults intentionally passes all.
+ * A normal edit passes one key.
  * Hand-written `glyphs`/`tokens`/`excludeTools` values survive untouched.
  *
  * REFUSES to write a file containing comments. `JSON.stringify` would silently
@@ -263,6 +282,8 @@ export function saveBasicSettings(settings: Partial<BasicSettings>, env = proces
   }
   const existing = isRecord(root[SETTINGS_KEY]) ? root[SETTINGS_KEY] : {};
   const merged: Json = { ...existing };
+  // The first write must pin the fresh-install preset, or the file would stop looking fresh and become `custom`.
+  if (isFresh(existing)) merged.preset = FRESH_PRESET;
   for (const key of BASIC_KEYS) {
     if (settings[key] !== undefined) merged[key] = settings[key];
   }

package/src/config-ui.ts

@@ -3,7 +3,9 @@
 import { truncateToWidth, type AutocompleteItem, type Component, type SettingItem, type SettingsList, type SettingsListTheme } from "@earendil-works/pi-tui";
 import {
   BASIC_KEYS,
-  DEFAULT_BASIC,
+  LOOK_KEYS,
+  PRESET_NAMES,
+  isPreset,
   type BasicKey,
   type BasicSettings,
   type Config,
@@ -20,6 +22,11 @@ type Field = {
 
 /** Label and hover description for every basic setting, in display order. */
 export const FIELDS: Field[] = [
+  {
+    key: "preset",
+    label: "Preset",
+    description: "off = native Pi, lite = one-line rows, full = + groups and thinking rows, max = + collapsed earlier activity. custom uses your own values. A preset only sets the four look rows; your other settings are kept.",
+  },
   {
     key: "compactToolRows",
     label: "Compact tool rows",
@@ -83,18 +90,27 @@ type InputComponent = Component & { handleInput(data: string): void };
 type SettingsListConstructor = new (...args: ConstructorParameters<typeof SettingsList>) => SettingsList;
 type BasicValue = BasicSettings[BasicKey];
 
-/** Conditional rows plus their display values. */
-export function items(settings: Settings): SettingItem[] {
+const CHOICES: Partial<Record<BasicKey, string[]>> = {
+  preset: [...PRESET_NAMES],
+  activitySummary: ["elapsed time", "tools used"],
+  glyphStyle: ["Unicode", "ASCII"],
+};
+
+const isLook = (key: string) => (LOOK_KEYS as readonly string[]).includes(key);
+
+/** Conditional rows plus their display values. `dim` greys the look rows a preset owns. */
+export function items(settings: Settings, dim?: (text: string) => string): SettingItem[] {
   return FIELDS.filter((field) => !field.activityOption || settings.foldIntermediateActivity).map(
     ({ key, label, description }) => {
-      const value = settings[key];
-      return {
-        id: key,
-        label,
-        description,
-        currentValue: displayValue(value),
-        values: key === "activitySummary" ? ["elapsed time", "tools used"] : key === "glyphStyle" ? ["Unicode", "ASCII"] : ["on", "off"],
-      };
+      const value = displayValue(settings[key]);
+      // SettingsList has no disabled rows, so a locked row shows its dimmed value
+      // as its ONLY value: Enter "cycles" to the same text and nothing changes.
+      if (dim && isLook(key)) {
+        const shown = dim(value);
+        const hint = `Set by the '${settings.preset}' preset. Switch Preset to 'custom' to edit (your custom values are kept).`;
+        return { id: key, label, description: hint, currentValue: shown, values: [shown] };
+      }
+      return { id: key, label, description, currentValue: value, values: CHOICES[key] ?? ["on", "off"] };
     },
   );
 }
@@ -104,39 +120,35 @@ export type ConfigScreenDeps = {
   theme: SettingsListTheme;
   config: Config;
   onChange: (key: BasicKey, value: BasicValue) => void;
-  onReset: () => void;
   onClose: () => void;
 };
 
 /** Build a live screen; toggling prose folding immediately adds/removes its two child rows. */
 export function createConfigScreen(deps: ConfigScreenDeps): InputComponent {
-  const { SettingsList, theme, config, onChange, onReset, onClose } = deps;
+  const { SettingsList, theme, config, onChange, onClose } = deps;
   let list: SettingsList;
+  let locked = false;
 
   const build = () => {
-    const rows = [
-      ...items(config.all()),
-      {
-        id: "restoreDefaults",
-        label: "Restore defaults",
-        description: "Reset the settings in this editor, including Symbols. Custom glyphs, colours, and excluded tools are kept.",
-        currentValue: "Enter to restore",
-        values: ["Restore"],
-      },
-    ];
+    const preset = config.all().preset;
+    locked = preset !== "custom";
+    const rows = items(config.all(), locked ? theme.hint : undefined);
     return new SettingsList(
       rows,
       rows.length,
       theme,
       (id, displayValue) => {
-        if (id === "restoreDefaults") {
-          for (const key of BASIC_KEYS) config.set(key, DEFAULT_BASIC[key]);
-          onReset();
+        if (!isBasicKey(id)) return;
+        if (id === "preset") {
+          const value = isPreset(displayValue) ? displayValue : "custom";
+          config.set(id, value);
+          onChange(id, value);
           list = build();
           list.selectItem(id);
           return;
         }
-        if (!isBasicKey(id)) return;
+        // Locked rows only echo their own text; do nothing (their description explains).
+        if (locked && isLook(id)) return;
         if (id === "activitySummary") {
           const value = displayValue === "tools used" ? "tools" : "elapsed";
           config.set(id, value);
@@ -176,6 +188,7 @@ function isBasicKey(id: string): id is BasicKey {
 }
 
 function displayValue(value: BasicValue): string {
+  if (isPreset(value)) return value;
   if (value === "elapsed") return "elapsed time";
   if (value === "tools") return "tools used";
   if (value === "unicode") return "Unicode";
@@ -199,7 +212,8 @@ export function summary(settings: Settings): string {
   const width = Math.max(...visible.map((field) => field.label.length));
   return [
     ...visible.map(({ key, label }) => {
-      return `  ${label.padEnd(width)}  ${displayValue(settings[key])}`;
+      const dimmed = settings.preset !== "custom" && isLook(key) ? " (from preset)" : "";
+      return `  ${label.padEnd(width)}  ${displayValue(settings[key])}${dimmed}`;
     }),
     "",
     "  /minimalist          change these",

package/src/config.ts

@@ -85,7 +85,28 @@ export const DEFAULT_TOKENS: Tokens = {
 /** Settings `/minimalist` can edit: visible effect, no vocabulary needed. */
 export type ActivitySummary = "elapsed" | "tools";
 
+export const PRESET_NAMES = ["off", "lite", "full", "max", "custom"] as const;
+export type Preset = (typeof PRESET_NAMES)[number];
+
+export function isPreset(value: unknown): value is Preset {
+  return (PRESET_NAMES as readonly unknown[]).includes(value);
+}
+
+/** The only settings a preset names. Every other setting stays the user's own. */
+export const LOOK_KEYS = ["compactToolRows", "groupToolRuns", "foldIntermediateActivity", "thinkingAsToolCall"] as const;
+export type LookKey = (typeof LOOK_KEYS)[number];
+
+/** Preset of a user who has never configured anything (no basic key in the `minimalist` block). */
+export const FRESH_PRESET: Preset = "full";
+
+/** True when the `minimalist` block holds no basic key, so the user never configured anything. */
+export function isFresh(block: unknown): boolean {
+  return typeof block !== "object" || block === null || !BASIC_KEYS.some((key) => key in block);
+}
+
 export type BasicSettings = {
+  /** A named bundle of the four look settings below. `custom` uses the user's own values for all of them. */
+  preset: Preset;
   /** Master switch. Off restores Pi's native tool cards entirely. */
   compactToolRows: boolean;
   /** Fold adjacent finished rows into one summary line. */
@@ -127,6 +148,7 @@ export type AdvancedSettings = {
 export type Settings = BasicSettings & AdvancedSettings;
 
 export const DEFAULT_BASIC: BasicSettings = {
+  preset: "custom",
   compactToolRows: true,
   groupToolRuns: true,
   foldIntermediateActivity: false,
@@ -140,6 +162,17 @@ export const DEFAULT_BASIC: BasicSettings = {
   glyphStyle: "unicode",
 };
 
+/**
+ * The four look settings each non-custom preset forces. A preset is a LAYER
+ * applied on read (see `Config`); it never writes the user's own keys.
+ */
+export const PRESETS: Record<Exclude<Preset, "custom">, Record<LookKey, boolean>> = {
+  off: { compactToolRows: false, groupToolRuns: false, foldIntermediateActivity: false, thinkingAsToolCall: false },
+  lite: { compactToolRows: true, groupToolRuns: false, foldIntermediateActivity: false, thinkingAsToolCall: false },
+  full: { compactToolRows: true, groupToolRuns: true, foldIntermediateActivity: false, thinkingAsToolCall: true },
+  max: { compactToolRows: true, groupToolRuns: true, foldIntermediateActivity: true, thinkingAsToolCall: true },
+};
+
 export const DEFAULT_ADVANCED: AdvancedSettings = {
   // `subagent` ships a renderer showing run id, state and a ctrl+o hint that one
   // line cannot carry. Excluded by NAME rather than by the old "does this tool
@@ -167,6 +200,11 @@ export type BasicKey = keyof BasicSettings;
 // Live configuration
 // ---------------------------------------------------------------------------
 
+/** defaults < the user's own keys < the preset's four look keys (none for `custom`). */
+function layer(user: Settings): Settings {
+  return user.preset === "custom" ? user : { ...user, ...PRESETS[user.preset] };
+}
+
 /**
  * The live settings object.
  *
@@ -175,7 +213,12 @@ export type BasicKey = keyof BasicSettings;
  * and no restart.
  */
 export class Config {
+  /** The user's own values (what settings.json says), before any preset. */
   private settings: Settings;
+  /** What the rest of the extension sees: `settings` with the preset layered on. */
+  private get view(): Settings {
+    return layer(this.settings);
+  }
 
   /**
    * Values changed in this session that are NOT in settings.json.
@@ -192,9 +235,10 @@ export class Config {
   }
 
   get<K extends keyof Settings>(key: K): Settings[K] {
-    return this.settings[key];
+    return this.view[key];
   }
 
+  /** Writes the user's own value; a non-custom preset keeps shadowing it until `preset` is custom. */
   set<K extends keyof Settings>(key: K, value: Settings[K]): void {
     this.settings = { ...this.settings, [key]: value };
   }
@@ -211,7 +255,7 @@ export class Config {
   }
 
   all(): Settings {
-    return this.settings;
+    return this.view;
   }
 
   /** Adopt freshly read settings, re-applying anything held only in memory. */
@@ -221,12 +265,12 @@ export class Config {
 
   /** Preset chosen by `glyphStyle`, then per-glyph overrides. */
   glyphs(): Glyphs {
-    return { ...GLYPH_PRESETS[this.settings.glyphStyle], ...this.settings.glyphs };
+    return { ...GLYPH_PRESETS[this.view.glyphStyle], ...this.view.glyphs };
   }
 
   /** Default token map plus overrides. */
   tokens(): Tokens {
-    return { ...DEFAULT_TOKENS, ...this.settings.tokens };
+    return { ...DEFAULT_TOKENS, ...this.view.tokens };
   }
 
   /**
@@ -236,11 +280,11 @@ export class Config {
    * alongside it wherever claiming happens.
    */
   isExcluded(toolName: string): boolean {
-    return this.settings.excludeTools.includes(toolName);
+    return this.view.excludeTools.includes(toolName);
   }
 
   /** True when this tool should be drawn as a compact row. */
   compacts(toolName: string): boolean {
-    return this.settings.compactToolRows && !this.isExcluded(toolName);
+    return this.view.compactToolRows && !this.isExcluded(toolName);
   }
 }

package/src/run-grouping.ts

@@ -55,6 +55,8 @@ export class RunGrouping {
   private cycle = 0;
   private cycles = new Map<number, Cycle>();
   private agentActive = false;
+  /** Rows the user opened out of a summary by clicking it. Never fold again. */
+  private opened = new Set<string>();
   private version = 0;
   private cache?: ViewCache;
 
@@ -226,6 +228,33 @@ export class RunGrouping {
     return painter.summary(view);
   }
 
+  /**
+   * Open the summary this row draws back into separate rows, after a click.
+   *
+   * Needed because the summary is drawn by ONE member (the tail) and the others
+   * draw zero lines: Pi's own click handler would expand only the tail.
+   * Returns false when the row draws no summary, so Pi's click still applies.
+   */
+  open(id: string): boolean {
+    const entry = this.byId.get(id);
+    if (!entry) return false;
+    const { activity, grouped } = this.views();
+    const members = [entry];
+    if (activity.get(id) === "summary") {
+      members.push(...this.entries.filter((e) => e.cycle === entry.cycle && activity.get(e.id) === "hide"));
+    } else if (typeof grouped.get(id) === "object") {
+      // A run's hidden members are the contiguous "hide" rows before its tail.
+      for (let i = this.entries.indexOf(entry) - 1; i >= 0 && grouped.get(this.entries[i].id) === "hide"; i--) {
+        members.push(this.entries[i]);
+      }
+    } else {
+      return false;
+    }
+    for (const member of members) this.opened.add(member.id);
+    this.invalidateViews();
+    return true;
+  }
+
   view(id: string): RowView {
     return this.views().grouped.get(id) ?? "show";
   }
@@ -320,7 +349,7 @@ export class RunGrouping {
   }
 
   private activityFoldable(entry: Entry): boolean {
-    if (entry.expanded) return false;
+    if (entry.expanded || this.opened.has(entry.id)) return false;
     if (entry.outcome === "pending" && entry.kind !== "prose" && this.config.get("keepActiveToolsExpanded")) {
       return false;
     }
@@ -328,7 +357,7 @@ export class RunGrouping {
   }
 
   private foldable(entry: Entry | undefined): boolean {
-    if (!entry?.foldable || entry.expanded) return false;
+    if (!entry?.foldable || entry.expanded || this.opened.has(entry.id)) return false;
     if (entry.kind === "thinking" && !this.config.get("thinkingAsToolCall")) return false;
     if (entry.outcome === "pending" && this.config.get("keepActiveToolsExpanded")) return false;
     return true;

package/src/thinking.ts

@@ -59,7 +59,7 @@ export function createThinkingPreview(deps: ThinkingDeps): ThinkingPreview {
 
     if (owner && runIndex !== undefined) {
       const id = grouping.thinkingId(owner, runIndex);
-      line.setRow(() => grouping.rowFor(id, new Painter(theme, config), paint));
+      line.setRow(() => grouping.rowFor(id, new Painter(theme, config), paint), () => grouping.open(id));
     } else {
       line.setRow(paint);
     }

package/src/tool-renderer.ts

@@ -194,7 +194,10 @@ export function createToolRenderer(deps: RendererDeps): ToolRenderer {
         return component;
       }
       grouping.observe(id, summaryName(name, args), status.outcome, context.expanded === true);
-      component.setRow((width) => grouping.rowFor(id, new Painter(theme, config), () => paint(width)));
+      component.setRow(
+        (width) => grouping.rowFor(id, new Painter(theme, config), () => paint(width)),
+        () => grouping.open(id),
+      );
       return component;
     },