pi-better-harness 0.13.1 → 0.15.0

package/README.md

@@ -63,11 +63,11 @@ 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 hides every collapsed result body,
-including built-in, extension, and MCP text/images, without changing execution,
-sandboxing, or agent-facing payloads. Tool headers and error coloring remain;
-Ctrl+O reveals results, and fullscreen Pi versions with clickable tool rows
-also support clicking headers.
+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,
+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.
 
 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,9 +7,13 @@ interface ToolComponent {
   expanded: boolean;
   showImages: boolean;
   resultRendererComponent?: unknown;
-  ui: { requestRender(): void };
+  toolName?: string;
+  toolCallId?: string;
+  result?: { isError?: boolean };
+  ui: { requestRender(): void; children?: ChatContainer[] };
   invalidate(): void;
   setExpanded(expanded: boolean): void;
+  render(width: number): string[];
 }
 
 type Method = (this: ToolComponent, ...args: unknown[]) => unknown;
@@ -21,36 +25,83 @@ interface ToolPrototype {
   invalidate: Method;
   [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() {} });
 
-/** Resolve the running host's SDK, not a second SDK bundled beside the extension. */
-export async function loadToolPrototype(): Promise<ToolPrototype> {
+function hostRequire(): NodeRequire {
   let require = createRequire(import.meta.url);
   if (process.argv[1]) {
     try {
-      const hostRequire = createRequire(realpathSync(process.argv[1]));
-      sdkEntry(hostRequire);
-      require = hostRequire;
+      const candidate = createRequire(realpathSync(process.argv[1]));
+      sdkEntry(candidate);
+      require = candidate;
     } catch { /* SDK embedding or a test runner: use the extension's SDK. */ }
   }
-  const entry = sdkEntry(require);
+  return require;
+}
+
+/** Resolve the running host's SDK, not a second SDK bundled beside the extension. */
+export async function loadToolPrototype(): Promise<ToolPrototype> {
+  const entry = sdkEntry(hostRequire());
   const path = join(dirname(entry), "modes/interactive/components/tool-execution.js");
   const module = await import(pathToFileURL(path).href);
   return module.ToolExecutionComponent.prototype;
 }
 
+/** Chat rows are Container children. Patch that host class, not a second copy. */
+export async function loadContainerPrototype(): Promise<ContainerPrototype> {
+  const entry = sdkEntry(hostRequire());
+  const tuiPath = createRequire(entry).resolve("@earendil-works/pi-tui");
+  const tui = await import(pathToFileURL(tuiPath).href);
+  const prototype = tui.Container?.prototype;
+  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());
+  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") ?? []) {
@@ -64,8 +115,37 @@ 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): MinimalOutputHook {
+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) {
     if (typeof prototype[name] !== "function") {
       throw new Error(`Pi's tool display API is incompatible: missing ${name}. Normal output remains enabled.`);
@@ -80,18 +160,131 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
     };
     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.
@@ -99,12 +292,23 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
         }
         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;
@@ -128,12 +332,15 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
     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, loadToolPrototype, type MinimalOutputHook } from "./hook.ts";
+import { installMinimalOutputHook, loadContainerPrototype, loadMutedText, loadToolPrototype, type MinimalOutputHook } from "./hook.ts";
 
 const ENTRY = "pi-better-harness-tool-output";
 
@@ -24,7 +24,12 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     }
     if (hook) return true;
     try {
-      hook = installMinimalOutputHook(await loadToolPrototype());
+      const [toolPrototype, containerPrototype, muted] = await Promise.all([
+        loadToolPrototype(),
+        loadContainerPrototype().catch(() => undefined),
+        loadMutedText().catch(() => undefined),
+      ]);
+      hook = installMinimalOutputHook(toolPrototype, containerPrototype, muted);
       return true;
     } catch (error) {
       ctx.ui.notify(`Minimal tool output is unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
@@ -56,11 +61,11 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
   });
 
   pi.registerCommand("tool-output", {
-    description: "Tool output: minimal | normal (no argument toggles). Display only; agent results are unchanged.",
+    description: "[minimal|normal] — Fold finished tool runs, or restore normal output. No argument toggles. Display only.",
     getArgumentCompletions: (argumentPrefix) => {
       const prefix = argumentPrefix.trimStart().toLowerCase();
       const matches = [
-        { value: "minimal", label: "minimal", description: "Hide collapsed tool result bodies" },
+        { value: "minimal", label: "minimal", description: "Fold finished tool runs after the next model text" },
         { value: "normal", label: "normal", description: "Restore ordinary tool output" },
       ].filter((option) => option.value.startsWith(prefix));
       return matches.length > 0 ? matches : null;
@@ -78,7 +83,9 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
       pi.appendEntry(ENTRY, { version: 1, enabled });
       status(ctx);
       ctx.ui.notify(enabled
-        ? "Minimal tool output on. Click a tool in fullscreen mode or use Ctrl+O to reveal results."
+        ? 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."
         : "Normal tool output restored.", "info");
     },
   });

package/node_modules/pi-better-background-tasks/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-background-tasks",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Pi extension for durable background shell tasks, watchers, logs, and status inspection.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-background-tasks/src/shared-navigator.ts

@@ -66,6 +66,8 @@ export type BackgroundWorkProvider = {
   detail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null;
   armCloseLabel(row: BackgroundWorkRow): string;
   close(id: string): BackgroundWorkCloseOutcome;
+  /** Return true when this detail handled the key. The navigator refreshes the sheet. */
+  handleDetailInput?(id: string, data: string): boolean;
   onVisibleChanged?(notify: () => void): () => void;
 };
 
@@ -559,7 +561,7 @@ function rowSummary(row: InternalRow): string {
     const parts: string[] = [];
     if (row.statusTone !== "running" && row.kind !== "main agent") parts.push(singleLine(row.status));
     if (row.model) parts.push(row.effort ? `${singleLine(row.model)} ${singleLine(row.effort)}` : singleLine(row.model));
-    if (row.tool) parts.push(`tool ${singleLine(row.tool)}`);
+    if (row.tool) parts.push(singleLine(row.tool));
     if (row.tokens) parts.push(singleLine(row.tokens));
     else if (row.primary) parts.push(singleLine(row.primary));
     if (parts.length) return parts.join(" · ");
@@ -703,12 +705,7 @@ function handleMainListInput(data: string, deps: HostDeps): boolean {
     return true;
   }
   if (deps.matchKey(data, "enter")) {
-    const selected = selectedMainListRow();
-    if (selected?.parentRow) {
-      unfocusMainList();
-      dismissOverlay();
-    }
-    else openNavigator();
+    openNavigator();
     return true;
   }
   if (data === "x" || data === "X" || deps.matchKey(data, "x") || deps.matchKey(data, "X")) {
@@ -851,7 +848,8 @@ function createOverlayComponent(
   let logTailRows: number = DEFAULT_LOG_TAIL_ROWS;
   const expandedSections = new Set<string>();
   let detailId: string = initialDetailId;
-  let detail: BackgroundWorkDetail | null = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? null;
+  const initialRow = initialRows.find((row) => row.navigatorId === detailId);
+  let detail: BackgroundWorkDetail | null = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? (initialRow ? fallbackDetail(initialRow) : null);
   applyDefaultExpandedSections(detail, expandedSections);
   {
     const idx = overlayState.rows.findIndex((row) => row.navigatorId === detailId);
@@ -891,8 +889,7 @@ function createOverlayComponent(
   }
 
   function activateSelectedRow(): void {
-    if (selectedRow()?.parentRow) close();
-    else openDetail();
+    openDetail();
   }
 
   function clearCloseArm(): void {
@@ -922,10 +919,6 @@ function createOverlayComponent(
   function openDetail(): void {
     const row = selectedRow();
     if (!row) return;
-    if (row.parentRow) {
-      close();
-      return;
-    }
     clearCloseArm();
     detailId = row.navigatorId;
     expandedSections.clear();
@@ -1073,6 +1066,15 @@ function createOverlayComponent(
           requestRender();
         }
       }
+      else if (data === "m" || data === "M" || data === "\x13" || deps.matchKey(data, "ctrl+s")) {
+        const row = selectedRow();
+        const provider = row ? state().providers.get(row.providerId) : undefined;
+        const key = data === "m" || data === "M" ? "m" : "ctrl+s";
+        if (!row || !provider?.handleDetailInput?.(row.id, key)) return;
+        detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
+        refreshMainListWidget();
+        requestRender();
+      }
       else if (data === "l" || data === "L") {
         logTailRows = cycleLogTailRows(logTailRows);
         if (detailId) detail = detailFor(detailId, Date.now(), { logTailLines: logTailRows }) ?? detail;
@@ -1091,8 +1093,7 @@ function createOverlayComponent(
       if (idx < 0) return;
       overlayState.selected = idx;
       state().mainListSelectedId = navigatorId;
-      if (overlayState.rows[idx]!.parentRow) close();
-      else openDetail();
+      openDetail();
     },
     /** Close the overlay (done), e.g. when the navigator is disposed. */
     dismiss() { close(); },
@@ -1150,7 +1151,11 @@ function buildTranscriptDetailLines(
     ...detail.metadata.map((item) => `   ${item.label.padEnd(8, " ").slice(0, 8)} ${item.value}`),
   ];
   const transcriptHeader = ["", dim(section(`transcript · latest ${tailRows} rows`, width), fg)];
-  if (detail.transcriptDiagnostic) transcriptHeader.push(`   ${dim(detail.transcriptDiagnostic, fg)}`);
+  if (detail.transcriptDiagnostic) {
+    for (const diagnosticRow of detail.transcriptDiagnostic.split(/\r\n|\r|\n/)) {
+      transcriptHeader.push(`   ${dim(diagnosticRow, fg)}`);
+    }
+  }
   // Metadata always renders; the transcript tail takes only the rows left over (the tail size is a cap, not a guarantee).
   lines.push(...optionalMetadata);
   if (options.maxRows !== undefined) {

package/node_modules/pi-better-goal/README.md

@@ -17,7 +17,7 @@ Use `pi-better-goal` when a Pi session should keep an explicit objective visible
 - Background work that finishes while an `ask_user_question` is pending is handed to the agent right after the answer.
 - A compact goal widget that does not replace Pi's footer.
 - Background activity tracking for subagents and other registered providers.
-- A progress-aware follow-up loop that holds after repeated identical outcomes.
+- A progress-aware follow-up loop with ten identical no-progress retries and linear backoff (30s through 300s by default), followed by a hold recoverable with `/goal resume`. Delays saturate at Node's timer limit, and observed background drains reset progress before callback turns can cancel the wake. Pi's network retry policy remains independent.
 - An observable-progress stall state for active goals.
 
 ## Skill-Owned Workflows

package/node_modules/pi-better-goal/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-goal",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "Pi extension for goal tracking with background-aware continuation.",
   "license": "MIT",
   "type": "module",