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

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

@@ -205,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 =
@@ -735,6 +736,7 @@ export class AgentSession {
 	readonly agent: Agent;
 	readonly sessionManager: SessionManager;
 	readonly settings: Settings;
+	readonly yieldQueue: YieldQueue;
 
 	#powerAssertion: MacOSPowerAssertion | undefined;
 
@@ -1031,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;
@@ -2720,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")) {

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/gh.ts

@@ -4,7 +4,7 @@ import * as path from "node:path";
 import { scheduler } from "node:timers/promises";
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 
-import { getWorktreesDir, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
+import { getWorktreeDir, hashPath, isEnoent, prompt, untilAborted } from "@oh-my-pi/pi-utils";
 import * as z from "zod/v4";
 import type { Settings } from "../config/settings";
 import githubDescription from "../prompts/tools/github.md" with { type: "text" };
@@ -859,18 +859,8 @@ function sanitizeRemoteName(value: string): string {
 	return sanitized.length > 0 ? `fork-${sanitized}` : "fork";
 }
 
-/**
- * Encode an absolute repository path into a single filesystem-safe segment.
- * Mirrors the legacy session-dir encoding used elsewhere in the project: drop
- * the leading separator, then collapse `/`, `\\`, and `:` to `-`. The result
- * is not strictly injective for pathological inputs (e.g. `/a/b` vs `/a-b`)
- * but matches the rest of the codebase and stays human-readable.
- */
-function encodeRepoPathForFilesystem(repoPath: string): string {
-	const resolved = path.resolve(repoPath);
-	const encoded = resolved.replace(/^[/\\]/, "").replace(/[/\\:]/g, "-");
-	return encoded || "root";
-}
+/** Maximum disambiguation suffixes we try before giving up on a worktree path. */
+const WORKTREE_PATH_MAX_SUFFIX = 100;
 
 function toLocalBranchRef(value: string): string {
 	return `refs/heads/${value}`;
@@ -912,25 +902,38 @@ async function requireCurrentGitHead(cwd: string, signal?: AbortSignal): Promise
 	return headSha;
 }
 
-async function ensureGitWorktreePathAvailable(
-	worktreePath: string,
+/**
+ * Resolve a worktree path that is free of conflicts.
+ *
+ * Given a `basePath`, return either `basePath` itself or `${basePath}-2`,
+ * `${basePath}-3`, … up to {@link WORKTREE_PATH_MAX_SUFFIX} — whichever is the
+ * first variant that is **not** registered with git as another worktree and
+ * **not** present on disk. The numeric tail salvages two rare cases that
+ * would otherwise abort a checkout: stale leftover dirs from an interrupted
+ * `git worktree add`, and the (vanishingly unlikely) `hashPath` collision
+ * between two repos that happen to produce the same 7-hex digest.
+ */
+async function resolveAvailableWorktreePath(
+	basePath: string,
 	existingWorktrees: git.GitWorktreeEntry[],
-): Promise<void> {
-	const normalizedTarget = path.resolve(worktreePath);
-	const conflictingWorktree = existingWorktrees.find(entry => path.resolve(entry.path) === normalizedTarget);
-	if (conflictingWorktree) {
-		throw new ToolError(`worktree path is already registered: ${conflictingWorktree.path}`);
-	}
-
-	try {
-		await fs.stat(normalizedTarget);
-		throw new ToolError(`worktree path already exists: ${normalizedTarget}`);
-	} catch (error) {
-		if (isEnoent(error)) {
-			return;
+): Promise<string> {
+	const registered = new Set(existingWorktrees.map(entry => path.resolve(entry.path)));
+	for (let attempt = 0; attempt < WORKTREE_PATH_MAX_SUFFIX; attempt += 1) {
+		const candidate = attempt === 0 ? basePath : `${basePath}-${attempt + 1}`;
+		const normalized = path.resolve(candidate);
+		if (registered.has(normalized)) continue;
+		try {
+			await fs.stat(normalized);
+		} catch (error) {
+			if (isEnoent(error)) {
+				return candidate;
+			}
+			throw error;
 		}
-		throw error;
 	}
+	throw new ToolError(
+		`could not find an unused worktree path under ${basePath} (tried ${WORKTREE_PATH_MAX_SUFFIX} suffixes)`,
+	);
 }
 
 function selectPrCloneUrl(originUrl: string | undefined, repo: Pick<GhRepoViewData, "url" | "sshUrl">): string {
@@ -2939,7 +2942,7 @@ async function checkoutPullRequest(
 	const repoRoot = await requireGitRepoRoot(session.cwd, signal);
 	const primaryRepoRoot = await requirePrimaryGitRepoRoot(repoRoot, signal);
 	const localBranch = `pr-${prNumber}`;
-	const worktreePath = path.join(getWorktreesDir(), encodeRepoPathForFilesystem(primaryRepoRoot), localBranch);
+	const worktreePath = getWorktreeDir(`${prNumber}-${hashPath(primaryRepoRoot)}`);
 
 	// Every git mutation against `repoRoot` from here on must run under the
 	// per-repo lock. Worktrees of the same primary repo share `.git/config`,
@@ -3003,9 +3006,9 @@ async function checkoutPullRequest(
 				signal,
 			);
 
-			const finalWorktreePath = existingWorktree?.path ?? worktreePath;
+			let finalWorktreePath = existingWorktree?.path ?? worktreePath;
 			if (!existingWorktree) {
-				await ensureGitWorktreePathAvailable(finalWorktreePath, existingWorktrees);
+				finalWorktreePath = await resolveAvailableWorktreePath(worktreePath, existingWorktrees);
 				await fs.mkdir(path.dirname(finalWorktreePath), { recursive: true });
 				await git.worktree.add(repoRoot, finalWorktreePath, localBranch, { signal });
 			}

package/src/utils/git.ts

@@ -1157,6 +1157,10 @@ export const worktree = {
 	async list(cwd: string, signal?: AbortSignal): Promise<GitWorktreeEntry[]> {
 		return parseWorktreeList(await runText(cwd, ["worktree", "list", "--porcelain"], { readOnly: true, signal }));
 	},
+
+	async prune(cwd: string, signal?: AbortSignal): Promise<void> {
+		await runEffect(cwd, ["worktree", "prune"], { signal });
+	},
 };
 
 // ════════════════════════════════════════════════════════════════════════════