@oh-my-pi/pi-coding-agent 16.3.9 → 16.3.10

package/src/task/render.test.ts

@@ -2,7 +2,8 @@ import { afterEach, beforeAll, describe, expect, it } from "bun:test";
 import { Settings } from "../config/settings";
 import { getThemeByName, setThemeInstance, type Theme } from "../modes/theme/theme";
 import { renderResult } from "./render";
-import type { AgentProgress, TaskToolDetails } from "./types";
+import { taskToolRenderer } from "./renderer";
+import type { AgentProgress, SingleResult, TaskToolDetails } from "./types";
 
 const strip = (lines: readonly string[]): string =>
 	lines
@@ -42,6 +43,71 @@ function makeProgress(recentOutput: string[]): AgentProgress {
 	};
 }
 
+function makeParentWithNestedProgress(childCount: number): AgentProgress {
+	const children = Array.from(
+		{ length: childCount },
+		(_, index): AgentProgress => ({
+			...makeProgress([]),
+			index,
+			id: `Nested${index + 1}`,
+			task: `nested child ${index + 1}`,
+		}),
+	);
+	return {
+		...makeProgress([]),
+		id: "Parent",
+		task: "parent task",
+		inflightTaskDetails: {
+			projectAgentsDir: null,
+			results: [],
+			totalDurationMs: 1,
+			progress: children,
+		},
+	};
+}
+
+function makeSingleResult(index: number, overrides?: Partial<SingleResult>): SingleResult {
+	return {
+		index,
+		id: `Done${index + 1}`,
+		agent: "task",
+		agentSource: "bundled",
+		task: `finished child ${index + 1}`,
+		exitCode: 0,
+		output: "ok",
+		stderr: "",
+		truncated: false,
+		durationMs: 5,
+		tokens: 0,
+		requests: 1,
+		...overrides,
+	};
+}
+
+function makeParentWithNestedResults(childCount: number): TaskToolDetails {
+	const nested: TaskToolDetails = {
+		projectAgentsDir: null,
+		// Failure on the LAST child in display order (equal durations, index tiebreak):
+		// a plain head-of-list pick would elide it, so its visibility proves the
+		// failure-first selection of `selectCollapsedResults`.
+		results: Array.from({ length: childCount }, (_, index) =>
+			makeSingleResult(index, index === childCount - 1 ? { exitCode: 1, error: "boom" } : undefined),
+		),
+		totalDurationMs: 1,
+	};
+	const parent = makeSingleResult(0, { id: "Parent", extractedToolData: { task: [nested] } });
+	return { projectAgentsDir: null, results: [parent], totalDurationMs: 1 };
+}
+
+function renderResultText(details: TaskToolDetails, expanded: boolean, uiTheme: Theme): string {
+	const component = renderResult(
+		{ content: [{ type: "text", text: "Ran 1 agent" }], details },
+		{ expanded, isPartial: false },
+		uiTheme,
+	);
+	return strip(component.render(120));
+}
+
 function renderProgressText(progress: AgentProgress, expanded: boolean, uiTheme: Theme): string {
 	const details: TaskToolDetails = {
 		projectAgentsDir: null,
@@ -118,4 +184,71 @@ describe("task live progress rendering", () => {
 		expect(collapsedText).not.toContain("line 1");
 		expect(collapsedText).not.toContain("raw output:");
 	});
+
+	it("caps collapsed nested task progress at four rows plus an elision line", () => {
+		setViewportRows(40);
+		const text = renderProgressText(makeParentWithNestedProgress(6), false, uiTheme);
+
+		expect(text).not.toContain("Nested1");
+		expect(text).not.toContain("Nested2");
+		expect(text).toContain("Nested3");
+		expect(text).toContain("Nested4");
+		expect(text).toContain("Nested5");
+		expect(text).toContain("Nested6");
+		expect(text).toContain("2 more agents");
+	});
+
+	it("shows every nested task progress row when expanded", () => {
+		setViewportRows(40);
+		const text = renderProgressText(makeParentWithNestedProgress(6), true, uiTheme);
+
+		for (let index = 1; index <= 6; index++) {
+			expect(text).toContain(`Nested${index}`);
+		}
+		expect(text).not.toContain("more agents");
+	});
+
+	it("caps collapsed finalized nested task results and keeps the failed child visible", () => {
+		setViewportRows(40);
+		const text = renderResultText(makeParentWithNestedResults(6), false, uiTheme);
+
+		expect(text).toContain("Done6"); // failed child wins a slot despite sorting last
+		expect(text).toContain("2 more agents");
+		const visibleChildren = [1, 2, 3, 4, 5, 6].filter(index => text.includes(`Done${index}`));
+		expect(visibleChildren).toHaveLength(4);
+	});
+
+	it("shows every finalized nested task result when expanded", () => {
+		setViewportRows(40);
+		const text = renderResultText(makeParentWithNestedResults(6), true, uiTheme);
+
+		for (let index = 1; index <= 6; index++) {
+			expect(text).toContain(`Done${index}`);
+		}
+		expect(text).not.toContain("more agents");
+	});
+
+	it("does not request spinner ticks for static partial progress", () => {
+		expect("animatedPartialResult" in taskToolRenderer).toBe(false);
+	});
+
+	it("renders running progress identically across spinner frames", () => {
+		const progress = makeProgress([]);
+		const details: TaskToolDetails = {
+			projectAgentsDir: null,
+			results: [],
+			totalDurationMs: 1,
+			progress: [progress],
+		};
+		const render = (spinnerFrame: number) =>
+			strip(
+				renderResult(
+					{ content: [{ type: "text", text: "Running 1 agent..." }], details },
+					{ expanded: false, isPartial: true, spinnerFrame },
+					uiTheme,
+				).render(120),
+			);
+
+		expect(render(0)).toBe(render(1));
+	});
 });

package/src/task/render.ts

@@ -1679,10 +1679,16 @@ function renderNestedTaskResults(
 			continue;
 		}
 		const ordered = orderResultsForDisplay(details.results);
-		ordered.forEach((result, index) => {
-			const { prefix, continuePrefix } = nestedMarkers(index === ordered.length - 1, theme);
+		const visible = expanded ? ordered : selectCollapsedResults(ordered);
+		const hiddenCount = ordered.length - visible.length;
+		visible.forEach((result, index) => {
+			const { prefix, continuePrefix } = nestedMarkers(hiddenCount === 0 && index === visible.length - 1, theme);
 			lines.push(...renderAgentResult(result, prefix, continuePrefix, expanded, theme, seen, depth + 1));
 		});
+		if (hiddenCount > 0) {
+			const { prefix } = nestedMarkers(true, theme);
+			lines.push(`${prefix} ${theme.fg("dim", formatMoreItems(hiddenCount, "agent"))}`);
+		}
 		seen.delete(details);
 	}
 	return lines;
@@ -1716,18 +1722,26 @@ function renderNestedTaskTree(
 		const hasResults = Boolean(details.results && details.results.length > 0);
 		if (hasResults) {
 			const ordered = orderResultsForDisplay(details.results);
-			ordered.forEach((result, index) => {
-				const { prefix, continuePrefix } = nestedMarkers(index === ordered.length - 1, theme);
+			const visible = expanded ? ordered : selectCollapsedResults(ordered);
+			const hiddenCount = ordered.length - visible.length;
+			visible.forEach((result, index) => {
+				const { prefix, continuePrefix } = nestedMarkers(hiddenCount === 0 && index === visible.length - 1, theme);
 				lines.push(...renderAgentResult(result, prefix, continuePrefix, expanded, theme, seen, depth + 1));
 			});
+			if (hiddenCount > 0) {
+				const { prefix } = nestedMarkers(true, theme);
+				lines.push(`${prefix} ${theme.fg("dim", formatMoreItems(hiddenCount, "agent"))}`);
+			}
 			seen.delete(details);
 			continue;
 		}
 		const inflight = details.progress;
 		if (inflight && inflight.length > 0) {
 			const ordered = orderProgressForDisplay(inflight);
-			ordered.forEach((prog, index) => {
-				const { prefix, continuePrefix } = nestedMarkers(index === ordered.length - 1, theme);
+			const visible = expanded ? ordered : ordered.slice(Math.max(0, ordered.length - COLLAPSED_AGENT_LIMIT));
+			const hiddenCount = ordered.length - visible.length;
+			visible.forEach((prog, index) => {
+				const { prefix, continuePrefix } = nestedMarkers(hiddenCount === 0 && index === visible.length - 1, theme);
 				lines.push(
 					...renderAgentProgress(
 						prog,
@@ -1742,6 +1756,10 @@ function renderNestedTaskTree(
 					),
 				);
 			});
+			if (hiddenCount > 0) {
+				const { prefix } = nestedMarkers(true, theme);
+				lines.push(`${prefix} ${theme.fg("dim", formatMoreItems(hiddenCount, "agent"))}`);
+			}
 		}
 		seen.delete(details);
 	}

package/src/task/renderer.ts

@@ -11,5 +11,4 @@ export const taskToolRenderer = {
 	renderCall,
 	renderResult,
 	mergeCallAndResult: true,
-	animatedPartialResult: true,
 } as const;

package/src/tools/browser/cmux/cmux-tab.ts

@@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
-import { logger, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
+import { logger, postmortem, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
 import { JsRuntime, type RuntimeHooks } from "../../../eval/js/shared/runtime";
 import type { JsDisplayOutput } from "../../../eval/js/shared/types";
 import { callSessionTool } from "../../../eval/js/tool-bridge";
@@ -1306,7 +1306,11 @@ export async function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promi
 		if (timeoutSignal.aborted) {
 			reject(new ToolError(`Browser code execution timed out after ${opts.timeoutMs}ms`));
 		} else {
-			reject(new ToolAbortError());
+			reject(
+				signal.reason instanceof ToolAbortError
+					? signal.reason
+					: new ToolAbortError(undefined, { cause: signal.reason }),
+			);
 		}
 	};
 	if (signal.aborted) onAbort();
@@ -1336,7 +1340,7 @@ export async function runCmuxCode(tab: CmuxTab, opts: RunCmuxCodeOptions): Promi
 		return { displays, returnValue: cloneSafe(returnValue), screenshots };
 	} finally {
 		signal.removeEventListener("abort", onAbort);
-		runAc.abort(new ToolAbortError("Browser run ended"));
+		runAc.abort(postmortem.markExpectedCleanupError(new ToolAbortError("Browser run ended")));
 		tab.clearRunContext();
 	}
 }

package/src/tools/browser/run-cancellation.ts

@@ -1,11 +1,29 @@
 import { untilAborted } from "@oh-my-pi/pi-utils";
 import { throwIfAborted } from "../tool-errors";
 
+/**
+ * Marks a run-scoped promise as observed without changing its behavior for awaited callers.
+ *
+ * Browser run teardown aborts can reject promises created for evaluated code after user code
+ * has stopped observing them (for example fire-and-forget `wait()`/facade calls). In 16.3.0
+ * those zero-consumer rejections reached the process-level `unhandledRejection` handler and
+ * killed every subagent sharing the process (issues #4499/#4672). Attaching a no-op rejection
+ * handler at creation makes the promise observed while returning the original promise so callers
+ * that do await it still receive the rejection.
+ */
+export function markHandled<T>(promise: Promise<T>): Promise<T> {
+	void promise.catch(() => undefined);
+	return promise;
+}
+
 /** Sleeps inside evaluated browser code while honoring the owning run's cancellation signal. */
-export async function waitForBrowserRun(ms: number, signal: AbortSignal): Promise<void> {
-	throwIfAborted(signal);
-	await untilAborted(signal, () => Bun.sleep(ms));
-	throwIfAborted(signal);
+export function waitForBrowserRun(ms: number, signal: AbortSignal): Promise<void> {
+	const promise = (async (): Promise<void> => {
+		throwIfAborted(signal);
+		await untilAborted(signal, () => Bun.sleep(ms));
+		throwIfAborted(signal);
+	})();
+	return markHandled(promise);
 }
 
 /** Binds a long-lived browser facade to one evaluated run's abort signal. */
@@ -24,10 +42,12 @@ export function bindBrowserRunFacade<T extends object>(target: T, signal: AbortS
 					if (result && typeof result === "object") {
 						const then = Reflect.get(result, "then");
 						if (typeof then === "function") {
-							return Promise.resolve(result).then(resolved => {
-								throwIfAborted(signal);
-								return resolved;
-							});
+							return markHandled(
+								Promise.resolve(result).then(resolved => {
+									throwIfAborted(signal);
+									return resolved;
+								}),
+							);
 						}
 					}
 					throwIfAborted(signal);

package/src/tools/browser/tab-protocol.ts

@@ -66,7 +66,7 @@ export type ToolReply = { ok: true; value: unknown } | { ok: false; error: RunEr
 export type WorkerInbound =
 	| { type: "init"; payload: WorkerInitPayload }
 	| { type: "run"; id: string; name: string; code: string; timeoutMs: number; session: SessionSnapshot }
-	| { type: "abort"; id: string }
+	| { type: "abort"; id: string; expectedCleanup?: boolean }
 	| { type: "tool-reply"; id: string; reply: ToolReply }
 	| { type: "close" };
 

package/src/tools/browser/tab-supervisor.ts

@@ -1,4 +1,4 @@
-import { getPuppeteerDir, logger, Snowflake, workerHostEntry } from "@oh-my-pi/pi-utils";
+import { getPuppeteerDir, logger, postmortem, Snowflake, workerHostEntry } from "@oh-my-pi/pi-utils";
 import type { Page, Target } from "puppeteer-core";
 import { callSessionTool } from "../../eval/js/tool-bridge";
 import { webpExclusionForModel } from "../../utils/image-loading";
@@ -486,11 +486,11 @@ export async function releaseTab(name: string, opts: ReleaseTabOptions = {}): Pr
 	}
 	const wasAlive = tab.state === "alive";
 	tab.state = "dead";
-	const closeError = new ToolError(`Tab ${JSON.stringify(name)} was closed`);
+	const closeError = postmortem.markExpectedCleanupError(new ToolError(`Tab ${JSON.stringify(name)} was closed`));
 	for (const [id, pending] of tab.pending) {
 		if (tab.backend === "worker") {
 			try {
-				tab.worker.send({ type: "abort", id });
+				tab.worker.send({ type: "abort", id, expectedCleanup: true });
 			} catch {}
 		}
 		for (const ctrl of pending.toolCalls.values()) ctrl.abort(closeError);
@@ -744,7 +744,7 @@ async function forceKillTab(name: string, reason: string): Promise<void> {
 	const tab = tabs.get(name);
 	if (!tab) return;
 	tab.state = "dead";
-	const error = new ToolError(reason);
+	const error = postmortem.markExpectedCleanupError(new ToolError(reason));
 	for (const pending of tab.pending.values()) pending.reject(error);
 	tab.pending.clear();
 	if (tab.backend === "cmux") {

package/src/tools/browser/tab-worker.ts

@@ -2,7 +2,7 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
-import { Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
+import { postmortem, Snowflake, untilAborted } from "@oh-my-pi/pi-utils";
 import type { HTMLElement } from "linkedom";
 import type {
 	Browser,
@@ -36,7 +36,7 @@ import {
 	loadPuppeteerInWorker,
 } from "./launch";
 import { extractReadableFromHtml, type ReadableFormat } from "./readable";
-import { waitForBrowserRun } from "./run-cancellation";
+import { markHandled, waitForBrowserRun } from "./run-cancellation";
 import type {
 	Observation,
 	ObservationEntry,
@@ -593,7 +593,12 @@ export class WorkerCore {
 				await this.#run(msg);
 				return;
 			case "abort":
-				if (this.#active?.id === msg.id) this.#active.ac.abort(new ToolAbortError());
+				if (this.#active?.id === msg.id) {
+					const reason = msg.expectedCleanup
+						? postmortem.markExpectedCleanupError(new ToolAbortError())
+						: new ToolAbortError();
+					this.#active.ac.abort(reason);
+				}
 				return;
 			case "tool-reply":
 				this.#deliverToolReply(msg.id, msg.reply);
@@ -732,6 +737,10 @@ export class WorkerCore {
 			});
 			const { promise: cancelRejection, reject: rejectCancel } = Promise.withResolvers<never>();
 			const onCancel = (): void => {
+				const abortError =
+					signal.reason instanceof ToolAbortError
+						? signal.reason
+						: new ToolAbortError(undefined, { cause: signal.reason });
 				if (timeoutSignal.aborted) {
 					const stalled = describeInflight(active.inflight);
 					rejectCancel(
@@ -740,11 +749,14 @@ export class WorkerCore {
 						),
 					);
 				} else {
-					rejectCancel(new ToolAbortError());
+					rejectCancel(abortError);
 				}
 				// Cancel in-flight tool calls so user code's awaited proxies reject promptly.
+				const toolAbort = timeoutSignal.aborted
+					? postmortem.markExpectedCleanupError(new ToolAbortError(undefined, { cause: timeoutSignal.reason }))
+					: abortError;
 				for (const pending of active.pendingTools.values()) {
-					pending.reject(new ToolAbortError());
+					pending.reject(toolAbort);
 				}
 				active.pendingTools.clear();
 			};
@@ -771,7 +783,7 @@ export class WorkerCore {
 			this.#transport.send({ type: "result", id: msg.id, ok: false, error: errorPayload(error) });
 		} finally {
 			if (this.#active?.id === msg.id) this.#active = null;
-			runAc.abort(new ToolAbortError("Browser run ended"));
+			runAc.abort(postmortem.markExpectedCleanupError(new ToolAbortError("Browser run ended")));
 		}
 	}
 
@@ -889,7 +901,7 @@ export class WorkerCore {
 		const waitMs = (explicit?: number): number => resolveWaitTimeout(timeoutMs, explicit);
 		const INF = Number.POSITIVE_INFINITY;
 		const op = <T>(label: string, perOpMs: number, fn: (sig: AbortSignal) => Promise<T>): Promise<T> =>
-			this.#runOp(active, label, signal, perOpMs, fn);
+			markHandled(this.#runOp(active, label, signal, perOpMs, fn));
 		return {
 			name,
 			page,

package/src/tools/irc.ts

@@ -171,7 +171,7 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 			case "send":
 				return this.#executeSend(registry, senderId, params, signal);
 			case "wait":
-				return this.#executeWait(senderId, params, signal);
+				return this.#executeWait(registry, senderId, params, signal);
 			case "inbox":
 				return this.#executeInbox(registry, senderId, params);
 			default:
@@ -367,8 +367,24 @@ export class IrcTool implements AgentTool<typeof ircSchema, IrcDetails> {
 		}
 	}
 
-	async #executeWait(senderId: string, params: IrcParams, signal?: AbortSignal): Promise<AgentToolResult<IrcDetails>> {
+	async #executeWait(
+		registry: AgentRegistry,
+		senderId: string,
+		params: IrcParams,
+		signal?: AbortSignal,
+	): Promise<AgentToolResult<IrcDetails>> {
 		const from = params.from?.trim() || undefined;
+		const session = registry.get(senderId)?.session;
+		const pending =
+			typeof session?.drainPendingIrcInboxMessages === "function"
+				? session.drainPendingIrcInboxMessages(senderId, { from, limit: 1 })[0]
+				: undefined;
+		if (pending) {
+			return {
+				content: [{ type: "text", text: formatIncoming(pending) }],
+				details: { op: "wait", from: senderId, waited: pending },
+			};
+		}
 		const timeoutMs = this.#resolveTimeoutMs(params);
 		const waited = await IrcBus.global().wait(senderId, { from }, timeoutMs, signal);
 		if (!waited) {

package/src/tools/tool-errors.ts

@@ -30,8 +30,8 @@ export class ToolError extends Error {
 export class ToolAbortError extends Error {
 	static readonly MESSAGE = "Operation aborted";
 
-	constructor(message: string = ToolAbortError.MESSAGE) {
-		super(message);
+	constructor(message: string = ToolAbortError.MESSAGE, options?: ErrorOptions) {
+		super(message, options);
 		this.name = "ToolAbortError";
 	}
 }
@@ -43,7 +43,7 @@ export class ToolAbortError extends Error {
 export function throwIfAborted(signal?: AbortSignal): void {
 	if (signal?.aborted) {
 		const reason = signal.reason instanceof Error ? signal.reason : undefined;
-		throw reason instanceof ToolAbortError ? reason : new ToolAbortError();
+		throw reason instanceof ToolAbortError ? reason : new ToolAbortError(undefined, { cause: signal.reason });
 	}
 }