@oh-my-pi/pi-coding-agent 17.3.0 → 17.3.2

package/src/modes/controllers/extension-ui-controller.ts

@@ -283,7 +283,7 @@ export class ExtensionUiController {
 			},
 		};
 
-		extensionRunner.initialize(actions, contextActions, commandActions, uiContext);
+		extensionRunner.initialize(actions, contextActions, commandActions, uiContext, "tui");
 
 		// Subscribe to extension errors
 		extensionRunner.onError((error: ExtensionError) => {
@@ -512,7 +512,7 @@ export class ExtensionUiController {
 			},
 		};
 
-		extensionRunner.initialize(actions, contextActions, commandActions, uiContext);
+		extensionRunner.initialize(actions, contextActions, commandActions, uiContext, "tui");
 	}
 
 	/**

package/src/modes/interactive-mode.ts

@@ -359,6 +359,20 @@ function readPersistedToolNames(value: unknown): string[] | undefined {
 	return value as string[];
 }
 
+export function shouldEnterPlanModeOnStartup(
+	sessionManager: Pick<SessionManager, "buildSessionContext" | "getEntries">,
+	sessionSettings: Pick<Settings, "get">,
+): boolean {
+	const hasConversationContext = sessionManager.buildSessionContext().messages.length > 0;
+	const hasExplicitMode = sessionManager.getEntries().some(entry => entry.type === "mode_change");
+	return (
+		!hasConversationContext &&
+		!hasExplicitMode &&
+		sessionSettings.get("plan.defaultOnStartup") &&
+		sessionSettings.get("plan.enabled")
+	);
+}
+
 /** Options for creating an InteractiveMode instance (for future API use) */
 export interface InteractiveModeOptions {
 	/** Providers that were migrated during startup */
@@ -1140,14 +1154,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		// execution handoff clear never get dragged back into plan mode. #enterPlanMode
 		// is idempotent and self-guards against an already-active plan/goal mode; it
 		// does not check plan.enabled itself.
-		const hasConversationContext = this.sessionManager.buildSessionContext().messages.length > 0;
-		const hasExplicitMode = this.sessionManager.getEntries().some(entry => entry.type === "mode_change");
-		const isFreshSession = !hasConversationContext && !hasExplicitMode;
-		if (
-			isFreshSession &&
-			this.session.settings.get("plan.defaultOnStartup") &&
-			this.session.settings.get("plan.enabled")
-		) {
+		if (shouldEnterPlanModeOnStartup(this.sessionManager, this.session.settings)) {
 			await this.#enterPlanMode();
 		}
 
@@ -4597,7 +4604,7 @@ export class InteractiveMode implements InteractiveModeContext {
 		this.#uiHelpers.renderSessionContext(sessionContext, options);
 	}
 
-	/** Render a session context in bounded chunks so terminal input runs between transcript paints. */
+	/** Build a session context in bounded chunks so terminal input runs between event-loop turns. */
 	async renderSessionContextIncrementally(
 		sessionContext: SessionContext,
 		options: RenderSessionContextOptions,

package/src/modes/print-mode.ts

@@ -118,6 +118,7 @@ export async function runPrintMode(session: AgentSession, options: PrintModeOpti
 	}
 	// Set up extensions for print mode (no UI, no command context)
 	await initializeExtensions(session, {
+		mode: mode === "json" ? "json" : "print",
 		reportSendError: (action, err) => {
 			process.stderr.write(
 				`Extension ${action === "extension_send" ? "sendMessage" : "sendUserMessage"} failed: ${err.message}\n`,

package/src/modes/rpc/rpc-client.ts

@@ -62,6 +62,8 @@ export interface RpcClientOptions {
 	sessionDir?: string;
 	/** Additional CLI arguments */
 	args?: string[];
+	/** Grace period before escalating process termination (default: process utility default, 1000ms) */
+	terminationGraceMs?: number;
 	/** Custom tools owned by the embedding host and exposed over the RPC transport */
 	customTools?: RpcClientCustomTool[];
 }
@@ -324,7 +326,7 @@ export class RpcClient {
 			this.#pendingHostToolCalls.clear();
 
 			try {
-				child.kill();
+				child.kill(undefined, this.options.terminationGraceMs);
 			} catch {
 				// The process may already have exited.
 			}
@@ -440,7 +442,7 @@ export class RpcClient {
 
 		const error = new Error("Client stopped");
 		const child = this.#process;
-		child.kill();
+		child.kill(undefined, this.options.terminationGraceMs);
 		this.#abortController.abort(error);
 		this.#process = null;
 		for (const request of this.#pendingRequests.values()) request.reject(error);

package/src/modes/rpc/rpc-input.ts

@@ -1,3 +1,5 @@
+import { readLines } from "@oh-my-pi/pi-utils";
+
 /**
  * Claims Bun's singleton stdin reader immediately and exposes a separately readable stream.
  * RPC startup uses this before extension discovery so in-process modules cannot steal protocol input.
@@ -36,3 +38,28 @@ export function claimRpcInput(): ReadableStream<Uint8Array> {
 		},
 	});
 }
+
+/**
+ * Parses newline-delimited RPC input without letting one malformed line stop
+ * subsequent protocol frames.
+ */
+export async function readRpcInputFrames(
+	input: ReadableStream<Uint8Array>,
+	onFrame: (frame: unknown) => void,
+	onParseError: (message: string) => void,
+): Promise<void> {
+	const decoder = new TextDecoder();
+	for await (const line of readLines(input)) {
+		const text = decoder.decode(line).trim();
+		if (!text) continue;
+		let parsed: unknown;
+		try {
+			parsed = JSON.parse(text);
+		} catch (error: unknown) {
+			const message = error instanceof Error ? error.message : String(error);
+			onParseError(`Failed to parse command: ${message}`);
+			continue;
+		}
+		onFrame(parsed);
+	}
+}

package/src/modes/rpc/rpc-mode.ts

@@ -13,7 +13,7 @@
 import { once } from "node:events";
 import { getOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import { toolWireSchema } from "@oh-my-pi/pi-ai/utils/schema";
-import { $env, isRecord, readLines, Snowflake } from "@oh-my-pi/pi-utils";
+import { $env, isRecord, Snowflake } from "@oh-my-pi/pi-utils";
 import { reset as resetCapabilities } from "../../capability";
 import { clearPluginRootsAndCaches, resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import {
@@ -37,7 +37,7 @@ import { initializeExtensions } from "../runtime-init";
 import { isRpcHostToolResult, isRpcHostToolUpdate, RpcHostToolBridge } from "./host-tools";
 import { isRpcHostUriResult, RpcHostUriBridge } from "./host-uris";
 import { MAX_RPC_FRAME_BYTES, MAX_RPC_REASSEMBLED_BYTES, RpcFrameEncoder } from "./rpc-frame";
-import { claimRpcInput } from "./rpc-input";
+import { claimRpcInput, readRpcInputFrames } from "./rpc-input";
 import { pageRpcMessages, RPC_MESSAGES_PAGE_BUSY_ERROR, RpcMessagesPageError } from "./rpc-messages";
 import { RpcSubagentRegistry, readRpcSubagentTranscript } from "./rpc-subagents";
 import type {
@@ -933,6 +933,7 @@ export async function runRpcMode(
 
 	// Set up extensions with RPC-based UI context
 	await initializeExtensions(session, {
+		mode: "rpc",
 		reportSendError: (action, err) => {
 			output(error(undefined, action, err.message));
 		},
@@ -1484,23 +1485,14 @@ export async function runRpcMode(
 	// Keep the stdin reader moving: side-channel frames dispatch immediately,
 	// ordinary commands serialize through inputDispatcher, and bash remains
 	// background-dispatched so abort_bash can overtake it. Frames are read
-	// line-by-line and parsed here (not via readJsonl) so a single malformed
-	// line is reported as an error frame and the loop keeps running instead of
-	// throwing out of the generator and killing the whole process (issue #5194).
-	const decoder = new TextDecoder();
-	for await (const line of readLines(input ?? Bun.stdin.stream())) {
-		const text = decoder.decode(line).trim();
-		if (!text) continue;
-		let parsed: unknown;
-		try {
-			parsed = JSON.parse(text);
-		} catch (e: unknown) {
-			const message = e instanceof Error ? e.message : String(e);
-			output(error(undefined, "parse", `Failed to parse command: ${message}`));
-			continue;
-		}
-		inputDispatcher.dispatch(parsed);
-	}
+	// line-by-line by readRpcInputFrames so a single malformed line is reported
+	// as an error frame and the loop keeps running instead of throwing out of
+	// the reader and killing the whole process (issue #5194).
+	await readRpcInputFrames(
+		input ?? Bun.stdin.stream(),
+		parsed => inputDispatcher.dispatch(parsed),
+		message => output(error(undefined, "parse", message)),
+	);
 
 	// stdin closed — RPC client is gone. Fail pending side-channel requests
 	// first so active/queued commands can settle, then drain accepted work.

package/src/modes/runtime-init.ts

@@ -8,7 +8,7 @@
  */
 import { runExtensionCompact, runExtensionSetModel } from "../extensibility/extensions/compact-handler";
 import { getSessionSlashCommands } from "../extensibility/extensions/get-commands-handler";
-import type { ExtensionError, ExtensionUIContext } from "../extensibility/extensions/types";
+import type { ExtensionError, ExtensionMode, ExtensionUIContext } from "../extensibility/extensions/types";
 import type { AgentSession } from "../session/agent-session";
 import { USER_INTERRUPT_LABEL } from "../session/messages";
 
@@ -22,6 +22,8 @@ export interface InitializeExtensionsOptions {
 	reportRuntimeError: (error: ExtensionError) => void;
 	/** Optional shutdown hook (rpc mode signals its loop; print mode is a no-op). */
 	onShutdown?: () => void;
+	/** Pi-compatible mode exposed to extension contexts. Defaults to `"print"`. */
+	mode?: ExtensionMode;
 	/** Optional UI context (rpc supplies one; print runs headless). */
 	uiContext?: ExtensionUIContext;
 	/** Optional lifecycle hook for extension-originated messages that can start an agent turn. */
@@ -44,6 +46,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 		reportSendError,
 		reportRuntimeError,
 		onShutdown,
+		mode = "print",
 		uiContext,
 		markAgentInvokingMessage,
 		trackAgentInvokingMessage,
@@ -137,6 +140,7 @@ export async function initializeExtensions(session: AgentSession, options: Initi
 			compact: instructionsOrOptions => runExtensionCompact(session, instructionsOrOptions),
 		},
 		uiContext,
+		mode,
 	);
 
 	runner.onError(reportRuntimeError);

package/src/modes/utils/ui-helpers.ts

@@ -33,8 +33,8 @@ import {
 import { SkillMessageComponent } from "../../modes/components/skill-message";
 import { StrippedToolCallsPlaceholder } from "../../modes/components/stripped-tool-calls-placeholder";
 import { ToolActivityContainer } from "../../modes/components/tool-activity";
-import { ToolExecutionComponent } from "../../modes/components/tool-execution";
-import { TranscriptBlock } from "../../modes/components/transcript-container";
+import { ToolExecutionComponent, type ToolExecutionHandle } from "../../modes/components/tool-execution";
+import { TranscriptBlock, TranscriptContainer } from "../../modes/components/transcript-container";
 import { createUsageRowBlock } from "../../modes/components/usage-row";
 import { UserMessageComponent } from "../../modes/components/user-message";
 import { decodeStreamedToolArgs, streamingStringKeysForTool } from "../../modes/controllers/tool-args-reveal";
@@ -325,7 +325,7 @@ export class UiHelpers {
 		while (!steps.next().done) {}
 	}
 
-	/** Render a session context in bounded chunks so terminal input runs between transcript paints. */
+	/** Build a session context in bounded chunks so terminal input runs between event-loop turns. */
 	async renderSessionContextIncrementally(
 		sessionContext: SessionContext,
 		options: RenderSessionContextOptions,
@@ -729,18 +729,23 @@ export class UiHelpers {
 	}
 
 	async renderInitialMessages(options: RenderInitialMessagesOptions = {}): Promise<void> {
-		// This path is used to rebuild the visible chat transcript (e.g. after custom/debug UI).
-		// Clear existing rendered chat first to avoid duplicating the full session in the container.
-		// On a non-preserving rebuild the existing blocks are discarded for good, so
-		// dispose them (stopping any live timers/subscriptions) before clearing. When
-		// preserving, the same instances are re-added below, so detach without dispose.
-		const preservedChatChildren = options.preserveExistingChat ? this.ctx.chatContainer.children : undefined;
+		// Build against a detached container. Incremental construction still yields
+		// to terminal input, while paints keep using the complete visible transcript
+		// until the replacement is ready to swap in.
+		const visibleChatContainer = this.ctx.chatContainer;
+		const stagedChatContainer = new TranscriptContainer();
+		stagedChatContainer.setToolActivityVisible(!this.ctx.hideToolActivity);
+		const preservedChatChildren = options.preserveExistingChat ? [...visibleChatContainer.children] : undefined;
+		const previousTranscriptMessageComponents = this.ctx.transcriptMessageComponents;
+		const previousPendingTools = this.ctx.pendingTools;
+		const previousPendingBashComponents = this.ctx.pendingBashComponents;
+		const previousPendingPythonComponents = this.ctx.pendingPythonComponents;
+		const previousLastAssistantUsage = this.ctx.lastAssistantUsage;
 		const chatWasAlreadyRendered = this.ctx.initialChatRendered;
-		if (preservedChatChildren) {
-			this.ctx.chatContainer.clear();
-		} else {
-			this.ctx.resetTranscript();
-		}
+
+		this.ctx.chatContainer = stagedChatContainer;
+		this.ctx.transcriptMessageComponents = new WeakMap<AgentMessage, Component>();
+		this.ctx.pendingTools = new Map<string, ToolExecutionHandle>();
 		this.ctx.pendingMessagesContainer.disposeChildren();
 		this.ctx.pendingBashComponents = [];
 		this.ctx.pendingPythonComponents = [];
@@ -751,13 +756,6 @@ export class UiHelpers {
 		// (focus attach/unfocus while a tool executes) keep dangling toolCalls so
 		// the in-flight call re-renders as pending instead of vanishing;
 		// renderSessionContext then keeps it in `pendingTools` for live routing.
-		let terminalHistoryCleared = false;
-		const renderChunk = options.clearTerminalHistory
-			? () => {
-					this.ctx.ui.requestRender(true, { clearScrollback: !terminalHistoryCleared });
-					terminalHistoryCleared = true;
-				}
-			: undefined;
 		let context = this.ctx.viewSession.buildTranscriptSessionContext({
 			collapseCompactedHistory: settings.get("display.collapseCompacted"),
 			keepDanglingToolCalls: this.ctx.viewSession.isStreaming,
@@ -770,6 +768,7 @@ export class UiHelpers {
 			// every attempt.
 			populateHistory: false,
 		};
+		let committed = false;
 		this.ctx.initialChatRendered = false;
 		try {
 			while (true) {
@@ -777,8 +776,6 @@ export class UiHelpers {
 					// Live events mutate the same component maps; keep their replay atomic so
 					// a delta cannot land halfway through rebuilding its pending tool block.
 					this.ctx.renderSessionContext(context, renderOptions);
-				} else if (renderChunk) {
-					await this.ctx.renderSessionContextIncrementally(context, renderOptions, renderChunk);
 				} else {
 					await this.ctx.renderSessionContextIncrementally(context, renderOptions);
 				}
@@ -790,49 +787,73 @@ export class UiHelpers {
 				// yielded. The display callback stayed gated by initialChatRendered;
 				// discard the stale partial tree and replay the current session once
 				// more instead of letting a reentrant synchronous rebuild interleave.
-				this.ctx.resetTranscript();
+				stagedChatContainer.disposeChildren();
+				this.ctx.transcriptMessageComponents = new WeakMap<AgentMessage, Component>();
+				this.ctx.pendingTools.clear();
 				this.ctx.pendingBashComponents = [];
 				this.ctx.pendingPythonComponents = [];
-				terminalHistoryCleared = false;
 				context = this.ctx.viewSession.buildTranscriptSessionContext({
 					collapseCompactedHistory: settings.get("display.collapseCompacted"),
 					keepDanglingToolCalls: this.ctx.viewSession.isStreaming,
 				});
 				replayEntryCount = this.ctx.viewSession.sessionManager.getEntries().length;
 			}
-		} finally {
-			this.ctx.initialChatRendered = chatWasAlreadyRendered;
-		}
-		if (!this.ctx.focusedAgentId) {
-			for (const message of context.messages) {
-				if (message.role !== "user" || message.synthetic) continue;
-				const text = this.getUserMessageText(message);
-				if (text) this.ctx.editor.addToHistory(text);
+
+			const replayedChatChildren = [...stagedChatContainer.children];
+			stagedChatContainer.clear();
+			this.ctx.chatContainer = visibleChatContainer;
+			if (preservedChatChildren) {
+				visibleChatContainer.clear();
+			} else {
+				visibleChatContainer.disposeChildren();
 			}
-		}
+			for (const child of replayedChatChildren) {
+				visibleChatContainer.addChild(child);
+			}
+			if (preservedChatChildren) {
+				for (const child of preservedChatChildren) {
+					visibleChatContainer.addChild(child);
+				}
+			}
+			committed = true;
 
-		// Show compaction info if session was compacted
-		const allEntries = this.ctx.viewSession.sessionManager.getEntries();
-		let compactionCount = 0;
-		for (const entry of allEntries) {
-			if (entry.type === "compaction") {
-				compactionCount++;
+			if (!this.ctx.focusedAgentId) {
+				for (const message of context.messages) {
+					if (message.role !== "user" || message.synthetic) continue;
+					const text = this.getUserMessageText(message);
+					if (text) this.ctx.editor.addToHistory(text);
+				}
 			}
-		}
-		if (compactionCount > 0) {
-			const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
-			this.ctx.showStatus(`Session compacted ${times}`);
-		}
-		if (options.clearTerminalHistory) {
-			this.ctx.ui.requestRender(true, { clearScrollback: !terminalHistoryCleared });
-		}
-		if (preservedChatChildren && preservedChatChildren.length > 0) {
-			for (const child of preservedChatChildren) {
-				this.ctx.chatContainer.addChild(child);
+
+			// Show compaction info if session was compacted.
+			const allEntries = this.ctx.viewSession.sessionManager.getEntries();
+			let compactionCount = 0;
+			for (const entry of allEntries) {
+				if (entry.type === "compaction") {
+					compactionCount++;
+				}
 			}
-			this.ctx.ui.requestRender();
+			if (compactionCount > 0) {
+				const times = compactionCount === 1 ? "1 time" : `${compactionCount} times`;
+				this.ctx.showStatus(`Session compacted ${times}`);
+			}
+			if (options.clearTerminalHistory) {
+				this.ctx.ui.requestRender(true, { clearScrollback: true });
+			} else {
+				this.ctx.ui.requestRender();
+			}
+		} finally {
+			if (!committed) {
+				this.ctx.chatContainer = visibleChatContainer;
+				this.ctx.transcriptMessageComponents = previousTranscriptMessageComponents;
+				this.ctx.pendingTools = previousPendingTools;
+				this.ctx.pendingBashComponents = previousPendingBashComponents;
+				this.ctx.pendingPythonComponents = previousPendingPythonComponents;
+				this.ctx.lastAssistantUsage = previousLastAssistantUsage;
+				stagedChatContainer.disposeChildren();
+			}
+			this.ctx.initialChatRendered = committed ? true : chatWasAlreadyRendered;
 		}
-		this.ctx.initialChatRendered = true;
 	}
 
 	clearEditor(): void {

package/src/session/agent-session.ts

@@ -37,6 +37,7 @@ import {
 	type AsideMessage,
 	type BeforeToolCallContext,
 	type BeforeToolCallResult,
+	EventLoopKeepalive,
 	resolveTelemetry,
 	type StreamFn,
 	TERMINAL_TOOL_RESULT_ABORT_REASON,
@@ -1213,15 +1214,28 @@ export class AgentSession {
 				}
 			},
 			scheduleIdleFlush: run => {
-				this.#schedulePostPromptTask(
-					async () => {
-						await run();
-					},
-					{
-						delayMs: 1,
-						onSkip: () => this.yieldQueue.cancelIdleFlushScheduling(),
-					},
-				);
+				const keepalive = new EventLoopKeepalive();
+				try {
+					this.#schedulePostPromptTask(
+						async () => {
+							try {
+								await run();
+							} finally {
+								keepalive[Symbol.dispose]();
+							}
+						},
+						{
+							delayMs: 1,
+							onSkip: () => {
+								keepalive[Symbol.dispose]();
+								this.yieldQueue.cancelIdleFlushScheduling();
+							},
+						},
+					);
+				} catch (error) {
+					keepalive[Symbol.dispose]();
+					throw error;
+				}
 			},
 		});
 		this.yieldQueue.register<LaunchCompletionEntry>(LAUNCH_COMPLETION_MESSAGE_TYPE, {
@@ -5647,6 +5661,7 @@ export class AgentSession {
 
 		return {
 			ui: noOpUIContext,
+			mode: "print",
 			hasUI: false,
 			cwd: this.sessionManager.getCwd(),
 			sessionManager: this.sessionManager,

package/src/session/claude-session-store.ts

@@ -1,6 +1,5 @@
 import type * as fsTypes from "node:fs";
 import * as fs from "node:fs/promises";
-import * as os from "node:os";
 import * as path from "node:path";
 import type {
 	AssistantMessage,
@@ -13,6 +12,7 @@ import type {
 	UserMessage,
 } from "@oh-my-pi/pi-ai";
 import { isRecord } from "@oh-my-pi/pi-utils";
+import { resolveClaudePaths } from "../config/claude-paths";
 import { collectForeignJsonRecords, type ForeignJsonRecord, readForeignJsonRecords } from "./foreign-session-jsonl";
 import type { ForeignSessionInfo, ForeignSessionStore } from "./foreign-session-store";
 import type { ModelChangeEntry, SessionMessageEntry } from "./session-entries";
@@ -99,7 +99,8 @@ async function readHistoryIndex(file: string): Promise<Map<string, ClaudeHistory
 }
 
 async function readRegisteredProjects(root: string): Promise<string[]> {
-	const config = path.join(path.dirname(root), ".claude.json");
+	const { configDir, configFile } = resolveClaudePaths();
+	const config = root === configDir ? configFile : path.join(path.dirname(root), ".claude.json");
 	try {
 		const parsed: unknown = await Bun.file(config).json();
 		if (!isRecord(parsed) || !isRecord(parsed.projects)) return [];
@@ -306,7 +307,7 @@ export class ClaudeSessionStore implements ForeignSessionStore {
 	readonly #root: string;
 
 	/** Creates a store rooted at Claude's data directory, or at a fixture root when supplied. */
-	constructor(root: string = path.join(os.homedir(), ".claude")) {
+	constructor(root: string = resolveClaudePaths().configDir) {
 		this.#root = path.resolve(root);
 	}
 

package/src/task/executor.ts

@@ -6,7 +6,7 @@
 
 import path from "node:path";
 import type { AgentEvent, AgentIdentity, AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core";
-import { recordHandoff, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
+import { EventLoopKeepalive, recordHandoff, resolveTelemetry } from "@oh-my-pi/pi-agent-core";
 import type { Api, Model, ServiceTierByFamily, Usage } from "@oh-my-pi/pi-ai";
 import { logger, popLoopPhase, prompt, pushLoopPhase, untilAborted } from "@oh-my-pi/pi-utils";
 import { ASYNC_JOB_MANAGER_SHUTDOWN_REASON, AsyncJobManager } from "../async";
@@ -493,6 +493,8 @@ export interface ExecutorOptions {
 	keepAlive?: boolean;
 	/** Internal ownership handoff for cleanup that outlives the visible Task result. */
 	onCleanupDeferred?: (completion: Promise<void>) => void;
+	/** Internal cleanup grace override for deterministic lifecycle tests. */
+	cleanupGraceMs?: number;
 }
 
 function parseStringifiedJson(value: unknown): unknown {
@@ -1866,6 +1868,7 @@ async function driveSessionToYield(
 	monitor: SubagentRunMonitor,
 	task: string,
 ): Promise<DriveOutcome> {
+	using _keepalive = new EventLoopKeepalive();
 	const abortSignal = monitor.abortSignal;
 	let exitCode = 0;
 	let error: string | undefined;
@@ -2657,6 +2660,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 		signal,
 		onProgress,
 	} = options;
+	const cleanupGraceMs = options.cleanupGraceMs ?? TASK_ABORT_CLEANUP_GRACE_MS;
 	const startTime = Date.now();
 	// Set by the session's onFirstChatDispatch hook the first time the agent
 	// loop dispatches a chat request to the provider — the launch-complete boundary.
@@ -3328,7 +3332,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				error = err instanceof Error ? err.stack || err.message : String(err);
 			}
 		} finally {
-			const cleanupDeadlineAt = Date.now() + TASK_ABORT_CLEANUP_GRACE_MS;
+			const cleanupDeadlineAt = Date.now() + cleanupGraceMs;
 			const cleanupChangeStatus =
 				worktree === undefined
 					? "This task was not isolated, so its changes may remain in the working directory."
@@ -3339,8 +3343,8 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				lateCleanups.push(completion);
 				exitCode = 1;
 				aborted = true;
-				abortReasonText = `cleanup exceeded ${TASK_ABORT_CLEANUP_GRACE_MS} ms`;
-				error ??= `Task aborted. Cleanup did not finish within ${TASK_ABORT_CLEANUP_GRACE_MS} ms. ${cleanupChangeStatus}`;
+				abortReasonText = `cleanup exceeded ${cleanupGraceMs} ms`;
+				error ??= `Task aborted. Cleanup did not finish within ${cleanupGraceMs} ms. ${cleanupChangeStatus}`;
 			};
 			if (abortSignal.aborted) {
 				aborted = monitor.isAbortedRun();

package/src/tools/browser/launch.ts

@@ -204,6 +204,15 @@ function isExecutableFile(p: string): boolean {
 
 async function isChromiumExecutable(p: string): Promise<boolean> {
 	if (!isExecutableFile(p)) return false;
+	// The version probe below launches the candidate. It exists to reject
+	// non-Chromium `chrome`/`chromium` wrapper scripts that appear on a Linux
+	// PATH (ecb22957, "validate Linux browser executables"). On Windows and
+	// macOS the candidates are fixed GUI application paths, not PATH wrappers,
+	// and executing them is harmful: a GUI `chrome.exe --version` does not print
+	// to a detached stdout and can hand off to the user's running instance,
+	// opening/activating a normal browser window (#8445). Confine the probe to
+	// Linux and trust the executable-file check elsewhere.
+	if (process.platform !== "linux") return true;
 	try {
 		const probeTimeoutMs = 3000;
 		const proc = Bun.spawn([p, "--version"], {

package/src/tools/read-format.ts

@@ -37,16 +37,17 @@ export interface HashlineHeaderContext {
 }
 
 export function formatReadHashlineHeader(displayPath: string, tag: string): string {
-	// In-workspace reads collapse to the bare filename for brevity: the edit
-	// tool's snapshot-tag recovery rebinds a bare `[name#tag]` onto the in-tree
-	// file it uniquely names. Out-of-workspace reads can't lean on that —
-	// recovery refuses to redirect a write outside the cwd/sandbox
-	// (HashlineFilesystem.allowTagPathRecovery) — so an absolute displayPath
-	// must stay directly resolvable, otherwise the basename resolves against
-	// cwd, misses, and the edit fails with "File not found" (e.g. ~/.claude/*).
-	// `shortenPath` keeps `~/.claude/...` (round-trips through resolveToCwd's ~
-	// expansion) instead of leaking the full home path into the read output.
-	const anchor = path.isAbsolute(displayPath) ? shortenPath(displayPath) : path.basename(displayPath);
+	// In-workspace reads keep their workspace-relative path (e.g.
+	// `src/settings.json`), not just the basename: collapsing to the bare name
+	// made a header ambiguous whenever another same-named file exists at cwd —
+	// the edit tool would resolve the bare name against cwd, hit the wrong
+	// file, and reject the valid edit via the snapshot-tag guard (the authored
+	// path exists, so Patcher's tag-path recovery never runs). The relative
+	// path stays directly resolvable against cwd and names the file uniquely.
+	// Out-of-workspace reads use an absolute displayPath; `shortenPath` keeps
+	// `~/.claude/...` (round-trips through resolveToCwd's ~ expansion) instead
+	// of leaking the full home path into the read output.
+	const anchor = path.isAbsolute(displayPath) ? shortenPath(displayPath) : displayPath;
 	return formatHashlineHeader(anchor, tag);
 }
 

package/src/tools/run-scope.ts

@@ -38,7 +38,7 @@ interface ObservedPromiseState {
 const observedBrowserPromises = new WeakMap<Promise<unknown>, ObservedPromiseState>();
 const observedPromiseConstructor = { [Symbol.species]: Promise };
 
-type PromiseCombinatorName = "all" | "race";
+type PromiseCombinatorName = "all" | "race" | "allSettled" | "any";
 type PromiseCombinator = (this: PromiseConstructor, values: Iterable<unknown>) => Promise<unknown>;
 
 interface PromiseCombinatorTrackingContext {
@@ -46,11 +46,13 @@ interface PromiseCombinatorTrackingContext {
 	onFloatingRejection: FloatingRejectionHandler;
 }
 
-const PROMISE_COMBINATORS: readonly PromiseCombinatorName[] = ["all", "race"];
+const PROMISE_COMBINATORS: readonly PromiseCombinatorName[] = ["all", "race", "allSettled", "any"];
 const NativePromise = Promise;
 const nativePromiseCombinators: Record<PromiseCombinatorName, PromiseCombinator> = {
 	all: Promise.all,
 	race: Promise.race,
+	allSettled: Promise.allSettled,
+	any: Promise.any,
 };
 const promiseCombinatorTracking = new AsyncLocalStorage<PromiseCombinatorTrackingContext>();
 let previousPromiseDescriptor: PropertyDescriptor | undefined;