pi-better-harness 0.15.1 → 0.15.2

package/README.md

@@ -63,11 +63,12 @@ need interactive confirmation. Full policy: [pi-better-sandbox](https://github.c
 ## Minimal Tool Output
 
 The bundled harness also provides `/tool-output minimal`, `/tool-output normal`,
-and `/tool-output` (toggle). Minimal mode leaves the current tool run visible,
-then folds every finished run between model texts into one line. Built-in,
+and `/tool-output` (toggle). Minimal mode hides tool blocks entirely, including
+running calls, headers, results, images, summary rows, and tool spacers. Built-in,
 extension, and MCP calls are included. Execution, sandboxing, and agent-facing
-payloads are unchanged. Ctrl+O unfolds runs and reveals results. Clickable Pi
-builds can also open one folded run by clicking its summary.
+payloads are unchanged. Ctrl+O reveals the original tool blocks; Ctrl+O again
+hides them. `/tool-output normal` restores ordinary rendering. Error results
+are also hidden in minimal mode and remain available when revealed.
 
 Normal mode is the default. The preference is saved in the current session,
 including resume/reload. This is a version-sensitive internal TUI adapter,

package/extensions/minimal-output/hook.ts

@@ -7,10 +7,7 @@ interface ToolComponent {
   expanded: boolean;
   showImages: boolean;
   resultRendererComponent?: unknown;
-  toolName?: string;
-  toolCallId?: string;
-  result?: { isError?: boolean };
-  ui: { requestRender(): void; children?: ChatContainer[] };
+  ui: { requestRender(): void };
   invalidate(): void;
   setExpanded(expanded: boolean): void;
   render(width: number): string[];
@@ -23,43 +20,21 @@ interface ToolPrototype {
   getTextOutput: Method;
   setExpanded: Method;
   invalidate: Method;
+  render: ToolComponent["render"];
   [HOOK]?: HookState;
 }
-interface ChatContainer {
-  children: unknown[];
-  render: (width: number) => string[];
-  mouseLayout?: { width: number; children: Array<{ component: unknown; height: number }> };
-  [CHAT]?: { original: (width: number) => string[]; wrapper: (width: number) => string[] };
-}
-interface ContainerPrototype {
-  addChild: (child: unknown, ...rest: unknown[]) => unknown;
-  render: (width: number) => string[];
-  [ADD]?: { original: ContainerPrototype["addChild"]; wrapper: ContainerPrototype["addChild"] };
-}
 interface HookState {
   enabled: boolean;
   owners: number;
-  foldsTurns: boolean;
-  closeRuns(): void;
   redraw(collapse?: boolean): void;
   restore(): void;
-  installContainer(prototype: ContainerPrototype): void;
 }
 export interface MinimalOutputHook {
   setEnabled(enabled: boolean): void;
   dispose(): void;
-  readonly foldsTurns: boolean;
-}
-interface FoldSummary {
-  render(width: number): string[];
-  invalidate(): void;
-  handleMouse(event: { type?: string; button?: string }): { handled: true } | undefined;
-  setTools(tools: ToolComponent[]): void;
 }
 
 const HOOK = Symbol.for("pi-better-harness.minimal-output-hook");
-const CHAT = Symbol.for("pi-better-harness.minimal-output-chat");
-const ADD = Symbol.for("pi-better-harness.minimal-output-add-child");
 const emptyResult = () => ({ render: () => [] as string[], invalidate() {} });
 
 function hostRequire(): NodeRequire {
@@ -96,25 +71,6 @@ export async function loadToolPrototype(): Promise<ToolPrototype> {
   return module.ToolExecutionComponent.prototype;
 }
 
-/** Use the actual tool class's Container base, including in bundled hosts. */
-export async function loadContainerPrototype(): Promise<ContainerPrototype> {
-  const prototype = Object.getPrototypeOf(await loadToolPrototype());
-  if (typeof prototype?.addChild !== "function" || typeof prototype?.render !== "function") {
-    throw new Error("Pi's chat container API is incompatible: missing Container.addChild. Turn folding is unavailable.");
-  }
-  return prototype;
-}
-
-export async function loadMutedText(): Promise<(text: string) => string> {
-  const entry = sdkEntry(hostRequire());
-  // The bundled SDK does not export its live theme singleton.
-  if (bundledHostEntry(entry)) return (text) => text;
-  const theme = await import(pathToFileURL(join(dirname(entry), "modes/interactive/theme/theme.js")).href);
-  return (text) => {
-    try { return theme.theme.fg("muted", text); } catch { return text; }
-  };
-}
-
 // Pi's ESM-only export cannot be resolved with require.resolve on older SDKs.
 function sdkEntry(require: ReturnType<typeof createRequire>): string {
   for (const directory of require.resolve.paths("@earendil-works/pi-coding-agent") ?? []) {
@@ -128,38 +84,9 @@ function sdkEntry(require: ReturnType<typeof createRequire>): string {
   throw new Error("Could not locate the running Pi SDK. Normal output remains enabled.");
 }
 
-function hasModelText(component: unknown): boolean {
-  const content = (component as { lastMessage?: { content?: unknown } } | null)?.lastMessage?.content;
-  if (!Array.isArray(content)) return false;
-  return content.some((block) => block?.type === "text" && typeof block.text === "string" && block.text.trim().length > 0);
-}
-
-function formatRun(tools: ToolComponent[], open: boolean): string {
-  const counts = new Map<string, number>();
-  let errors = 0;
-  for (const tool of tools) {
-    const name = tool.toolName || "tool";
-    counts.set(name, (counts.get(name) ?? 0) + 1);
-    if (tool.result?.isError) errors += 1;
-  }
-  const names = [...counts].map(([name, count]) => count > 1 ? `${name} ×${count}` : name);
-  const noun = tools.length === 1 ? "tool" : "tools";
-  const error = errors === 0 ? "" : errors === 1 ? " · 1 error" : ` · ${errors} errors`;
-  return `${open ? "▾" : "▸"} ${tools.length} ${noun}${error} · ${names.join(", ")}`;
-}
-
-function clip(text: string, width: number): string {
-  if (width <= 0 || text.length <= width) return text;
-  return width === 1 ? "…" : `${text.slice(0, width - 1)}…`;
-}
-
 /** Internal TUI adapter: no tools are replaced and no result content is changed. */
-export function installMinimalOutputHook(
-  prototype: ToolPrototype,
-  containerPrototype?: ContainerPrototype,
-  muted: (text: string) => string = (text) => text,
-): MinimalOutputHook {
-  for (const name of ["updateDisplay", "getResultRenderer", "getTextOutput", "setExpanded", "invalidate"] as const) {
+export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutputHook {
+  for (const name of ["updateDisplay", "getResultRenderer", "getTextOutput", "setExpanded", "invalidate", "render"] as const) {
     if (typeof prototype[name] !== "function") {
       throw new Error(`Pi's tool display API is incompatible: missing ${name}. Normal output remains enabled.`);
     }
@@ -170,158 +97,35 @@ export function installMinimalOutputHook(
       updateDisplay: prototype.updateDisplay,
       getResultRenderer: prototype.getResultRenderer,
       getTextOutput: prototype.getTextOutput,
+      render: prototype.render,
     };
     const seen = new WeakSet<ToolComponent>();
     const components = new Set<WeakRef<ToolComponent>>();
-    const chats = new Set<WeakRef<ChatContainer>>();
-    const summaries = new WeakMap<ToolComponent, FoldSummary>();
-    const openedAt = new WeakMap<ToolComponent, number>();
-    let generation = 0;
-    let containerHooked = false;
-    let installedContainer: ContainerPrototype | undefined;
-    const isOpen = (tool: ToolComponent) => openedAt.get(tool) === generation;
-    const laterModelText = (children: unknown[], index: number) => {
-      for (let i = index; i < children.length; i++) {
-        if (hasModelText(children[i])) return true;
-      }
-      return false;
-    };
-    const attachFromTool = (tool: ToolComponent) => {
-      for (const child of tool.ui?.children ?? []) {
-        if (child?.children?.includes(tool)) wrapChat(child);
-      }
-    };
-    const wrapChat = (container: ChatContainer) => {
-      if (!container || seen.has(container as unknown as ToolComponent) || container[CHAT] || typeof container.render !== "function") return;
-      const original = container.render;
-      const wrapper = function (this: ChatContainer, width: number) {
-        if (!current.enabled || !Array.isArray(this.children) || !needsFold(this.children)) return original.call(this, width);
-        const lines: string[] = [];
-        const mouseChildren: Array<{ component: unknown; height: number }> = [];
-        const push = (component: { render(width: number): string[] }) => {
-          const childLines = component.render(width) ?? [];
-          mouseChildren.push({ component, height: childLines.length });
-          lines.push(...childLines);
-        };
-        let index = 0;
-        while (index < this.children.length) {
-          const child = this.children[index];
-          if (!seen.has(child as ToolComponent)) {
-            push(child as { render(width: number): string[] });
-            index += 1;
-            continue;
-          }
-          let end = index;
-          while (end < this.children.length && seen.has(this.children[end] as ToolComponent)) end += 1;
-          const tools = this.children.slice(index, end) as ToolComponent[];
-          const closed = laterModelText(this.children, end) && tools.every((tool) => !tool.expanded);
-          if (!closed) {
-            for (const tool of tools) push(tool);
-          } else {
-            const open = isOpen(tools[0]!);
-            let summary = summaries.get(tools[0]!);
-            if (!summary) {
-              summary = createSummary(tools[0]!);
-              summaries.set(tools[0]!, summary);
-            }
-            summary.setTools(tools);
-            push(summary);
-            if (open) for (const tool of tools) push(tool);
-          }
-          index = end;
-        }
-        this.mouseLayout = { width, children: mouseChildren };
-        return lines;
-      };
-      container[CHAT] = { original, wrapper };
-      container.render = wrapper;
-      chats.add(new WeakRef(container));
-    };
-    const createSummary = (anchor: ToolComponent): FoldSummary => {
-      let tools = [anchor];
-      return {
-        setTools(next) { tools = next; },
-        invalidate() {},
-        render(width) {
-          return ["", muted(clip(formatRun(tools, isOpen(anchor)), width))];
-        },
-        handleMouse(event) {
-          if (event.type !== "click" || (event.button && event.button !== "left")) return undefined;
-          if (isOpen(anchor)) openedAt.delete(anchor);
-          else openedAt.set(anchor, generation);
-          anchor.ui.requestRender();
-          return { handled: true };
-        },
-      };
-    };
-    const needsFold = (children: unknown[]) => {
-      let index = 0;
-      while (index < children.length) {
-        if (!seen.has(children[index] as ToolComponent)) { index += 1; continue; }
-        let end = index;
-        while (end < children.length && seen.has(children[end] as ToolComponent)) end += 1;
-        const tools = children.slice(index, end) as ToolComponent[];
-        if (laterModelText(children, end) && tools.every((tool) => !tool.expanded)) return true;
-        index = end;
-      }
-      return false;
-    };
     state = {
       enabled: false,
       owners: 0,
-      foldsTurns: false,
-      closeRuns() { generation += 1; },
       redraw(collapse = false) {
         for (const reference of components) {
           const component = reference.deref();
           if (!component) { components.delete(reference); continue; }
           if (collapse) component.setExpanded(false);
           else component.invalidate();
-          attachFromTool(component);
           component.ui.requestRender();
         }
       },
-      installContainer(next) {
-        if (containerHooked) return;
-        if (typeof next.addChild !== "function") {
-          throw new Error("Pi's chat container API is incompatible: missing Container.addChild. Turn folding is unavailable.");
-        }
-        const original = next[ADD]?.original ?? next.addChild;
-        const wrapper: ContainerPrototype["addChild"] = function (this: ChatContainer, child, ...rest) {
-          const result = original.call(this, child, ...rest);
-          if (seen.has(child as ToolComponent)) wrapChat(this);
-          return result;
-        };
-        next.addChild = wrapper;
-        next[ADD] = { original, wrapper };
-        containerHooked = true;
-        installedContainer = next;
-        state!.foldsTurns = true;
-      },
       restore() {
         for (const name of Object.keys(originals) as Array<keyof typeof originals>) {
           // Do not remove another extension's subsequently installed wrapper.
-          if (prototype[name] === wrappers[name]) prototype[name] = originals[name];
+          if (prototype[name] === wrappers[name]) Object.assign(prototype, { [name]: originals[name] });
         }
         delete prototype[HOOK];
         components.clear();
-        if (installedContainer && installedContainer[ADD]?.wrapper === installedContainer.addChild) {
-          installedContainer.addChild = installedContainer[ADD].original;
-          delete installedContainer[ADD];
-        }
-        for (const reference of chats) {
-          const container = reference.deref();
-          if (container?.[CHAT] && container.render === container[CHAT].wrapper) container.render = container[CHAT].original;
-          if (container) delete container[CHAT];
-        }
-        chats.clear();
       },
     };
     const current = state;
     const wrappers = {
       updateDisplay(this: ToolComponent, ...args: unknown[]) {
         if (!seen.has(this)) { seen.add(this); components.add(new WeakRef(this)); }
-        attachFromTool(this);
         if (!current.enabled || this.expanded) return originals.updateDisplay.apply(this, args);
         const showImages = this.showImages;
         const lastRenderer = this.resultRendererComponent;
@@ -340,20 +144,20 @@ export function installMinimalOutputHook(
       getTextOutput(this: ToolComponent, ...args: unknown[]) {
         return current.enabled && !this.expanded ? "" : originals.getTextOutput.apply(this, args);
       },
+      render(this: ToolComponent, width: number): string[] {
+        return current.enabled && !this.expanded ? [] : originals.render.call(this, width);
+      },
     };
     Object.assign(prototype, wrappers);
     prototype[HOOK] = state;
   }
   const current = state;
-  if (containerPrototype) current.installContainer(containerPrototype);
   current.owners += 1;
   let disposed = false;
   return {
-    foldsTurns: current.foldsTurns,
     setEnabled(enabled) {
       if (disposed) return;
       current.enabled = enabled;
-      if (enabled) current.closeRuns();
       current.redraw(enabled);
     },
     dispose() {

package/extensions/minimal-output/index.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { installMinimalOutputHook, loadContainerPrototype, loadMutedText, loadToolPrototype, type MinimalOutputHook } from "./hook.ts";
+import { installMinimalOutputHook, loadToolPrototype, type MinimalOutputHook } from "./hook.ts";
 
 const ENTRY = "pi-better-harness-tool-output";
 
@@ -24,12 +24,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     }
     if (hook) return true;
     try {
-      const [toolPrototype, containerPrototype, muted] = await Promise.all([
-        loadToolPrototype(),
-        loadContainerPrototype().catch(() => undefined),
-        loadMutedText().catch(() => undefined),
-      ]);
-      hook = installMinimalOutputHook(toolPrototype, containerPrototype, muted);
+      hook = installMinimalOutputHook(await loadToolPrototype());
       return true;
     } catch (error) {
       ctx.ui.notify(`Minimal tool output is unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
@@ -61,11 +56,11 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("tool-output", {
-    description: "[minimal|normal] — Fold finished tool runs, or restore normal output. No argument toggles. Display only.",
+    description: "[minimal|normal] — Hide tool blocks entirely, or restore normal output. No argument toggles. Display only.",
     getArgumentCompletions: (argumentPrefix) => {
       const prefix = argumentPrefix.trimStart().toLowerCase();
       const matches = [
-        { value: "minimal", label: "minimal", description: "Fold finished tool runs after the next model text" },
+        { value: "minimal", label: "minimal", description: "Hide all tool blocks, including running tools" },
         { value: "normal", label: "normal", description: "Restore ordinary tool output" },
       ].filter((option) => option.value.startsWith(prefix));
       return matches.length > 0 ? matches : null;
@@ -83,9 +78,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
       pi.appendEntry(ENTRY, { version: 1, enabled });
       status(ctx);
       ctx.ui.notify(enabled
-        ? hook!.foldsTurns
-          ? "Minimal tool output on. Finished tool runs fold after the next model text. Ctrl+O reveals them; click a folded run when the terminal supports it."
-          : "Minimal tool output on, but turn folding is unavailable in this Pi version. Ctrl+O reveals results."
+        ? "Minimal tool output on. Tool blocks are hidden. Ctrl+O reveals them."
         : "Normal tool output restored.", "info");
     },
   });

package/package.json

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