pi-better-harness 0.22.0 → 0.24.0

package/README.md

@@ -68,14 +68,26 @@ The bundled harness provides **Tool output: Normal / Minimal** in
 `/harness-settings`. `/tool-output minimal`, `/tool-output normal`, and
 `/tool-output` (toggle) remain compatibility shortcuts to the same preference.
 Minimal mode folds each tool call into a single-line header, including running
-calls. Muted tool names and quieter inline command/path context distinguish
-activity from conversation text; running and failed calls retain visible state
-markers. Long headers are truncated to the terminal width; result bodies,
+calls. Each row has a single tool-specific icon: accent-colored while running,
+muted when completed, and error-colored when failed. Tool names stay muted;
+inline command/path arguments use the theme's distinct dim tone. Running and
+failed calls retain text labels so state never depends on color alone. Activity
+stays quieter than conversation text. Tool rows are indented two columns past
+the assistant text padding. Long
+headers are truncated to the terminal width; result bodies,
 images, boxes, and tool spacers are hidden. Built-in, extension, and MCP calls
 are included. Execution, sandboxing, and agent-facing payloads are unchanged.
-In newer Pi fullscreen mode, click a folded row to expand its original details,
-then click the expanded call/result to collapse it. Regular terminals keep mouse
-input for terminal selection and scrollback; Ctrl+O expands tools in all modes.
+When a foreground run ends, each consecutive block of tool calls folds further
+into one disclosure row showing the call count and any failures. Only the failure
+count uses the error color; the disclosure and total stay muted. Assistant text
+stays visible, and restored history uses the same folded view. In newer Pi
+fullscreen mode, click a block disclosure to reveal its call rows, then click a
+call to expand its original details. Hover highlights compact call and disclosure
+rows using the selection background (reverse video for themes without one), and
+tool icons sit centered in a three-column gutter. Click the disclosure again to refold the
+block; native expanded call/result clicks collapse individual details. Regular
+terminals keep mouse input for terminal selection and scrollback; Ctrl+O expands
+all original tool details in both modes and folds them again on the next toggle.
 `/tool-output normal` restores ordinary rendering. Error result bodies are also
 hidden in minimal mode and remain available when expanded.
 

package/extensions/minimal-output/hook.ts

@@ -1,4 +1,4 @@
-import { truncateToWidth, type Component } from "@earendil-works/pi-tui";
+import { truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 import { readFileSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
@@ -6,8 +6,14 @@ import { pathToFileURL } from "node:url";
 import { stripVTControlCharacters } from "node:util";
 import type { Theme } from "@earendil-works/pi-coding-agent";
 
+interface ToolUI {
+  requestRender(): void;
+  children?: TranscriptComponent[];
+  handleViewportInput?(data: string): unknown;
+}
 interface ToolComponent {
   toolName: string;
+  toolCallId: string;
   args: unknown;
   callRendererComponent?: Component;
   expanded: boolean;
@@ -15,14 +21,21 @@ interface ToolComponent {
   result?: { isError?: boolean };
   showImages: boolean;
   resultRendererComponent?: unknown;
-  ui: { requestRender(): void };
+  ui: ToolUI;
   invalidate(): void;
   setExpanded(expanded: boolean): void;
   render(width: number): string[];
 }
 
+interface TranscriptComponent extends Component {
+  children?: TranscriptComponent[];
+  outputPad?: number;
+  lastMessage?: { content: { type: string; text?: string; thinking?: string }[]; stopReason?: string };
+}
+interface ToolGroup { members: ToolComponent[]; open: boolean; expanded: number }
+
 type Method = (this: ToolComponent, ...args: unknown[]) => unknown;
-interface ToolMouseEvent { type: string; button: string; y: number; shift?: boolean; alt?: boolean; ctrl?: boolean }
+interface ToolMouseEvent { type: string; button: string; x: number; y: number; screenX: number; screenY: number; width: number; shift?: boolean; alt?: boolean; ctrl?: boolean }
 type MouseHandler = (this: ToolComponent, event: ToolMouseEvent) => unknown;
 interface ToolPrototype {
   handleMouse?: MouseHandler;
@@ -39,16 +52,30 @@ interface HookState {
   owners: number;
   redraw(collapse?: boolean): void;
   restore(): void;
+  completeRun(): void;
+  restoreCompletedCalls(ids: Iterable<string>): void;
+  handleTerminalInput(data: string): void;
 }
 export interface MinimalOutputHook {
   setEnabled(enabled: boolean): void;
+  completeRun(): void;
+  restoreCompletedCalls(ids: Iterable<string>): void;
   dispose(): void;
 }
 
 const HOOK = Symbol.for("pi-better-harness.minimal-output-hook");
 const emptyResult = () => ({ render: () => [] as string[], invalidate() {} });
+const TOOL_ICONS: Record<string, string> = {
+  bash: "\u2318",
+  read: "\u25a4",
+  write: "\u2710",
+  edit: "\u270e",
+  grep: "\u2315",
+  find: "\u2316",
+  ls: "\u2261",
+};
 
-function compactCall(component: ToolComponent, width: number, theme?: Theme): string[] {
+function compactCall(component: ToolComponent, width: number, theme?: Theme, indent = 3): string[] {
   if (width <= 0) return [];
   // Render the call alone at a wider width so terminal wrapping becomes truncation.
   const header = component.callRendererComponent?.render(Math.max(4096, width + 1))
@@ -67,13 +94,35 @@ function compactCall(component: ToolComponent, width: number, theme?: Theme): st
     : text === component.toolName ? "" : text;
   const label = component.toolName === "bash" ? "Shell"
     : component.toolName.replace(/_/g, " ").replace(/^./, letter => letter.toUpperCase());
-  const marker = failed ? "!" : running ? "~" : ">";
   const suffix = failed ? " (failed)" : running ? " (running)" : "";
-  const title = `${marker} ${label}`;
+  const icon = TOOL_ICONS[component.toolName] ?? "\u25c7";
+  const title = ` ${icon} ${label}`;
   const styled = theme
-    ? `${theme.fg(failed ? "error" : "muted", title)}${detail ? `  ${theme.fg("dim", detail)}` : ""}${theme.fg(failed ? "error" : "muted", suffix)}`
+    ? ` ${theme.fg(failed ? "error" : running ? "accent" : "muted", icon)} ${theme.fg("muted", label)}${detail ? `  ${theme.fg("dim", detail)}` : ""}${theme.fg(failed ? "error" : "dim", suffix)}`
     : `${title}${detail ? `  ${detail}` : ""}${suffix}`;
-  return [truncateToWidth(styled, width)];
+  return [truncateToWidth(`${" ".repeat(Math.min(indent, Math.max(0, width - 1)))}${styled}`, width)];
+}
+
+function toolParent(component: ToolComponent): TranscriptComponent | undefined {
+  const visit = (children: TranscriptComponent[]): TranscriptComponent | undefined => {
+    for (const child of children) {
+      if (child.children?.includes(component)) return child;
+      if (child.children) {
+        const found = visit(child.children);
+        if (found) return found;
+      }
+    }
+    return undefined;
+  };
+  return visit(component.ui.children ?? []);
+}
+
+function paddingAnchor(component: ToolComponent, parent?: TranscriptComponent): TranscriptComponent | undefined {
+  const siblings = parent?.children ?? [];
+  for (let index = siblings.indexOf(component) - 1; index >= 0; index--) {
+    if (typeof siblings[index].outputPad === "number") return siblings[index];
+  }
+  return undefined;
 }
 
 function hostRequire(): NodeRequire {
@@ -136,15 +185,93 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
       updateDisplay: prototype.updateDisplay,
       getResultRenderer: prototype.getResultRenderer,
       getTextOutput: prototype.getTextOutput,
+      setExpanded: prototype.setExpanded,
       render: prototype.render,
       ...(typeof prototype.handleMouse === "function" ? { handleMouse: prototype.handleMouse } : {}),
     };
+    let mouseHandling = false;
+    const inputWrappers = new Map<ToolUI, { original: NonNullable<ToolUI["handleViewportInput"]>; wrapper: NonNullable<ToolUI["handleViewportInput"]> }>();
+    let hovered: { component: ToolComponent; row: number; left: number; top: number; width: number } | undefined;
+    const clearHover = () => {
+      if (!hovered) return;
+      const component = hovered.component;
+      hovered = undefined;
+      component.ui.requestRender();
+    };
+    const highlight = (component: ToolComponent, lines: string[], width: number): string[] => {
+      if (hovered?.component !== component) return lines;
+      const theme = getTheme?.();
+      if (width !== hovered.width || hovered.row >= lines.length) { clearHover(); return lines; }
+      if (theme) {
+        const row = lines[hovered.row] + " ".repeat(Math.max(0, width - visibleWidth(lines[hovered.row])));
+        const shaded = theme.bg("selectedBg", row);
+        lines[hovered.row] = shaded.startsWith("\x1b[49m") ? theme.inverse(row) : shaded;
+      }
+      return lines;
+    };
     const seen = new WeakSet<ToolComponent>();
     const components = new Set<WeakRef<ToolComponent>>();
+    let completed = new Map<string, object>();
+    let groups = new WeakMap<ToolComponent, ToolGroup>();
+    let layouts = new WeakMap<ToolComponent, { parent: TranscriptComponent; anchor?: TranscriptComponent }>();
+    const layoutFor = (component: ToolComponent) => {
+      const cached = layouts.get(component);
+      if (cached) return cached;
+      const parent = toolParent(component);
+      if (!parent) return undefined;
+      const layout = { parent, anchor: paddingAnchor(component, parent) };
+      layouts.set(component, layout);
+      return layout;
+    };
+    const groupFor = (component: ToolComponent, parent?: TranscriptComponent): ToolGroup | undefined => {
+      const cached = groups.get(component);
+      if (cached) return cached;
+      if (!completed.has(component.toolCallId) || component.isPartial || !parent?.children) return undefined;
+      let members: ToolComponent[] = [];
+      const save = () => {
+        if (!members.length) return;
+        const group = { members, open: false, expanded: members.filter(member => member.expanded).length };
+        for (const member of members) groups.set(member, group);
+        members = [];
+      };
+      for (const child of parent.children) {
+        const tool = child as ToolComponent;
+        if (seen.has(tool) && completed.has(tool.toolCallId) && !tool.isPartial && !groups.has(tool)) {
+          if (members.length && completed.get(members[0].toolCallId) !== completed.get(tool.toolCallId)) save();
+          members.push(tool);
+        } else if (typeof child.outputPad === "number" && child.lastMessage
+          && !["length", "error", "aborted"].includes(child.lastMessage.stopReason ?? "")
+          && !child.lastMessage.content.some(content => content.text?.trim() || content.thinking?.trim())) {
+          // Tool-only assistant messages occupy no transcript rows and do not split a visual block.
+          continue;
+        } else save();
+      }
+      save();
+      return groups.get(component);
+    };
     state = {
       enabled: false,
       owners: 0,
+      completeRun() {
+        const run = {};
+        for (const reference of components) {
+          const component = reference.deref();
+          if (component?.result && !component.isPartial && !completed.has(component.toolCallId)) {
+            completed.set(component.toolCallId, run);
+            if (this.enabled) component.setExpanded(false);
+          }
+        }
+        this.redraw();
+      },
+      restoreCompletedCalls(ids) {
+        const history = {};
+        completed = new Map(Array.from(ids, id => [id, history]));
+        groups = new WeakMap();
+        layouts = new WeakMap();
+        this.redraw();
+      },
       redraw(collapse = false) {
+        clearHover();
         for (const reference of components) {
           const component = reference.deref();
           if (!component) { components.delete(reference); continue; }
@@ -154,7 +281,12 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
         }
       },
       restore() {
-        for (const name of ["updateDisplay", "getResultRenderer", "getTextOutput", "render"] as const) {
+        clearHover();
+        for (const [ui, { original, wrapper }] of inputWrappers) {
+          if (ui.handleViewportInput === wrapper) ui.handleViewportInput = original;
+        }
+        inputWrappers.clear();
+        for (const name of ["updateDisplay", "getResultRenderer", "getTextOutput", "setExpanded", "render"] as const) {
           // Do not remove another extension's subsequently installed wrapper.
           if (prototype[name] === wrappers[name]) Object.assign(prototype, { [name]: originals[name] });
         }
@@ -162,10 +294,30 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
         delete prototype[HOOK];
         components.clear();
       },
+      handleTerminalInput(data) {
+        if (!hovered) return;
+        // Pi routes moves only to the new target; observe input to clear a row on exit.
+        const motion = /^\x1b\[<35;(\d+);(\d+)M$/.exec(data);
+        if (motion) {
+          const x = Number(motion[1]) - 1;
+          const y = Number(motion[2]) - 1;
+          if (y === hovered.top && x >= hovered.left && x < hovered.left + hovered.width) return;
+        }
+        clearHover();
+      },
     };
     const current = state;
     const wrappers = {
       updateDisplay(this: ToolComponent, ...args: unknown[]) {
+        if (typeof this.ui.handleViewportInput === "function" && !inputWrappers.has(this.ui)) {
+          const original = this.ui.handleViewportInput;
+          const wrapper = function(this: ToolUI, data: string) {
+            current.handleTerminalInput(data);
+            return original.call(this, data);
+          };
+          inputWrappers.set(this.ui, { original, wrapper });
+          this.ui.handleViewportInput = wrapper;
+        }
         if (!seen.has(this)) { seen.add(this); components.add(new WeakRef(this)); }
         if (!current.enabled || this.expanded) return originals.updateDisplay.apply(this, args);
         const showImages = this.showImages;
@@ -179,6 +331,15 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
           this.resultRendererComponent = lastRenderer;
         }
       },
+      setExpanded(this: ToolComponent, ...args: unknown[]) {
+        clearHover();
+        const group = groups.get(this);
+        const wasExpanded = this.expanded;
+        if (args[0] === false && !mouseHandling && group) group.open = false;
+        const result = originals.setExpanded.apply(this, args);
+        if (group) group.expanded += Number(this.expanded) - Number(wasExpanded);
+        return result;
+      },
       getResultRenderer(this: ToolComponent, ...args: unknown[]) {
         return current.enabled && !this.expanded ? emptyResult : originals.getResultRenderer.apply(this, args);
       },
@@ -186,17 +347,55 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
         return current.enabled && !this.expanded ? "" : originals.getTextOutput.apply(this, args);
       },
       render(this: ToolComponent, width: number): string[] {
-        return current.enabled && !this.expanded ? compactCall(this, width, getTheme?.()) : originals.render.call(this, width);
+        if (!current.enabled || this.expanded) return originals.render.call(this, width);
+        const layout = layoutFor(this);
+        const padding = layout?.anchor?.outputPad ?? 1;
+        const indent = Number.isFinite(padding) ? Math.max(0, Math.floor(padding)) + 2 : 3;
+        const group = groupFor(this, layout?.parent);
+        if (!group) return highlight(this, compactCall(this, width, getTheme?.(), indent), width);
+        const open = group.open || group.expanded > 0;
+        const first = group.members[0] === this;
+        const lines: string[] = [];
+        if (first && width > 0) {
+          const failed = group.members.filter(member => member.result?.isError).length;
+          const text = `${open ? "\u25be" : "\u25b8"} ${group.members.length} tool call${group.members.length === 1 ? "" : "s"}`;
+          const failure = failed ? `${failed} failed` : "";
+          const theme = getTheme?.();
+          const styled = theme
+            ? `${theme.fg("muted", text)}${failed ? `${theme.fg("dim", " \u00b7 ")}${theme.fg("error", failure)}` : ""}`
+            : `${text}${failed ? ` \u00b7 ${failure}` : ""}`;
+          lines.push(truncateToWidth(`${" ".repeat(Math.min(indent, Math.max(0, width - 1)))}${styled}`, width));
+        }
+        if (open) lines.push(...compactCall(this, width, getTheme?.(), indent + 2));
+        return highlight(this, lines, width);
       },
     };
     const mouseWrapper: MouseHandler = function(event) {
       if (current.enabled && !this.expanded) {
-        if (event.type !== "click" || event.button !== "left" || event.y !== 0 || event.shift || event.alt || event.ctrl) return undefined;
+        if (event.type === "move" && event.button === "none") {
+          const lines = this.render(event.width);
+          if (event.y < 0 || event.y >= lines.length) { clearHover(); return undefined; }
+          if (hovered?.component === this && hovered.row === event.y) return { handled: true, render: false };
+          clearHover();
+          hovered = { component: this, row: event.y, left: event.screenX - event.x, top: event.screenY, width: event.width };
+          return { handled: true, render: true };
+        }
+        if (event.type !== "click" || event.button !== "left" || event.shift || event.alt || event.ctrl) return undefined;
+        const group = groupFor(this, layoutFor(this)?.parent);
+        if (group?.members[0] === this && event.y === 0) {
+          group.open = !(group.open || group.expanded > 0);
+          if (!group.open) for (const member of group.members) member.setExpanded(false);
+          this.ui.requestRender();
+          return { handled: true, render: true };
+        }
+        if (event.y !== (group?.members[0] === this ? 1 : 0)) return undefined;
         this.setExpanded(true);
         this.ui.requestRender();
         return { handled: true, render: true };
       }
-      return originals.handleMouse?.call(this, event);
+      mouseHandling = true;
+      try { return originals.handleMouse?.call(this, event); }
+      finally { mouseHandling = false; }
     };
     if (originals.handleMouse) prototype.handleMouse = mouseWrapper;
     Object.assign(prototype, wrappers);
@@ -206,6 +405,8 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
   current.owners += 1;
   let disposed = false;
   return {
+    completeRun() { if (!disposed) current.completeRun(); },
+    restoreCompletedCalls(ids) { if (!disposed) current.restoreCompletedCalls(ids); },
     setEnabled(enabled) {
       if (disposed) return;
       current.enabled = enabled;

package/extensions/minimal-output/index.ts

@@ -7,6 +7,7 @@ const ENTRY = "pi-better-harness-tool-output";
 export default function minimalOutputExtension(pi: ExtensionAPI): void {
   let hook: MinimalOutputHook | undefined;
   let enabled = false;
+  let running = false;
 
   function status(ctx: ExtensionContext): void {
     ctx.ui.setStatus(ENTRY, enabled ? "tools: minimal" : undefined);
@@ -44,6 +45,8 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     }
     // Observe transcript components from startup, so the toggle also redraws existing rows.
     if (await ensureHook(ctx)) {
+      hook!.restoreCompletedCalls(ctx.sessionManager.getBranch().flatMap(entry =>
+        entry.type === "message" && entry.message.role === "toolResult" ? [entry.message.toolCallId] : []));
       if (enabled) collapseTools(ctx);
       hook!.setEnabled(enabled);
     } else enabled = false;
@@ -59,6 +62,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     enabled = data.enabled;
     if (enabled) collapseTools(ctx);
     hook!.setEnabled(enabled);
+    if (enabled && !running) hook!.completeRun();
     status(ctx);
   }
 
@@ -73,6 +77,12 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
   register();
   pi.on("session_start", async (_event, ctx) => { subscribe(); await restore(ctx); register(); });
   pi.on("session_tree", async (_event, ctx) => { await restore(ctx); });
+  pi.on("agent_start", () => { running = true; });
+  pi.on("agent_settled", (_event, ctx) => {
+    running = false;
+    if (enabled) ctx.ui.setToolsExpanded(false);
+    hook?.completeRun();
+  });
 
   pi.on("session_shutdown", () => {
     stopSettings?.();
@@ -80,6 +90,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     hook?.dispose();
     hook = undefined;
     enabled = false;
+    running = false;
   });
 
   pi.registerCommand("tool-output", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.22.0",
+  "version": "0.24.0",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, and structured plans.",
   "license": "MIT",
   "type": "module",