@oh-my-pi/pi-coding-agent 15.2.1 → 15.2.3

package/src/prompts/tools/async-result.md

@@ -1,5 +1,8 @@
 <system-notice>
-Background job {{jobId}} has completed. Resume your work using the result below.
+{{#if multiple}}{{jobs.length}} background jobs have completed. Resume your work using the results below.
 
-{{result}}
+{{else}}Background job {{jobs.[0].jobId}} has completed. Resume your work using the result below.
+{{/if}}{{#each jobs}}{{#if @root.multiple}}── Job {{this.jobId}}{{#if this.label}} ({{this.label}}){{/if}} ──
+{{/if}}{{this.result}}{{#unless @last}}
+{{/unless}}{{/each}}
 </system-notice>

package/src/sdk.ts

@@ -31,7 +31,7 @@ import {
 	Snowflake,
 } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
-import { AsyncJobManager, isBackgroundJobSupportEnabled } from "./async";
+import { type AsyncJob, AsyncJobManager, isBackgroundJobSupportEnabled } from "./async";
 import { createAutoresearchExtension } from "./autoresearch";
 import { loadCapability } from "./capability";
 import { type Rule, ruleCapability, setActiveRules } from "./capability/rule";
@@ -101,7 +101,7 @@ import {
 import { AgentSession } from "./session/agent-session";
 import { resolveAuthBrokerConfig } from "./session/auth-broker-config";
 import { AuthBrokerClient, AuthStorage, RemoteAuthCredentialStore } from "./session/auth-storage";
-import { convertToLlm } from "./session/messages";
+import { type CustomMessage, convertToLlm } from "./session/messages";
 import { SessionManager } from "./session/session-manager";
 import { closeAllConnections } from "./ssh/connection-manager";
 import { unmountAll } from "./ssh/sshfs-mount";
@@ -152,6 +152,83 @@ import { EventBus } from "./utils/event-bus";
 import { buildNamedToolChoice } from "./utils/tool-choice";
 import { buildWorkspaceTree, type WorkspaceTree } from "./workspace-tree";
 
+type AsyncResultEntry = {
+	jobId: string;
+	result: string;
+	job: AsyncJob | undefined;
+	durationMs: number | undefined;
+};
+
+type AsyncResultJobDetails = {
+	jobId: string;
+	type?: "bash" | "task";
+	label?: string;
+	durationMs?: number;
+};
+
+type AsyncResultDetails = {
+	jobs: AsyncResultJobDetails[];
+};
+
+type McpNotificationEntry = {
+	serverName: string;
+	uri: string;
+};
+
+function buildAsyncResultBatchMessage(entries: AsyncResultEntry[]): CustomMessage<AsyncResultDetails> | null {
+	if (entries.length === 0) return null;
+	const jobs = entries.map(entry => ({
+		jobId: entry.jobId,
+		result: entry.result,
+		type: entry.job?.type,
+		label: entry.job?.label,
+		durationMs: entry.durationMs,
+	}));
+	const details: AsyncResultDetails = {
+		jobs: jobs.map(job => ({
+			jobId: job.jobId,
+			type: job.type,
+			label: job.label,
+			durationMs: job.durationMs,
+		})),
+	};
+	return {
+		role: "custom",
+		customType: "async-result",
+		content: prompt.render(asyncResultTemplate, {
+			multiple: jobs.length > 1,
+			jobs,
+		}),
+		display: true,
+		attribution: "agent",
+		details,
+		timestamp: Date.now(),
+	};
+}
+
+function buildMcpNotificationBatchMessage(entries: McpNotificationEntry[]): AgentMessage | null {
+	const resources: McpNotificationEntry[] = [];
+	const seen = new Set<string>();
+	for (const entry of entries) {
+		const key = `${entry.serverName}\0${entry.uri}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		resources.push(entry);
+	}
+	if (resources.length === 0) return null;
+	const lines = [`[MCP notification] ${resources.length} resource(s) updated:`];
+	for (const resource of resources) {
+		lines.push(`- server="${resource.serverName}" uri=${resource.uri}`);
+	}
+	lines.push('Use read(path="mcp://<uri>") to inspect if relevant.');
+	return {
+		role: "user",
+		content: [{ type: "text", text: lines.join("\n") }],
+		attribution: "agent",
+		timestamp: Date.now(),
+	};
+}
+
 // Types
 export interface CreateAgentSessionOptions {
 	/** Working directory for project-local discovery. Default: getProjectDir() */
@@ -1035,23 +1112,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						const formattedResult = await formatAsyncResultForFollowUp(result);
 						if (asyncJobManager!.isDeliverySuppressed(jobId)) return;
 
-						const message = prompt.render(asyncResultTemplate, { jobId, result: formattedResult });
 						const durationMs = job ? Math.max(0, Date.now() - job.startTime) : undefined;
-						await session.sendCustomMessage(
-							{
-								customType: "async-result",
-								content: message,
-								display: true,
-								attribution: "agent",
-								details: {
-									jobId,
-									type: job?.type,
-									label: job?.label,
-									durationMs,
-								},
-							},
-							{ deliverAs: "followUp", triggerTurn: true },
-						);
+						session.yieldQueue.enqueue<AsyncResultEntry>("async-result", {
+							jobId,
+							result: formattedResult,
+							job,
+							durationMs,
+						});
 					},
 				})
 			: undefined;
@@ -1902,6 +1969,15 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			providerSessionId: options.providerSessionId,
 		});
 		hasSession = true;
+		if (asyncJobManager) {
+			session.yieldQueue.register<AsyncResultEntry>("async-result", {
+				isStale: entry => asyncJobManager.isDeliverySuppressed(entry.jobId),
+				build: buildAsyncResultBatchMessage,
+			});
+		}
+		session.yieldQueue.register<McpNotificationEntry>("mcp-notification", {
+			build: buildMcpNotificationBatchMessage,
+		});
 
 		// Attach the live session to the pre-registered ref so peers can route IRC
 		// messages here. Refresh sessionFile in case it was unavailable at pre-register
@@ -2036,9 +2112,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 						notificationDebounceTimers.delete(key);
 						// Re-check: user may have disabled notifications during the debounce window
 						if (!settings.get("mcp.notifications")) return;
-						void session.followUp(
-							`[MCP notification] Server "${serverName}" reports resource \`${uri}\` was updated. Use read(path="mcp://${uri}") to inspect if relevant.`,
-						);
+						session.yieldQueue.enqueue<McpNotificationEntry>("mcp-notification", { serverName, uri });
 					}, debounceMs),
 				);
 			});

package/src/session/agent-session.ts

@@ -76,6 +76,7 @@ import {
 } from "@oh-my-pi/pi-ai";
 import { MacOSPowerAssertion } from "@oh-my-pi/pi-natives";
 import {
+	extractRetryHint,
 	getAgentDbPath,
 	isEnoent,
 	isUnexpectedSocketCloseMessage,
@@ -204,6 +205,7 @@ import type {
 } from "./session-manager";
 import { getLatestCompactionEntry } from "./session-manager";
 import { ToolChoiceQueue } from "./tool-choice-queue";
+import { YieldQueue } from "./yield-queue";
 
 /** Session-specific events that extend the core AgentEvent */
 export type AgentSessionEvent =
@@ -734,6 +736,7 @@ export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
+	readonly yieldQueue: YieldQueue;
 
 	#powerAssertion: MacOSPowerAssertion | undefined;
 
@@ -1030,6 +1033,24 @@ export class AgentSession {
 				};
 		this.agent.setProviderResponseInterceptor(this.#onResponse);
 		this.agent.setRawSseEventInterceptor(this.#onSseEvent);
+		this.yieldQueue = new YieldQueue({
+			isStreaming: () => this.isStreaming,
+			injectStreaming: message => this.agent.followUp(message),
+			injectIdle: async messages => {
+				const first = messages[0];
+				if (!first) return;
+				await this.agent.prompt(messages.length === 1 ? first : messages);
+			},
+			scheduleIdleFlush: run => {
+				this.#schedulePostPromptTask(
+					async () => {
+						await run();
+					},
+					{ delayMs: 1 },
+				);
+			},
+		});
+		this.agent.setOnBeforeYield(() => this.yieldQueue.flush("streaming"));
 		this.#convertToLlm = config.convertToLlm ?? convertToLlm;
 		this.#rebuildSystemPrompt = config.rebuildSystemPrompt;
 		this.#getMcpServerInstructions = config.getMcpServerInstructions;
@@ -2719,6 +2740,8 @@ export class AgentSession {
 	async dispose(): Promise<void> {
 		this.#isDisposed = true;
 		this.#pendingBackgroundExchanges = [];
+		this.yieldQueue.clear();
+		this.agent.setOnBeforeYield(undefined);
 		this.#evalExecutionDisposing = true;
 		try {
 			if (this.#extensionRunner?.hasHandlers("session_shutdown")) {
@@ -6949,6 +6972,11 @@ export class AgentSession {
 			}
 		}
 
+		const retryHintMs = extractRetryHint(undefined, errorMessage);
+		if (retryHintMs !== undefined) {
+			return retryHintMs;
+		}
+
 		const resetMsMatch = /x-ratelimit-reset-ms\s*[:=]\s*(\d+)/i.exec(errorMessage);
 		if (resetMsMatch) {
 			const resetMs = Number(resetMsMatch[1]);

package/src/session/yield-queue.ts

@@ -0,0 +1,155 @@
+import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { logger } from "@oh-my-pi/pi-utils";
+
+export interface YieldDispatcher<P> {
+	/** Drop entries already delivered through another path. Called per-entry at flush time. */
+	isStale?(entry: P): boolean;
+	/** Produce one batched AgentMessage from non-stale entries. Return null to skip. */
+	build(survivors: P[]): AgentMessage | null;
+}
+
+export interface YieldQueueOptions {
+	isStreaming: () => boolean;
+	injectStreaming(msg: AgentMessage): void;
+	injectIdle(messages: AgentMessage[]): Promise<void>;
+	scheduleIdleFlush(run: () => Promise<void>): void;
+}
+
+type YieldFlushMode = "streaming" | "idle";
+
+interface StoredDispatcher {
+	isStale?: (entry: unknown) => boolean;
+	build: (survivors: unknown[]) => AgentMessage | null;
+}
+
+function formatError(error: unknown): string {
+	return error instanceof Error ? error.message : String(error);
+}
+
+export class YieldQueue {
+	readonly #options: YieldQueueOptions;
+	readonly #dispatchers = new Map<string, StoredDispatcher>();
+	readonly #entries = new Map<string, unknown[]>();
+	#idleFlushPending = false;
+
+	constructor(options: YieldQueueOptions) {
+		this.#options = options;
+	}
+
+	register<P>(kind: string, dispatcher: YieldDispatcher<P>): () => void {
+		const stored: StoredDispatcher = {
+			...(dispatcher.isStale ? { isStale: entry => dispatcher.isStale?.(entry as P) ?? false } : {}),
+			build: survivors => dispatcher.build(survivors as P[]),
+		};
+		this.#dispatchers.set(kind, stored);
+		return () => {
+			if (this.#dispatchers.get(kind) !== stored) return;
+			this.#dispatchers.delete(kind);
+			this.#entries.delete(kind);
+		};
+	}
+
+	enqueue<P>(kind: string, entry: P): void {
+		if (!this.#dispatchers.has(kind)) {
+			logger.warn("Yield queue entry ignored for unregistered kind", { kind });
+			return;
+		}
+		let entries = this.#entries.get(kind);
+		if (!entries) {
+			entries = [];
+			this.#entries.set(kind, entries);
+		}
+		entries.push(entry);
+		if (!this.#options.isStreaming()) {
+			this.#scheduleIdleFlush();
+		}
+	}
+
+	has(kind?: string): boolean {
+		if (kind !== undefined) return (this.#entries.get(kind)?.length ?? 0) > 0;
+		for (const entries of this.#entries.values()) {
+			if (entries.length > 0) return true;
+		}
+		return false;
+	}
+
+	async flush(mode: YieldFlushMode): Promise<void> {
+		if (mode === "idle") {
+			this.#idleFlushPending = false;
+		}
+		const idleMessages: AgentMessage[] = [];
+		for (const [kind, dispatcher] of this.#dispatchers) {
+			const entries = this.#drain(kind);
+			if (entries.length === 0) continue;
+			const message = this.#build(kind, dispatcher, entries);
+			if (!message) continue;
+			if (mode === "streaming") {
+				try {
+					this.#options.injectStreaming(message);
+				} catch (error) {
+					logger.warn("Yield queue streaming dispatch failed", { kind, error: formatError(error) });
+				}
+			} else {
+				idleMessages.push(message);
+			}
+		}
+		if (mode === "idle" && idleMessages.length > 0) {
+			try {
+				await this.#options.injectIdle(idleMessages);
+			} catch (error) {
+				logger.warn("Yield queue idle dispatch failed", { error: formatError(error) });
+			}
+		}
+	}
+
+	clear(): void {
+		this.#entries.clear();
+		this.#idleFlushPending = false;
+	}
+
+	#scheduleIdleFlush(): void {
+		if (this.#idleFlushPending) return;
+		this.#idleFlushPending = true;
+		try {
+			this.#options.scheduleIdleFlush(async () => {
+				this.#idleFlushPending = false;
+				if (this.#options.isStreaming()) return;
+				await this.flush("idle");
+			});
+		} catch (error) {
+			this.#idleFlushPending = false;
+			logger.warn("Yield queue idle flush scheduling failed", { error: formatError(error) });
+		}
+	}
+
+	#drain(kind: string): unknown[] {
+		const entries = this.#entries.get(kind);
+		if (!entries || entries.length === 0) return [];
+		this.#entries.delete(kind);
+		return entries;
+	}
+
+	#build(kind: string, dispatcher: StoredDispatcher, entries: unknown[]): AgentMessage | null {
+		const survivors: unknown[] = [];
+		for (const entry of entries) {
+			if (dispatcher.isStale) {
+				let stale: boolean;
+				try {
+					stale = dispatcher.isStale(entry);
+				} catch (error) {
+					logger.warn("Yield queue stale check failed", { kind, error: formatError(error) });
+					continue;
+				}
+				if (stale) continue;
+			}
+			survivors.push(entry);
+		}
+		if (survivors.length === 0) return null;
+		try {
+			return dispatcher.build(survivors);
+		} catch (error) {
+			logger.warn("Yield queue build failed", { kind, error: formatError(error) });
+			return null;
+		}
+	}
+}

package/src/slash-commands/helpers/format.ts

@@ -13,7 +13,7 @@ export function formatDuration(ms: number): string {
 	return `${days}d`;
 }
 
-type ProgressBarTheme = Pick<Theme, "bold" | "fg">;
+type ProgressBarTheme = Pick<Theme, "bold" | "fg" | "getFgAnsi">;
 
 const unstyledProgressBarTheme: ProgressBarTheme = {
 	fg(_color, text) {
@@ -22,6 +22,9 @@ const unstyledProgressBarTheme: ProgressBarTheme = {
 	bold(text) {
 		return text;
 	},
+	getFgAnsi() {
+		return "";
+	},
 };
 
 function resolveProgressBarTheme(uiTheme: ProgressBarTheme | undefined): ProgressBarTheme {

package/src/task/worktree.ts

@@ -3,7 +3,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as natives from "@oh-my-pi/pi-natives";
-import { getWorktreeDir, logger, Snowflake } from "@oh-my-pi/pi-utils";
+import { getWorktreeDir, hashPath, logger, Snowflake } from "@oh-my-pi/pi-utils";
 import * as git from "../utils/git";
 
 const { IsoBackendKind } = natives;
@@ -26,10 +26,6 @@ export interface WorktreeBaseline {
 	nested: Array<{ relativePath: string; baseline: RepoBaseline }>;
 }
 
-export function getEncodedProjectName(cwd: string): string {
-	return `--${cwd.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-")}--`;
-}
-
 export async function getRepoRoot(cwd: string): Promise<string> {
 	const repoRoot = await git.repo.root(cwd);
 	if (!repoRoot) {
@@ -316,8 +312,7 @@ export async function ensureIsolation(
 	preferred?: IsoBackendKind,
 ): Promise<IsolationHandle> {
 	const repoRoot = await getRepoRoot(baseCwd);
-	const encodedProject = getEncodedProjectName(repoRoot);
-	const baseDir = getWorktreeDir(encodedProject, id);
+	const baseDir = getWorktreeDir(`${id}-${hashPath(repoRoot)}`);
 	const mergedDir = path.join(baseDir, "merged");
 
 	const resolution = natives.isoResolve(preferred ?? null);

package/src/tools/browser/launch.ts

@@ -540,24 +540,24 @@ async function withSoftTimeout<T>(promise: Promise<T>, timeoutMs: number, label:
 	}
 }
 
-async function injectStealthScripts(page: Page): Promise<void> {
-	const scripts = [
-		stealthTamperingScript,
-		stealthActivityScript,
-		stealthHairlineScript,
-		stealthBotdScript,
-		stealthIframeScript,
-		stealthWebglScript,
-		stealthScreenScript,
-		stealthFontsScript,
-		stealthAudioScript,
-		stealthLocaleScript,
-		stealthPluginsScript,
-		stealthHardwareScript,
-		stealthCodecsScript,
-		stealthWorkerScript,
-	];
+const STEALTH_PATCH_SCRIPTS = [
+	stealthTamperingScript,
+	stealthActivityScript,
+	stealthHairlineScript,
+	stealthBotdScript,
+	stealthIframeScript,
+	stealthWebglScript,
+	stealthScreenScript,
+	stealthFontsScript,
+	stealthAudioScript,
+	stealthLocaleScript,
+	stealthPluginsScript,
+	stealthHardwareScript,
+	stealthCodecsScript,
+	stealthWorkerScript,
+];
 
+function buildStealthInjectionScript(scripts: readonly string[] = STEALTH_PATCH_SCRIPTS): string {
 	const joint = scripts
 		.map(
 			script => `
@@ -568,43 +568,55 @@ async function injectStealthScripts(page: Page): Promise<void> {
 		)
 		.join(";\n");
 
-	await page.evaluateOnNewDocument(`(() => {
+	return `(() => {
 				// Native function cache - captured before any tampering
 				const iframe = document.createElement("iframe");
 				iframe.style.display = "none";
-				document.head.appendChild(iframe);
-				const nativeWindow = iframe.contentWindow;
-				if (!nativeWindow) return;
-
-				// Cache pristine native functions
-				const Function_toString = nativeWindow.Function.prototype.toString;
-				const Object_getOwnPropertyDescriptor = nativeWindow.Object.getOwnPropertyDescriptor;
-				const Object_getOwnPropertyDescriptors = nativeWindow.Object.getOwnPropertyDescriptors;
-				const Object_getPrototypeOf = nativeWindow.Object.getPrototypeOf;
-				const Object_defineProperty = nativeWindow.Object.defineProperty;
-				const Object_getOwnPropertyDescriptorOriginal = nativeWindow.Object.getOwnPropertyDescriptor;
-				const Object_create = nativeWindow.Object.create;
-				const Object_keys = nativeWindow.Object.keys;
-				const Object_getOwnPropertyNames = nativeWindow.Object.getOwnPropertyNames;
-				const Object_entries = nativeWindow.Object.entries;
-				const Object_setPrototypeOf = nativeWindow.Object.setPrototypeOf;
-				const Object_assign = nativeWindow.Object.assign;
-				const Window_setTimeout = nativeWindow.setTimeout;
-				const Math_random = nativeWindow.Math.random;
-				const Math_floor = nativeWindow.Math.floor;
-				const Math_max = nativeWindow.Math.max;
-				const Math_min = nativeWindow.Math.min;
-				const Window_Event = nativeWindow.Event;
-				const Promise_resolve = nativeWindow.Promise.resolve.bind(nativeWindow.Promise);
-				const Window_Blob = nativeWindow.Blob;
-				const Window_Proxy = nativeWindow.Proxy;
-				const Intl_DateTimeFormat = nativeWindow.Intl.DateTimeFormat;
-				const Date_constructor = nativeWindow.Date;
-
-				
-				${joint}
-
-				document.head.removeChild(iframe);})();`);
+				const container = document.head ?? document.documentElement;
+				if (!container) return;
+				container.appendChild(iframe);
+				try {
+					const nativeWindow = iframe.contentWindow;
+					if (!nativeWindow) return;
+
+					// Cache pristine native functions
+					const Function_toString = nativeWindow.Function.prototype.toString;
+					const Object_getOwnPropertyDescriptor = nativeWindow.Object.getOwnPropertyDescriptor;
+					const Object_getOwnPropertyDescriptors = nativeWindow.Object.getOwnPropertyDescriptors;
+					const Object_getPrototypeOf = nativeWindow.Object.getPrototypeOf;
+					const Object_defineProperty = nativeWindow.Object.defineProperty;
+					const Object_getOwnPropertyDescriptorOriginal = nativeWindow.Object.getOwnPropertyDescriptor;
+					const Object_create = nativeWindow.Object.create;
+					const Object_keys = nativeWindow.Object.keys;
+					const Object_getOwnPropertyNames = nativeWindow.Object.getOwnPropertyNames;
+					const Object_entries = nativeWindow.Object.entries;
+					const Object_setPrototypeOf = nativeWindow.Object.setPrototypeOf;
+					const Object_assign = nativeWindow.Object.assign;
+					const Window_setTimeout = nativeWindow.setTimeout;
+					const Math_random = nativeWindow.Math.random;
+					const Math_floor = nativeWindow.Math.floor;
+					const Math_max = nativeWindow.Math.max;
+					const Math_min = nativeWindow.Math.min;
+					const Window_Event = nativeWindow.Event;
+					const Promise_resolve = nativeWindow.Promise.resolve.bind(nativeWindow.Promise);
+					const Window_Blob = nativeWindow.Blob;
+					const Window_Proxy = nativeWindow.Proxy;
+					const Intl_DateTimeFormat = nativeWindow.Intl.DateTimeFormat;
+					const Date_constructor = nativeWindow.Date;
+
+					${joint}
+				} finally {
+					if (iframe.parentNode) iframe.parentNode.removeChild(iframe);
+				}})();`;
+}
+
+async function injectStealthScripts(page: Page): Promise<void> {
+	await page.evaluateOnNewDocument(buildStealthInjectionScript());
+}
+
+/** Builds the browser-page stealth bootstrap source for regression tests. */
+export function buildStealthInjectionScriptForTest(scripts: readonly string[] = STEALTH_PATCH_SCRIPTS): string {
+	return buildStealthInjectionScript(scripts);
 }
 
 /** Apply stealth patches + UA override to a headless page. Idempotent within a tab. */