@oh-my-pi/pi-coding-agent 16.5.0 → 16.5.1

package/src/eval/agent-bridge.ts

@@ -449,130 +449,135 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 	// runtime is parked waiting for the result, and the cell timeout must
 	// not abort us mid-cherry-pick or mid-nested-commit. The clock restarts
 	// only after we hand control back to the runtime.
-	const { result, mergeSummary, changesApplied } = await withBridgeTimeoutPause(options.emitStatus, async () => {
-		let isolationContext: IsolationContext | null = null;
-		if (isIsolated) {
-			try {
-				isolationContext = await prepareIsolationContext(options.session.cwd);
-			} catch (err) {
-				const message = err instanceof Error ? err.message : String(err);
-				throw new ToolError(`Isolated agent() execution requires a git repository. ${message}`);
-			}
-		}
-		const preferredBackend = isIsolated ? parseIsolationMode(isolationMode) : undefined;
-
-		const result = await (async () => {
-			if (!isolationContext) {
-				return taskExecutor.runSubprocess(baseRunOptions);
-			}
-			const taskStart = Date.now();
-			return runIsolatedSubprocess({
-				baseOptions: baseRunOptions,
-				context: isolationContext,
-				preferredBackend,
-				agentId: id,
-				mergeMode,
-				artifactsDir,
-				description: trimToUndefined(parsed.label),
-				buildCommitMessage,
-				buildFailureResult: err => {
+	const { result, mergeSummary, changesApplied } = await withBridgeTimeoutPause(
+		options.emitStatus,
+		async () => {
+			let isolationContext: IsolationContext | null = null;
+			if (isIsolated) {
+				try {
+					isolationContext = await prepareIsolationContext(options.session.cwd);
+				} catch (err) {
 					const message = err instanceof Error ? err.message : String(err);
-					return {
-						index: 0,
-						id,
-						agent: effectiveAgent.name,
-						agentSource: effectiveAgent.source,
-						task: renderSubagentPrompt(assignment),
-						assignment,
-						description: trimToUndefined(parsed.label),
-						exitCode: 1,
-						output: "",
-						stderr: message,
-						truncated: false,
-						durationMs: Date.now() - taskStart,
-						tokens: 0,
-						requests: 0,
-						modelOverride,
-						error: message,
-					};
-				},
-			});
-		})();
-
-		if (result.exitCode !== 0 || result.error || result.aborted) {
-			const failureMessage = buildSubagentFailureMessage(agentName, result);
-			const recoveryHint = isIsolated ? await buildIsolationRecoveryHint(result, artifactsDir) : "";
-			throw new ToolError(`${failureMessage}${recoveryHint}`);
-		}
-
-		let mergeSummary = "";
-		let changesApplied: boolean | null = null;
-		if (isIsolated && isolationContext) {
-			if (applyChanges) {
-				const outcome = await mergeIsolatedChanges({
-					result,
-					repoRoot: isolationContext.repoRoot,
-					mergeMode,
-				});
-				mergeSummary = outcome.summary;
-				changesApplied = outcome.changesApplied;
-				if (outcome.changesApplied === false) {
-					const summaryText = outcome.summary.trim();
-					const recoveryHint = await buildIsolationRecoveryHint(result, artifactsDir);
-					throw new ToolError(
-						`agent() isolated apply failed for ${result.id}${summaryText ? `: ${summaryText}` : ""}${recoveryHint}`,
-					);
+					throw new ToolError(`Isolated agent() execution requires a git repository. ${message}`);
 				}
+			}
+			const preferredBackend = isIsolated ? parseIsolationMode(isolationMode) : undefined;
 
-				const nestedSummary = await applyEligibleNestedPatches({
-					result,
-					repoRoot: isolationContext.repoRoot,
+			const result = await (async () => {
+				if (!isolationContext) {
+					return taskExecutor.runSubprocess(baseRunOptions);
+				}
+				const taskStart = Date.now();
+				return runIsolatedSubprocess({
+					baseOptions: baseRunOptions,
+					context: isolationContext,
+					preferredBackend,
+					agentId: id,
 					mergeMode,
-					changesApplied: outcome.changesApplied,
-					mergedBranchForNestedPatches: outcome.mergedBranchForNestedPatches,
-					commitMessage: buildCommitMessage(),
+					artifactsDir,
+					description: trimToUndefined(parsed.label),
+					buildCommitMessage,
+					buildFailureResult: err => {
+						const message = err instanceof Error ? err.message : String(err);
+						return {
+							index: 0,
+							id,
+							agent: effectiveAgent.name,
+							agentSource: effectiveAgent.source,
+							task: renderSubagentPrompt(assignment),
+							assignment,
+							description: trimToUndefined(parsed.label),
+							exitCode: 1,
+							output: "",
+							stderr: message,
+							truncated: false,
+							durationMs: Date.now() - taskStart,
+							tokens: 0,
+							requests: 0,
+							modelOverride,
+							error: message,
+						};
+					},
 				});
-				mergeSummary += nestedSummary;
-				if (structured && nestedSummary.trim()) {
-					const recoveryHint = await buildIsolationRecoveryHint(
-						{ ...result, patchPath: undefined, branchName: undefined },
-						artifactsDir,
-					);
-					throw new ToolError(
-						`agent() isolated nested patch apply failed for ${result.id}: ${plainIsolationSummary(nestedSummary)}${recoveryHint}`,
-					);
-				}
-			} else if (result.branchName) {
-				mergeSummary = `\n\nIsolation: changes captured on branch \`${result.branchName}\` (apply=false). Not merged.`;
-			} else if (result.patchPath) {
-				mergeSummary = `\n\nIsolation: changes captured at \`${result.patchPath}\` (apply=false). Not applied.`;
-			} else {
-				const nestedPatches = result.nestedPatches ?? [];
-				if (nestedPatches.length > 0) {
-					mergeSummary = `\n\nIsolation: changes captured for ${nestedPatches.length} nested repositor${nestedPatches.length === 1 ? "y" : "ies"} (apply=false). Not applied.`;
+			})();
+
+			if (result.exitCode !== 0 || result.error || result.aborted) {
+				const failureMessage = buildSubagentFailureMessage(agentName, result);
+				const recoveryHint = isIsolated ? await buildIsolationRecoveryHint(result, artifactsDir) : "";
+				throw new ToolError(`${failureMessage}${recoveryHint}`);
+			}
+
+			let mergeSummary = "";
+			let changesApplied: boolean | null = null;
+			if (isIsolated && isolationContext) {
+				if (applyChanges) {
+					const outcome = await mergeIsolatedChanges({
+						result,
+						repoRoot: isolationContext.repoRoot,
+						mergeMode,
+					});
+					mergeSummary = outcome.summary;
+					changesApplied = outcome.changesApplied;
+					if (outcome.changesApplied === false) {
+						const summaryText = outcome.summary.trim();
+						const recoveryHint = await buildIsolationRecoveryHint(result, artifactsDir);
+						throw new ToolError(
+							`agent() isolated apply failed for ${result.id}${summaryText ? `: ${summaryText}` : ""}${recoveryHint}`,
+						);
+					}
+
+					const nestedSummary = await applyEligibleNestedPatches({
+						result,
+						repoRoot: isolationContext.repoRoot,
+						mergeMode,
+						changesApplied: outcome.changesApplied,
+						mergedBranchForNestedPatches: outcome.mergedBranchForNestedPatches,
+						commitMessage: buildCommitMessage(),
+					});
+					mergeSummary += nestedSummary;
+					if (structured && nestedSummary.trim()) {
+						const recoveryHint = await buildIsolationRecoveryHint(
+							{ ...result, patchPath: undefined, branchName: undefined },
+							artifactsDir,
+						);
+						throw new ToolError(
+							`agent() isolated nested patch apply failed for ${result.id}: ${plainIsolationSummary(nestedSummary)}${recoveryHint}`,
+						);
+					}
+				} else if (result.branchName) {
+					mergeSummary = `\n\nIsolation: changes captured on branch \`${result.branchName}\` (apply=false). Not merged.`;
+				} else if (result.patchPath) {
+					mergeSummary = `\n\nIsolation: changes captured at \`${result.patchPath}\` (apply=false). Not applied.`;
 				} else {
-					mergeSummary = "\n\nIsolation: no changes captured.";
+					const nestedPatches = result.nestedPatches ?? [];
+					if (nestedPatches.length > 0) {
+						mergeSummary = `\n\nIsolation: changes captured for ${nestedPatches.length} nested repositor${nestedPatches.length === 1 ? "y" : "ies"} (apply=false). Not applied.`;
+					} else {
+						mergeSummary = "\n\nIsolation: no changes captured.";
+					}
 				}
 			}
-		}
-
-		// Clean up the temp artifacts dir we created for this call only when the
-		// caller will not need files from it later. Keep it when the runtime helper
-		// will return an `agent://` handle (the `.md`/`.jsonl` backing files live
-		// here) and on `apply=false` (`changesApplied === null`) where the caller
-		// consumes `details.patchPath` / `details.branchName` /
-		// `details.nestedPatches` out of band. Failed isolated applies throw
-		// earlier with a recovery hint, so they never reach this gate.
-		const shouldCleanupTempArtifacts = tempArtifactsDir && !parsed.handle && (!isIsolated || changesApplied === true);
-		if (shouldCleanupTempArtifacts) {
-			await fs.rm(artifactsDir, { recursive: true, force: true });
-			unregisterArtifactsDir?.();
-		}
-
-		options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);
-
-		return { result, mergeSummary, changesApplied };
-	});
+
+			// Clean up the temp artifacts dir we created for this call only when the
+			// caller will not need files from it later. Keep it when the runtime helper
+			// will return an `agent://` handle (the `.md`/`.jsonl` backing files live
+			// here) and on `apply=false` (`changesApplied === null`) where the caller
+			// consumes `details.patchPath` / `details.branchName` /
+			// `details.nestedPatches` out of band. Failed isolated applies throw
+			// earlier with a recovery hint, so they never reach this gate.
+			const shouldCleanupTempArtifacts =
+				tempArtifactsDir && !parsed.handle && (!isIsolated || changesApplied === true);
+			if (shouldCleanupTempArtifacts) {
+				await fs.rm(artifactsDir, { recursive: true, force: true });
+				unregisterArtifactsDir?.();
+			}
+
+			options.session.recordEvalSubagentUsage?.(result.usage?.output ?? 0);
+
+			return { result, mergeSummary, changesApplied };
+		},
+		{ deferExternalAbort: true },
+	);
 
 	return {
 		text: structured ? result.output : result.output + mergeSummary,

package/src/eval/bridge-timeout.ts

@@ -26,6 +26,15 @@ export function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean {
 	return event.op === EVAL_TIMEOUT_PAUSE_OP || event.op === EVAL_TIMEOUT_RESUME_OP;
 }
 
+/** Optional behavior for a timeout pause around a host bridge call. */
+export interface BridgeTimeoutPauseOptions {
+	/**
+	 * Marks the pause as an `agent()` call whose already-started work must finish
+	 * before an external eval abort reaches the kernel.
+	 */
+	deferExternalAbort?: boolean;
+}
+
 /**
  * Run {@link operation} while suspending the eval watchdog through
  * {@link emitStatus}. A no-op wrapper when no status sink is wired.
@@ -33,12 +42,21 @@ export function isEvalTimeoutControlEvent(event: JsStatusEvent): boolean {
 export async function withBridgeTimeoutPause<T>(
 	emitStatus: ((event: JsStatusEvent) => void) | undefined,
 	operation: () => Promise<T>,
+	options?: BridgeTimeoutPauseOptions,
 ): Promise<T> {
 	if (!emitStatus) return operation();
-	emitStatus({ op: EVAL_TIMEOUT_PAUSE_OP });
+	emitStatus(
+		options?.deferExternalAbort
+			? { op: EVAL_TIMEOUT_PAUSE_OP, deferExternalAbort: true }
+			: { op: EVAL_TIMEOUT_PAUSE_OP },
+	);
 	try {
 		return await operation();
 	} finally {
-		emitStatus({ op: EVAL_TIMEOUT_RESUME_OP });
+		emitStatus(
+			options?.deferExternalAbort
+				? { op: EVAL_TIMEOUT_RESUME_OP, deferExternalAbort: true }
+				: { op: EVAL_TIMEOUT_RESUME_OP },
+		);
 	}
 }

package/src/eval/executor-base.ts

@@ -3,7 +3,7 @@ import { Settings } from "../config/settings";
 import { OutputSink } from "../session/streaming-output";
 import type { ToolSession } from "../tools";
 import { resolveOutputMaxColumns, resolveOutputSinkHeadBytes } from "../tools/output-meta";
-import { isEvalTimeoutControlEvent } from "./bridge-timeout";
+import { EVAL_TIMEOUT_PAUSE_OP, EVAL_TIMEOUT_RESUME_OP, isEvalTimeoutControlEvent } from "./bridge-timeout";
 import type { JsStatusEvent } from "./js/shared/types";
 import type { KernelDisplayOutput } from "./py/display";
 import { registerPyToolBridge } from "./py/tool-bridge";
@@ -158,6 +158,77 @@ export async function waitForPromiseWithCancellation<T>(
 	return await resultPromise;
 }
 
+interface BridgeAbortShield {
+	signal: AbortSignal | undefined;
+	abortRequested: boolean;
+	timedOut: boolean;
+	handleStatus?: (event: JsStatusEvent) => void;
+	dispose?: () => void;
+}
+
+function createBridgeAbortShield(source: AbortSignal | undefined): BridgeAbortShield {
+	const shield: BridgeAbortShield = {
+		signal: undefined,
+		abortRequested: false,
+		timedOut: false,
+	};
+	if (!source) return shield;
+
+	const controller = new AbortController();
+	let pauseDepth = 0;
+	let abortReason: unknown;
+	let removeAbortListener: (() => void) | undefined;
+
+	const requestAbort = (reason: unknown): void => {
+		shield.abortRequested = true;
+		shield.timedOut =
+			shield.timedOut ||
+			(typeof DOMException !== "undefined" && reason instanceof DOMException
+				? reason.name === "TimeoutError"
+				: reason instanceof Error && reason.name === "TimeoutError");
+		abortReason = reason;
+		if (pauseDepth > 0 || controller.signal.aborted) return;
+		controller.abort(reason);
+	};
+
+	const onAbort = (): void => {
+		const reason = source.reason;
+		requestAbort(reason);
+	};
+
+	shield.signal = controller.signal;
+	shield.handleStatus = (event: JsStatusEvent): void => {
+		if (event.deferExternalAbort !== true) return;
+		if (event.op === EVAL_TIMEOUT_PAUSE_OP) {
+			pauseDepth++;
+			return;
+		}
+		if (event.op !== EVAL_TIMEOUT_RESUME_OP || pauseDepth === 0) return;
+		pauseDepth--;
+		if (shield.abortRequested && !controller.signal.aborted) controller.abort(abortReason);
+	};
+	shield.dispose = (): void => {
+		removeAbortListener?.();
+		removeAbortListener = undefined;
+	};
+
+	if (source.aborted) {
+		requestAbort(source.reason);
+	} else {
+		source.addEventListener("abort", onAbort, { once: true });
+		removeAbortListener = () => {
+			source.removeEventListener("abort", onAbort);
+		};
+		if (source.aborted) {
+			source.removeEventListener("abort", onAbort);
+			removeAbortListener = undefined;
+			requestAbort(source.reason);
+		}
+	}
+
+	return shield;
+}
+
 export function createCancelledKernelResult(output: string): KernelExecutionResult {
 	const outputBytes = Buffer.byteLength(output, "utf-8");
 	const outputLines = output.length > 0 ? 1 : 0;
@@ -304,9 +375,11 @@ export async function executeWithKernelBase<
 	const displayOutputs: KernelDisplayOutput[] = [];
 	const deadlineMs = (resolveDeadlineMs ?? getExecutionDeadlineMs)(options);
 	let executionTimeoutMs: number | undefined;
+	const abortShield = createBridgeAbortShield(options?.signal);
 
 	const collectDisplay = (output: KernelDisplayOutput): void => {
 		if (output.type === "status") {
+			abortShield.handleStatus?.(output.event);
 			options?.onStatus?.(output.event);
 			if (!isJulia && isEvalTimeoutControlEvent(output.event)) return;
 		}
@@ -320,8 +393,11 @@ export async function executeWithKernelBase<
 		options?.toolSession && options?.bridgeSessionId
 			? registerPyToolBridge(options.bridgeSessionId, runId, {
 					toolSession: options.toolSession,
-					signal: options.signal,
+					signal: abortShield.signal,
 					emitStatus,
+					abortRequested: () => {
+						return abortShield.abortRequested;
+					},
 				})
 			: null;
 
@@ -338,14 +414,15 @@ export async function executeWithKernelBase<
 			cwd: options?.cwd,
 			env: buildKernelEnvPatch(options ?? ({} as TOptions)),
 			id: runId,
-			signal: options?.signal,
+			signal: abortShield.signal,
 			timeoutMs: executionTimeoutMs,
 			onChunk: text => sink.push(text),
 			onDisplay: output => collectDisplay(output),
 		});
 
-		if (result.cancelled) {
-			const annotation = result.timedOut
+		if (result.cancelled || abortShield.abortRequested) {
+			const timedOut = result.timedOut || abortShield.timedOut;
+			const annotation = timedOut
 				? formatKernelTimeoutAnnotation(executionTimeoutMs ?? options?.idleTimeoutMs, result.kernelKilled ?? false)
 				: undefined;
 			const dumped = await sink.dump(annotation);
@@ -397,8 +474,8 @@ export async function executeWithKernelBase<
 			stdinRequested: false,
 		};
 	} catch (err) {
-		if (isCancellationError(err, cancelledErrorClass) || options?.signal?.aborted) {
-			const timedOut = isTimedOutCancellation(err, cancelledErrorClass, options?.signal);
+		if (isCancellationError(err, cancelledErrorClass) || abortShield.abortRequested || abortShield.signal?.aborted) {
+			const timedOut = abortShield.timedOut || isTimedOutCancellation(err, cancelledErrorClass, abortShield.signal);
 			const dumped = await sink.dump(
 				timedOut ? formatTimeoutAnnotation(executionTimeoutMs ?? options?.idleTimeoutMs) : undefined,
 			);
@@ -421,5 +498,6 @@ export async function executeWithKernelBase<
 		throw error;
 	} finally {
 		unregisterBridge?.();
+		abortShield.dispose?.();
 	}
 }

package/src/eval/jl/kernel.ts

@@ -13,7 +13,7 @@ import { $ } from "bun";
 import { Settings } from "../../config/settings";
 import { BaseKernel, getRemainingTimeMs, type KernelStartOptions } from "../kernel-base";
 import type { KernelDisplayOutput } from "../py/display";
-import { hostHasInheritableConsole, shouldHideKernelWindow } from "../py/spawn-options";
+import { hostHasInheritableConsole, shouldDetachKernel, shouldHideKernelWindow } from "../py/spawn-options";
 import { JULIA_PRELUDE } from "./prelude";
 import RUNNER_SCRIPT from "./runner.jl" with { type: "text" };
 import {
@@ -187,6 +187,7 @@ export class JuliaKernel extends BaseKernel<KernelExecuteOptions> {
 			[runtime.juliaPath, "--startup-file=no", "--history-file=no", "--color=no", "--project=@.", scriptPath],
 			{
 				cwd: options.cwd,
+				detached: shouldDetachKernel(process.platform),
 				env: spawnEnv,
 				stdin: "pipe",
 				stdout: "pipe",