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

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 });
 	}
 }
 

package/src/tts/speakable.ts

@@ -318,15 +318,20 @@ export class SpeakableStream {
 		this.#drain(out);
 	}
 
-	/** Emit every buffered character, force-splitting anything over the cap. */
+	/**
+	 * Emit every buffered character. Runs the bounded streaming segmenter first
+	 * so a large buffer (paste-sized delta, one-shot push) prefers sentence and
+	 * clause cuts within {@link MAX_SEGMENT}, instead of word-splitting whole
+	 * paragraphs at the cap ("…a big jump is" / "coming"). Not byte-identical to
+	 * char-by-char streaming — the soft-clause latency cut can fire earlier
+	 * there — but every segment obeys the same cap and boundary preferences.
+	 * {@link #extract} leaves at most MAX_SEGMENT behind, emitted as the
+	 * trailing segment.
+	 */
 	#drain(out: string[]): void {
-		let text = this.#buf;
+		this.#extract(out);
+		const text = this.#buf;
 		this.#buf = "";
-		while (text.length > MAX_SEGMENT) {
-			const cut = findForcedCut(text, MAX_SEGMENT);
-			this.#emit(text.slice(0, cut), out);
-			text = text.slice(cut);
-		}
 		this.#emit(text, out);
 	}
 
@@ -335,14 +340,19 @@ export class SpeakableStream {
 		for (;;) {
 			const buf = this.#buf;
 			const min = this.#spoke ? MIN_SEGMENT : FIRST_SEGMENT_MIN;
+			// Bounded: a sentence past MAX_SEGMENT risks Kokoro's ~510-phoneme
+			// truncation — fall through to clause/word cuts instead.
 			const sentence = findSentenceCut(buf, min);
-			if (sentence !== -1) {
+			if (sentence !== -1 && sentence <= MAX_SEGMENT) {
 				this.#cut(sentence, out);
 				continue;
 			}
 			if (!this.#spoke && buf.length >= FIRST_CLAUSE_MIN) {
+				// Bounded like the sentence branch: in a one-shot buffer the earliest
+				// clause can lie far past the cap; per-char streaming would have
+				// force-cut at FIRST_FORCED_MAX long before seeing it.
 				const clause = findClauseCut(buf, FIRST_SEGMENT_MIN);
-				if (clause !== -1) {
+				if (clause !== -1 && clause <= FIRST_FORCED_MAX) {
 					this.#cut(clause, out);
 					continue;
 				}