pi-minimalist 0.1.2 → 0.2.2

package/src/run-grouping.ts

@@ -1,9 +1,6 @@
 /**
  * Folding adjacent low-noise rows into one summary (the `groupToolRuns` setting).
  *
- * Formerly `quiet-mode.ts` / `QuietMode`, named after a `/quiet` command that no
- * longer exists.
- *
  * WHY THIS STATE EXISTS AT ALL
  * ---------------------------
  * Each tool row is an independent transcript entry that knows nothing about its
@@ -19,7 +16,8 @@ import type { Count, Painter, Row, RunSummary } from "./row.ts";
 
 export type Outcome = "success" | "failure" | "pending";
 
-type EntryKind = "tool" | "thinking" | "prose";
+/** "other" = visible in the transcript but not ours to fold (user message, excluded tool card). */
+type EntryKind = "tool" | "thinking" | "prose" | "other";
 
 type Entry = {
   id: string;
@@ -33,11 +31,13 @@ type Entry = {
   foldable: boolean;
 };
 
-type Cycle = { startedAt: number; settledAt?: number; finalAnswerStarted: boolean };
+type Cycle = { startedAt: number; settledAt?: number };
 
 /** "show" keeps the row as-is, "hide" draws nothing, a summary folds a whole run. */
 export type RowView = "show" | "hide" | RunSummary;
 type ActivityState = "show" | "hide" | "summary";
+/** A run the user opened. Every member id maps to the same object. */
+type OpenRun = { members: Entry[]; activity: boolean };
 type ViewCache = {
   key: string;
   activity: Map<string, ActivityState>;
@@ -51,12 +51,14 @@ export class RunGrouping {
   private byId = new Map<string, Entry>();
   private ownerIds = new WeakMap<object, number>();
   private ownerEntries = new Map<number, Set<string>>();
+  /** Message identity per owner. Rebuilt components of one message share it, so they share entries. */
+  private messageKeys = new WeakMap<object, string>();
   private nextOwnerId = 1;
   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>();
+  /** Rows the user opened out of a summary by clicking it. They stay out of folds until `close()`. */
+  private opened = new Map<string, OpenRun>();
   private version = 0;
   private cache?: ViewCache;
 
@@ -73,7 +75,7 @@ export class RunGrouping {
     // Replay leaves `cycle` pointing at the next empty slot. A subsequent live
     // interaction can use it directly; consecutive live interactions advance.
     if (this.entries.some((entry) => entry.cycle === this.cycle)) this.cycle++;
-    this.cycles.set(this.cycle, { startedAt: now, finalAnswerStarted: false });
+    this.cycles.set(this.cycle, { startedAt: now });
     this.agentActive = true;
     this.invalidateViews();
   }
@@ -116,50 +118,49 @@ export class RunGrouping {
     this.invalidateViews();
   }
 
-  /** Observe a thinking block by its component identity and local run index. */
-  observeThinking(owner: object, runIndex: number, done: boolean, expanded: boolean): void {
+  /**
+   * Record something visible that we never fold or draw (a user message, an
+   * excluded tool card). It only exists to cut runs, so no summary jumps over it.
+   */
+  observeBarrier(id: string): void {
+    this.observe(id, "other", "success", false, false, "other");
+  }
+
+  /** Observe a thinking block by its message identity and local run index. */
+  observeThinking(owner: object, runIndex: number, done: boolean, expanded: boolean, timestamp?: number): void {
+    this.identify(owner, timestamp);
     const id = this.thinkingId(owner, runIndex);
     this.rememberOwnerEntry(owner, id);
     this.observe(id, "think", done ? "success" : "pending", expanded, true, "thinking");
   }
 
-  /**
-   * Record prose and return its stable id. `stopReason=stop` is available on the
-   * first empty final-answer update, before OpenAI streams its first text delta;
-   * the finalized block later confirms the same fact through `phase`.
-   */
+  /** Record prose and return its stable id. `stopReason=stop` marks a final answer. */
   observeProse(
     owner: object,
     contentIndex: number,
     signal: {
-      phase?: "commentary" | "final_answer";
       stopReason?: string;
       streaming?: boolean;
       timestamp?: number;
     } = {},
   ): string {
-    const id = `prose:${this.ownerId(owner)}:${contentIndex}`;
+    this.identify(owner, signal.timestamp);
+    const id = `prose:${this.messageKey(owner)}:${contentIndex}`;
     const isNew = !this.byId.has(id);
     const timestamp = signal.timestamp ?? Date.now();
     if (!this.cycles.has(this.cycle)) {
-      this.cycles.set(this.cycle, { startedAt: timestamp, finalAnswerStarted: false });
+      this.cycles.set(this.cycle, { startedAt: timestamp });
     }
     this.rememberOwnerEntry(owner, id);
     this.observe(id, "prose", "pending", false, false, "prose");
 
-    const isFinal = signal.phase === "final_answer" || signal.stopReason === "stop";
-    const cycle = this.cycles.get(this.byId.get(id)!.cycle)!;
-    if (isFinal && !cycle.finalAnswerStarted) {
-      cycle.finalAnswerStarted = true;
-      this.invalidateViews();
-    }
-
+    const isFinal = signal.stopReason === "stop";
     // session replay has no agent_start/agent_settled events. A newly observed,
     // finalized answer is therefore the only reliable boundary between old user
     // interactions. Advance AFTER assigning the answer so it remains the latest
     // prose of its own cycle; stable ids prevent re-renders from advancing twice.
     if (!this.agentActive && isNew && isFinal && !signal.streaming) {
-      cycle.settledAt = timestamp;
+      this.cycles.get(this.byId.get(id)!.cycle)!.settledAt = timestamp;
       this.cycle++;
     }
     return id;
@@ -193,7 +194,7 @@ export class RunGrouping {
   }
 
   thinkingId(owner: object, runIndex: number): string {
-    return `think:${this.ownerId(owner)}:${runIndex}`;
+    return `think:${this.messageKey(owner)}:${runIndex}`;
   }
 
   /** Hide a message's leading spacer only when every one of its rows is hidden. */
@@ -223,7 +224,7 @@ export class RunGrouping {
     if (activity === "summary") return this.activitySummary(entry!, painter);
 
     const view = this.view(id);
-    if (view === "show") return base();
+    if (view === "show") return entry ? this.withHeader(entry, base(), painter) : base();
     if (view === "hide") return null;
     return painter.summary(view);
   }
@@ -240,44 +241,69 @@ export class RunGrouping {
     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"));
+    const isActivity = activity.get(id) === "summary";
+    if (isActivity) {
+      members.unshift(...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]);
+        members.unshift(this.entries[i]);
       }
     } else {
       return false;
     }
-    for (const member of members) this.opened.add(member.id);
+    const run: OpenRun = { members, activity: isActivity };
+    for (const member of members) this.opened.set(member.id, run);
     this.invalidateViews();
     return true;
   }
 
+  /**
+   * Fold an opened run back, after a click on its header. `CompactLine` reports
+   * `onHeader` only for a row that drew the header, so `id` is that row.
+   */
+  close(id: string): boolean {
+    const run = this.opened.get(id);
+    if (!run) return false;
+    for (const member of run.members) this.opened.delete(member.id);
+    this.invalidateViews();
+    return true;
+  }
+
+  /** The click handler of a row drawn by `CompactLine`: header folds back, anything else opens. */
+  click(id: string, onHeader: boolean): boolean {
+    return onHeader ? this.close(id) : this.open(id);
+  }
+
+  /** The header of an opened run, on its first member only, while the fold that made it is on. */
+  headerFor(id: string, painter: Painter): Row | undefined {
+    const entry = this.byId.get(id);
+    const run = this.opened.get(id);
+    if (!entry || !run || run.members[0].id !== id || !(run.activity ? this.config.get("foldIntermediateActivity") : this.enabled)) {
+      return undefined;
+    }
+    return painter.header();
+  }
+
+  private withHeader(entry: Entry, row: Row, painter: Painter): Row {
+    const header = this.headerFor(entry.id, painter);
+    return header ? { ...row, header } : row;
+  }
+
   view(id: string): RowView {
     return this.views().grouped.get(id) ?? "show";
   }
 
-  /**
-   * Can this entry disappear into a run summary?
-   *
-   * A RUNNING entry folds by default: folds are recomputed on every render, so
-   * the row reappears the moment it matters, and the summary still counts it in
-   * its `running` group. `keepActiveToolsExpanded` opts out for people who want
-   * to watch a long command in place.
-   */
   /** Collapse every collapsible row before the latest prose into ONE activity summary. */
   private activityState(entry: Entry | undefined): ActivityState {
     return entry ? (this.views().activity.get(entry.id) ?? "show") : "show";
   }
 
+  /** The `activitySummary` mode decides what a folded activity run shows. */
   private activitySummary(entry: Entry, painter: Painter, now = Date.now()): Row {
-    const cycle = this.cycles.get(entry.cycle);
     const actions = this.views().actions.get(entry.cycle);
-    if (this.config.get("activitySummary") === "tools" && actions) {
-      return painter.summary(actions);
-    }
+    if (this.config.get("activitySummary") === "tools" && actions) return painter.summary(actions);
+    const cycle = this.cycles.get(entry.cycle);
     const elapsed = Math.max(0, (cycle?.settledAt ?? now) - (cycle?.startedAt ?? now));
     return painter.labeled({ label: "Worked", details: `for ${formatDuration(elapsed)}` });
   }
@@ -288,7 +314,6 @@ export class RunGrouping {
       this.config.get("groupToolRuns"),
       this.config.get("thinkingAsToolCall"),
       this.config.get("foldIntermediateActivity"),
-      this.config.get("foldActivityOnFinalAnswer"),
       this.config.get("keepActiveToolsExpanded"),
     ].join(":");
     if (this.cache?.key === key) return this.cache;
@@ -304,7 +329,12 @@ export class RunGrouping {
           continue;
         }
         let last = first + 1;
-        while (last < this.entries.length && this.foldable(this.entries[last])) last++;
+        // A new agent cycle (user prompt) also cuts the run.
+        while (
+          last < this.entries.length &&
+          this.foldable(this.entries[last]) &&
+          this.entries[last].cycle === this.entries[first].cycle
+        ) last++;
         if (last - first > 1) {
           for (let index = first; index < last - 1; index++) grouped.set(this.entries[index].id, "hide");
           grouped.set(this.entries[last - 1].id, summarize(this.entries.slice(first, last)));
@@ -322,20 +352,18 @@ export class RunGrouping {
       }
       for (const [cycleId, entries] of byCycle) {
         const prose = entries.filter((entry) => entry.kind === "prose");
-        const cycle = this.cycles.get(cycleId);
-        if (
-          prose.length < 2 ||
-          (this.config.get("foldActivityOnFinalAnswer") && !cycle?.finalAnswerStarted)
-        ) continue;
+        if (prose.length < 2) continue;
 
         const beforeLatest = entries.slice(0, entries.indexOf(prose.at(-1)!));
+        // A cycle of consecutive prose only (no tool, no thinking) has nothing to fold.
+        if (!beforeLatest.some(isAction)) continue;
         const collapsible = beforeLatest.filter((entry) => this.activityFoldable(entry));
         for (let index = 0; index < collapsible.length - 1; index++) {
           activity.set(collapsible[index].id, "hide");
         }
         const tail = collapsible.at(-1);
         if (tail) activity.set(tail.id, "summary");
-        const actionEntries = beforeLatest.filter((entry) => entry.kind !== "prose");
+        const actionEntries = beforeLatest.filter(isAction);
         if (actionEntries.length > 0) actions.set(cycleId, summarize(actionEntries));
       }
     }
@@ -349,6 +377,7 @@ export class RunGrouping {
   }
 
   private activityFoldable(entry: Entry): boolean {
+    if (entry.kind === "other") 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;
@@ -373,6 +402,20 @@ export class RunGrouping {
     entries.add(entryId);
   }
 
+  /**
+   * Ids follow the MESSAGE, not the component: Pi builds new components for the
+   * same messages on every rebuild (Ctrl+T, tree navigation), and ids tied to
+   * the dropped components would leave ghost entries counted in summaries.
+   * `timestamp` is set once when a message starts streaming and never changes.
+   */
+  private identify(owner: object, timestamp?: number): void {
+    if (timestamp !== undefined) this.messageKeys.set(owner, `t${timestamp}`);
+  }
+
+  private messageKey(owner: object): string {
+    return this.messageKeys.get(owner) ?? `o${this.ownerId(owner)}`;
+  }
+
   private ownerId(owner: object): number {
     let id = this.ownerIds.get(owner);
     if (id === undefined) {
@@ -383,6 +426,9 @@ export class RunGrouping {
   }
 }
 
+/** A tool or thinking row: what a "Worked for" fold and its tool counts are made of. */
+const isAction = (entry: Entry) => entry.kind === "tool" || entry.kind === "thinking";
+
 /** Group a run's entries by outcome, each in first-seen order. */
 export function summarize(run: Entry[]): RunSummary {
   const named = (outcome: Outcome) =>

package/src/thinking.ts

@@ -1,14 +1,14 @@
 /**
  * FEATURE 2: thinking blocks.
  *
- * Collapsed — one line replacing Pi's bare "Thinking..." label, installed on
- * `Symbol.for("pi.thinkingPreview")`:
+ * Collapsed — one line replacing Pi's bare "Thinking..." label, installed as
+ * `Bridge.thinkingPreview`:
  *
  *     • think The user wants me to…    ← while streaming
  *     ✓ think The user wants me to…    ← once the message completes
  *
  * Expanded (Ctrl+T) — Pi's native italic Markdown, but with every token-specific
- * color replaced by the thinking hue, on `Symbol.for("pi.thinkingMarkdownTheme")`.
+ * color replaced by the thinking hue, as `Bridge.thinkingMarkdownTheme`.
  */
 
 import { CompactLine, realTimers, type Timers } from "./components.ts";
@@ -20,7 +20,6 @@ import type { Config } from "./config.ts";
 export type ThinkingPreview = (
   text: string,
   theme: ThemeLike,
-  pad: number,
   streaming?: boolean,
   owner?: object,
   runIndex?: number,
@@ -36,9 +35,7 @@ export function createThinkingPreview(deps: ThinkingDeps): ThinkingPreview {
   const { config, grouping } = deps;
   const timers = deps.timers ?? realTimers;
 
-  // `pad` is part of the core bridge signature but unused: the gutter already
-  // positions the row, so honoring pad too would double-indent it.
-  return (text, theme, _pad, streaming, owner, runIndex) => {
+  return (text, theme, streaming, owner, runIndex) => {
     const line = new CompactLine(timers);
 
     // Takes no width: thinking has a single detail field, so CompactLine's
@@ -59,7 +56,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), () => grouping.open(id));
+      line.setRow(() => grouping.rowFor(id, new Painter(theme, config), paint), (onHeader) => grouping.click(id, onHeader));
     } else {
       line.setRow(paint);
     }

package/src/tool-renderer.ts

@@ -1,8 +1,8 @@
 /**
  * FEATURE 1: the compact tool renderer.
  *
- * Installed on the process-global bridge `Symbol.for("pi.defaultToolRenderer")`
- * and consulted by the prototype wrappers in `core-patch.ts`.
+ * Installed as `Bridge.toolRenderer` (see `bridge.ts`) and consulted by the
+ * prototype wrappers in `core-patch.ts`.
  *
  * Core overrides RENDERING only. Native tool definitions keep their schema,
  * `execute()`, and builtin source ownership — that ownership is what lets
@@ -172,17 +172,28 @@ export function createToolRenderer(deps: RendererDeps): ToolRenderer {
 
       // Painted at render time, because the detail budget depends on the real
       // viewport width and TUI only reveals it during render().
+      const expanded = context.expanded === true;
       const paint = (width: number) => {
         const painter = new Painter(theme, config);
         const badge = timerBadge(status.elapsed, config);
+        // Expanded (Ctrl+O): the full details, wrapped by CompactLine instead of
+        // truncated, so a long command is readable.
         const { label, details } = describeTool(name, args, {
-          expanded: context.expanded === true,
-          budget: detailBudget(width, status.glyph, name, badge),
-          config,
+          budget: expanded ? undefined : detailBudget(width, status.glyph, name, badge),
         });
         // No background while executing — the animated timer already signals
         // activity, and a highlight flashing on each repaint was distracting.
-        return painter.labeled({ glyph: status.glyph, glyphColor: status.color, label, badge, details });
+        // One colour for glyph, label and gutter (the gutter follows the label), so
+        // a failed row is red all over and a done one is label-coloured all over.
+        return painter.labeled({
+          glyph: status.glyph,
+          glyphColor: status.color,
+          label,
+          labelColor: status.color,
+          badge,
+          details,
+          wrap: expanded,
+        });
       };
 
       // EVERY call is observed, so a non-foldable one still cuts a run. Core
@@ -193,10 +204,10 @@ export function createToolRenderer(deps: RendererDeps): ToolRenderer {
         component.setRow(paint);
         return component;
       }
-      grouping.observe(id, summaryName(name, args), status.outcome, context.expanded === true);
+      grouping.observe(id, summaryName(name, args), status.outcome, expanded);
       component.setRow(
         (width) => grouping.rowFor(id, new Painter(theme, config), () => paint(width)),
-        () => grouping.open(id),
+        (onHeader) => grouping.click(id, onHeader),
       );
       return component;
     },
@@ -247,8 +258,8 @@ function detailBudget(width: number, glyph: string, label: string, badge: string
  *
  * Two caches on purpose: core's renderer path passes `lastComponent`, but its
  * FALLBACK path always passes undefined, so `context.state` is the only stable
- * per-call cache there. Allocating a fresh row per repaint used to start another
- * 1s ticker while clearing none — an interval leak that froze the UI.
+ * per-call cache there. Allocating a fresh row per repaint would start another
+ * 1s ticker while clearing none — an interval leak that freezes the UI.
  */
 function reuseRow(context: CallContext & { lastComponent?: unknown }, timers: Timers): CompactLine {
   const cached =

package/src/tools.ts

@@ -1,17 +1,14 @@
 /**
- * Tool vocabulary: how each tool describes itself on one line.
+ * Tool vocabulary: how each tool describes itself (a label and its details).
  *
  * Pure and deterministic — no components, no theme, no globals. Which tools get
  * compacted is `Config.compacts()`, not this file.
  *
  * `describeTool` returns the label and details SEPARATELY and must never join
- * them: the painter colors each part, and an earlier version that returned one
- * string forced the painter to split it back apart on the first space, silently
- * assuming no label ever contains one.
+ * them: the painter colors each part, and one joined string would
+ * force it to split on the first space, assuming no label contains one.
  */
 
-import type { Config } from "./config.ts";
-
 /** Native tools with a per-tool details extractor below. */
 // `as const` preserves literal names instead of widening every item to string.
 export const BUILT_INS = ["read", "bash", "edit", "write", "grep", "find", "ls"] as const;
@@ -19,7 +16,7 @@ export const BUILT_INS = ["read", "bash", "edit", "write", "grep", "find", "ls"]
 // `(typeof BUILT_INS)[number]` turns the tuple values into a union type.
 export type ToolName = (typeof BUILT_INS)[number];
 
-/** True for native tools with a hand-written one-line description. */
+/** True for native tools with a hand-written description. */
 export function isBuiltIn(name: string): name is ToolName {
   return BUILT_INS.includes(name as ToolName);
 }
@@ -30,8 +27,8 @@ const mcpTools = new Set<string>();
 /**
  * Refresh after MCP adapter registration.
  *
- * No longer decides what gets COMPACTED (the blacklist does that). It is kept
- * because it decides what gets LABELED `mcp`, which is real information: a bare
+ * Decides what gets LABELED `mcp` (not what gets compacted; the blacklist does
+ * that). It is real information: a bare
  * `atlassian_getConfluencePage` row does not tell you it crossed an MCP server.
  */
 export function refreshMcpTools(tools: { name: string; sourceInfo: { path: string } }[]): void {
@@ -48,60 +45,80 @@ export function isMcpTool(name: string): boolean {
 /**
  * Collapse whitespace and truncate for one-line display.
  *
- * `max` is a DISPLAY budget in characters; `hardCap` is a sanity limit that
- * exists only so a multi-megabyte heredoc is not whitespace-collapsed, colored
- * and measured on every repaint. Neither is the final word on width —
- * `CompactLine` truncates at the real viewport column count.
+ * `max` is a DISPLAY budget in characters. It is not the final word on width —
+ * `CompactLine` truncates at the real viewport column count. There is no other
+ * cap: with no budget the whole value is kept.
  */
-export function compact(value: unknown, max = Number.POSITIVE_INFINITY, hardCap = 4000): string {
-  const limit = Math.min(max, hardCap);
-  // Slice BEFORE the regex so a huge string is never fully scanned. The extra
-  // headroom leaves room for whitespace runs that collapse away.
+export function compact(value: unknown, max = Number.POSITIVE_INFINITY): string {
   const raw = String(value ?? "");
-  const sliced = Number.isFinite(limit) ? raw.slice(0, limit * 2 + 16) : raw.slice(0, hardCap * 2 + 16);
+  // With a finite budget, slice BEFORE the regex so a huge string is never fully
+  // scanned for a collapsed row. The extra headroom leaves room for whitespace
+  // runs that collapse away.
+  const sliced = Number.isFinite(max) ? raw.slice(0, max * 2 + 16) : raw;
   // Replacing every whitespace run prevents multi-line call rows.
   const text = sliced.replace(/\s+/g, " ").trim();
-  return text.length > limit ? `${text.slice(0, limit - 1)}…` : text;
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+
+/**
+ * The value for an EXPANDED row: complete, with its line structure kept.
+ * `\r\n` becomes `\n`, tabs become two spaces, trailing whitespace goes, and
+ * blank lines at the start and end of the whole value go. Each line keeps its
+ * own leading indentation; `CompactLine` wraps every line under the details.
+ */
+export function block(value: unknown): string {
+  const lines = String(value ?? "")
+    // \v, \f, \u2028, \u2029 and \u0085 would reach the terminal raw (the
+    // collapsed path folds them away with \s+).
+    .replace(/[\v\f\u2028\u2029\u0085]/g, " ")
+    .replace(/\r\n?/g, "\n")
+    .split("\n")
+    .map((line) => line.replace(/\t/g, "  ").trimEnd());
+  while (lines.length > 0 && lines[0] === "") lines.shift();
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines.join("\n");
+}
+
+/** A budget means a collapsed one-line row; no budget means an expanded row. */
+function field(value: unknown, budget: number): string {
+  return Number.isFinite(budget) ? compact(value, budget) : block(value);
 }
 
 /** Minimum columns a composed field keeps, so it never vanishes entirely. */
 const MIN_FIELD = 12;
 
 export type DescribeOptions = {
-  /** Expanded rows keep full-length details (still on ONE physical line). */
-  expanded?: boolean;
   /**
    * Columns available for the details segment.
    *
    * Approximate on purpose: `CompactLine` performs the exact, ANSI-aware,
    * wide-character-aware truncation. This budget only decides WHICH field is
    * sacrificed when a composed detail (`/pattern/ in path`) cannot fit.
+   * Omitted (expanded rows): full-length details, wrapped by `CompactLine`.
    */
   budget?: number;
-  config?: Config;
 };
 
 /**
- * The one-line description of a call: `read` + `src/a.ts:1-50`, `bash` +
+ * The description of a call: `read` + `src/a.ts:1-50`, `bash` +
  * `go test ./...`, or a third-party tool's name plus its most identifying
  * argument.
  */
 export function describeTool(name: string, args: any, options: DescribeOptions = {}): { label: string; details: string } {
-  const hardCap = options.config?.get("maxDetailChars") ?? 4000;
   const budget = options.budget ?? Number.POSITIVE_INFINITY;
   const a = args ?? {};
 
-  if (name === "mcp") return { label: "mcp", details: mcpDetails(a, budget, hardCap) };
-  if (name === "mcpScript") return { label: "mcpScript", details: compact(a.code, budget, hardCap) };
+  if (name === "mcp") return { label: "mcp", details: mcpDetails(a, budget) };
+  if (name === "mcpScript") return { label: "mcpScript", details: field(a.code, budget) };
   if (name.startsWith("mcp__")) {
     const server = name.slice("mcp__".length);
-    const tool = compact(a.tool, budget, hardCap);
+    const tool = field(a.tool, budget);
     return { label: "mcp", details: tool ? `${tool} @ ${server}` : `@ ${server}` };
   }
   if (isMcpTool(name)) return { label: "mcp", details: name };
-  if (isBuiltIn(name)) return { label: name, details: builtInDetails(name, a, options, hardCap) };
+  if (isBuiltIn(name)) return { label: name, details: builtInDetails(name, a, options) };
   // Any other tool: show the name plus whichever argument identifies the call.
-  return { label: name, details: genericDetails(a, budget, hardCap) };
+  return { label: name, details: genericDetails(a, budget) };
 }
 
 /**
@@ -120,10 +137,10 @@ export function summaryName(name: string, args: any): string {
   return name;
 }
 
-function mcpDetails(args: any, budget: number, hardCap: number): string {
-  if (args.tool) return compact(args.tool, budget, hardCap);
+function mcpDetails(args: any, budget: number): string {
+  if (args.tool) return field(args.tool, budget);
   for (const key of ["search", "describe", "connect", "action"] as const) {
-    if (args[key]) return `${key} ${compact(args[key], budget, hardCap)}`;
+    if (args[key]) return `${key} ${field(args[key], budget)}`;
   }
   return "";
 }
@@ -139,20 +156,19 @@ const GENERIC_KEYS = [
   "tool", "action", "id", "target", "message", "text", "prompt",
 ] as const;
 
-function genericDetails(args: any, budget: number, hardCap: number): string {
+function genericDetails(args: any, budget: number): string {
   for (const key of GENERIC_KEYS) {
     const value = args[key];
-    // Only scalars: an object would serialize into noise on a one-line row.
+    // Only scalars: an object would serialize into noise on a row.
     if (value !== undefined && value !== null && typeof value !== "object") {
-      const text = compact(value, budget, hardCap);
+      const text = field(value, budget);
       if (text) return text;
     }
   }
   return "";
 }
 
-function builtInDetails(name: ToolName, args: any, options: DescribeOptions, hardCap: number): string {
-  const expanded = options.expanded === true;
+function builtInDetails(name: ToolName, args: any, options: DescribeOptions): string {
   const budget = options.budget ?? Number.POSITIVE_INFINITY;
   // Paths are shown verbatim (no ~/ home abbreviation — it was decorative and
   // cost a homedir() call per render).
@@ -161,10 +177,9 @@ function builtInDetails(name: ToolName, args: any, options: DescribeOptions, har
   switch (name) {
     case "bash":
       // ONE field, so no budget split is needed: CompactLine truncates at the
-      // real viewport width. An earlier version also capped this at 100
-      // characters, which threw away ~89 usable columns on a 200-column
-      // terminal. Newlines still collapse so a heredoc cannot escape the row.
-      return compact(args.command, expanded ? Number.POSITIVE_INFINITY : budget, hardCap);
+      // real viewport width (no character cap). A collapsed row folds newlines into spaces; an expanded one
+      // keeps its lines (see `field`).
+      return field(args.command, budget);
     case "read": {
       // Show the line range when offset/limit were used, mirroring the built-in
       // read tool's "path:start-end" notation.
@@ -186,7 +201,7 @@ function builtInDetails(name: ToolName, args: any, options: DescribeOptions, har
       const wrapper = name === "grep" ? 2 : 0; // the two slashes in /pattern/
       const overhead = where.length + " in ".length + wrapper;
       const room = Number.isFinite(budget) ? Math.max(MIN_FIELD, budget - overhead) : Number.POSITIVE_INFINITY;
-      const pattern = compact(args.pattern, room, hardCap);
+      const pattern = field(args.pattern, room);
       return name === "grep" ? `/${pattern}/ in ${where}` : `${pattern} in ${where}`;
     }
     case "ls":