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

package/dist/types/web/search/render.d.ts

@@ -4,9 +4,9 @@
  * Tree-based rendering with collapsed/expanded states for web search results.
  */
 import type { Component } from "@oh-my-pi/pi-tui";
-import type { RenderResultOptions } from "../../extensibility/custom-tools/types";
-import { type Theme } from "../../modes/theme/theme";
-import type { SearchResponse } from "./types";
+import type { RenderResultOptions } from "../../extensibility/custom-tools/types.js";
+import { type Theme } from "../../modes/theme/theme.js";
+import type { SearchResponse } from "./types.js";
 export interface SearchRenderDetails {
     response: SearchResponse;
     error?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.3.5",
+	"version": "16.3.7",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -56,17 +56,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.3.5",
-		"@oh-my-pi/omp-stats": "16.3.5",
-		"@oh-my-pi/pi-agent-core": "16.3.5",
-		"@oh-my-pi/pi-ai": "16.3.5",
-		"@oh-my-pi/pi-catalog": "16.3.5",
-		"@oh-my-pi/pi-mnemopi": "16.3.5",
-		"@oh-my-pi/pi-natives": "16.3.5",
-		"@oh-my-pi/pi-tui": "16.3.5",
-		"@oh-my-pi/pi-utils": "16.3.5",
-		"@oh-my-pi/pi-wire": "16.3.5",
-		"@oh-my-pi/snapcompact": "16.3.5",
+		"@oh-my-pi/hashline": "16.3.7",
+		"@oh-my-pi/omp-stats": "16.3.7",
+		"@oh-my-pi/pi-agent-core": "16.3.7",
+		"@oh-my-pi/pi-ai": "16.3.7",
+		"@oh-my-pi/pi-catalog": "16.3.7",
+		"@oh-my-pi/pi-mnemopi": "16.3.7",
+		"@oh-my-pi/pi-natives": "16.3.7",
+		"@oh-my-pi/pi-tui": "16.3.7",
+		"@oh-my-pi/pi-utils": "16.3.7",
+		"@oh-my-pi/pi-wire": "16.3.7",
+		"@oh-my-pi/snapcompact": "16.3.7",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/advisor/__tests__/advisor.test.ts

@@ -164,6 +164,65 @@ describe("advisor", () => {
 			expect(md).toContain("[irc]");
 			expect(md).not.toContain("<primary-context");
 		});
+
+		it("omits hidden non-primary custom messages while keeping visible custom messages", () => {
+			const hiddenPrelude = {
+				role: "custom",
+				customType: "eager-todo-prelude",
+				content: "<system-reminder>Task delegation is enabled",
+				display: false,
+				timestamp: 1,
+			} as AgentMessage;
+			const hiddenHookMessage = {
+				role: "hookMessage",
+				customType: "hidden-hook-reminder",
+				content: "Hidden hook reminder should never reach advisor history",
+				display: false,
+				timestamp: 2,
+			} as AgentMessage;
+			const visibleCustom = {
+				role: "custom",
+				customType: "visible-status",
+				content: "Visible custom update",
+				display: true,
+				timestamp: 3,
+			} as AgentMessage;
+
+			const md = formatSessionHistoryMarkdown([hiddenPrelude, hiddenHookMessage, visibleCustom], {
+				expandPrimaryContext: true,
+			});
+
+			expect(md).toContain("[visible-status] Visible custom update");
+			expect(md).not.toContain("eager-todo-prelude");
+			expect(md).not.toContain("system-reminder");
+			expect(md).not.toContain("Task delegation");
+			expect(md).not.toContain("hidden-hook-reminder");
+			expect(md).not.toContain("Hidden hook reminder");
+		});
+
+		it("keeps hidden image descriptions because they are the text transcript for attached images", () => {
+			const imageDescription = {
+				role: "custom",
+				customType: "image-attachment-description",
+				content: [{ type: "text", text: '<image path="local://session/cat.png">cat on a keyboard</image>' }],
+				display: false,
+				timestamp: 1,
+			} as AgentMessage;
+			const hiddenPrelude = {
+				role: "custom",
+				customType: "eager-todo-prelude",
+				content: "<system-reminder>Task delegation is enabled",
+				display: false,
+				timestamp: 2,
+			} as AgentMessage;
+
+			const md = formatSessionHistoryMarkdown([imageDescription, hiddenPrelude], { expandPrimaryContext: true });
+
+			expect(md).toContain("[image-attachment-description]");
+			expect(md).toContain("cat on a keyboard");
+			expect(md).not.toContain("eager-todo-prelude");
+			expect(md).not.toContain("Task delegation");
+		});
 	});
 
 	describe("formatSessionHistoryMarkdown expandEditDiffs", () => {

package/src/auto-thinking/classifier.ts

@@ -35,13 +35,14 @@ const DIFFICULTY_SYSTEM_PROMPT = prompt.render(difficultySystemPrompt);
 const MAX_INPUT_CHARS = 6000;
 const HEAD_CHARS = 4000;
 const TAIL_CHARS = 2000;
-/** The online answer is a single word; keep budgets tiny for non-reasoning backends. */
-const ANSWER_MAX_TOKENS = 8;
 /** Local classifiers occasionally need more room for chat-template boilerplate. */
 const LOCAL_ANSWER_MAX_TOKENS = 16;
 /**
- * Reasoning backends ignore `disableReasoning` on some providers, so reserve
- * enough output room for the keyword to still land after unavoidable thinking.
+ * Online classifier budget. Sized to survive backends that ignore
+ * `disableReasoning` (e.g. Qwen3 via llama.cpp catalogued `reasoning: false`
+ * but still emitting thinking): the classifier keyword needs to land after any
+ * unavoidable thinking preamble. `maxTokens` is a hard cap — non-thinking
+ * completions still return in a handful of tokens (issue #4355).
  */
 const REASONING_SAFE_MAX_TOKENS = 1024;
 
@@ -85,7 +86,7 @@ async function classifyOnline(input: string, deps: ClassifyDifficultyDeps): Prom
 	}
 	// Resolve metadata after getApiKey so the session-sticky credential is recorded first.
 	const metadata = deps.metadataResolver?.(model.provider);
-	const maxTokens = model.reasoning ? Math.max(ANSWER_MAX_TOKENS, REASONING_SAFE_MAX_TOKENS) : ANSWER_MAX_TOKENS;
+	const maxTokens = REASONING_SAFE_MAX_TOKENS;
 
 	const response = await completeSimple(
 		model,

package/src/collab/relay-client.ts

@@ -21,6 +21,9 @@ const BACKOFF_BASE_MS = 1_000;
 const BACKOFF_MAX_MS = 30_000;
 /** Max enveloped frames buffered while a reconnect is pending; overflow is dropped. */
 const MAX_PENDING_SENDS = 256;
+const WS_BACKPRESSURE_THRESHOLD = 64 * 1024;
+const WS_BACKPRESSURE_DRAIN_THRESHOLD = 32 * 1024;
+const WS_BACKPRESSURE_DRAIN_RETRY_MS = 25;
 
 export interface CollabSocketOptions {
 	/** wss://host[:port]/r/<roomId> — no query string. */
@@ -40,6 +43,7 @@ export class CollabSocket {
 	readonly #opts: CollabSocketOptions;
 	#ws: WebSocket | null = null;
 	#retryTimer: NodeJS.Timeout | undefined;
+	#backpressureDrainTimer: NodeJS.Timeout | undefined;
 	#attempt = 0;
 	/** Terminal state: intentional close or fatal failure. Cleared by connect(). */
 	#closed = false;
@@ -72,28 +76,84 @@ export class CollabSocket {
 					logger.debug("collab: dropping frame, socket closed", { t: frame.t });
 					return;
 				}
+				const openWs = this.#ws;
+				if (openWs && openWs.readyState === WebSocket.OPEN) this.#drainPendingSends(openWs);
 				const sealed = await seal(this.#opts.key, frame);
 				const envelope = packEnvelope(targetPeer, sealed);
 				const ws = this.#ws;
 				if (ws && ws.readyState === WebSocket.OPEN) {
+					if (this.#pendingSends.length > 0) {
+						this.#enqueuePendingSend(envelope, frame.t);
+						if (ws.bufferedAmount < WS_BACKPRESSURE_DRAIN_THRESHOLD) {
+							this.#drainPendingSends(ws);
+						} else {
+							this.#scheduleBackpressureDrain(ws);
+						}
+						return;
+					}
+					if (ws.bufferedAmount >= WS_BACKPRESSURE_THRESHOLD) {
+						this.#enqueuePendingSend(envelope, frame.t);
+						this.#scheduleBackpressureDrain(ws);
+						return;
+					}
 					ws.send(envelope);
 					return;
 				}
-				if (this.#pendingSends.length >= MAX_PENDING_SENDS) {
-					logger.debug("collab: dropping frame, reconnect buffer full", { t: frame.t });
-					return;
-				}
-				this.#pendingSends.push(envelope);
+				this.#enqueuePendingSend(envelope, frame.t);
 			})
 			.catch((err: unknown) => {
 				logger.debug("collab: send failed", { error: String(err) });
 			});
 	}
 
+	#enqueuePendingSend(envelope: Uint8Array, frameType: CollabFrame["t"]): void {
+		if (this.#pendingSends.length >= MAX_PENDING_SENDS) {
+			logger.debug("collab: dropping frame, reconnect buffer full", { t: frameType });
+			return;
+		}
+		this.#pendingSends.push(envelope);
+	}
+
+	#drainPendingSends(ws: WebSocket): void {
+		while (
+			this.#pendingSends.length > 0 &&
+			ws.readyState === WebSocket.OPEN &&
+			ws.bufferedAmount < WS_BACKPRESSURE_DRAIN_THRESHOLD
+		) {
+			const envelope = this.#pendingSends.shift();
+			if (!envelope) return;
+			ws.send(envelope);
+		}
+	}
+
+	#scheduleBackpressureDrain(ws: WebSocket): void {
+		if (this.#backpressureDrainTimer !== undefined) return;
+		this.#backpressureDrainTimer = setTimeout(() => {
+			this.#backpressureDrainTimer = undefined;
+			this.#sendChain = this.#sendChain
+				.then(async () => {
+					if (this.#closed || this.#ws !== ws || ws.readyState !== WebSocket.OPEN) return;
+					this.#drainPendingSends(ws);
+					if (this.#pendingSends.length > 0) this.#scheduleBackpressureDrain(ws);
+				})
+				.catch((err: unknown) => {
+					logger.debug("collab: backpressure drain failed", { error: String(err) });
+				});
+		}, WS_BACKPRESSURE_DRAIN_RETRY_MS);
+	}
+
+	#clearBackpressureDrain(): void {
+		if (this.#backpressureDrainTimer !== undefined) {
+			clearTimeout(this.#backpressureDrainTimer);
+			this.#backpressureDrainTimer = undefined;
+		}
+	}
+
 	/** Intentional close: clears any retry timer, suppresses reconnect. A later connect() starts fresh. */
 	close(): void {
 		const hadActivity = this.#ws !== null || this.#retryTimer !== undefined;
 		this.#clearRetry();
+		this.#clearBackpressureDrain();
 		const wasClosed = this.#closed;
 		this.#closed = true;
 		this.#pendingSends.length = 0;
@@ -110,14 +170,17 @@ export class CollabSocket {
 	}
 
 	#openSocket(): void {
+		this.#clearBackpressureDrain();
 		const ws = new WebSocket(`${this.#opts.wsUrl}?role=${this.#opts.role}`);
 		ws.binaryType = "arraybuffer";
 		this.#ws = ws;
 		ws.onopen = () => {
 			if (this.#ws !== ws) return;
 			this.#attempt = 0;
-			for (const envelope of this.#pendingSends) ws.send(envelope);
-			this.#pendingSends.length = 0;
+			if (this.#pendingSends.length > 0) {
+				this.#drainPendingSends(ws);
+				if (this.#pendingSends.length > 0) this.#scheduleBackpressureDrain(ws);
+			}
 			this.onOpen?.();
 		};
 		ws.onmessage = (event: MessageEvent) => {
@@ -129,6 +192,7 @@ export class CollabSocket {
 		};
 		ws.onclose = (event: CloseEvent) => {
 			if (this.#ws !== ws) return;
+			this.#clearBackpressureDrain();
 			this.#ws = null;
 			this.#handleClose(event.code, event.reason);
 		};
@@ -167,6 +231,7 @@ export class CollabSocket {
 
 	#handleClose(code: number, reason: string): void {
 		if (this.#closed) return;
+		this.#clearBackpressureDrain();
 		const fatalReason = FATAL_CLOSE_REASONS[code];
 		if (fatalReason !== undefined) {
 			this.#closed = true;
@@ -186,6 +251,7 @@ export class CollabSocket {
 		this.#pendingSends.length = 0;
 		const ws = this.#ws;
 		this.#ws = null;
+		this.#clearBackpressureDrain();
 		if (ws) {
 			try {
 				ws.close(1000);

package/src/config/model-registry.ts

@@ -48,6 +48,13 @@ const STARTUP_MODEL_CACHE_PROVIDER_IDS: readonly string[] = [
 // packages/ai/src/registry/lm-studio.ts, and packages/ai/src/registry/vllm.ts.
 const LOCAL_PROVIDER_PLACEHOLDERS = new Set<string>(["llama-cpp-local", "lm-studio-local", "vllm-local"]);
 
+/**
+ * Hard bound for extension-provided fetchDynamicModels to prevent indefinite hangs
+ * during runtime provider discovery. Uses a cancellable manual timer (not AbortSignal.timeout)
+ * so a successful fast path does not leave an armed timeout signal for concurrent GC.
+ */
+const RUNTIME_DYNAMIC_MODEL_FETCH_TIMEOUT_MS = 15_000;
+
 import type { ApiKeyResolver, FetchImpl } from "@oh-my-pi/pi-ai";
 import { registerOAuthProvider, unregisterOAuthProviders } from "@oh-my-pi/pi-ai/oauth";
 import type { OAuthCredentials, OAuthLoginCallbacks } from "@oh-my-pi/pi-ai/oauth/types";
@@ -81,6 +88,24 @@ function isDiscoveryBearerApiKey(apiKey: string | undefined | null): apiKey is s
 	return isAuthenticated(apiKey) && !LOCAL_PROVIDER_PLACEHOLDERS.has(apiKey);
 }
 
+/**
+ * Wraps an extension-provided fetchDynamicModels call with a hard timeout.
+ * Uses a cancellable manual timer (not AbortSignal.timeout) so that a fast
+ * successful path does not leave an armed timeout signal for concurrent GC.
+ * The inner fetcher does not receive a signal (extension contract has none).
+ */
+async function withRuntimeDynamicModelsTimeout<T>(timeoutMs: number, run: () => Promise<T>): Promise<T> {
+	const { promise: timeoutPromise, reject: timeoutReject } = Promise.withResolvers<never>();
+	const timer = setTimeout(() => {
+		timeoutReject(new Error(`fetchDynamicModels timed out after ${timeoutMs}ms`));
+	}, timeoutMs);
+	try {
+		return await Promise.race([run(), timeoutPromise]);
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
 /** Provider override config (baseUrl, headers, apiKey, compat, transport) without custom models */
 interface ProviderOverride {
 	baseUrl?: string;
@@ -240,6 +265,13 @@ interface CustomModelsResult {
 }
 
 const commandValueCache = new Map<string, string>();
+// Failed `!command` resolutions (non-zero exit, empty stdout) are negative-cached
+// with a TTL instead of forever: a transient failure (locked password manager,
+// network hiccup) must not disable the key until process restart, but re-running
+// the command on every resolution would restore the execSync storm this cache
+// exists to prevent. One probe per TTL window bounds both.
+const COMMAND_FAILURE_RETRY_MS = 30_000;
+const commandFailureRetryAt = new Map<string, number>();
 
 function isCommandConfigValue(valueConfig: string | undefined): valueConfig is string {
 	return valueConfig?.startsWith("!") === true;
@@ -248,13 +280,20 @@ function isCommandConfigValue(valueConfig: string | undefined): valueConfig is s
 function resolveCommandConfig(command: string): string | undefined {
 	const cached = commandValueCache.get(command);
 	if (cached !== undefined) return cached;
+	const retryAt = commandFailureRetryAt.get(command);
+	if (retryAt !== undefined && Date.now() < retryAt) return undefined;
 	try {
 		const stdout = execSync(command, { encoding: "utf8", timeout: 10_000, windowsHide: true });
 		const trimmed = stdout.trim();
-		if (trimmed.length === 0) return undefined;
+		if (trimmed.length === 0) {
+			commandFailureRetryAt.set(command, Date.now() + COMMAND_FAILURE_RETRY_MS);
+			return undefined;
+		}
+		commandFailureRetryAt.delete(command);
 		commandValueCache.set(command, trimmed);
 		return trimmed;
 	} catch {
+		commandFailureRetryAt.set(command, Date.now() + COMMAND_FAILURE_RETRY_MS);
 		return undefined;
 	}
 }
@@ -2134,7 +2173,9 @@ export class ModelRegistry {
 				fetchDynamicModels: async () => {
 					const apiKey = await this.#peekApiKeyForProvider(providerName);
 					const resolvedKey = isAuthenticated(apiKey) ? apiKey : undefined;
-					const modelDefs = await fetcher(resolvedKey);
+					const modelDefs = await withRuntimeDynamicModelsTimeout(RUNTIME_DYNAMIC_MODEL_FETCH_TIMEOUT_MS, () =>
+						fetcher(resolvedKey),
+					);
 					const results: Model<Api>[] = [];
 					for (const modelDef of modelDefs) {
 						const overlay = buildCustomModelOverlay(

package/src/config/model-resolver.ts

@@ -864,7 +864,7 @@ function getModelRoleAlias(value: string): ModelRole | undefined {
 
 function normalizeModelPatternList(value: string | string[] | undefined): string[] {
 	if (!value) return [];
-	const patterns = Array.isArray(value) ? value : value.split(",");
+	const patterns = Array.isArray(value) ? value.flatMap(pattern => pattern.split(",")) : value.split(",");
 	return patterns.map(pattern => pattern.trim()).filter(Boolean);
 }
 

package/src/config/settings-schema.ts

@@ -2268,6 +2268,11 @@ export const SETTINGS_SCHEMA = {
 					description:
 						"8x13 glyphs on an 11x16 cell — extra letter spacing so characters don't merge. Default for Anthropic.",
 				},
+				{
+					value: "silver16-bw",
+					label: "Silver 16, CJK",
+					description: "Embedded Silver TrueType font on a 16px grid for CJK and other non-Latin text.",
+				},
 				{
 					value: "doc-8on16-bw",
 					label: "Doc 8on16, black",
@@ -3166,18 +3171,6 @@ export const SETTINGS_SCHEMA = {
 	},
 	"bashInterceptor.patterns": { type: "array", default: DEFAULT_BASH_INTERCEPTOR_RULES },
 
-	"bash.stripTrailingHeadTail": {
-		type: "boolean",
-		default: true,
-		ui: {
-			tab: "shell",
-			group: "Bash",
-			label: "Strip head/tail Pipes",
-			description:
-				"Silently drop trailing `| head`/`| tail` pipes from single-line bash commands. Output is already truncated automatically.",
-		},
-	},
-
 	// Shell output minimizer
 	"shellMinimizer.enabled": {
 		type: "boolean",

package/src/config/settings.ts

@@ -172,6 +172,14 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
+function modelRoleValueFromUnknown(value: unknown): string | undefined {
+	if (typeof value === "string") return value;
+	if (!Array.isArray(value)) return undefined;
+
+	const entries = stringArrayFromUnknown(value);
+	return entries.length === value.length ? entries.join(",") : undefined;
+}
+
 type EditVariantEntry = {
 	patternLower: string;
 	mode: EditMode;
@@ -580,8 +588,8 @@ export class Settings {
 		const roles: Record<string, string> = {};
 		for (const role in value) {
 			if (!Object.hasOwn(value, role)) continue;
-			const modelId = value[role];
-			if (typeof modelId === "string") {
+			const modelId = modelRoleValueFromUnknown(value[role]);
+			if (modelId !== undefined) {
 				roles[role] = modelId;
 			}
 		}
@@ -614,15 +622,27 @@ export class Settings {
 	 * Get a model role (helper for modelRoles record).
 	 */
 	getModelRole(role: ModelRole | string): string | undefined {
-		const roles = this.get("modelRoles");
-		return roles[role];
+		const roles: unknown = this.get("modelRoles");
+		if (!isRecord(roles)) return undefined;
+		return modelRoleValueFromUnknown(roles[role]);
 	}
 
 	/**
 	 * Get all model roles (helper for modelRoles record).
 	 */
 	getModelRoles(): ReadOnlyDict<string> {
-		return { ...this.get("modelRoles") };
+		const roles: unknown = this.get("modelRoles");
+		if (!isRecord(roles)) return {};
+
+		const normalized: Record<string, string> = {};
+		for (const role in roles) {
+			if (!Object.hasOwn(roles, role)) continue;
+			const modelId = modelRoleValueFromUnknown(roles[role]);
+			if (modelId !== undefined) {
+				normalized[role] = modelId;
+			}
+		}
+		return normalized;
 	}
 
 	/*

package/src/edit/file-snapshot-store.ts

@@ -74,17 +74,20 @@ export function canonicalSnapshotKey(absolutePath: string): string {
  * Producers that only displayed a slice of the file (range reads, search hits)
  * use this to mint a whole-file tag: the displayed lines stay partial, but the
  * tag fingerprints the entire file so a follow-up edit anchored at any line
- * validates whenever the live file is byte-identical to what was read.
+ * validates whenever the live file is byte-identical to what was read. Raw
+ * reads pass `seenLines` even though they do not emit a header, letting a prior
+ * or later same-content hashline tag inherit the raw range's provenance.
  */
 export async function recordFileSnapshot(
 	session: FileSnapshotStoreOwner,
 	absolutePath: string,
+	seenLines?: Iterable<number>,
 ): Promise<string | undefined> {
 	try {
 		const file = Bun.file(absolutePath);
 		if (file.size > SNAPSHOT_MAX_BYTES) return undefined;
 		const normalized = normalizeToLF(await file.text());
-		return getFileSnapshotStore(session).record(canonicalSnapshotKey(absolutePath), normalized);
+		return getFileSnapshotStore(session).record(canonicalSnapshotKey(absolutePath), normalized, seenLines);
 	} catch {
 		return undefined;
 	}

package/src/edit/hashline/filesystem.ts

@@ -21,6 +21,7 @@ import * as path from "node:path";
 import { Filesystem, NotFoundError, type PreflightWriteOptions, type WriteResult } from "@oh-my-pi/hashline";
 import { isEnoent } from "@oh-my-pi/pi-utils";
 import type { FileDiagnosticsResult, WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
+import { FileChangeType, notifyWorkspaceWatchedFiles } from "../../lsp/client";
 import type { ToolSession } from "../../tools";
 import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { assertEditableFileContent } from "../../tools/auto-generated-guard";
@@ -157,6 +158,13 @@ export class HashlineFilesystem extends Filesystem {
 			if (isEnoent(error)) throw new NotFoundError(relativePath, error);
 			throw error;
 		}
+		if (this.session.enableLsp ?? true) {
+			await notifyWorkspaceWatchedFiles(
+				this.session.cwd,
+				[{ filePath: absolutePath, type: FileChangeType.Deleted }],
+				this.#signal,
+			);
+		}
 		invalidateFsScanAfterWrite(absolutePath);
 	}
 
@@ -170,6 +178,16 @@ export class HashlineFilesystem extends Filesystem {
 		} else {
 			await fs.rename(fromAbsolute, toAbsolute);
 		}
+		if (this.session.enableLsp ?? true) {
+			await notifyWorkspaceWatchedFiles(
+				this.session.cwd,
+				[
+					{ filePath: fromAbsolute, type: FileChangeType.Deleted },
+					{ filePath: toAbsolute, type: FileChangeType.Created },
+				],
+				this.#signal,
+			);
+		}
 		invalidateFsScanAfterWrite(fromAbsolute);
 		invalidateFsScanAfterWrite(toAbsolute);
 	}
@@ -180,7 +198,7 @@ export class HashlineFilesystem extends Filesystem {
 		const finalContent = await serializeEditFileText(absolutePath, relativePath, content);
 
 		// Route through ACP bridge when available; skips internal artifacts.
-		if (await routeWriteThroughBridge(this.session, relativePath, absolutePath, finalContent)) {
+		if (await routeWriteThroughBridge(this.session, relativePath, absolutePath, finalContent, this.#signal)) {
 			this.#diagnosticsByPath.set(relativePath, undefined);
 			return { text: finalContent };
 		}

package/src/edit/modes/patch.ts

@@ -16,6 +16,7 @@ import {
 	type WritethroughCallback,
 	type WritethroughDeferredHandle,
 } from "../../lsp";
+import { FileChangeType, notifyWorkspaceWatchedFiles } from "../../lsp/client";
 import type { ToolSession } from "../../tools";
 import { routeWriteThroughBridge } from "../../tools/acp-bridge";
 import { assertEditableFile } from "../../tools/auto-generated-guard";
@@ -1732,7 +1733,7 @@ class LspFileSystem implements FileSystem {
 		const finalContent = await serializeEditFileText(path, path, content);
 
 		// Route through ACP bridge when available; skips internal artifacts and local:// paths.
-		if (await routeWriteThroughBridge(this.session, this.requestedPath, path, finalContent)) {
+		if (await routeWriteThroughBridge(this.session, this.requestedPath, path, finalContent, this.signal)) {
 			return;
 		}
 
@@ -1753,6 +1754,13 @@ class LspFileSystem implements FileSystem {
 
 	async delete(path: string): Promise<void> {
 		await this.#getFile(path).unlink();
+		if (this.session.enableLsp ?? true) {
+			await notifyWorkspaceWatchedFiles(
+				this.session.cwd,
+				[{ filePath: path, type: FileChangeType.Deleted }],
+				this.signal,
+			);
+		}
 	}
 
 	async mkdir(path: string): Promise<void> {

package/src/edit/modes/replace.ts

@@ -1103,7 +1103,7 @@ export async function executeReplaceSingle(
 
 	// Route through ACP bridge when available; skips internal artifacts.
 	let diagnostics: FileDiagnosticsResult | undefined;
-	if (await routeWriteThroughBridge(session, path, absolutePath, finalContent)) {
+	if (await routeWriteThroughBridge(session, path, absolutePath, finalContent, signal)) {
 		// bridge handled the write; diagnostics not available via writethrough
 	} else {
 		diagnostics = await writethrough(absolutePath, finalContent, signal, Bun.file(absolutePath), batchRequest, dst =>