pi-better-harness 0.26.1 → 0.27.1

package/README.md

@@ -79,6 +79,11 @@ images, boxes, and tool spacers are hidden. Built-in, extension, and MCP calls
 are included. Tools without a custom call renderer use a generic icon and a
 compact argument hint. Compaction summaries also collapse to one quiet row with
 the pre-compaction token count; Ctrl+O reveals their original summary.
+Custom transcript messages from any extension also fold to a quiet disclosure
+row with the message type and first content line. This includes background
+completion batches and subagent health/timing alerts. Ctrl+O or a fullscreen
+click reveals the original content and any custom renderer. Direct UI notices
+are unchanged.
 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
@@ -105,7 +110,7 @@ Normal mode is the initial default. Changing tool output saves the choice in
 global `settings.json` under `piBetterHarness.toolOutput`, as well as the current
 session. New sessions inherit it; resumed branches retain their own saved choice.
 This is a version-sensitive internal TUI adapter,
-tested with Pi 0.82.1, 0.99.1, and the bundled Pi 1.0.0 CLI; incompatible APIs
+tested with Pi 0.82.1, 0.99.1, and the bundled Pi 1.0.4 CLI; incompatible APIs
 produce a warning and leave ordinary output enabled. Print/RPC output and
 exported transcripts are unchanged.
 

package/extensions/minimal-output/hook.ts

@@ -42,6 +42,18 @@ interface CompactionComponent extends Component {
 interface CompactionPrototype {
   render: CompactionComponent["render"];
 }
+interface CustomMessageComponent extends Component {
+  _expanded: boolean;
+  outputPad?: number;
+  message: { customType: string; content: string | { type: string; text?: string }[] };
+  setExpanded(expanded: boolean): void;
+}
+interface CustomMessagePrototype {
+  render: CustomMessageComponent["render"];
+  setExpanded: CustomMessageComponent["setExpanded"];
+  invalidate(): void;
+  handleMouse?(event: ToolMouseEvent): unknown;
+}
 
 type Method = (this: ToolComponent, ...args: unknown[]) => unknown;
 interface ToolMouseEvent { type: string; button: string; x: number; y: number; screenX: number; screenY: number; width: number; shift?: boolean; alt?: boolean; ctrl?: boolean }
@@ -229,6 +241,17 @@ export async function loadCompactionPrototype(): Promise<CompactionPrototype> {
   return module.CompactionSummaryMessageComponent.prototype;
 }
 
+export async function loadCustomMessagePrototype(): Promise<CustomMessagePrototype> {
+  const entry = sdkEntry(hostRequire());
+  const path = bundledHostEntry(entry) ?? join(dirname(entry), "modes/interactive/components/custom-message.js");
+  const module = await import(pathToFileURL(path).href);
+  const prototype = module.CustomMessageComponent?.prototype;
+  if (!prototype || ["render", "setExpanded", "invalidate"].some(name => typeof prototype[name] !== "function")) {
+    throw new Error("Pi's runtime does not expose its expandable custom-message display class.");
+  }
+  return prototype;
+}
+
 // 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") ?? []) {
@@ -243,7 +266,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, getTheme?: () => Theme, compactionPrototype?: CompactionPrototype): MinimalOutputHook {
+export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: () => Theme, compactionPrototype?: CompactionPrototype, customMessagePrototype?: CustomMessagePrototype): 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.`);
@@ -409,6 +432,60 @@ export function installMinimalOutputHook(prototype: ToolPrototype, getTheme?: ()
         restore.call(this);
       };
     }
+    if (customMessagePrototype) {
+      const originalRender = customMessagePrototype.render;
+      const originalMouse = customMessagePrototype.handleMouse;
+      const renderDescriptor = Object.getOwnPropertyDescriptor(customMessagePrototype, "render");
+      const mouseDescriptor = Object.getOwnPropertyDescriptor(customMessagePrototype, "handleMouse");
+      const messages = new Set<WeakRef<CustomMessageComponent>>();
+      const seenMessages = new WeakSet<CustomMessageComponent>();
+      const render = function(this: CustomMessageComponent, width: number): string[] {
+        if (!seenMessages.has(this)) { seenMessages.add(this); messages.add(new WeakRef(this)); }
+        if (!current.enabled || this._expanded) return originalRender.call(this, width);
+        if (width <= 0) return [];
+        const label = stripVTControlCharacters(this.message.customType).replace(/[-_\s]+/g, " ").trim().replace(/^./, letter => letter.toUpperCase());
+        const content = typeof this.message.content === "string" ? this.message.content
+          : this.message.content.filter(block => block.type === "text").map(block => block.text ?? "").join("\n");
+        const detail = stripVTControlCharacters(content).split(/\r?\n/).map(line => line.replace(/\s+/g, " ").trim()).find(Boolean) ?? "";
+        const theme = getTheme?.();
+        const text = theme
+          ? ` ${theme.fg("muted", "\u25b8")} ${theme.fg("muted", label)}${detail ? `  ${theme.fg("dim", detail)}` : ""}`
+          : ` \u25b8 ${label}${detail ? `  ${detail}` : ""}`;
+        const padding = this.outputPad ?? 1;
+        const indent = Number.isFinite(padding) ? Math.max(0, Math.floor(padding)) + 2 : 3;
+        return [truncateToWidth(`${" ".repeat(Math.min(indent, width - 1))}${text}`, width)];
+      };
+      const mouse = function(this: CustomMessageComponent, event: ToolMouseEvent): unknown {
+        if (current.enabled && !this._expanded && event.type === "click" && event.button === "left"
+          && event.y === 0 && !event.shift && !event.alt && !event.ctrl) {
+          this.setExpanded(true);
+          return { handled: true, render: true };
+        }
+        return originalMouse?.call(this, event);
+      };
+      customMessagePrototype.render = render;
+      customMessagePrototype.handleMouse = mouse;
+      const redraw = current.redraw;
+      current.redraw = function(collapse) {
+        for (const reference of messages) {
+          const component = reference.deref();
+          if (!component) { messages.delete(reference); continue; }
+          if (collapse) component.setExpanded(false);
+          else component.invalidate();
+        }
+        redraw.call(this, collapse);
+      };
+      const restore = current.restore;
+      current.restore = function() {
+        for (const [name, wrapper, descriptor] of [["render", render, renderDescriptor], ["handleMouse", mouse, mouseDescriptor]] as const) {
+          if (customMessagePrototype[name] !== wrapper) continue;
+          if (descriptor) Object.defineProperty(customMessagePrototype, name, descriptor);
+          else Reflect.deleteProperty(customMessagePrototype, name);
+        }
+        messages.clear();
+        restore.call(this);
+      };
+    }
     const wrappers = {
       updateDisplay(this: ToolComponent, ...args: unknown[]) {
         if (typeof this.ui.handleViewportInput === "function" && !inputWrappers.has(this.ui)) {

package/extensions/minimal-output/index.ts

@@ -1,5 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { installMinimalOutputHook, loadToolPrototype, loadCompactionPrototype, type MinimalOutputHook } from "./hook.ts";
+import { installMinimalOutputHook, loadToolPrototype, loadCompactionPrototype, loadCustomMessagePrototype, type MinimalOutputHook } from "./hook.ts";
 import type { SettingsControl } from "../settings/registry.ts";
 import { readHarnessSetting, updateHarnessSetting } from "../shared-harness-settings.ts";
 
@@ -37,7 +37,7 @@ export default function minimalOutputExtension(pi: ExtensionAPI): void {
     }
     if (hook) return true;
     try {
-      hook = installMinimalOutputHook(await loadToolPrototype(), () => ctx.ui.theme, await loadCompactionPrototype());
+      hook = installMinimalOutputHook(await loadToolPrototype(), () => ctx.ui.theme, await loadCompactionPrototype(), await loadCustomMessagePrototype());
       return true;
     } catch (error) {
       ctx.ui.notify(`Minimal tool output is unavailable: ${error instanceof Error ? error.message : String(error)}`, "warning");

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

@@ -1,6 +1,6 @@
 {
   "name": "pi-better-background-tasks",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "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/runtime.ts

@@ -204,7 +204,7 @@ export function spawnTask(
   // Resolved before any task directory, log, or metadata exists so a blocked
   // launch leaves nothing behind. Structured SSH must also honor launch restrictions.
   const intent = readTaskIntent(params);
-  const sandboxPlan = resolveForegroundSandboxPlan(pi, !!params.ssh);
+  const sandboxPlan = resolveForegroundSandboxPlan(pi, !!params.ssh, params);
   const id = nextTaskId();
   const cwd = params.cwd ?? defaultCwd;
   const logPath = logPathFor(id);
@@ -495,7 +495,7 @@ export function startWatchTask(
   }
   const blindChecks = readBlindChecks(params.blind_checks);
   const intent = readTaskIntent(params);
-  const sandboxPlan = resolveForegroundSandboxPlan(pi, !!params.ssh);
+  const sandboxPlan = resolveForegroundSandboxPlan(pi, !!params.ssh, params, "bg_task_watch");
   const id = nextTaskId();
   const cwd = params.cwd ?? defaultCwd;
   const now = Date.now();
@@ -514,7 +514,7 @@ export function startWatchTask(
   const sandboxNotices: string[] = [];
   const launchSpec = remoteTask
     ? commandSpec
-    : confineCommandSpec(commandSpec, sandboxPlan, sandboxProfilePathFor(id), {}, (line) => sandboxNotices.push(line));
+    : confineCommandSpec(commandSpec, sandboxPlan, sandboxProfilePathFor(id), {}, (line) => sandboxNotices.push(line), "bg_task_watch");
   const meta: BackgroundTaskMeta = {
     id,
     name: params.name,

package/node_modules/pi-better-background-tasks/src/sandbox.ts

@@ -29,7 +29,7 @@ import { dirname } from "node:path";
 
 import { commandExecution } from "./process.js";
 import { baseDir } from "./registry.js";
-import { compileWritePolicy, maybeBuildSandboxCommand, type SandboxSeams } from "./shared-sandbox-core.js";
+import { compileWritePolicy, describeSandboxSupport, maybeBuildSandboxCommand, type SandboxSeams } from "./shared-sandbox-core.js";
 
 type SandboxPermissions = {
   /** `write` = read, create and overwrite in place; `read-write` = Write & delete. */
@@ -40,6 +40,18 @@ type SandboxPermissions = {
   network: boolean;
 };
 import type { CommandSpec } from "./types.js";
+import { SandboxDiagnostics, diagnosticPackageVersion, type DiagnosticResource } from "./shared-sandbox-diagnostics.js";
+
+function backgroundDiagnostics(policy: unknown): SandboxDiagnostics | undefined {
+  try {
+    return new SandboxDiagnostics({ context: "background",
+      version: diagnosticPackageVersion(new URL("../package.json", import.meta.url)),
+      policy: () => policy,
+      backend: () => { const support = describeSandboxSupport(); return support.supported ? support.backend : undefined; },
+      onError: () => { console.error("Sandbox diagnostics collection gap; enforcement unchanged."); },
+    });
+  } catch { return undefined; }
+}
 
 /**
  * What an operator can do about a missing backend here.
@@ -225,16 +237,25 @@ export function currentForegroundSandboxPolicy(pi: unknown): ForegroundSandboxPo
  * Throws for every state that is neither confinable nor intentionally
  * unconfined, which keeps a blocked launch from leaving task state behind.
  */
-export function resolveForegroundSandboxPlan(pi: unknown, remote = false): ForegroundSandboxPlan {
+export function resolveForegroundSandboxPlan(pi: unknown, remote = false, operation?: unknown, tool = "bg_task_spawn"): ForegroundSandboxPlan {
   const policy = currentForegroundSandboxPolicy(pi);
   if (remote && !policy?.permissions) return UNCONFINED; // Preserve legacy SSH behavior.
-  const plan = planFor(policy);
-  if (remote && plan.confined) {
-    throw new ForegroundSandboxBlockedError(policy!, !plan.permissions?.network
-      ? "Main profile disables network. SSH launches are blocked."
-      : "Structured SSH cannot apply local file and credential permissions yet. Use SSH through confined bash, or change Main permissions in /sandbox.");
+  try {
+    const plan = planFor(policy);
+    if (remote && plan.confined) {
+      throw new ForegroundSandboxBlockedError(policy!, !plan.permissions?.network
+        ? "Main profile disables network. SSH launches are blocked."
+        : "Structured SSH cannot apply local file and credential permissions yet. Use SSH through confined bash, or change Main permissions in /sandbox.");
+    }
+    return plan;
+  } catch (error) {
+    if (error instanceof ForegroundSandboxBlockedError) {
+      const resource: DiagnosticResource = policy?.permissions?.enabled && !policy.permissions.commands ? "command-execution"
+        : remote && policy?.permissions?.network === false ? "network-access" : "sandbox-backend";
+      backgroundDiagnostics(policy)?.observe({ tool, operation, resource, basis: "policy-refusal", outcome: "denied" });
+    }
+    throw error;
   }
-  return plan;
 }
 
 /** The plan for one already-read policy. Exposed for tests and reuse. */
@@ -281,6 +302,7 @@ export function confineCommandSpec(
   seams: SandboxSeams = {},
   /** Receives lines to show with the launch (e.g. a placeholder left in the user's files). */
   onNotice: (line: string) => void = () => {},
+  tool = "bg_task_spawn",
 ): CommandSpec {
   if (!plan.confined) return spec;
 
@@ -330,9 +352,13 @@ export function confineCommandSpec(
       seams,
     );
   } catch (error) {
+    backgroundDiagnostics(plan)?.observe({ tool, operation: spec, resource: "sandbox-backend", basis: "policy-refusal", outcome: "denied" });
     throw blocked(plan, error instanceof Error ? error.message : String(error));
   }
-  if (!command) throw blocked(plan, "no sandbox backend was applied");
+  if (!command) {
+    backgroundDiagnostics(plan)?.observe({ tool, operation: spec, resource: "sandbox-backend", basis: "policy-refusal", outcome: "denied" });
+    throw blocked(plan, "no sandbox backend was applied");
+  }
   for (const line of command.notices ?? []) onNotice(line);
 
   return { ...spec, argv: [command.file, ...command.fileArgs], shell: false };