@oh-my-pi/pi-coding-agent 16.3.6 → 16.3.7

package/src/task/executor.ts

@@ -215,7 +215,12 @@ function renderIrcPeerRoster(selfId: string): string {
 	return lines.join("\n");
 }
 
-function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: AbortSignal): Promise<T> {
+function withAbortTimeout<T>(
+	promise: Promise<T>,
+	timeoutMs: number,
+	signal?: AbortSignal,
+	timeoutController?: AbortController,
+): Promise<T> {
 	if (signal?.aborted) {
 		return Promise.reject(new ToolAbortError());
 	}
@@ -225,6 +230,7 @@ function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: Ab
 	const timeoutId = setTimeout(() => {
 		if (settled) return;
 		settled = true;
+		timeoutController?.abort(new DOMException(`MCP tool call timed out after ${timeoutMs}ms`, "TimeoutError"));
 		reject(new Error(`MCP tool call timed out after ${timeoutMs}ms`));
 	}, timeoutMs);
 
@@ -232,6 +238,7 @@ function withAbortTimeout<T>(promise: Promise<T>, timeoutMs: number, signal?: Ab
 		if (settled) return;
 		settled = true;
 		clearTimeout(timeoutId);
+		timeoutController?.abort();
 		reject(new ToolAbortError());
 	};
 
@@ -708,13 +715,21 @@ export function createMCPProxyTools(mcpManager: MCPManager): CustomTool[] {
 				const serverName = mcpTool.mcpServerName ?? "";
 				const mcpToolName = mcpTool.mcpToolName ?? "";
 				try {
+					const timeoutController = new AbortController();
+					const timeoutSignal = timeoutController.signal;
+					const combinedSignal = signal ? AbortSignal.any([signal, timeoutSignal]) : timeoutSignal;
 					const result = await withAbortTimeout(
 						(async () => {
-							const connection = await mcpManager.waitForConnection(serverName);
-							return callTool(connection, mcpToolName, params as Record<string, unknown>, { signal });
+							const connection = await untilAborted(combinedSignal, () =>
+								mcpManager.waitForConnection(serverName),
+							);
+							return callTool(connection, mcpToolName, params as Record<string, unknown>, {
+								signal: combinedSignal,
+							});
 						})(),
 						MCP_CALL_TIMEOUT_MS,
 						signal,
+						timeoutController,
 					);
 					return {
 						content: (result.content ?? []).map(item =>
@@ -2161,6 +2176,11 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				modelRegistry,
 				settings: subagentSettings,
 				model,
+				modelPattern: model || modelOverride === undefined ? undefined : modelPatterns,
+				modelPatternAuthFallback:
+					model || modelOverride === undefined ? undefined : options.parentActiveModelPattern,
+				modelPatternFallbackRole:
+					model || modelOverride === undefined ? undefined : `${SUBAGENT_RETRY_FALLBACK_ROLE_PREFIX}${id}`,
 				thinkingLevel: effectiveThinkingLevel,
 				toolNames,
 				outputSchema,

package/src/task/isolation-runner.ts

@@ -37,6 +37,7 @@ import {
 	getRepoRoot,
 	type IsolationHandle,
 	mergeTaskBranches,
+	type NestedRepoPatch,
 	type WorktreeBaseline,
 } from "./worktree";
 
@@ -100,7 +101,7 @@ export interface IsolatedRunOptions {
 	agentId: string;
 	/** Merge mode driving how changes are captured ("branch" commits, "patch" diffs). */
 	mergeMode: "patch" | "branch";
-	/** Output dir for `${agentId}.patch` artifacts (patch mode). */
+	/** Output dir for `${agentId}.patch` artifacts (patch mode and branch-mode commit failures). */
 	artifactsDir: string;
 	/** Human description carried onto the branch commit (branch mode). */
 	description?: string;
@@ -114,12 +115,25 @@ export interface IsolatedRunOptions {
 	buildFailureResult: (err: unknown) => SingleResult;
 }
 
+async function writeIsolationPatch(
+	isolationDir: string,
+	baseline: WorktreeBaseline,
+	artifactsDir: string,
+	agentId: string,
+): Promise<{ patchPath: string; nestedPatches: NestedRepoPatch[] }> {
+	const delta = await captureDeltaPatch(isolationDir, baseline);
+	const patchPath = path.join(artifactsDir, `${agentId}.patch`);
+	await Bun.write(patchPath, delta.rootPatch);
+	return { patchPath, nestedPatches: delta.nestedPatches };
+}
+
 /**
  * Run a subagent inside an isolation worktree and capture its changes.
  *
  * Branch mode: on success, commits the diff onto `omp/task/${agentId}` and
  * returns `branchName` + `nestedPatches`. On commit failure the branch is
- * deleted and `result.error` carries the merge-failure message.
+ * deleted, the still-live isolation diff is written to `${artifactsDir}/${agentId}.patch`,
+ * and `result.error` carries the merge-failure message.
  *
  * Patch mode: on success, writes `${artifactsDir}/${agentId}.patch` and
  * returns `patchPath` + `nestedPatches`.
@@ -162,18 +176,32 @@ export async function runIsolatedSubprocess(opts: IsolatedRunOptions): Promise<S
 				const branchName = `omp/task/${opts.agentId}`;
 				await git.branch.tryDelete(opts.context.repoRoot, branchName);
 				const msg = mergeErr instanceof Error ? mergeErr.message : String(mergeErr);
-				return { ...result, error: `Merge failed: ${msg}` };
+				try {
+					const patchResult = await writeIsolationPatch(
+						isolationDir,
+						taskBaseline,
+						opts.artifactsDir,
+						opts.agentId,
+					);
+					return {
+						...result,
+						patchPath: patchResult.patchPath,
+						nestedPatches: patchResult.nestedPatches,
+						error: `Merge failed: ${msg}`,
+					};
+				} catch (patchErr) {
+					const patchMsg = patchErr instanceof Error ? patchErr.message : String(patchErr);
+					return { ...result, error: `Merge failed: ${msg}; patch capture failed: ${patchMsg}` };
+				}
 			}
 		}
 		if (result.exitCode === 0) {
 			try {
-				const delta = await captureDeltaPatch(isolationDir, taskBaseline);
-				const patchPath = path.join(opts.artifactsDir, `${opts.agentId}.patch`);
-				await Bun.write(patchPath, delta.rootPatch);
+				const patchResult = await writeIsolationPatch(isolationDir, taskBaseline, opts.artifactsDir, opts.agentId);
 				return {
 					...result,
-					patchPath,
-					nestedPatches: delta.nestedPatches,
+					patchPath: patchResult.patchPath,
+					nestedPatches: patchResult.nestedPatches,
 				};
 			} catch (patchErr) {
 				const msg = patchErr instanceof Error ? patchErr.message : String(patchErr);
@@ -224,8 +252,9 @@ export async function mergeIsolatedChanges(opts: IsolationMergeOptions): Promise
 	try {
 		if (mergeMode === "branch") {
 			if (!result.branchName && result.exitCode === 0 && !result.aborted && result.error) {
+				const patchList = result.patchPath ? `\nPatch artifact:\n- ${result.patchPath}` : "";
 				return {
-					summary: `\n\n<system-notification>Branch merge failed before a task branch could be created: ${result.error}\nTask outputs are preserved but changes were not applied.</system-notification>`,
+					summary: `\n\n<system-notification>Branch merge failed before a task branch could be created: ${result.error}\nTask outputs are preserved but changes were not applied.${patchList}</system-notification>`,
 					changesApplied: false,
 					hadAnyChanges: false,
 					mergedBranchForNestedPatches: false,

package/src/tools/__tests__/glob.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { Settings } from "../../config/settings";
+import type { ToolSession } from "..";
+import { GlobTool } from "../glob";
+import { ToolError } from "../tool-errors";
+
+const ROOT_SEARCH_ERROR = "Searching from root directory '/' is not allowed";
+
+async function expectRootSearchRejected(searchPath: string): Promise<void> {
+	const session: ToolSession = {
+		cwd: process.cwd(),
+		hasUI: false,
+		settings: Settings.isolated({}),
+		getSessionFile: () => null,
+		getSessionSpawns: () => null,
+	};
+	const tool = new GlobTool(session);
+	let thrown: unknown;
+	try {
+		await tool.execute("glob-root-regression", { path: searchPath });
+	} catch (error) {
+		thrown = error;
+	}
+
+	if (!(thrown instanceof Error)) {
+		throw new Error(`Expected glob path ${JSON.stringify(searchPath)} to reject`);
+	}
+
+	expect(thrown).toBeInstanceOf(ToolError);
+	expect(thrown.message).toBe(ROOT_SEARCH_ERROR);
+}
+
+describe("GlobTool.execute", () => {
+	test.each(["/", "//"])("rejects bare root search path %s", async searchPath => {
+		await expectRootSearchRejected(searchPath);
+	});
+});

package/src/tools/acp-bridge.ts

@@ -7,6 +7,8 @@
  * URLs) are always written directly to disk — those are OMP-owned and should
  * never be pushed into the editor.
  */
+
+import { FileChangeType, notifyWorkspaceWatchedFiles } from "../lsp/client";
 import type { ToolSession } from ".";
 import { invalidateFsScanAfterWrite } from "./fs-cache-invalidation";
 import { isInternalUrlPath } from "./path-utils";
@@ -53,18 +55,26 @@ export async function routeWriteThroughBridge(
 	requestedPath: string,
 	absolutePath: string,
 	content: string,
+	signal?: AbortSignal,
 ): Promise<boolean> {
 	if (!shouldRouteWriteThroughBridge(session, requestedPath, absolutePath)) return false;
 
 	const bridge = session.getClientBridge?.();
 	if (!bridge?.capabilities.writeTextFile || !bridge.writeTextFile) return false;
 
+	const changeType = (await Bun.file(absolutePath).exists()) ? FileChangeType.Changed : FileChangeType.Created;
+	// The ACP protocol has no cancellation for fs writes; the most we can do is
+	// refuse to start one after the tool was aborted. Racing the promise would
+	// report failure while the editor still applies the write.
+	signal?.throwIfAborted();
 	try {
 		await bridge.writeTextFile({ path: absolutePath, content });
 	} catch (error) {
 		throw new ToolError(error instanceof Error ? error.message : String(error));
 	}
-
+	if (session.enableLsp ?? true) {
+		await notifyWorkspaceWatchedFiles(session.cwd, [{ filePath: absolutePath, type: changeType }], signal);
+	}
 	invalidateFsScanAfterWrite(absolutePath);
 	session.bumpFileMutationVersion?.(absolutePath);
 	return true;

package/src/tools/bash-command-fixup.ts

@@ -1,37 +1,4 @@
-/**
- * Conservative transforms applied to a bash command before execution.
- *
- * Two fixups are applied, each anchored to the end of a top-level segment
- * (segments split on `;`, `&&`, `||`, and background `&`):
- *
- *  1. Trailing `| head [args]` / `| tail [args]` (and the `|&` variant) — these
- *     pipes exist purely to limit output length. The harness already truncates
- *     bash output and exposes the full result via an artifact, so they only
- *     hide content the agent wanted.
- *
- *  2. A redundant trailing `2>&1` left on a segment that has no remaining pipe
- *     or other redirect. The harness already merges stderr into stdout, so the
- *     duplication is purely cosmetic — and often a leftover after fixup (1)
- *     drops a downstream pipe.
- *
- * The heavy lifting (tokenization, quoting, heredoc handling, command
- * substitution, nested compound commands) lives in Rust under
- * `pi_shell::fixup`, driven by the real `brush-parser` AST. This module is a
- * thin sync wrapper plus user-facing notice formatting.
- */
-import { applyBashFixups as nativeApplyBashFixups } from "@oh-my-pi/pi-natives";
+/** Compatibility shim for extensions importing the historical bash fixup helper. */
 
-export interface BashFixupResult {
-	/** Possibly-rewritten command. */
-	command: string;
-	/** Substrings that were stripped, in the order they were removed. */
-	stripped: string[];
-}
-
-/**
- * Apply both fixups to a bash command. On any parse failure, multi-line input,
- * or no-op transform, returns the input verbatim with `stripped: []`.
- */
-export function applyBashFixups(command: string): BashFixupResult {
-	return nativeApplyBashFixups(command);
-}
+export type { BashFixupResult } from "@oh-my-pi/pi-natives";
+export { applyBashFixups } from "@oh-my-pi/pi-natives";

package/src/tools/bash.ts

@@ -23,7 +23,6 @@ import { CachedOutputBlock, markFramedBlockComponent, outputBlockContentWidth }
 import { getSixelLineMask } from "../utils/sixel";
 import type { ToolSession } from ".";
 import { truncateForPrompt } from "./approval";
-import { applyBashFixups } from "./bash-command-fixup";
 import { type BashInteractiveResult, runInteractiveBashPty } from "./bash-interactive";
 import { checkBashInterception } from "./bash-interceptor";
 import { canUseInteractiveBashPty } from "./bash-pty-selection";
@@ -132,10 +131,12 @@ async function saveBashOriginalArtifact(session: ToolSession, originalText: stri
 	}
 }
 
+const BASH_TIMEOUT_DESCRIPTION = `timeout in seconds; clamped to ${TOOL_TIMEOUTS.bash.min}-${TOOL_TIMEOUTS.bash.max}`;
+
 const bashSchemaBase = type({
 	command: type("string").describe("command to execute"),
 	"env?": type({ "[string]": "string" }).describe("extra env vars"),
-	"timeout?": type("number").describe("timeout in seconds"),
+	"timeout?": type("number").describe(BASH_TIMEOUT_DESCRIPTION),
 	"cwd?": type("string").describe("working directory"),
 	"pty?": type("boolean").describe("run in pty mode"),
 });
@@ -143,7 +144,7 @@ const bashSchemaBase = type({
 const bashSchemaWithAsync = type({
 	command: "string",
 	"env?": { "[string]": "string" },
-	"timeout?": "number",
+	"timeout?": type("number").describe(BASH_TIMEOUT_DESCRIPTION),
 	"cwd?": "string",
 	"pty?": "boolean",
 	"async?": type("boolean").describe("run in background"),
@@ -684,16 +685,6 @@ export class BashTool implements AgentTool<typeof bashSchemaBase | typeof bashSc
 		let command = rawCommand;
 		const env = normalizeBashEnv(rawEnv);
 
-		// Apply conservative bash fixups (strip trailing `| head|tail` and redundant
-		// `2>&1`). The helper is single-line only and refuses anything that could
-		// change semantics.
-		if (this.session.settings.get("bash.stripTrailingHeadTail")) {
-			const fixup = applyBashFixups(command);
-			if (fixup.stripped.length > 0) {
-				command = fixup.command;
-			}
-		}
-
 		// Extract leading `cd <path> && ...` into cwd when the model ignores the cwd parameter.
 		// Constrained to a single line so a `&&` that sits on a later line of a multiline
 		// script can't pull the entire script into the "cwd" capture.

package/src/tools/browser/render.ts

@@ -34,8 +34,10 @@ interface BrowserRenderContext {
 }
 
 function describeBrowser(args: BrowserRenderArgs, details: BrowserToolDetails | undefined): string | undefined {
-	if (args.app?.cdp_url) return `connected ${args.app.cdp_url}`;
-	if (args.app?.path) return `spawned ${shortenPath(args.app.path)}`;
+	const cdpUrl = typeof args.app?.cdp_url === "string" ? args.app.cdp_url : "";
+	if (cdpUrl) return `connected ${cdpUrl}`;
+	const appPath = typeof args.app?.path === "string" ? args.app.path : "";
+	if (appPath) return `spawned ${shortenPath(appPath)}`;
 	if (args.app?.cmux !== false && (args.app?.cmux === true || args.app?.surface)) {
 		return args.app.surface ? `cmux ${args.app.surface}` : "cmux";
 	}
@@ -92,7 +94,7 @@ function renderRunCell(
 	const status = cellStatus(options.isPartial, isError);
 
 	const titleParts: string[] = [tabLabel(args, details)];
-	const url = details?.url ?? args.url;
+	const url = typeof details?.url === "string" ? details.url : typeof args.url === "string" ? args.url : "";
 	if (url) titleParts.push(shortenPath(url));
 	const browserDesc = describeBrowser(args, details);
 	if (browserDesc) titleParts.push(browserDesc);
@@ -165,7 +167,7 @@ function renderOpenOrCloseLine(
 	const meta: string[] = [];
 	const browserDesc = describeBrowser(args, details);
 	if (browserDesc) meta.push(browserDesc);
-	const url = details?.url ?? args.url;
+	const url = typeof details?.url === "string" ? details.url : typeof args.url === "string" ? args.url : "";
 	if (url) meta.push(shortenPath(url));
 
 	const header =

package/src/tools/glob.ts

@@ -90,6 +90,8 @@ export interface GlobOperations {
 export interface GlobToolOptions {
 	/** Custom operations for find. Default: local filesystem + rg */
 	operations?: GlobOperations;
+	/** Remap slash-only paths to the session cwd before root-search validation. */
+	rootPathAlias?: boolean;
 }
 
 interface GlobTarget {
@@ -127,12 +129,14 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 	readonly strict = true;
 
 	readonly #customOps?: GlobOperations;
+	readonly #rootPathAlias: boolean;
 
 	constructor(
 		private readonly session: ToolSession,
 		options?: GlobToolOptions,
 	) {
 		this.#customOps = options?.operations;
+		this.#rootPathAlias = options?.rootPathAlias === true;
 		this.description = prompt.render(globDescription);
 	}
 
@@ -153,9 +157,15 @@ export class GlobTool implements AgentTool<typeof findSchema, GlobToolDetails> {
 				? effectivePaths
 				: await expandDelimitedPathEntries(effectivePaths, this.session.cwd, { splitter: parseFindPattern });
 			const rawPatterns = rawPatternInputs.map(input => normalizePathLikeInput(input).replace(/\\/g, "/"));
+			const aliasResolvedPatterns = this.#rootPathAlias
+				? rawPatterns.map(pattern => (/^\/+$/.test(pattern) ? "." : pattern))
+				: rawPatterns;
+			if (aliasResolvedPatterns.some(pattern => /^\/+$/.test(pattern))) {
+				throw new ToolError("Searching from root directory '/' is not allowed");
+			}
 			const internalRouter = InternalUrlRouter.instance();
 			const normalizedPatterns: string[] = [];
-			for (const rawPattern of rawPatterns) {
+			for (const rawPattern of aliasResolvedPatterns) {
 				if (!internalRouter.canHandle(rawPattern)) {
 					normalizedPatterns.push(rawPattern);
 					continue;

package/src/tools/index.ts

@@ -451,7 +451,7 @@ export const BUILTIN_TOOLS: Record<BuiltinToolName, ToolFactory> = {
 	eval: s => new EvalTool(s),
 	ssh: loadSshTool,
 	github: GithubTool.createIf,
-	glob: s => new GlobTool(s),
+	glob: s => new GlobTool(s, { rootPathAlias: true }),
 	grep: s => new GrepTool(s),
 	lsp: LspTool.createIf,
 	inspect_image: s => new InspectImageTool(s),

package/src/tools/inspect-image-renderer.ts

@@ -33,10 +33,10 @@ function questionLine(question: string, uiTheme: Theme): string {
 
 export const inspectImageToolRenderer = {
 	renderCall(args: InspectImageRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		const rawPath = args.path ?? "";
+		const rawPath = typeof args.path === "string" ? args.path : "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "…";
 		const header = renderStatusLine({ icon: "pending", title: "Inspect", description: pathDisplay }, uiTheme);
-		const question = args.question?.trim();
+		const question = typeof args.question === "string" ? args.question.trim() : "";
 		// Call is at most a status line plus a one-line question — too small to box.
 		// The container renders a lone Text cleanly with no chrome.
 		if (!question) return new Text(header, 0, 0);
@@ -51,7 +51,8 @@ export const inspectImageToolRenderer = {
 		args?: InspectImageRenderArgs,
 	): Component {
 		const details = result.details;
-		const rawPath = details?.imagePath ?? args?.path ?? "";
+		const rawPath =
+			typeof details?.imagePath === "string" ? details.imagePath : typeof args?.path === "string" ? args.path : "";
 		const pathDisplay = rawPath ? shortenPath(rawPath) : "image";
 		const success = !result.isError;
 		const header = renderStatusLine(
@@ -69,7 +70,7 @@ export const inspectImageToolRenderer = {
 			uiTheme,
 		);
 
-		const question = args?.question?.trim();
+		const question = typeof args?.question === "string" ? args.question.trim() : "";
 		const outputText = result.content.find(content => content.type === "text")?.text?.trimEnd() ?? "";
 
 		if (result.isError) {

package/src/tools/read.ts

@@ -3254,8 +3254,8 @@ export class ReadTool implements AgentTool<typeof readSchema, ReadToolDetails> {
 // =============================================================================
 
 interface ReadRenderArgs {
-	path?: string;
-	file_path?: string;
+	path?: unknown;
+	file_path?: unknown;
 	sel?: string;
 	// Legacy fields from old schema — tolerated for in-flight tool calls during transition
 	offset?: number;
@@ -3320,11 +3320,12 @@ function formatReadPathLink(
 
 export const readToolRenderer = {
 	renderCall(args: ReadRenderArgs, _options: RenderResultOptions, uiTheme: Theme): Component {
-		if (isReadableUrlPath(args.file_path || args.path || "")) {
-			return renderReadUrlCall(args, _options, uiTheme);
+		const rawPath =
+			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
+		if (isReadableUrlPath(rawPath)) {
+			return renderReadUrlCall({ path: rawPath, raw: args.raw }, _options, uiTheme);
 		}
 
-		const rawPath = args.file_path || args.path || "";
 		const offset = args.offset;
 		const limit = args.limit;
 
@@ -3346,7 +3347,9 @@ export const readToolRenderer = {
 		args?: ReadRenderArgs,
 	): Component {
 		const urlDetails = result.details as ReadUrlToolDetails | undefined;
-		if (urlDetails?.kind === "url" || isReadableUrlPath(args?.file_path || args?.path || "")) {
+		const rawPathForKind =
+			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
+		if (urlDetails?.kind === "url" || isReadableUrlPath(rawPathForKind)) {
 			return renderReadUrlResult(
 				result as {
 					content: Array<{ type: string; text?: string }>;
@@ -3361,7 +3364,8 @@ export const readToolRenderer = {
 		if (result.isError) {
 			const rawErrorText = result.content?.find(c => c.type === "text")?.text ?? "";
 			const errorText = (rawErrorText || "Unknown error").replace(/^Error:\s*/, "");
-			const rawPath = args?.file_path || args?.path || "";
+			const rawPath =
+				typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
 			const filePath =
 				formatReadPathLink(rawPath, { offset: args?.offset, sourcePath: readSourceFsPath(result.details) }) ||
 				shortenPath(rawPath);
@@ -3388,7 +3392,8 @@ export const readToolRenderer = {
 		// echo next to the styled warning line below.
 		const contentText = details?.displayContent?.text ?? stripOutputNotice(rawText, details?.meta);
 		const imageContent = result.content?.find(c => c.type === "image");
-		const rawPath = args?.file_path || args?.path || "";
+		const rawPath =
+			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
 		const renderPath = splitReadRenderPath(rawPath);
 		const lang = getLanguageFromPath(renderPath.path);
 

package/src/tools/render-utils.ts

@@ -669,7 +669,10 @@ export function truncateDiffByHunk(
 // Path Utilities
 // =============================================================================
 
-export function shortenPath(filePath: string, homeDir?: string): string {
+export function shortenPath(filePath: unknown, homeDir?: string): string {
+	if (typeof filePath !== "string") {
+		return "";
+	}
 	const home = homeDir ?? os.homedir();
 	if (home && filePath.startsWith(home)) {
 		const suffix = filePath.slice(home.length);

package/src/tools/write.ts

@@ -914,7 +914,7 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 
 			// Try ACP bridge first for editor-visible filesystem paths. Internal
 			// artifacts such as local:// plans are owned by OMP, not the editor.
-			if (await routeWriteThroughBridge(this.session, path, absolutePath, cleanContent)) {
+			if (await routeWriteThroughBridge(this.session, path, absolutePath, cleanContent, signal)) {
 				const madeExecutable = await maybeMarkExecutableForShebang(absolutePath, cleanContent);
 				const header = maybeWriteSnapshotHeader(this.session, absolutePath, cleanContent);
 				const writeLine = `Successfully wrote ${cleanContent.length} bytes to ${displayPath}`;
@@ -972,8 +972,8 @@ export class WriteTool implements AgentTool<typeof writeSchema, WriteToolDetails
 // =============================================================================
 
 interface WriteRenderArgs {
-	path?: string;
-	file_path?: string;
+	path?: unknown;
+	file_path?: unknown;
 	content?: unknown;
 }
 
@@ -1088,9 +1088,10 @@ function renderContentPreview(
 
 export const writeToolRenderer = {
 	renderCall(args: WriteRenderArgs, options: RenderResultOptions, uiTheme: Theme): Component {
-		const rawPath = args.file_path || args.path || "";
+		const rawPath =
+			typeof args.file_path === "string" ? args.file_path : typeof args.path === "string" ? args.path : "";
 		const filePath = shortenPath(rawPath);
-		const lang = getLanguageFromPath(rawPath) ?? "text";
+		const lang = rawPath ? (getLanguageFromPath(rawPath) ?? "text") : "text";
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 		const pathDisplay = filePath ? uiTheme.fg("accent", filePath) : uiTheme.fg("toolOutput", "…");
 		// No status icon on the head row: it's the head of the framed block, and
@@ -1135,10 +1136,11 @@ export const writeToolRenderer = {
 		uiTheme: Theme,
 		args?: WriteRenderArgs,
 	): Component {
-		const rawPath = args?.file_path || args?.path || "";
+		const rawPath =
+			typeof args?.file_path === "string" ? args.file_path : typeof args?.path === "string" ? args.path : "";
 		const filePath = shortenPath(rawPath);
 		const fileContent = normalizeDisplayText(args?.content);
-		const lang = getLanguageFromPath(rawPath);
+		const lang = rawPath ? getLanguageFromPath(rawPath) : undefined;
 		const langIcon = uiTheme.fg("muted", uiTheme.getLangIcon(lang));
 		// The header shows the cwd-relative path but links to the absolute path the
 		// write resolved to (args.path may be relative, which would yield a broken

package/src/tts/speech-enhancer.ts

@@ -23,10 +23,12 @@ import type { Settings } from "../config/settings";
 import speechRewritePrompt from "../prompts/system/speech-rewrite.md" with { type: "text" };
 
 const SYSTEM_PROMPT = prompt.render(speechRewritePrompt);
-/** Rewrite budget: a paragraph in, a spoken paragraph (usually shorter) out. */
-const ANSWER_MAX_TOKENS = 512;
-/** Reasoning backends may burn tokens before the answer despite `disableReasoning`. */
-const REASONING_SAFE_MAX_TOKENS = 1536;
+// Rewrite budget: a paragraph in, a spoken paragraph (usually shorter) out.
+// Always reserve enough room to survive backends that ignore `disableReasoning`
+// (e.g. Qwen3 via llama.cpp catalogued `reasoning: false` but still emitting
+// thinking). `maxTokens` is a hard cap — non-thinking completions still return
+// in a normal spoken-paragraph budget (issue #4355).
+const ANSWER_MAX_TOKENS = 1536;
 /** Per-block completion deadline before falling back to mechanical cleanup. */
 const REWRITE_TIMEOUT_MS = 6000;
 /** Bound block characters sent to the model (huge diffs/code dumps get elided). */
@@ -89,7 +91,7 @@ export class SpeechEnhancer {
 				},
 				{
 					apiKey: registry.resolver(model, sessionId),
-					maxTokens: model.reasoning ? REASONING_SAFE_MAX_TOKENS : ANSWER_MAX_TOKENS,
+					maxTokens: ANSWER_MAX_TOKENS,
 					disableReasoning: true,
 					metadata,
 					signal: signal ? AbortSignal.any([signal, timeout]) : timeout,

package/src/tts/vocalizer.ts

@@ -195,6 +195,15 @@ export class Vocalizer {
 		this.#livePlayers.clear();
 	}
 
+	/**
+	 * True while any utterance is still audible or synthesizing — a live
+	 * player, an unfinished stream handle, or an in-flight rewrite is enough.
+	 * Callers (Esc handler) treat this as the "silence me" signal.
+	 */
+	isSpeaking(): boolean {
+		return this.#livePlayers.size > 0 || this.#liveAborts.size > 0 || this.#handle !== null;
+	}
+
 	/** Lower the volume while the user is speaking (push-to-talk), so speech doesn't drown them out. */
 	duck(): void {
 		this.#ducked = true;

package/src/utils/commit-message-generator.ts

@@ -16,8 +16,12 @@ import { concreteThinkingLevel, toReasoningEffort } from "../thinking";
 
 const COMMIT_SYSTEM_PROMPT = prompt.render(commitSystemPrompt);
 const MAX_DIFF_CHARS = 4000;
-const COMMIT_MAX_TOKENS = 60;
-const REASONING_SAFE_MAX_TOKENS = 1024;
+// Cover the "backend ignores `disableReasoning`" case unconditionally: the
+// static `model.reasoning` catalog flag can't distinguish a thinking model
+// declared `reasoning: false` (e.g. Qwen3 served locally via llama.cpp) from
+// one that never emits thinking. `maxTokens` is a hard cap — non-thinking
+// completions still return in a handful of tokens (issue #4355).
+const COMMIT_MAX_TOKENS = 1024;
 
 /** File patterns that should be excluded from commit message generation diffs. */
 const NOISE_SUFFIXES = [".lock", ".lockb", "-lock.json", "-lock.yaml"];
@@ -101,9 +105,7 @@ export async function generateCommitMessage(
 		if (!apiKey) continue;
 
 		try {
-			const maxTokens = candidate.model.reasoning
-				? Math.max(COMMIT_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS)
-				: COMMIT_MAX_TOKENS;
+			const maxTokens = COMMIT_MAX_TOKENS;
 			const response = await completeSimple(
 				candidate.model,
 				{

package/src/utils/shell-snapshot.ts

@@ -260,6 +260,7 @@ export async function getOrCreateSnapshot(
 	// Generate and execute snapshot script
 	const script = generateSnapshotScript(shell, snapshotPath, rcFile);
 
+	let succeeded = false;
 	try {
 		const snapshotEnv = sanitizeSnapshotEnv(env);
 		const spawnEnv: Record<string, string> = {};
@@ -289,10 +290,19 @@ export async function getOrCreateSnapshot(
 			}
 			scrubSnapshotInPlace(snapshotPath);
 			cachedSnapshotPaths.set(cacheKey, snapshotPath);
+			succeeded = true;
 			return snapshotPath;
 		}
 	} catch {
 		// Snapshot creation failed, proceed without it
+	} finally {
+		if (!succeeded) {
+			try {
+				fs.rmSync(snapshotPath, { force: true });
+			} catch {
+				// best-effort cleanup; force: true ignores ENOENT
+			}
+		}
 	}
 
 	return null;