@oh-my-pi/pi-coding-agent 17.2.7 → 17.2.9

package/src/discovery/agents.ts

@@ -28,9 +28,77 @@ const DISPLAY_NAME = "Agent Dirs (.agent/.agents)";
 const PRIORITY = 70;
 const AGENT_DIR_CANDIDATES = [".agent", ".agents"] as const;
 
-/** User-level paths: ~/.agent/<segments> and ~/.agents/<segments>. */
-function getUserPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
-	return AGENT_DIR_CANDIDATES.map(baseDir => path.join(ctx.home, baseDir, ...segments));
+interface UserPathCandidateOptions {
+	platform?: NodeJS.Platform;
+	env?: NodeJS.ProcessEnv;
+	windowsUserProfile?: () => string | undefined;
+	wslPath?: (windowsPath: string) => string | undefined;
+}
+
+const WINDOWS_DRIVE_PROFILE_PATTERN = /^([A-Za-z]):[\\/](.*)$/;
+
+function isWsl(platform: NodeJS.Platform, env: NodeJS.ProcessEnv): boolean {
+	return platform === "linux" && Boolean(env.WSL_DISTRO_NAME || env.WSL_INTEROP);
+}
+
+function convertWindowsPathToDefaultWslMount(windowsPath: string): string | undefined {
+	const trimmed = windowsPath.trim();
+	if (trimmed.length === 0) return undefined;
+	if (path.isAbsolute(trimmed)) return path.normalize(trimmed);
+	const match = WINDOWS_DRIVE_PROFILE_PATTERN.exec(trimmed);
+	if (!match) return undefined;
+	const [, drive, rest] = match;
+	const segments = rest.replace(/\\/g, "/").split("/").filter(Boolean);
+	return path.join("/mnt", drive.toLowerCase(), ...segments);
+}
+
+function resolveWithWslPath(windowsPath: string): string | undefined {
+	try {
+		const result = Bun.spawnSync(["wslpath", "-u", windowsPath], { stdout: "pipe", stderr: "ignore" });
+		if (result.exitCode !== 0) return undefined;
+		const resolved = result.stdout.toString().trim();
+		return resolved.length > 0 ? resolved : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function resolveWindowsUserProfile(): string | undefined {
+	try {
+		const result = Bun.spawnSync(["cmd.exe", "/d", "/c", "echo", "%USERPROFILE%"], {
+			stdout: "pipe",
+			stderr: "ignore",
+		});
+		if (result.exitCode !== 0) return undefined;
+		const resolved = result.stdout.toString().trim();
+		return resolved.length > 0 && resolved !== "%USERPROFILE%" ? resolved : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+/** Resolve the Windows host profile home exposed to WSL, if available. */
+export function getWslWindowsHomeCandidate(options: UserPathCandidateOptions = {}): string | undefined {
+	const platform = options.platform ?? process.platform;
+	const env = options.env ?? process.env;
+	if (!isWsl(platform, env)) return undefined;
+	const userProfile = env.USERPROFILE ?? (options.windowsUserProfile ?? resolveWindowsUserProfile)();
+	if (!userProfile) return undefined;
+	return (options.wslPath ?? resolveWithWslPath)(userProfile) ?? convertWindowsPathToDefaultWslMount(userProfile);
+}
+
+function getUserHomeCandidates(ctx: LoadContext): string[] {
+	const homes = [ctx.home];
+	const wslHome = getWslWindowsHomeCandidate();
+	if (wslHome && !homes.includes(wslHome)) homes.push(wslHome);
+	return homes;
+}
+
+/** User-level paths: ~/.agent[s]/<segments>, plus the Windows host profile under WSL. */
+export function getUserPathCandidates(ctx: LoadContext, ...segments: string[]): string[] {
+	return getUserHomeCandidates(ctx).flatMap(home =>
+		AGENT_DIR_CANDIDATES.map(baseDir => path.join(home, baseDir, ...segments)),
+	);
 }
 
 /**

package/src/discovery/claude.ts

@@ -90,6 +90,7 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 			const serverConfig = config as Record<string, unknown>;
 			return {
 				name,
+				enabled: typeof serverConfig.enabled === "boolean" ? serverConfig.enabled : undefined,
 				timeout: typeof serverConfig.timeout === "number" ? serverConfig.timeout : undefined,
 				command: serverConfig.command as string | undefined,
 				args: serverConfig.args as string[] | undefined,
@@ -102,17 +103,19 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 		});
 	};
 
-	for (let i = 0; i < userPaths.length; i++) {
-		const servers = parseMcpServers(contents[i], userPaths[i].path, userPaths[i].level);
+	// Load project entries before user entries so a project `enabled: false`
+	// claims its dedupe key before a same-named user server can survive (#7654).
+	const projectOffset = userPaths.length;
+	for (let i = 0; i < projectPaths.length; i++) {
+		const servers = parseMcpServers(contents[projectOffset + i], projectPaths[i].path, projectPaths[i].level);
 		if (servers.length > 0) {
 			items.push(...servers);
 			break;
 		}
 	}
 
-	const projectOffset = userPaths.length;
-	for (let i = 0; i < projectPaths.length; i++) {
-		const servers = parseMcpServers(contents[projectOffset + i], projectPaths[i].path, projectPaths[i].level);
+	for (let i = 0; i < userPaths.length; i++) {
+		const servers = parseMcpServers(contents[i], userPaths[i].path, userPaths[i].level);
 		if (servers.length > 0) {
 			items.push(...servers);
 			break;

package/src/discovery/cursor.ts

@@ -57,6 +57,7 @@ function parseMCPServers(
 		const serverConfig = config as Record<string, unknown>;
 		items.push({
 			name,
+			enabled: typeof serverConfig.enabled === "boolean" ? serverConfig.enabled : undefined,
 			command: serverConfig.command as string | undefined,
 			args: serverConfig.args as string[] | undefined,
 			env: serverConfig.env as Record<string, string> | undefined,
@@ -86,15 +87,17 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 
 	const projectContentPromise = projectPath ? readFile(projectPath) : Promise.resolve(null);
 
-	if (userContent && userPath) {
-		const result = parseMCPServers(userContent, userPath, "user");
+	// Load project entries before user entries so a project `enabled: false`
+	// claims its dedupe key before a same-named user server can survive (#7654).
+	const projectContent = await projectContentPromise;
+	if (projectContent && projectPath) {
+		const result = parseMCPServers(projectContent, projectPath, "project");
 		items.push(...result.items);
 		if (result.warning) warnings.push(result.warning);
 	}
 
-	const projectContent = await projectContentPromise;
-	if (projectContent && projectPath) {
-		const result = parseMCPServers(projectContent, projectPath, "project");
+	if (userContent && userPath) {
+		const result = parseMCPServers(userContent, userPath, "user");
 		items.push(...result.items);
 		if (result.warning) warnings.push(result.warning);
 	}

package/src/discovery/gemini.ts

@@ -48,14 +48,8 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 	const items: MCPServer[] = [];
 	const warnings: string[] = [];
 
-	// User-level: ~/.gemini/settings.json → mcpServers
-	const userPath = getUserPath(ctx, "gemini", "settings.json");
-	if (userPath) {
-		const result = await loadMCPFromSettings(ctx, userPath, "user");
-		items.push(...result.items);
-		if (result.warnings) warnings.push(...result.warnings);
-	}
-
+	// Load project entries before user entries so a project `enabled: false`
+	// claims its dedupe key before a same-named user server can survive (#7654).
 	// Project-level: .gemini/settings.json → mcpServers
 	const projectPath = getProjectPath(ctx, "gemini", "settings.json");
 	if (projectPath) {
@@ -64,6 +58,14 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 		if (result.warnings) warnings.push(...result.warnings);
 	}
 
+	// User-level: ~/.gemini/settings.json → mcpServers
+	const userPath = getUserPath(ctx, "gemini", "settings.json");
+	if (userPath) {
+		const result = await loadMCPFromSettings(ctx, userPath, "user");
+		items.push(...result.items);
+		if (result.warnings) warnings.push(...result.warnings);
+	}
+
 	return { items, warnings };
 }
 
@@ -102,6 +104,7 @@ async function loadMCPFromSettings(
 
 		items.push({
 			name,
+			enabled: typeof raw.enabled === "boolean" ? raw.enabled : undefined,
 			command: typeof raw.command === "string" ? raw.command : undefined,
 			args: Array.isArray(raw.args) ? (raw.args as string[]) : undefined,
 			env: raw.env && typeof raw.env === "object" ? (raw.env as Record<string, string>) : undefined,

package/src/discovery/vscode.ts

@@ -83,6 +83,7 @@ async function loadMCPConfig(
 
 		const server: MCPServer = {
 			name,
+			enabled: typeof expanded.enabled === "boolean" ? expanded.enabled : undefined,
 			command: typeof expanded.command === "string" ? expanded.command : undefined,
 			args: Array.isArray(expanded.args) ? (expanded.args as string[]) : undefined,
 			env: expanded.env && typeof expanded.env === "object" ? (expanded.env as Record<string, string>) : undefined,

package/src/discovery/windsurf.ts

@@ -48,6 +48,7 @@ function parseServerConfig(
 	return {
 		server: {
 			name,
+			enabled: typeof server.enabled === "boolean" ? server.enabled : undefined,
 			command: server.command as string | undefined,
 			args: server.args as string[] | undefined,
 			env: server.env as Record<string, string> | undefined,
@@ -71,10 +72,11 @@ async function loadMCPServers(ctx: LoadContext): Promise<LoadResult<MCPServer>>
 	]);
 
 	const projectContent = projectPath ? await readFile(projectPath) : null;
-
+	// Load project entries before user entries so a project `enabled: false`
+	// claims its dedupe key before a same-named user server can survive (#7654).
 	const configs: Array<{ content: string | null; path: string | null; scope: "user" | "project" }> = [
-		{ content: userContent, path: userPath, scope: "user" },
 		{ content: projectContent, path: projectPath, scope: "project" },
+		{ content: userContent, path: userPath, scope: "user" },
 	];
 
 	for (const { content, path, scope } of configs) {

package/src/edit/hashline/filesystem.ts

@@ -87,11 +87,11 @@ export class HashlineFilesystem extends Filesystem {
 		return resolvePlanPath(this.session, relativePath);
 	}
 
-	canonicalPath(relativePath: string): string {
+	override canonicalPath(relativePath: string): string {
 		return canonicalSnapshotKey(this.resolveAbsolute(relativePath));
 	}
 
-	allowTagPathRecovery(authoredPath: string, resolvedPath: string): boolean {
+	override allowTagPathRecovery(authoredPath: string, resolvedPath: string): boolean {
 		// Internal-URL authored targets (`local://`, `vault://`, …) are approved
 		// at the lower "read" privilege; never let one redirect onto a "write".
 		if (isInternalUrlPath(authoredPath)) return false;
@@ -125,7 +125,7 @@ export class HashlineFilesystem extends Filesystem {
 		return content;
 	}
 
-	async readBinary(relativePath: string): Promise<Uint8Array | undefined> {
+	override async readBinary(relativePath: string): Promise<Uint8Array | undefined> {
 		const absolutePath = this.resolveAbsolute(relativePath);
 		if (isNotebookPath(absolutePath)) return undefined;
 		try {
@@ -136,7 +136,7 @@ export class HashlineFilesystem extends Filesystem {
 		}
 	}
 
-	async preflightWrite(relativePath: string, options?: PreflightWriteOptions): Promise<void> {
+	override async preflightWrite(relativePath: string, options?: PreflightWriteOptions): Promise<void> {
 		const fileOp = options?.fileOp;
 		if (fileOp?.kind === "rem") {
 			enforcePlanModeWrite(this.session, relativePath, { op: "delete" });
@@ -149,7 +149,7 @@ export class HashlineFilesystem extends Filesystem {
 		enforcePlanModeWrite(this.session, relativePath, { op: "update" });
 	}
 
-	async delete(relativePath: string): Promise<void> {
+	override async delete(relativePath: string): Promise<void> {
 		enforcePlanModeWrite(this.session, relativePath, { op: "delete" });
 		const absolutePath = this.resolveAbsolute(relativePath);
 		try {
@@ -168,7 +168,7 @@ export class HashlineFilesystem extends Filesystem {
 		invalidateFsScanAfterWrite(absolutePath);
 	}
 
-	async move(fromRelative: string, toRelative: string, content?: string): Promise<void> {
+	override async move(fromRelative: string, toRelative: string, content?: string): Promise<void> {
 		enforcePlanModeWrite(this.session, fromRelative, { op: "update", move: toRelative });
 		const fromAbsolute = this.resolveAbsolute(fromRelative);
 		const toAbsolute = this.resolveAbsolute(toRelative);
@@ -240,7 +240,7 @@ export class HashlineFilesystem extends Filesystem {
 		return { text: content };
 	}
 
-	async exists(relativePath: string): Promise<boolean> {
+	override async exists(relativePath: string): Promise<boolean> {
 		const absolutePath = this.resolveAbsolute(relativePath);
 		return Bun.file(absolutePath).exists();
 	}

package/src/eval/agent-bridge.ts

@@ -23,7 +23,6 @@ export const EVAL_AGENT_BRIDGE_NAME = "__agent__";
 const agentArgsSchema = type({
 	prompt: "string>0",
 	"agent?": "string>0",
-	"model?": "string>0|string>0[]",
 	"label?": "string",
 	"schema?": "unknown",
 	"schemaMode?": "'permissive' | 'strict'",
@@ -31,12 +30,12 @@ const agentArgsSchema = type({
 	"apply?": "boolean",
 	"merge?": "boolean",
 	"handle?": "boolean",
+	"+": "delete",
 });
 
 interface EvalAgentArgs {
 	prompt: string;
 	agent?: string;
-	model?: string | string[];
 	label?: string;
 	schema?: unknown;
 	schemaMode?: StructuredSubagentSchemaMode;
@@ -148,7 +147,6 @@ export async function runEvalAgent(args: unknown, options: EvalAgentBridgeOption
 					invocationKind: "eval",
 					assignment: parsed.prompt,
 					...(parsed.agent !== undefined ? { agent: parsed.agent } : {}),
-					...(parsed.model !== undefined ? { model: parsed.model } : {}),
 					...(Object.hasOwn(parsed, "schema") ? { outputSchema: parsed.schema } : {}),
 					...(parsed.schemaMode !== undefined ? { schemaMode: parsed.schemaMode } : {}),
 					...(parsed.label !== undefined ? { identity: { label: parsed.label } } : {}),

package/src/eval/jl/prelude.jl

@@ -519,14 +519,11 @@ function completion(prompt::String; model="default", system=nothing, schema=noth
     return schema === nothing ? text : Main.json_parse(string(text))
 end
 
-function agent(prompt::String; agent="task", model=nothing, label=nothing, schema=nothing, schema_mode=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
+function agent(prompt::String; agent="task", label=nothing, schema=nothing, schema_mode=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
     args_dict = Dict{String, Any}("prompt" => prompt)
     if agent !== nothing
         args_dict["agent"] = agent
     end
-    if model !== nothing
-        args_dict["model"] = model
-    end
     if label !== nothing
         args_dict["label"] = label
     end
@@ -545,6 +542,9 @@ function agent(prompt::String; agent="task", model=nothing, label=nothing, schem
     if merge !== nothing
         args_dict["merge"] = Bool(merge)
     end
+    if haskey(kwargs, :model)
+        error("agent() no longer accepts a per-call model override; the selected agent's frontmatter model is used")
+    end
     handle_result = handle
     for (k, v) in kwargs
         args_dict[string(k)] = v

package/src/eval/js/shared/prelude.txt

@@ -104,8 +104,8 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 			"agent",
 			opts,
 			rest,
-			["agent", "model", "label", "schema", "isolated", "apply", "merge", "schemaMode"],
-			"{ agent, model, label, schema, isolated, apply, merge, schemaMode, handle }",
+			["agent", "label", "schema", "isolated", "apply", "merge", "schemaMode"],
+			"{ agent, label, schema, isolated, apply, merge, schemaMode, handle }",
 		);
 		const { handle, ...callArgs } = o;
 		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...callArgs, handle: Boolean(handle) });

package/src/eval/py/prelude.py

@@ -488,7 +488,6 @@ if "__omp_prelude_loaded__" not in globals():
         prompt,
         *,
         agent="task",
-        model=None,
         label=None,
         schema=None,
         schema_mode=None,
@@ -506,8 +505,6 @@ if "__omp_prelude_loaded__" not in globals():
         args = {"prompt": prompt}
         if agent is not None:
             args["agent"] = agent
-        if model is not None:
-            args["model"] = model
         if label is not None:
             args["label"] = label
         if schema is not None:

package/src/eval/rb/prelude.rb

@@ -392,10 +392,9 @@ unless defined?($__omp_prelude_loaded) && $__omp_prelude_loaded
     schema.nil? ? text : JSON.parse(text)
   end
 
-  def agent(prompt, agent: "task", model: nil, label: nil, schema: nil, schema_mode: nil, isolated: nil, apply: nil, merge: nil, handle: false)
+  def agent(prompt, agent: "task", label: nil, schema: nil, schema_mode: nil, isolated: nil, apply: nil, merge: nil, handle: false)
     args = { "prompt" => prompt }
     args["agent"] = agent unless agent.nil?
-    args["model"] = model unless model.nil?
     args["label"] = label unless label.nil?
     args["schema"] = schema unless schema.nil?
     args["schemaMode"] = schema_mode unless schema_mode.nil?

package/src/extensibility/legacy-pi-coding-agent-shim.ts

@@ -54,6 +54,7 @@ import { ReadTool } from "../tools/read";
 import { formatBytes } from "../tools/render-utils";
 import { WriteTool } from "../tools/write";
 import { EventBus } from "../utils/event-bus";
+import { convertImageToPng } from "../utils/image-loading";
 import { discoverExtensionPaths, loadExtensionFromFactory, loadExtensions } from "./extensions";
 import { ExtensionRuntime } from "./extensions/loader";
 import type { ExtensionFactory, ToolDefinition } from "./extensions/types";
@@ -384,6 +385,28 @@ async function executeLegacyBashOperations(
 	}
 }
 
+/**
+ * Convert an image attachment to PNG using the legacy package-root contract.
+ *
+ * Invalid or unsupported image data returns `null`, matching Pi's historical
+ * helper instead of surfacing Bun's decoder error to extensions.
+ */
+export async function convertToPng(
+	base64Data: string,
+	mimeType: string,
+): Promise<{ data: string; mimeType: string } | null> {
+	if (mimeType === "image/png") {
+		return { data: base64Data, mimeType };
+	}
+
+	try {
+		const converted = await convertImageToPng({ type: "image", data: base64Data, mimeType });
+		return { data: converted.data, mimeType: converted.mimeType };
+	} catch {
+		return null;
+	}
+}
+
 /** Format the active shortcut for legacy extensions that render keybinding hints. */
 export function keyText(action: Keybinding): string {
 	return formatKeyHints(getKeybindings().getKeys(action));

package/src/hindsight/state.ts

@@ -411,24 +411,6 @@ export class HindsightSessionState {
 		}
 	}
 
-	async maybeRecallOnAgentStart(): Promise<void> {
-		if (!this.config.autoRecall || this.hasRecalledForFirstTurn) return;
-		const messages = extractMessages(this.session.sessionManager);
-		const lastUser = messages.findLast(m => m.role === "user");
-		if (!lastUser) return;
-
-		const query = composeRecallQuery(lastUser.content, messages, this.config.recallContextTurns);
-		const truncated = truncateRecallQuery(query, lastUser.content, this.config.recallMaxQueryChars);
-		const { context, ok } = await this.recallForContext(truncated);
-		if (!ok) return;
-
-		this.hasRecalledForFirstTurn = true;
-		if (!context) return;
-
-		this.lastRecallSnippet = context;
-		await this.#refreshBaseSystemPromptAfter("recall");
-	}
-
 	async beforeAgentStartPrompt(promptText: string): Promise<string | undefined> {
 		if (this.config.mentalModelsEnabled && this.mentalModelsLoadPromise && this.mentalModelsLoadedAt === undefined) {
 			await Promise.race([this.mentalModelsLoadPromise, Bun.sleep(MENTAL_MODEL_FIRST_TURN_DEADLINE_MS)]);
@@ -509,9 +491,7 @@ export class HindsightSessionState {
 	attachSessionListeners(): void {
 		this.unsubscribe?.();
 		this.unsubscribe = this.session.subscribe(event => {
-			if (event.type === "agent_start") {
-				void this.maybeRecallOnAgentStart();
-			} else if (event.type === "agent_end") {
+			if (event.type === "agent_end") {
 				void this.maybeRetainOnAgentEnd();
 				// Drain any queued tool-initiated retain calls now that the turn
 				// is settled. The queue is also debounced/size-bounded, but
@@ -540,7 +520,7 @@ export class HindsightSessionState {
 		this.retainQueue.dispose();
 	}
 
-	async #refreshBaseSystemPromptAfter(reason: "recall" | "MM load" | "MM reload" | "MM TTL reload"): Promise<void> {
+	async #refreshBaseSystemPromptAfter(reason: "MM load" | "MM reload" | "MM TTL reload"): Promise<void> {
 		try {
 			await this.session.refreshBaseSystemPrompt();
 		} catch (err) {

package/src/internal-urls/memory-protocol.ts

@@ -222,6 +222,18 @@ function mnemopiSessionStatesFromRegistry(): MnemopiSessionState[] {
 	return states;
 }
 
+function memoryBackendFromContext(context?: ResolveContext): string | undefined {
+	if (!context?.settings || typeof context.settings !== "object") return undefined;
+	try {
+		const get = Reflect.get(context.settings, "get");
+		if (typeof get !== "function") return undefined;
+		const backend = Reflect.apply(get, context.settings, ["memory.backend"]);
+		return typeof backend === "string" ? backend : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
 /**
  * Look up a mnemopi memory row by id across every live session's scoped banks.
  * First hit wins; returns `null` when the id is not stored anywhere in scope.
@@ -290,6 +302,23 @@ export class MemoryProtocolHandler implements ProtocolHandler {
 		// clipped recall preview before overwriting it (issue #4443).
 		if (namespace !== MEMORY_NAMESPACE) {
 			const mnemopiStates = mnemopiSessionStatesFromRegistry();
+			const hindsightActive =
+				memoryBackendFromContext(context) === "hindsight" ||
+				(mnemopiStates.length === 0 &&
+					AgentRegistry.global()
+						.list()
+						.some(ref => ref.session?.getHindsightSessionState?.()));
+			if (hindsightActive) {
+				// Hindsight keeps memories server-side and exposes no
+				// `memory://<id>` addressing, yet the shared `recall` tool
+				// description still steers a follow-up `read memory://<id>`.
+				// Return a corrective pointer so that stray read self-corrects in
+				// one turn instead of derailing on the generic namespace error
+				// (issue #7587).
+				throw new Error(
+					"Hindsight memories are not addressable via memory://. Recall results are final — use `recall` to search or `reflect` to synthesize. `read memory://<id>` is only available with memory.backend=mnemopi.",
+				);
+			}
 			if (mnemopiStates.length === 0) {
 				throw new Error(
 					`Unknown memory namespace: ${namespace}. Supported: ${MEMORY_NAMESPACE} (file-backed memory summary), or a mnemopi memory id when memory.backend=mnemopi is active.`,

package/src/lsp/client.ts

@@ -17,7 +17,7 @@ import type {
 	ServerConfig,
 	WorkspaceEdit,
 } from "./types";
-import { detectLanguageId, fileToUri } from "./utils";
+import { detectLanguageId, EquivalentUriMap, fileToUri } from "./utils";
 
 // =============================================================================
 // Client State
@@ -787,7 +787,7 @@ export async function getOrCreateClient(
 			proc,
 			config,
 			requestId: 0,
-			diagnostics: new Map(),
+			diagnostics: new EquivalentUriMap(),
 			diagnosticsVersion: 0,
 			dynamicCapabilityRegistrations: new Map(),
 			openFiles: new Map(),

package/src/lsp/utils.ts

@@ -78,6 +78,35 @@ function laxUriToFile(uri: string): string {
 	return filePath;
 }
 
+/** Map that treats equivalent file URI spellings as the same key. */
+export class EquivalentUriMap<Value> extends Map<string, Value> {
+	#key(uri: string): string {
+		if (!uri.startsWith("file://")) return uri;
+		const filePath = path.normalize(uriToFile(uri));
+		return process.platform === "win32" ? filePath.toLowerCase() : filePath;
+	}
+
+	override delete(uri: string): boolean {
+		const key = this.#key(uri);
+		return super.delete(key);
+	}
+
+	override get(uri: string): Value | undefined {
+		const key = this.#key(uri);
+		return super.get(key);
+	}
+
+	override has(uri: string): boolean {
+		const key = this.#key(uri);
+		return super.has(key);
+	}
+
+	override set(uri: string, value: Value): this {
+		const key = this.#key(uri);
+		return super.set(key, value);
+	}
+}
+
 // =============================================================================
 // Diagnostic Formatting
 // =============================================================================

package/src/modes/acp/acp-agent.ts

@@ -2312,7 +2312,7 @@ export class AcpAgent implements Agent {
 			this.#clientCapabilities,
 		);
 		if (this.#clientCapabilities?.elicitation?.form != null) {
-			record.session.setUsageFallbackConfirmer(confirmation => {
+			record.session.setUsageFallbackConfirmer((confirmation, signal) => {
 				const reserve =
 					confirmation.remainingPercent === undefined
 						? "inside the configured reserve margin"
@@ -2320,6 +2320,7 @@ export class AcpAgent implements Agent {
 				return uiContext.confirm(
 					"Coding-plan reserve reached",
 					`${confirmation.from} has ${reserve}. Switch to ${confirmation.to}? Choose No to keep using the current plan.`,
+					{ signal },
 				);
 			});
 		}