pi-better-harness 0.14.0 → 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-sandbox/README.md

@@ -121,8 +121,9 @@ repository's `.git/hooks` or `.git/config` (`core.hooksPath`, `core.fsmonitor`,
 Write, those paths are also protected from removal and renaming.
 
 Space applies every change immediately, including higher permission levels,
-capabilities switched on, and a sandbox switched off. Saving looser defaults
-still needs a second Enter, with a prompt listing what would loosen. The focused
+capabilities switched on, and a sandbox switched off. `ctrl+s` saves the
+defaults from any row on the first press, and the note names anything that
+loosened. Enter on the Save row still saves. The focused
 row has a full-width background and bold text; the selected Main/Subagents cell
 also uses inverse styling. No model
 tool can change these settings. Other rows toggle Off/On. Detail cells under an

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

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-sandbox",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Pi extension with independent Main and Subagents permission profiles, file guards, and OS sandbox enforcement.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-sandbox/permissions-page.ts

@@ -9,7 +9,7 @@ export interface PermissionPageHandlers {
     getConfig(): PermissionSettings;
     change(settings: PermissionSettings): void | Promise<void>;
     save(settings: PermissionSettings): void | Promise<void>;
-    /** What saving `settings` would loosen versus the saved defaults; non-empty requires a confirming second Enter. */
+    /** What saving `settings` would loosen versus the saved defaults. Reported after the save. */
     loosening?(settings: PermissionSettings): string[];
     /** Trusted-tool candidates registered in the running Pi (builtins and harness tools excluded). */
     discoverTools?(): readonly Pick<DiscoveredTool, "name" | "package">[];
@@ -128,7 +128,6 @@ export function createPermissionsPage(
     let row = 0;
     let column = 0;
     let busy = false;
-    let pendingConfirmation: string | undefined;
 
     function report(error: unknown): void {
         message = errorText(error);
@@ -202,19 +201,10 @@ export function createPermissionsPage(
             report(error);
             return;
         }
-        const key = JSON.stringify(settings);
-        if (loosened.length && pendingConfirmation !== key) {
-            pendingConfirmation = key;
-            message = `Looser defaults (${loosened.join("; ")}). Press Enter again to save.`;
-            isError = false;
-            requestRender();
-            return;
-        }
-        pendingConfirmation = undefined;
         busy = true;
         try {
             await handlers.save(snapshot(settings));
-            message = "Defaults saved.";
+            message = loosened.length ? `Defaults saved. Looser: ${loosened.join("; ")}.` : "Defaults saved.";
             isError = false;
             requestRender();
         } catch (error) {
@@ -238,7 +228,6 @@ export function createPermissionsPage(
     return {
         invalidate() {},
         handleInput(data: string) {
-            if (!matchesKey(data, Key.enter)) pendingConfirmation = undefined;
             if (matchesKey(data, Key.escape)) {
                 close();
             } else if (matchesKey(data, Key.up)) {
@@ -257,6 +246,8 @@ export function createPermissionsPage(
                 requestRender();
             } else if (matchesKey(data, Key.space)) {
                 void change();
+            } else if (matchesKey(data, "ctrl+s")) {
+                void save();
             } else if (matchesKey(data, Key.enter) && row === saveRow()) {
                 void save();
             } else if (matchesKey(data, Key.enter)) {
@@ -330,7 +321,7 @@ export function createPermissionsPage(
             const contextual = tool ? (tool.kind === "guarded" ? GUARDED_HINT : TRUSTED_HINT)
                 : selected && settings ? cellHint(selected, settings[columns[column]!]) : undefined;
             for (const hint of [
-                "↑↓ Select · ←→ Column/fold · Space Toggle tool/group · Enter Fold/Save · Esc Back",
+                "↑↓ Select · ←→ Column/fold · Space Toggle · ctrl+s Save · Enter Fold · Esc Back",
                 "Changes apply to new launches. Background tasks follow their launcher.",
                 "Stored credentials: known files only; excludes OS vaults and environment tokens.",
                 "Trusted tools run outside the file rules.",
@@ -338,8 +329,7 @@ export function createPermissionsPage(
             ]) output.push(theme.fg("dim", truncateToWidth(hint, w, "")));
             if (message) {
                 const clean = message.replace(/[\r\n]+/g, " ");
-                const confirmation = /^(.*) (Press Enter again to save\.)$/.exec(clean);
-                const messages = confirmation && visibleWidth(clean) > w ? [confirmation[1]!, confirmation[2]!] : [clean];
+                const messages = visibleWidth(clean) > w && clean.includes(". ") ? clean.split(/(?<=\. )/) : [clean];
                 for (const text of messages) output.push(theme.fg(isError ? "error" : "muted", truncateToWidth(text, w, "")));
             }
             return output;

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

@@ -38,7 +38,10 @@ Linux confinement requires a usable `bubblewrap` backend and Pi SDK 0.82.1 or ne
 `config.json` sets `delegationMode` to `manual`, `adaptive` (default), or
 `coordinator`. `/subagents` displays the active mode, and
 `/subagents mode manual|adaptive|coordinator` changes it for the current
-session without changing config. Manual delegates only on explicit user or workflow request, even with a
+session without changing config. `/subagents save` writes the current mode as
+the next session's default. The navigator's `main` row opens the same control:
+`m` cycles the session mode, `ctrl+s` saves that default, and `x`
+does not stop it. Manual delegates only on explicit user or workflow request, even with a
 plan. Adaptive delegates substantial independent work when useful. Coordinator
 uses `agents_catalog` to discover current role descriptions and delegates every
 nontrivial role-owned task, while the foreground coordinates, integrates, and

package/node_modules/pi-better-subagents/agent-commands.ts

@@ -123,7 +123,7 @@ interface ParsedArgs {
 
 export function registerAgentCommands(pi: Pick<ExtensionAPI, "registerCommand">, deps: AgentCommandDeps = {}): void {
     pi.registerCommand("agents", {
-        description: "List, inspect, create, reload, or import Codex agent definitions",
+        description: "[list|show|create|reload|import-codex] — List, inspect, create, reload, or import agent definitions",
         getArgumentCompletions(prefix: string) {
             const commands = ["list", "inspect", "show", "create", "reload", "import-codex", "help"];
             const first = prefix.trim().split(/\s+/)[0] ?? "";

package/node_modules/pi-better-subagents/config.ts

@@ -8,12 +8,12 @@
  * `defaultTools` absent → the built-in SAFE_DEFAULT_TOOLS.
  */
 
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
 import { SELF_SPEC } from "./extensions.ts";
-import type { DelegationMode } from "./delegation.ts";
+import { isDelegationMode, type DelegationMode } from "./delegation.ts";
 import type { TimingSettings } from "./timing.ts";
 
 export interface SubagentConfig extends TimingSettings {
@@ -80,24 +80,49 @@ export const SAFE_DEFAULT_TOOLS = "read, bash, edit, write, web_search, web_fetc
 export const SAFE_CLEAN_TOOLS = "read, bash";
 
 let cached: SubagentConfig | undefined;
+let configPathForTests: string | undefined;
 
 /** Test seam. Pass undefined to reload config.json on the next loadConfig call. */
 export function setConfigForTests(next: SubagentConfig | undefined): void {
     cached = next;
 }
 
+/** Test seam. Save and load use this file instead of the package config.json. */
+export function setConfigPathForTests(path: string | undefined): void {
+    configPathForTests = path;
+    cached = undefined;
+}
+
+export function configPath(): string {
+    return configPathForTests ?? join(dirname(fileURLToPath(import.meta.url)), "config.json");
+}
+
 /** Load config.json from the extension directory. Missing/invalid → {}. */
 export function loadConfig(): SubagentConfig {
     if (cached) return cached;
     try {
-        const dir = dirname(fileURLToPath(import.meta.url));
-        cached = JSON.parse(readFileSync(join(dir, "config.json"), "utf-8")) as SubagentConfig;
+        cached = JSON.parse(readFileSync(configPath(), "utf-8")) as SubagentConfig;
     } catch {
         cached = {};
     }
     return cached;
 }
 
+/** Write delegationMode into config.json, preserving every other key. */
+export function writeDelegationMode(mode: DelegationMode, path = configPath()): void {
+    if (!isDelegationMode(mode)) throw new Error(`Invalid delegation mode: ${String(mode)}`);
+    let current: SubagentConfig = {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8")) as unknown;
+        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) current = parsed as SubagentConfig;
+    } catch { /* missing file starts as an empty config */ }
+    current.delegationMode = mode;
+    const pending = `${path}.${process.pid}.tmp`;
+    writeFileSync(pending, `${JSON.stringify(current, null, 2)}\n`);
+    renameSync(pending, path);
+    if (path === configPath()) cached = current;
+}
+
 /** Normalize a comma/space tool list to pi's bare comma form: "a, b" → "a,b". */
 export function normalizeTools(list: string): string {
     return list.split(",").map((t) => t.trim()).filter(Boolean).join(",");

package/node_modules/pi-better-subagents/docs/usage.md

@@ -18,9 +18,12 @@ Set `delegationMode` in this package's `config.json` to `manual`, `adaptive`, or
 `coordinator` (default `adaptive`). This controls foreground delegation guidance,
 not child permissions or catalog definitions. `/subagents` reports the active
 mode; `/subagents mode manual|adaptive|coordinator` overrides it for the current
-session without editing config. Other arguments show usage. `/reload` retains
-this override; new sessions use config, while resuming a session restores that
-session's override.
+session without editing config. `/subagents save` writes the current mode into
+`config.json` after confirmation when a UI is available, and clears the session
+override so the next session starts there. On the navigator `main` sheet, `m`
+cycles the session mode and `ctrl+s` saves that default.
+Other arguments show usage. `/reload` retains a session override; new sessions
+use config, while resuming a session restores that session's override.
 
 - **Manual:** no proactive delegation, including in plan mode. A user request or
   explicit workflow requirement may still delegate.
@@ -380,6 +383,7 @@ top.
   foreground model).
 - `delegationMode` — foreground policy (`manual`, `adaptive`, or `coordinator`;
   default `adaptive`). `/subagents mode ...` changes only the current session.
+  `/subagents save` writes that mode as the config default.
 - `maxConcurrent` — how many subagents may run at once (**default 4**). A spawn
   past the cap is rejected until a running one finishes.
 
@@ -517,9 +521,11 @@ is unchanged in every mode.
 - While the main-window list is focused, the title hint changes to
   `Enter to view · x to stop`; the selected row is marked with `›`. Press
   `↓` from the bottom row to return to the input line.
-- The Subagents lane pins an informational `main` row above child runs. It
-  shows the foreground model, effort, active tool, context tokens, and active
-  elapsed time. It is not selectable and can never become an `x` stop target.
+- The Subagents lane pins a `main` row above child runs. It shows the
+  foreground model, effort, active tool, context tokens, elapsed time, and
+  delegation mode. Enter opens its detail sheet. `m` cycles the session mode.
+  `ctrl+s` saves that mode as the config default. `x` still stops
+  a child run; it never stops main.
 - `↑` moves to the previous row when multiple running rows are shown. `↓`
   moves toward the input line, returning to normal input from the bottom row.
 - `Enter` opens the selected run's live detail view. `x` stops the selected
@@ -637,6 +643,10 @@ health model:
   orphaned, lost, and degraded running runs; #65 orphaned/lost result bodies kept.
 - **Passive live widget** — healthy/quiet unchanged; degraded (and orphaned) may
   show a short suffix. Still `setWidget` only — never focusable.
+- **Navigator** — lifecycle status and operational health facts remain visible;
+  child tool/model incident summaries and history are omitted from rows and detail
+  chrome. Tool labels show just their name (for example, `bash`). The original
+  transcript, including error results, and transcript-read diagnostics remain available.
 - **`callback:false`** suppresses coordinator follow-up only; human `ui.notify` and
   TUI/passive visibility remain.
 

package/node_modules/pi-better-subagents/health-surface.mjs

@@ -162,6 +162,7 @@ export function formatNavigatorHealthFacts(obs) {
     if (!obs || !isActionableHealth(obs)) return [];
     const facts = [];
     for (const f of surfaceableCompactFacts(obs)) {
+        if (obs.model?.state === "error" && f === obs.model.listWarning) continue;
         if (f && f !== obs.status && !facts.includes(f)) facts.push(f);
     }
     if (obs.activity === "stale" && !facts.some((f) => /\bstale\b/i.test(f))) {

package/node_modules/pi-better-subagents/index.ts

@@ -35,7 +35,7 @@ import {
 import { spawnDetached, type SpawnResult } from "./spawn.ts";
 import { parseRun, readRunTranscript, resetParseRunCursor, type Usage } from "./parse.ts";
 import { finalizeRun as finalizeRunCore } from "./finalization.ts";
-import { loadConfig, normalizeTools, resolveExtensionPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS, DEFAULT_MAX_CONCURRENT } from "./config.ts";
+import { loadConfig, writeDelegationMode, normalizeTools, resolveExtensionPath, selfDir, SAFE_DEFAULT_TOOLS, SAFE_CLEAN_TOOLS, DEFAULT_MAX_CONCURRENT } from "./config.ts";
 import { STEER_FILE_ENV, readSteerReceipt } from "./child-steer.ts";
 import {
     decideTiming,
@@ -117,7 +117,7 @@ import {
 import { buildHealthCallbackDelivery } from "./completion.ts";
 import { cancelCallbackBatch, getCallbackBatcher } from "./shared-callback-batcher.ts";
 import { completionCallbackFields, failureAttentionFields, healthCallbackFields } from "./callback-fields.ts";
-import { collectRunFailures, failurePath, failureView, markFailureAttentionDelivered, pendingFailureAttention, prependFailureSummary } from "./failures.ts";
+import { collectRunFailures, failurePath, markFailureAttentionDelivered, pendingFailureAttention } from "./failures.ts";
 import { failureAttentionHandled, observeFailures } from "./shared-failure-observations.ts";
 import {
     text,
@@ -165,6 +165,7 @@ const SUBAGENT_MODE_ACTIONS: readonly AutocompleteItem[] = [
     { value: "mode manual", label: "mode manual", description: "Delegate only when explicitly requested" },
     { value: "mode adaptive", label: "mode adaptive", description: "Delegate substantial independent work" },
     { value: "mode coordinator", label: "mode coordinator", description: "Delegate role-owned work by default" },
+    { value: "save", label: "save", description: "Write the current mode as the next session's default" },
 ];
 
 export function subagentsArgumentCompletions(argumentPrefix: string): AutocompleteItem[] | null {
@@ -1149,9 +1150,6 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
         if (row.model) bits.push(row.effort ? `${row.model} ${row.effort}` : row.model);
         if (row.tool) bits.push(row.tool);
         if (row.spend) bits.push(row.spend);
-        const failure = failureView(row.id, metaById.get(row.id)?.cwd ?? "", row.status !== "running" && row.status !== "orphaned");
-        // Only a failure that needs action replaces the row's columns; history stays in the detail view.
-        const firstFailure = failure.actionable ? failure.text.split("\n")[0] || "" : "";
         return {
             providerId: "subagents",
             id: row.id,
@@ -1164,9 +1162,8 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
             statusTone: statusTone(row.status),
             kind: "subagent",
             elapsed: row.elapsed,
-            primary: firstFailure || bits.join(" · ") || "subagent run",
-            secondary: firstFailure ? bits.join(" · ") : undefined,
-            facts: [firstFailure, ...row.healthFacts].filter(Boolean).slice(0, 2),
+            primary: bits.join(" · ") || "subagent run",
+            facts: row.healthFacts,
             sortStartedAt: metaById.get(row.id)?.startedAt ?? now,
             expiresAt: (() => {
                 const meta = metaById.get(row.id);
@@ -1179,6 +1176,16 @@ function subagentWorkRows(now: number): BackgroundWorkRow[] {
     });
 }
 
+const DELEGATION_MODES = ["manual", "adaptive", "coordinator"] as const;
+const DELEGATION_BLURB: Record<DelegationMode, string> = {
+    manual: "only when you or a workflow asks",
+    adaptive: "substantial independent work",
+    coordinator: "every role-owned task",
+};
+let readDelegation = (): { mode: DelegationMode; source: "session" | "config" } => ({ mode: "adaptive", source: "config" });
+let cycleDelegation = (): void => {};
+let saveDelegationDefault: (mode: DelegationMode) => { ok: boolean; message: string } = () => ({ ok: false, message: "Saving the delegation default is unavailable." });
+
 function mainAgentWorkRow(now: number): BackgroundWorkRow {
     let running = mainAgentStartedAt !== undefined;
     try { running ||= uiCtx?.isIdle() === false; } catch { /* use event state */ }
@@ -1188,10 +1195,12 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
     let contextTokens: number | null | undefined;
     try { contextTokens = uiCtx?.getContextUsage()?.tokens; } catch { contextTokens = undefined; }
     const tokens = typeof contextTokens === "number" ? `${fmtTokens(contextTokens)} tok` : undefined;
+    const delegation = readDelegation();
     const bits = [
         effort ? `${model} ${effort}` : model,
-        tool ? `tool ${tool}` : undefined,
+        tool,
         tokens,
+        delegation.source === "session" ? `${delegation.mode} · session` : delegation.mode,
     ].filter((bit): bit is string => Boolean(bit));
     return {
         providerId: "subagents",
@@ -1210,15 +1219,43 @@ function mainAgentWorkRow(now: number): BackgroundWorkRow {
     };
 }
 
+function mainAgentWorkDetail(now: number): BackgroundWorkDetail {
+    const row = mainAgentWorkRow(now);
+    const delegation = readDelegation();
+    return {
+        providerId: "subagents",
+        id: "main",
+        title: "main",
+        status: row.status,
+        statusTone: row.statusTone,
+        subtitle: row.primary,
+        metadata: [
+            { label: "kind", value: "main agent" },
+            { label: "model", value: row.effort ? `${row.model} · effort ${row.effort}` : (row.model || "-") },
+            { label: "tool", value: row.tool || "-" },
+            { label: "context", value: row.tokens || "-" },
+            { label: "elapsed", value: row.elapsed },
+            { label: "mode", value: `${delegation.mode} · ${delegation.source}` },
+        ],
+        evidence: {
+            label: "delegation",
+            text: [
+                `${delegation.mode}: ${DELEGATION_BLURB[delegation.mode]}.`,
+                "m cycles this session. ctrl+s saves that mode as the next session's default.",
+                "x does not stop the main agent.",
+            ].filter(Boolean).join(" "),
+        },
+        footerActions: ["m mode", "ctrl+s save"],
+    };
+}
+
 function subagentWorkDetail(id: string, now: number, options?: { logTailLines?: number }): BackgroundWorkDetail | null {
+    if (id === "main") return mainAgentWorkDetail(now);
     const detail = navigatorDetail(id, now);
     if (!detail) return null;
     void options;
     const transcript = readRunTranscript(id);
-    const view = failureView(id, readMeta(id)?.cwd ?? "", detail.status !== "running" && detail.status !== "orphaned");
-    const failure = view.text;
     const metadata = [
-        ...(failure ? [{ label: "failure", value: failure.split("\n")[0]! }] : []),
         { label: "provider", value: "Subagents" },
         { label: "id", value: detail.id },
         ...(detail.role ? [{ label: "role", value: String(detail.role) }] : []),
@@ -1235,11 +1272,11 @@ function subagentWorkDetail(id: string, now: number, options?: { logTailLines?:
         title: detail.name || detail.id,
         status: detail.status,
         statusTone: statusTone(detail.status),
-        subtitle: (view.actionable && failure.split("\n")[0]) || (detail.currentTool ? `current tool ${detail.currentTool}` : undefined),
+        subtitle: detail.currentTool || undefined,
         metadata,
-        evidence: { label: "transcript", text: prependFailureSummary(detail.output || "(no transcript yet)", failure) },
+        evidence: { label: "transcript", text: detail.output || "(no transcript yet)" },
         transcript: transcript.entries,
-        transcriptDiagnostic: failure ? prependFailureSummary(transcript.diagnostic ?? "", failure) : transcript.diagnostic,
+        transcriptDiagnostic: transcript.diagnostic,
         footerActions: [detail.status === "running" || detail.status === "orphaned" ? "x stop" : "x dismiss"],
     };
 }
@@ -1307,6 +1344,16 @@ function ensureSubagentProvider(): void {
         parentRow: (now) => mainAgentWorkRow(now),
         listRows: (now) => subagentWorkRows(now),
         detail: (id, now, options) => subagentWorkDetail(id, now, options),
+        handleDetailInput: (id, data) => {
+            if (id !== "main") return false;
+            if (data === "m") {
+                cycleDelegation();
+                return true;
+            }
+            if (data !== "ctrl+s") return false;
+            saveDelegationDefault(readDelegation().mode);
+            return true;
+        },
         armCloseLabel: (row) => row.status === "running" || row.status === "orphaned" ? "x again to stop" : "x again to dismiss",
         close: (id) => {
             const outcome = navigatorCloseRun(id) as { action: string; id: string; status?: string };
@@ -1450,6 +1497,26 @@ function catalogRoleSchema(purpose: string) {
 export default function (pi: ExtensionAPI) {
     let delegationOverride: DelegationMode | undefined;
     const activeDelegationMode = (): DelegationMode => delegationOverride ?? normalizeDelegationMode(loadConfig().delegationMode);
+    readDelegation = () => ({
+        mode: activeDelegationMode(),
+        source: delegationOverride ? "session" : "config",
+    });
+    cycleDelegation = () => {
+        const current = activeDelegationMode();
+        const next = DELEGATION_MODES[(DELEGATION_MODES.indexOf(current) + 1) % DELEGATION_MODES.length]!;
+        delegationOverride = next;
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: next });
+    };
+    saveDelegationDefault = (mode) => {
+        try {
+            writeDelegationMode(mode);
+        } catch (error) {
+            return { ok: false, message: `Could not save the delegation default: ${error instanceof Error ? error.message : String(error)}` };
+        }
+        delegationOverride = undefined;
+        pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: null });
+        return { ok: true, message: `Delegation default saved: ${mode}.` };
+    };
     const restoreDelegationMode = (ctx: ExtensionContext): void => {
         delegationOverride = undefined;
         const branch = ctx.sessionManager?.getBranch?.();
@@ -1457,7 +1524,9 @@ export default function (pi: ExtensionAPI) {
         for (const entry of branch) {
             if (entry.type !== "custom" || entry.customType !== "pi-better-subagents-delegation") continue;
             const data = entry.data as { version?: unknown; mode?: unknown } | null;
-            if (data?.version === 1 && isDelegationMode(data.mode)) delegationOverride = data.mode;
+            if (data?.version !== 1) continue;
+            if (data.mode === null) delegationOverride = undefined;
+            else if (isDelegationMode(data.mode)) delegationOverride = data.mode;
         }
     };
     const unsubscribeDelegationRequest = pi.events?.on?.(DELEGATION_MODE_REQUEST, (data: unknown) => {
@@ -2166,7 +2235,7 @@ export default function (pi: ExtensionAPI) {
     if (typeof pi.registerCommand === "function") {
         agentOperations.registerCommands(pi);
         pi.registerCommand("subagents", {
-            description: "Show or change the current-session delegation mode",
+            description: "[mode manual|adaptive|coordinator|save] — Session mode, or save it as the next session's default",
             getArgumentCompletions: subagentsArgumentCompletions,
             async handler(args, ctx) {
                 const tokens = args.trim().split(/\s+/).filter(Boolean);
@@ -2175,12 +2244,20 @@ export default function (pi: ExtensionAPI) {
                     return;
                 }
                 const requested = tokens[1];
-                if (tokens.length === 2 && tokens[0] === "mode" && isDelegationMode(requested)) {
+                if (tokens.length === 1 && tokens[0] === "save") {
+                    const mode = activeDelegationMode();
+                    if (ctx.hasUI && !(await ctx.ui.confirm("Save delegation default?", `Future sessions will start in ${mode}.`))) {
+                        ctx.ui.notify("Delegation default unchanged.", "info");
+                        return;
+                    }
+                    const saved = saveDelegationDefault(mode);
+                    ctx.ui.notify(saved.message, saved.ok ? "info" : "warning");
+                } else if (tokens.length === 2 && tokens[0] === "mode" && isDelegationMode(requested)) {
                     delegationOverride = requested;
                     pi.appendEntry("pi-better-subagents-delegation", { version: 1, mode: delegationOverride });
                     ctx.ui.notify(`Delegation mode: ${delegationOverride} (current session).`, "info");
                 } else {
-                    ctx.ui.notify("Usage: /subagents [mode manual|adaptive|coordinator]", "warning");
+                    ctx.ui.notify("Usage: /subagents [mode manual|adaptive|coordinator|save]", "warning");
                 }
             },
         });

package/node_modules/pi-better-subagents/navigator.mjs

@@ -543,7 +543,6 @@ export function buildDetailLines(detail, opts = {}) {
             const bits = [];
             if (c.last.reason) bits.push(c.last.reason);
             if (c.last.aborted) bits.push("aborted");
-            if (c.last.errorMessage) bits.push(c.last.errorMessage);
             if (bits.length) lines.push(`   last ${bits.join(" · ")}`);
         }
     } else {
@@ -566,28 +565,17 @@ export function buildDetailLines(detail, opts = {}) {
         lines.push("   idle");
     }
 
-    // Model call / error, separate from tool state.
+    // Model activity only; incident summaries stay in result tools and logs.
     lines.push(sectionRule("model", width));
     if (h?.model) {
         const m = h.model;
-        lines.push(`   state ${m.state}`);
-        if (m.listWarning) lines.push(`   warning ${m.listWarning}`);
+        if (m.state !== "error") lines.push(`   state ${m.state}`);
+        if (m.state !== "error" && m.listWarning) lines.push(`   warning ${m.listWarning}`);
         if (m.retry) {
             const a = m.retry.attempt != null ? String(m.retry.attempt) : "?";
             const max = m.retry.maxAttempts != null ? String(m.retry.maxAttempts) : "?";
             lines.push(`   retry ${a}/${max}`);
         }
-        if (m.lastError) {
-            const age = m.lastError.at != null ? ` · ${fmtDetailTs(m.lastError.at, now)}` : "";
-            lines.push(`   last error ${m.lastError.message}${age}`);
-        }
-        if (Array.isArray(m.errorHistory) && m.errorHistory.length > 0) {
-            const recent = m.errorHistory.slice(-3);
-            for (const e of recent) {
-                const age = e.at != null ? ` · ${fmtDetailTs(e.at, now)}` : "";
-                lines.push(`   history ${e.message}${age}`);
-            }
-        }
         if (m.longModelCall) {
             const age = m.longModelCall.ageMs != null ? ` · ${fmtDetailAge(m.longModelCall.ageMs)}` : "";
             lines.push(`   long call${age}`);

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

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-subagents",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Pi extension for detached, sandboxed subagent runs that keep the foreground session free.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-subagents/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, and structured plans.",
   "license": "MIT",
   "type": "module",
@@ -52,12 +52,12 @@
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
-    "pi-better-background-tasks": "0.6.2",
+    "pi-better-background-tasks": "0.6.3",
     "pi-better-goal": "0.6.0",
     "pi-better-plan": "0.5.1",
-    "pi-better-sandbox": "0.8.0",
+    "pi-better-sandbox": "0.8.1",
     "pi-better-ssh": "0.1.1",
-    "pi-better-subagents": "0.10.0",
+    "pi-better-subagents": "0.11.0",
     "smol-toml": "1.9.0",
     "yaml": "^2.9.1"
   },