pi-better-harness 0.21.0 → 0.23.0

package/README.md

@@ -64,14 +64,30 @@ 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 folds each tool call into a single-line
-header, including running calls. Long headers are truncated to the terminal
-width; result bodies, images, boxes, and tool spacers are hidden. Built-in,
-extension, and MCP calls are included. Execution, sandboxing, and agent-facing
-payloads are unchanged. Ctrl+O reveals the original tool blocks; Ctrl+O again
-folds them. `/tool-output normal` restores ordinary rendering. Error result
-bodies are also hidden in minimal mode and remain available when expanded.
+The bundled harness provides **Tool output: Normal / Minimal** in
+`/harness-settings`. `/tool-output minimal`, `/tool-output normal`, and
+`/tool-output` (toggle) remain compatibility shortcuts to the same preference.
+Minimal mode folds each tool call into a single-line header, including running
+calls. Each row has a single tool-specific icon: accent-colored while running,
+muted when completed, and error-colored when failed. Tool names stay muted;
+inline command/path arguments use the theme's distinct dim tone. Running and
+failed calls retain text labels so state never depends on color alone. Activity
+stays quieter than conversation text. Tool rows are indented two columns past
+the assistant text padding. Long
+headers are truncated to the terminal width; result bodies,
+images, boxes, and tool spacers are hidden. Built-in, extension, and MCP calls
+are included. Execution, sandboxing, and agent-facing payloads are unchanged.
+When a foreground run ends, each consecutive block of tool calls folds further
+into one disclosure row showing the call count and any failures. Only the failure
+count uses the error color; the disclosure and total stay muted. Assistant text
+stays visible, and restored history uses the same folded view. In newer Pi
+fullscreen mode, click a block disclosure to reveal its call rows, then click a
+call to expand its original details. Click the disclosure again to refold the
+block; native expanded call/result clicks collapse individual details. Regular
+terminals keep mouse input for terminal selection and scrollback; Ctrl+O expands
+all original tool details in both modes and folds them again on the next toggle.
+`/tool-output normal` restores ordinary rendering. Error result bodies are also
+hidden in minimal mode and remain available when expanded.
 
 Normal mode is the default. The preference is saved in the current session,
 including resume/reload. This is a version-sensitive internal TUI adapter,
@@ -94,7 +110,9 @@ packages without duplicating their configuration. `/sandbox`, `/subagents
 settings`, and `/goal settings` remain available in standalone installations.
 Packages without a settings screen are not listed. Pi's `/settings` is unchanged.
 
-The hub also owns **Completions while busy**, shared by Subagents and Background
+The hub includes **Tool output** when the bundled renderer extension is loaded.
+Changes apply immediately to the current session and do not save a global
+default. The hub also owns **Completions while busy**, shared by Subagents and Background
 Tasks. Choose **Wait until idle** (the default) or **Steer active run**. Changes
 apply immediately and autosave to the current session branch, including across
 reloads. Press **Ctrl+S** to save the current choice as your default for future

package/extensions/minimal-output/hook.ts

@@ -4,22 +4,36 @@ import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { pathToFileURL } from "node:url";
 import { stripVTControlCharacters } from "node:util";
+import type { Theme } from "@earendil-works/pi-coding-agent";
 
 interface ToolComponent {
   toolName: string;
+  toolCallId: string;
   args: unknown;
   callRendererComponent?: Component;
   expanded: boolean;
+  isPartial?: boolean;
+  result?: { isError?: boolean };
   showImages: boolean;
   resultRendererComponent?: unknown;
-  ui: { requestRender(): void };
+  ui: { requestRender(): void; children?: TranscriptComponent[] };
   invalidate(): void;
   setExpanded(expanded: boolean): void;
   render(width: number): string[];
 }
 
+interface TranscriptComponent extends Component {
+  children?: TranscriptComponent[];
+  outputPad?: number;
+  lastMessage?: { content: { type: string; text?: string; thinking?: string }[]; stopReason?: string };
+}
+interface ToolGroup { members: ToolComponent[]; open: boolean; expanded: number }
+
 type Method = (this: ToolComponent, ...args: unknown[]) => unknown;
+interface ToolMouseEvent { type: string; button: string; y: number; shift?: boolean; alt?: boolean; ctrl?: boolean }
+type MouseHandler = (this: ToolComponent, event: ToolMouseEvent) => unknown;
 interface ToolPrototype {
+  handleMouse?: MouseHandler;
   updateDisplay: Method;
   getResultRenderer: Method;
   getTextOutput: Method;
@@ -33,16 +47,29 @@ interface HookState {
   owners: number;
   redraw(collapse?: boolean): void;
   restore(): void;
+  completeRun(): void;
+  restoreCompletedCalls(ids: Iterable<string>): void;
 }
 export interface MinimalOutputHook {
   setEnabled(enabled: boolean): void;
+  completeRun(): void;
+  restoreCompletedCalls(ids: Iterable<string>): void;
   dispose(): void;
 }
 
 const HOOK = Symbol.for("pi-better-harness.minimal-output-hook");
 const emptyResult = () => ({ render: () => [] as string[], invalidate() {} });
+const TOOL_ICONS: Record<string, string> = {
+  bash: "\u2318",
+  read: "\u25a4",
+  write: "\u2710",
+  edit: "\u270e",
+  grep: "\u2315",
+  find: "\u2316",
+  ls: "\u2261",
+};
 
-function compactCall(component: ToolComponent, width: number): string[] {
+function compactCall(component: ToolComponent, width: number, theme?: Theme, indent = 3): string[] {
   if (width <= 0) return [];
   // Render the call alone at a wider width so terminal wrapping becomes truncation.
   const header = component.callRendererComponent?.render(Math.max(4096, width + 1))
@@ -50,10 +77,46 @@ function compactCall(component: ToolComponent, width: number): string[] {
     .find((line) => line.length > 0);
   let text = header;
   if (!text) {
-    const args = JSON.stringify(component.args);
-    text = `${component.toolName}${args && args !== "{}" ? ` ${args}` : ""}`;
+    const args = component.args as Record<string, unknown> | undefined;
+    const hint = args?.command ?? args?.path ?? args?.pattern;
+    const detail = typeof hint === "string" ? hint.replace(/\r?\n/g, " ") : JSON.stringify(component.args);
+    text = `${component.toolName}${detail && detail !== "{}" ? ` ${detail}` : ""}`;
   }
-  return [truncateToWidth(text, width)];
+  const failed = component.result?.isError === true;
+  const running = !component.result || component.isPartial;
+  const detail = text.startsWith(`${component.toolName} `) ? text.slice(component.toolName.length).trimStart()
+    : text === component.toolName ? "" : text;
+  const label = component.toolName === "bash" ? "Shell"
+    : component.toolName.replace(/_/g, " ").replace(/^./, letter => letter.toUpperCase());
+  const suffix = failed ? " (failed)" : running ? " (running)" : "";
+  const icon = TOOL_ICONS[component.toolName] ?? "\u25c7";
+  const title = `${icon} ${label}`;
+  const styled = theme
+    ? `${theme.fg(failed ? "error" : running ? "accent" : "muted", icon)} ${theme.fg("muted", label)}${detail ? `  ${theme.fg("dim", detail)}` : ""}${theme.fg(failed ? "error" : "dim", suffix)}`
+    : `${title}${detail ? `  ${detail}` : ""}${suffix}`;
+  return [truncateToWidth(`${" ".repeat(Math.min(indent, Math.max(0, width - 1)))}${styled}`, width)];
+}
+
+function toolParent(component: ToolComponent): TranscriptComponent | undefined {
+  const visit = (children: TranscriptComponent[]): TranscriptComponent | undefined => {
+    for (const child of children) {
+      if (child.children?.includes(component)) return child;
+      if (child.children) {
+        const found = visit(child.children);
+        if (found) return found;
+      }
+    }
+    return undefined;
+  };
+  return visit(component.ui.children ?? []);
+}
+
+function paddingAnchor(component: ToolComponent, parent?: TranscriptComponent): TranscriptComponent | undefined {
+  const siblings = parent?.children ?? [];
+  for (let index = siblings.indexOf(component) - 1; index >= 0; index--) {
+    if (typeof siblings[index].outputPad === "number") return siblings[index];
+  }
+  return undefined;
 }
 
 function hostRequire(): NodeRequire {
@@ -104,7 +167,7 @@ function sdkEntry(require: ReturnType<typeof createRequire>): string {
 }
 
 /** Internal TUI adapter: no tools are replaced and no result content is changed. */
-export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutputHook {
+export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: () => Theme): 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.`);
@@ -116,13 +179,72 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
       updateDisplay: prototype.updateDisplay,
       getResultRenderer: prototype.getResultRenderer,
       getTextOutput: prototype.getTextOutput,
+      setExpanded: prototype.setExpanded,
       render: prototype.render,
+      ...(typeof prototype.handleMouse === "function" ? { handleMouse: prototype.handleMouse } : {}),
     };
+    let mouseHandling = false;
     const seen = new WeakSet<ToolComponent>();
     const components = new Set<WeakRef<ToolComponent>>();
+    let completed = new Map<string, object>();
+    let groups = new WeakMap<ToolComponent, ToolGroup>();
+    let layouts = new WeakMap<ToolComponent, { parent: TranscriptComponent; anchor?: TranscriptComponent }>();
+    const layoutFor = (component: ToolComponent) => {
+      const cached = layouts.get(component);
+      if (cached) return cached;
+      const parent = toolParent(component);
+      if (!parent) return undefined;
+      const layout = { parent, anchor: paddingAnchor(component, parent) };
+      layouts.set(component, layout);
+      return layout;
+    };
+    const groupFor = (component: ToolComponent, parent?: TranscriptComponent): ToolGroup | undefined => {
+      const cached = groups.get(component);
+      if (cached) return cached;
+      if (!completed.has(component.toolCallId) || component.isPartial || !parent?.children) return undefined;
+      let members: ToolComponent[] = [];
+      const save = () => {
+        if (!members.length) return;
+        const group = { members, open: false, expanded: members.filter(member => member.expanded).length };
+        for (const member of members) groups.set(member, group);
+        members = [];
+      };
+      for (const child of parent.children) {
+        const tool = child as ToolComponent;
+        if (seen.has(tool) && completed.has(tool.toolCallId) && !tool.isPartial && !groups.has(tool)) {
+          if (members.length && completed.get(members[0].toolCallId) !== completed.get(tool.toolCallId)) save();
+          members.push(tool);
+        } else if (typeof child.outputPad === "number" && child.lastMessage
+          && !["length", "error", "aborted"].includes(child.lastMessage.stopReason ?? "")
+          && !child.lastMessage.content.some(content => content.text?.trim() || content.thinking?.trim())) {
+          // Tool-only assistant messages occupy no transcript rows and do not split a visual block.
+          continue;
+        } else save();
+      }
+      save();
+      return groups.get(component);
+    };
     state = {
       enabled: false,
       owners: 0,
+      completeRun() {
+        const run = {};
+        for (const reference of components) {
+          const component = reference.deref();
+          if (component?.result && !component.isPartial && !completed.has(component.toolCallId)) {
+            completed.set(component.toolCallId, run);
+            if (this.enabled) component.setExpanded(false);
+          }
+        }
+        this.redraw();
+      },
+      restoreCompletedCalls(ids) {
+        const history = {};
+        completed = new Map(Array.from(ids, id => [id, history]));
+        groups = new WeakMap();
+        layouts = new WeakMap();
+        this.redraw();
+      },
       redraw(collapse = false) {
         for (const reference of components) {
           const component = reference.deref();
@@ -133,10 +255,11 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
         }
       },
       restore() {
-        for (const name of Object.keys(originals) as Array<keyof typeof originals>) {
+        for (const name of ["updateDisplay", "getResultRenderer", "getTextOutput", "setExpanded", "render"] as const) {
           // Do not remove another extension's subsequently installed wrapper.
           if (prototype[name] === wrappers[name]) Object.assign(prototype, { [name]: originals[name] });
         }
+        if (originals.handleMouse && prototype.handleMouse === mouseWrapper) prototype.handleMouse = originals.handleMouse;
         delete prototype[HOOK];
         components.clear();
       },
@@ -157,6 +280,14 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
           this.resultRendererComponent = lastRenderer;
         }
       },
+      setExpanded(this: ToolComponent, ...args: unknown[]) {
+        const group = groups.get(this);
+        const wasExpanded = this.expanded;
+        if (args[0] === false && !mouseHandling && group) group.open = false;
+        const result = originals.setExpanded.apply(this, args);
+        if (group) group.expanded += Number(this.expanded) - Number(wasExpanded);
+        return result;
+      },
       getResultRenderer(this: ToolComponent, ...args: unknown[]) {
         return current.enabled && !this.expanded ? emptyResult : originals.getResultRenderer.apply(this, args);
       },
@@ -164,9 +295,49 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
         return current.enabled && !this.expanded ? "" : originals.getTextOutput.apply(this, args);
       },
       render(this: ToolComponent, width: number): string[] {
-        return current.enabled && !this.expanded ? compactCall(this, width) : originals.render.call(this, width);
+        if (!current.enabled || this.expanded) return originals.render.call(this, width);
+        const layout = layoutFor(this);
+        const padding = layout?.anchor?.outputPad ?? 1;
+        const indent = Number.isFinite(padding) ? Math.max(0, Math.floor(padding)) + 2 : 3;
+        const group = groupFor(this, layout?.parent);
+        if (!group) return compactCall(this, width, getTheme?.(), indent);
+        const open = group.open || group.expanded > 0;
+        const first = group.members[0] === this;
+        const lines: string[] = [];
+        if (first && width > 0) {
+          const failed = group.members.filter(member => member.result?.isError).length;
+          const text = `${open ? "\u25be" : "\u25b8"} ${group.members.length} tool call${group.members.length === 1 ? "" : "s"}`;
+          const failure = failed ? `${failed} failed` : "";
+          const theme = getTheme?.();
+          const styled = theme
+            ? `${theme.fg("muted", text)}${failed ? `${theme.fg("dim", " \u00b7 ")}${theme.fg("error", failure)}` : ""}`
+            : `${text}${failed ? ` \u00b7 ${failure}` : ""}`;
+          lines.push(truncateToWidth(`${" ".repeat(Math.min(indent, Math.max(0, width - 1)))}${styled}`, width));
+        }
+        if (open) lines.push(...compactCall(this, width, getTheme?.(), indent + 2));
+        return lines;
       },
     };
+    const mouseWrapper: MouseHandler = function(event) {
+      if (current.enabled && !this.expanded) {
+        if (event.type !== "click" || event.button !== "left" || event.shift || event.alt || event.ctrl) return undefined;
+        const group = groupFor(this, layoutFor(this)?.parent);
+        if (group?.members[0] === this && event.y === 0) {
+          group.open = !(group.open || group.expanded > 0);
+          if (!group.open) for (const member of group.members) member.setExpanded(false);
+          this.ui.requestRender();
+          return { handled: true, render: true };
+        }
+        if (event.y !== (group?.members[0] === this ? 1 : 0)) return undefined;
+        this.setExpanded(true);
+        this.ui.requestRender();
+        return { handled: true, render: true };
+      }
+      mouseHandling = true;
+      try { return originals.handleMouse?.call(this, event); }
+      finally { mouseHandling = false; }
+    };
+    if (originals.handleMouse) prototype.handleMouse = mouseWrapper;
     Object.assign(prototype, wrappers);
     prototype[HOOK] = state;
   }
@@ -174,6 +345,8 @@ export function installMinimalOutputHook(prototype: ToolPrototype): MinimalOutpu
   current.owners += 1;
   let disposed = false;
   return {
+    completeRun() { if (!disposed) current.completeRun(); },
+    restoreCompletedCalls(ids) { if (!disposed) current.restoreCompletedCalls(ids); },
     setEnabled(enabled) {
       if (disposed) return;
       current.enabled = enabled;

package/extensions/minimal-output/index.ts

@@ -1,11 +1,13 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { installMinimalOutputHook, loadToolPrototype, type MinimalOutputHook } from "./hook.ts";
+import type { SettingsControl } from "../settings/registry.ts";
 
 const ENTRY = "pi-better-harness-tool-output";
 
 export default function minimalOutputExtension(pi: ExtensionAPI): void {
   let hook: MinimalOutputHook | undefined;
   let enabled = false;
+  let running = false;
 
   function status(ctx: ExtensionContext): void {
     ctx.ui.setStatus(ENTRY, enabled ? "tools: minimal" : undefined);
@@ -24,7 +26,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     }
     if (hook) return true;
     try {
-      hook = installMinimalOutputHook(await loadToolPrototype());
+      hook = installMinimalOutputHook(await loadToolPrototype(), () => ctx.ui.theme);
       return true;
     } catch (error) {
       ctx.ui.notify(`Minimal tool output is unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");
@@ -32,27 +34,63 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     }
   }
 
-  pi.on("session_start", async (_event, ctx) => {
+  async function restore(ctx: ExtensionContext): Promise<void> {
     if (ctx.mode !== "tui") return;
     enabled = false;
     for (const entry of ctx.sessionManager.getBranch()) {
       if (entry.type === "custom" && entry.customType === ENTRY) {
-        const data = entry.data as { enabled?: unknown } | undefined;
-        if (typeof data?.enabled === "boolean") enabled = data.enabled;
+        const data = entry.data as { version?: unknown; enabled?: unknown } | undefined;
+        if (data?.version === 1 && typeof data.enabled === "boolean") enabled = data.enabled;
       }
     }
     // Observe transcript components from startup, so the toggle also redraws existing rows.
     if (await ensureHook(ctx)) {
+      hook!.restoreCompletedCalls(ctx.sessionManager.getBranch().flatMap(entry =>
+        entry.type === "message" && entry.message.role === "toolResult" ? [entry.message.toolCallId] : []));
       if (enabled) collapseTools(ctx);
       hook!.setEnabled(enabled);
     } else enabled = false;
     status(ctx);
+  }
+
+  async function change(value: string, ctx: ExtensionContext): Promise<void> {
+    if (value !== "Normal" && value !== "Minimal") throw new Error("Invalid tool output mode.");
+    if (!await ensureHook(ctx)) throw new Error("Tool output settings are unavailable in this Pi runtime.");
+    const data = { version: 1, enabled: value === "Minimal" };
+    try { pi.appendEntry(ENTRY, data); }
+    catch (error) { data.version = 0; data.enabled = enabled; throw error; }
+    enabled = data.enabled;
+    if (enabled) collapseTools(ctx);
+    hook!.setEnabled(enabled);
+    if (enabled && !running) hook!.completeRun();
+    status(ctx);
+  }
+
+  const setting: SettingsControl = {
+    id: "tool-output", label: "Tool output", values: ["Normal", "Minimal"],
+    get: () => enabled ? "Minimal" : "Normal", change,
+  };
+  const register = () => pi.events.emit("harness-settings:register", setting);
+  let stopSettings: (() => void) | undefined;
+  const subscribe = () => { stopSettings ??= pi.events.on("harness-settings:request", register); };
+  subscribe();
+  register();
+  pi.on("session_start", async (_event, ctx) => { subscribe(); await restore(ctx); register(); });
+  pi.on("session_tree", async (_event, ctx) => { await restore(ctx); });
+  pi.on("agent_start", () => { running = true; });
+  pi.on("agent_settled", (_event, ctx) => {
+    running = false;
+    if (enabled) ctx.ui.setToolsExpanded(false);
+    hook?.completeRun();
   });
 
   pi.on("session_shutdown", () => {
+    stopSettings?.();
+    stopSettings = undefined;
     hook?.dispose();
     hook = undefined;
     enabled = false;
+    running = false;
   });
 
   pi.registerCommand("tool-output", {
@@ -71,12 +109,8 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
         ctx.ui.notify("Usage: /tool-output [minimal|normal]", "warning");
         return;
       }
-      if (!await ensureHook(ctx)) return;
-      enabled = mode ? mode === "minimal" : !enabled;
-      if (enabled) collapseTools(ctx);
-      hook!.setEnabled(enabled);
-      pi.appendEntry(ENTRY, { version: 1, enabled });
-      status(ctx);
+      try { await change((mode ? mode === "minimal" : !enabled) ? "Minimal" : "Normal", ctx); }
+      catch (error) { ctx.ui.notify(error instanceof Error ? error.message : String(error), "warning"); return; }
       ctx.ui.notify(enabled
         ? "Minimal tool output on. Compact call headers remain visible. Ctrl+O reveals results."
         : "Normal tool output restored.", "info");

package/extensions/settings/index.ts

@@ -30,7 +30,7 @@ export default function harnessSettingsExtension(pi: ExtensionAPI): void {
             get: readSettings,
             change: mode => changeCallbackSetting(pi, ctx, mode),
             save: () => saveCallbackDefault(readSettings().mode),
-          });
+          }, registry.controls());
         } catch (error) {
           ctx.ui.notify(`Settings unavailable: ${error instanceof Error ? error.message : String(error)}`, "error");
           return;

package/extensions/settings/page.ts

@@ -1,6 +1,6 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import { Container, SettingsList, Text, getKeybindings, setKeybindings, KeybindingsManager, TUI_KEYBINDINGS, matchesKey, type SettingItem } from "@earendil-works/pi-tui";
-import type { SettingsLink } from "./registry.ts";
+import type { SettingsControl, SettingsLink } from "./registry.ts";
 
 export interface CallbackSettingsControl {
   get(): { mode: "hold" | "steer"; source: "session" | "default" };
@@ -11,7 +11,7 @@ export interface CallbackSettingsControl {
 const CALLBACK_SETTING_ID = "callbacks:while-busy";
 const callbackLabel = (mode: "hold" | "steer") => mode === "steer" ? "Steer active run" : "Wait until idle";
 
-export async function chooseHarnessSetting(ctx: any, links: SettingsLink[], selected?: string, callbacks?: CallbackSettingsControl): Promise<string | undefined> {
+export async function chooseHarnessSetting(ctx: any, links: SettingsLink[], selected?: string, callbacks?: CallbackSettingsControl, controls: SettingsControl[] = []): Promise<string | undefined> {
   return ctx.ui.custom((tui: any, theme: Theme, _kb: unknown, done: (id?: string) => void) => {
     let callbackMode = callbacks?.get().mode ?? "hold";
     const callbackSetting: SettingItem | undefined = callbacks ? {
@@ -23,9 +23,11 @@ export async function chooseHarnessSetting(ctx: any, links: SettingsLink[], sele
     } : undefined;
     const items: SettingItem[] = [
       ...(callbackSetting ? [callbackSetting] : []),
+      ...controls.map(control => ({ id: `setting:${control.id}`, label: control.label, currentValue: control.get(), description: "Session setting", values: control.values })),
       ...links.map(link => ({ id: `link:${link.id}`, label: link.label, currentValue: link.command, description: "Open package settings", values: [link.command] })),
     ];
     const feedback = new Text("", 0, 0);
+    let changing = false;
     const report = (message: string, error = false) => {
       feedback.setText(theme.fg(error ? "error" : "muted", message));
       tui.requestRender?.();
@@ -35,6 +37,20 @@ export async function chooseHarnessSetting(ctx: any, links: SettingsLink[], sele
       value: (text, active) => active ? theme.inverse(text) : theme.fg("muted", text),
       description: text => theme.fg("muted", text), cursor: "> ", hint: text => theme.fg("dim", text),
     }, (id, value) => {
+      const control = controls.find(item => `setting:${item.id}` === id);
+      if (control) {
+        const previous = control.get();
+        changing = true;
+        report("Saving session setting...");
+        Promise.resolve().then(() => control.change(value, ctx)).then(() => {
+          list.updateValue(id, control.get());
+          report("Session setting saved.");
+        }).catch(error => {
+          list.updateValue(id, previous);
+          report(error instanceof Error ? error.message : String(error), true);
+        }).finally(() => { changing = false; tui.requestRender?.(); });
+        return;
+      }
       if (id !== CALLBACK_SETTING_ID || !callbacks || !callbackSetting) { done(id); return; }
       try {
         const nextMode = value === "Steer active run" ? "steer" : "hold";
@@ -67,6 +83,7 @@ export async function chooseHarnessSetting(ctx: any, links: SettingsLink[], sele
       render: (width: number) => page.render(width),
       invalidate: () => page.invalidate(),
       handleInput(data: string) {
+        if (changing) return;
         if (callbacks && matchesKey(data, "ctrl+s")) {
           try { callbacks.save(); report("Callback default saved."); }
           catch (error) { report(error instanceof Error ? error.message : String(error), true); }

package/extensions/settings/registry.ts

@@ -7,21 +7,38 @@ export interface SettingsLink {
   open(ctx: ExtensionCommandContext): Promise<void> | void;
 }
 
+export interface SettingsControl {
+  id: string;
+  label: string;
+  values: string[];
+  get(): string;
+  change(value: string, ctx: ExtensionCommandContext): Promise<void> | void;
+}
+
 export function createSettingsRegistry(pi: ExtensionAPI) {
   const links = new Map<string, SettingsLink>();
+  const controls = new Map<string, SettingsControl>();
   const conflicts = new Set<string>();
   const stop = pi.events.on("harness-settings:register", (candidate: unknown) => {
-    const link = candidate as Partial<SettingsLink> | null;
-    if (!link || !/^[a-z][a-z0-9-]*$/.test(link.id ?? "") || typeof link.label !== "string" ||
-      typeof link.command !== "string" || !link.command.startsWith("/") || typeof link.open !== "function") return;
+    const link = candidate as Partial<SettingsLink & SettingsControl> | null;
+    if (!link || !/^[a-z][a-z0-9-]*$/.test(link.id ?? "") || typeof link.label !== "string") return;
+    const control = Array.isArray(link.values) && link.values.length > 1 && link.values.every(value => typeof value === "string")
+      && typeof link.get === "function" && typeof link.change === "function";
+    if (!control && (typeof link.command !== "string" || !link.command.startsWith("/") || typeof link.open !== "function")) return;
     if (conflicts.has(link.id!)) return;
     const prior = links.get(link.id!);
-    if (prior && prior.open !== link.open) { links.delete(link.id!); conflicts.add(link.id!); return; }
-    links.set(link.id!, link as SettingsLink);
+    const priorControl = controls.get(link.id!);
+    if ((prior && (control || prior.open !== link.open)) ||
+      (priorControl && (!control || priorControl.change !== link.change || priorControl.get !== link.get))) {
+      links.delete(link.id!); controls.delete(link.id!); conflicts.add(link.id!); return;
+    }
+    if (control) controls.set(link.id!, link as SettingsControl);
+    else links.set(link.id!, link as SettingsLink);
   });
   return {
-    refresh() { links.clear(); conflicts.clear(); pi.events.emit("harness-settings:request", undefined); },
+    refresh() { links.clear(); controls.clear(); conflicts.clear(); pi.events.emit("harness-settings:request", undefined); },
     list() { return [...links.values()].sort((a, b) => a.label.localeCompare(b.label)); },
-    dispose() { stop(); links.clear(); conflicts.clear(); },
+    controls() { return [...controls.values()].sort((a, b) => a.label.localeCompare(b.label)); },
+    dispose() { stop(); links.clear(); controls.clear(); conflicts.clear(); },
   };
-}
+}

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

@@ -45,13 +45,15 @@ For any workflow using the shared task-plan contract (including `resolve-issues`
   "event": "unit-validated",
   "revision": 12,
   "changes": [
-    { "id": "1201", "set": { "stage": "done", "status": "succeeded", "worker": null, "headSha": "abc123" } },
+    { "id": "1201", "set": { "stage": "done", "status": "in-flight", "worker": null, "headSha": "abc123" } },
     { "id": "C1", "set": { "status": "combining" } }
   ],
   "profiling": { "outcome": "succeeded", "wallMs": 540000 }
 } }
 ```
 
+Each issue row shows where it is between code and delivery: `●` while it is being built, `◐ implemented` once `stage` is `done` with a `headSha`, `◑ review passed` while `reviewedHead` equals `headSha`, and `✓` only at `status: succeeded`, when the change has landed on the target branch by a merged PR or a direct push. Only `✓` rows count as complete.
+
 `changes` addresses units, components, and fleet stages by id (a change without an id sets run-level fields); all changes in one call are one transition. For a scope change, a change with `target` `unit` or `component` and an `add` row appends a new row; existing rows cannot be removed or renamed. The tool checks ids, dependencies (including cycles), worker slots, and status/stage values against the shared issue-resolution contract (a fleet status of `n/a` is saved as `not-applicable`), refuses a stale `revision`, appends an optional `decision`, then saves the plan atomically with `planRevision + 1` and a new `updatedAt`, and appends one profiling event with the same revision to the log the run already uses (`profiling/run.jsonl` or `profiling.jsonl`). A rejected update changes nothing. The event is appended before the plan is renamed into place, so a crash between the two can leave the log one revision ahead; the next update notices, reuses that revision, and marks its event with `logAheadRevision`.
 
 The binding records the active workflow's name, which is shown in the plan view. A different workflow cannot read or update that binding; a new invocation or ownership release invalidates it. The skill name is not an allowlist: explicit binding opts a workflow into the shared schema and transition rules, while path confinement to `.resolve-issues/rush/<run-id>/task-plan.json`, run identity, size limits, and revision checks still apply. Workflows using other schemas or storage locations retain their own planning and must not bind incompatible state.

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

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-plan",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "Structured execution plans with persistent progress for Pi.",
   "license": "MIT",
   "type": "module",

package/node_modules/pi-better-plan/src/plan-presentation.ts

@@ -5,7 +5,9 @@ export interface PlanRenderTheme {
   fg(color: string, value: string): string;
 }
 
-export type DisplayStatus = "completed" | "in_progress" | "pending" | "blocked" | "failed" | "skipped" | "unknown";
+// `implemented` and `reviewed` are in-progress states a workflow row can show between
+// "code done" and "delivered"; native plans never use them.
+export type DisplayStatus = "completed" | "in_progress" | "implemented" | "reviewed" | "pending" | "blocked" | "failed" | "skipped" | "unknown";
 export interface PlanRow {
   label: string;
   title: string;
@@ -24,6 +26,8 @@ export function statusStyle(status: DisplayStatus): { glyph: string; color: stri
   switch (status) {
     case "completed": return { glyph: "✓", color: "success", label: "" };
     case "in_progress": return { glyph: "●", color: "accent", label: "active" };
+    case "implemented": return { glyph: "◐", color: "accent", label: "implemented" };
+    case "reviewed": return { glyph: "◑", color: "success", label: "review passed" };
     case "blocked": return { glyph: "!", color: "warning", label: "blocked" };
     case "failed": return { glyph: "×", color: "error", label: "failed" };
     case "skipped": return { glyph: "—", color: "dim", label: "skipped" };
@@ -45,7 +49,8 @@ export function renderPlanPresentation(
   const count = (status: DisplayStatus) => plan.rows.filter((row) => row.status === status).length;
   const summary = [`${count("completed")}/${plan.rows.length} complete`];
   for (const [status, label] of [
-    ["in_progress", "in progress"], ["blocked", "blocked"], ["failed", "failed"],
+    ["in_progress", "in progress"], ["implemented", "implemented"], ["reviewed", "review passed"],
+    ["blocked", "blocked"], ["failed", "failed"],
     ["skipped", "skipped"], ["unknown", "unknown"],
   ] as const) {
     if (count(status)) summary.push(`${count(status)} ${label}`);
@@ -67,7 +72,7 @@ export function renderPlanPresentation(
       theme.fg(style.color, style.glyph) + " " + theme.fg("dim", label) +
       " ".repeat(Math.max(0, labelWidth - visibleWidth(label)) + 2);
     const titleColor = row.status === "blocked" ? "warning" : row.status === "failed" ? "error" :
-      row.status === "in_progress" ? "text" : "muted";
+      row.status === "in_progress" || row.status === "implemented" || row.status === "reviewed" ? "text" : "muted";
     const badge = planText(row.statusLabel ?? style.label);
     const available = size - visibleWidth(prefix);
     // At narrow widths use an inline status so it survives title truncation.

package/node_modules/pi-better-plan/src/workflow-plan.ts

@@ -16,6 +16,9 @@ interface RushUnit {
   dependsOn: string[];
   worker?: string | number | undefined;
   note?: string | undefined;
+  headSha?: string | undefined;
+  reviewedHead?: string | undefined;
+  delivery?: string | undefined;
 }
 
 export interface RushPlan {
@@ -78,6 +81,9 @@ export function projectRushPlan(data: unknown, runId: string): RushPlan {
       dependsOn: Array.isArray(unit.dependsOn) ? unit.dependsOn.filter((id): id is string => typeof id === "string") : [],
       worker: typeof unit.worker === "string" || typeof unit.worker === "number" ? unit.worker : undefined,
       note: typeof unit.note === "string" ? unit.note : undefined,
+      headSha: typeof unit.headSha === "string" && unit.headSha ? unit.headSha : undefined,
+      reviewedHead: typeof unit.reviewedHead === "string" && unit.reviewedHead ? unit.reviewedHead : undefined,
+      delivery: typeof unit.delivery === "string" && unit.delivery ? unit.delivery : undefined,
     };
   });
   const fleet: RushPlan["fleet"] = {};
@@ -133,6 +139,15 @@ function workflowStatus(status: string): DisplayStatus {
   }
 }
 
+// A unit is delivered (completed) only at `status: succeeded`, whether its change landed by a
+// merged PR or a direct push. Between code done and delivery, a unit with a HEAD shows
+// whether that HEAD passed review; without one it shows plain in-progress, as before.
+function unitStatus(unit: RushUnit): DisplayStatus {
+  const status = workflowStatus(unit.status);
+  if (status !== "in_progress" || unit.stage !== "done" || !unit.headSha) return status;
+  return unit.reviewedHead === unit.headSha ? "reviewed" : "implemented";
+}
+
 function presentRushPlan(plan: RushPlan, owner: string): PlanPresentation {
   // The warehouse canary only applies to data work; hide it otherwise.
   const stages = ["explore", "implement", "review", "ci", ...(plan.warehouseCanaryRequired ? ["canary"] : [])];
@@ -147,8 +162,8 @@ function presentRushPlan(plan: RushPlan, owner: string): PlanPresentation {
   return {
     metadata,
     rows: plan.issues.map((unit) => {
-      const status = workflowStatus(unit.status);
-      const details = [`${unit.stage} · ${unit.status}${unit.worker !== undefined ? ` · worker ${unit.worker}` : ""}`];
+      const status = unitStatus(unit);
+      const details = [`${unit.stage} · ${unit.status}${unit.delivery ? ` · ${unit.delivery}` : ""}${unit.worker !== undefined ? ` · worker ${unit.worker}` : ""}`];
       if (unit.dependsOn.length) details.push(`after: ${unit.dependsOn.map((id) => `#${id}`).join(", ")}`);
       if (unit.note) details.push(unit.note);
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-harness",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Pi extension bundle for a write sandbox, subagents, background tasks, SSH, goals, and structured plans.",
   "license": "MIT",
   "type": "module",
@@ -55,7 +55,7 @@
   "dependencies": {
     "pi-better-background-tasks": "0.7.0",
     "pi-better-goal": "0.8.1",
-    "pi-better-plan": "0.5.4",
+    "pi-better-plan": "0.6.0",
     "pi-better-sandbox": "0.11.0",
     "pi-better-ssh": "0.1.2",
     "pi-better-subagents": "0.15.0",