@oh-my-pi/pi-coding-agent 14.1.2 → 14.2.1

package/src/edit/index.ts

@@ -8,6 +8,7 @@ import {
 	type WritethroughDeferredHandle,
 	writethroughNoop,
 } from "../lsp";
+import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
 import chunkEditDescription from "../prompts/tools/chunk-edit.md" with { type: "text" };
 import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
@@ -16,6 +17,13 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
+import {
+	type ApplyPatchParams,
+	applyPatchSchema,
+	expandApplyPatchToEntries,
+	isApplyPatchParams,
+} from "./modes/apply-patch";
+import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
 import {
 	type ChunkParams,
 	type ChunkToolEdit,
@@ -50,8 +58,10 @@ import {
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
 
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
+export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
+export * from "./modes/apply-patch";
 export * from "./modes/chunk";
 export * from "./modes/hashline";
 export * from "./modes/patch";
@@ -64,10 +74,11 @@ type TInput =
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
 	| typeof chunkEditParamsSchema
-	| typeof vimSchema;
+	| typeof vimSchema
+	| typeof applyPatchSchema;
 
 type VimParams = Static<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | ChunkParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
 type EditModeDefinition = {
@@ -265,6 +276,28 @@ export class EditTool implements AgentTool<TInput> {
 		return this.#getModeDefinition().parameters;
 	}
 
+	/**
+	 * When in `apply_patch` mode, expose the Codex Lark grammar so providers
+	 * that support OpenAI-style custom tools can emit a grammar-constrained
+	 * variant. Providers that don't support custom tools ignore this field
+	 * and fall back to emitting a JSON function tool from `parameters`.
+	 */
+	get customFormat(): { syntax: "lark"; definition: string } | undefined {
+		if (this.mode !== "apply_patch") return undefined;
+		return { syntax: "lark", definition: applyPatchGrammar };
+	}
+
+	/**
+	 * Wire-level tool name used when the custom-tool variant is active. GPT-5+
+	 * is trained on the literal name `apply_patch`; internally this is just a
+	 * mode of the `edit` tool. The agent-loop dispatcher matches both the
+	 * internal `name` and `customWireName`, so returned calls route correctly.
+	 */
+	get customWireName(): string | undefined {
+		if (this.mode !== "apply_patch") return undefined;
+		return "apply_patch";
+	}
+
 	async execute(
 		_toolCallId: string,
 		params: EditParams,
@@ -289,7 +322,8 @@ export class EditTool implements AgentTool<TInput> {
 						chunkAutoIndent: resolveChunkAutoIndent(),
 					}),
 				parameters: chunkEditParamsSchema,
-				invalidParamsMessage: "Invalid edit parameters for chunk mode.",
+				invalidParamsMessage:
+					"Invalid edit parameters for chunk mode. Expected `{ edits: [{ path: 'file:selector', ...op }, ...] }` with at least one edit. Each edit needs a `path`; supply one of `write` (string content; pass an empty string or omit it together with `replace`/`insert` to delete the chunk), `replace: { old, new }`, or `insert: { loc, body }`.",
 				validate: isChunkParams,
 				execute: (
 					tool: EditTool,
@@ -346,6 +380,36 @@ export class EditTool implements AgentTool<TInput> {
 					return executePerFile(entries, batchRequest, onUpdate);
 				},
 			},
+			apply_patch: {
+				description: () => prompt.render(applyPatchDescription),
+				parameters: applyPatchSchema,
+				invalidParamsMessage: "Invalid edit parameters for apply_patch mode.",
+				validate: isApplyPatchParams,
+				execute: (
+					tool: EditTool,
+					params: EditParams,
+					signal: AbortSignal | undefined,
+					batchRequest: LspBatchRequest | undefined,
+					onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
+				) => {
+					const entries = expandApplyPatchToEntries(params as ApplyPatchParams);
+					const perFile = entries.map((entry: PatchEditEntry) => ({
+						path: entry.path,
+						run: (br: LspBatchRequest | undefined) =>
+							executePatchSingle({
+								session: tool.session,
+								params: entry,
+								signal,
+								batchRequest: br,
+								allowFuzzy: tool.#allowFuzzy,
+								fuzzyThreshold: tool.#fuzzyThreshold,
+								writethrough: tool.#writethrough,
+								beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
+							}),
+					}));
+					return executePerFile(perFile, batchRequest, onUpdate);
+				},
+			},
 			hashline: {
 				description: () => prompt.render(hashlineDescription),
 				parameters: hashlineEditParamsSchema,

package/src/edit/modes/apply-patch.lark

@@ -0,0 +1,19 @@
+start: begin_patch hunk+ end_patch
+begin_patch: "*** Begin Patch" LF
+end_patch: "*** End Patch" LF?
+
+hunk: add_hunk | delete_hunk | update_hunk
+add_hunk: "*** Add File: " filename LF add_line+
+delete_hunk: "*** Delete File: " filename LF
+update_hunk: "*** Update File: " filename LF change_move? change?
+
+filename: /(.+)/
+add_line: "+" /(.*)/ LF -> line
+
+change_move: "*** Move to: " filename LF
+change: (change_context | change_line)+ eof_line?
+change_context: ("@@" | "@@ " /(.+)/) LF
+change_line: ("+" | "-" | " ") /(.*)/ LF
+eof_line: "*** End of File" LF
+
+%import common.LF

package/src/edit/modes/apply-patch.ts

@@ -0,0 +1,63 @@
+/**
+ * Edit mode wrapper for the Codex `apply_patch` envelope format.
+ *
+ * The mode accepts a single `input` string containing a full
+ * `*** Begin Patch ... *** End Patch` block, parses it, and fans out to
+ * the existing `executePatchSingle` — so all the machinery (plan mode,
+ * LSP writethrough, fs-cache invalidation, diagnostics) is shared with
+ * the `patch` mode.
+ */
+
+import { type Static, Type } from "@sinclair/typebox";
+import { parseApplyPatch, parseApplyPatchStreaming } from "../apply-patch/parser";
+import { ApplyPatchError } from "../diff";
+import type { PatchEditEntry } from "./patch";
+
+export const applyPatchSchema = Type.Object({
+	input: Type.String({
+		description:
+			"Full Codex apply_patch envelope, including '*** Begin Patch' and '*** End Patch'. Contains any mix of Add/Delete/Update (with optional Move to) file operations.",
+	}),
+});
+
+export type ApplyPatchParams = Static<typeof applyPatchSchema>;
+
+export function isApplyPatchParams(params: unknown): params is ApplyPatchParams {
+	return (
+		typeof params === "object" &&
+		params !== null &&
+		"input" in params &&
+		typeof (params as { input: unknown }).input === "string"
+	);
+}
+
+/**
+ * Parse the envelope and lower each hunk to a `PatchEditEntry` so it can
+ * be routed through `executePatchSingle`.
+ */
+export function expandApplyPatchToEntries(params: ApplyPatchParams): PatchEditEntry[] {
+	const hunks = parseApplyPatch(params.input);
+	if (hunks.length === 0) {
+		throw new ApplyPatchError("No files were modified.");
+	}
+	return hunks.map(
+		(h): PatchEditEntry => ({
+			path: h.path,
+			op: h.op,
+			rename: h.rename,
+			diff: h.diff,
+		}),
+	);
+}
+
+export function expandApplyPatchToPreviewEntries(params: ApplyPatchParams): PatchEditEntry[] {
+	const hunks = parseApplyPatchStreaming(params.input);
+	return hunks.map(
+		(h): PatchEditEntry => ({
+			path: h.path,
+			op: h.op,
+			rename: h.rename,
+			diff: h.diff,
+		}),
+	);
+}

package/src/edit/modes/chunk.ts

@@ -549,8 +549,12 @@ export function isChunkParams(params: unknown): params is ChunkParams {
 		return false;
 	}
 	const first = params.edits[0];
-	if (typeof first !== "object" || first === null || !("path" in first)) return false;
-	return "write" in first || "replace" in first || "insert" in first;
+	// Accept a bare `{ path }` entry: it is interpreted downstream as a chunk
+	// delete. Some providers strip `null` values from tool-call JSON, so a
+	// documented `{ path, write: null }` delete can arrive here as just
+	// `{ path }`. Rejecting that surfaced as a misleading
+	// "Invalid edit parameters for chunk mode." error.
+	return typeof first === "object" && first !== null && "path" in first;
 }
 
 /** Auto-correct indentation for content targeting a body region (`~`) when autoIndent is on.

package/src/edit/modes/hashline.ts

@@ -1157,11 +1157,11 @@ export async function computeHashlineDiff(
 	  }
 > {
 	const { path, edits, move } = input;
-	const absolutePath = resolveToCwd(path, cwd);
-	const movePath = move ? resolveToCwd(move, cwd) : undefined;
-	const isMoveOnly = Boolean(movePath) && movePath !== absolutePath && edits.length === 0;
 
 	try {
+		const absolutePath = resolveToCwd(path, cwd);
+		const movePath = move ? resolveToCwd(move, cwd) : undefined;
+		const isMoveOnly = Boolean(movePath) && movePath !== absolutePath && edits.length === 0;
 		const resolvedEdits = resolveHashlineEditsForDiff(edits);
 		const file = Bun.file(absolutePath);
 

package/src/edit/modes/replace.ts

@@ -5,7 +5,6 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@oh-my-pi/pi-agent-core";
-import { isEnoent } from "@oh-my-pi/pi-utils";
 import { type Static, Type } from "@sinclair/typebox";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
@@ -22,6 +21,7 @@ import {
 	restoreLineEndings,
 	stripBom,
 } from "../normalize";
+import { readEditFileText } from "../read-file";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";
 
 export interface FuzzyMatch {
@@ -140,17 +140,6 @@ function formatOccurrenceError(path: string, matchOutcome: MatchOutcome): string
 	return `Found ${matchOutcome.occurrences} occurrences in ${path}${moreMsg}:\n\n${previews}\n\nAdd more context lines to disambiguate.`;
 }
 
-async function readReplaceFileContent(absolutePath: string, path: string): Promise<string> {
-	try {
-		return await Bun.file(absolutePath).text();
-	} catch (error) {
-		if (isEnoent(error)) {
-			throw new Error(`File not found: ${path}`);
-		}
-		throw error;
-	}
-}
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Constants
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1045,7 +1034,7 @@ export async function executeReplaceSingle(
 	}
 
 	const absolutePath = resolvePlanPath(session, path);
-	const rawContent = await readReplaceFileContent(absolutePath, path);
+	const rawContent = await readEditFileText(absolutePath, path);
 	const { bom, text: content } = stripBom(rawContent);
 	const originalEnding = detectLineEnding(content);
 	const normalizedContent = normalizeToLF(content);

package/src/edit/read-file.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared file-read helper for edit-mode utilities.
+ *
+ * Reads a file via Bun and rethrows ENOENT as a user-facing "File not found"
+ * error referencing the display path.
+ */
+import { isEnoent } from "@oh-my-pi/pi-utils";
+
+export async function readEditFileText(absolutePath: string, path: string): Promise<string> {
+	try {
+		return await Bun.file(absolutePath).text();
+	} catch (error) {
+		if (isEnoent(error)) {
+			throw new Error(`File not found: ${path}`);
+		}
+		throw error;
+	}
+}

package/src/edit/renderer.ts

@@ -1,7 +1,6 @@
 /**
  * Edit tool renderer and LSP batching helpers.
  */
-import type { ToolCallContext } from "@oh-my-pi/pi-agent-core";
 import type { Component } from "@oh-my-pi/pi-tui";
 import { Text, visibleWidth, wrapTextWithAnsi } from "@oh-my-pi/pi-tui";
 import type { RenderResultOptions } from "../extensibility/custom-tools/types";
@@ -16,6 +15,8 @@ import {
 	formatStatusIcon,
 	formatTitle,
 	getDiffStats,
+	getLspBatchRequest,
+	type LspBatchRequest,
 	PREVIEW_LIMITS,
 	replaceTabs,
 	shortenPath,
@@ -25,34 +26,16 @@ import { type VimRenderArgs, vimToolRenderer } from "../tools/vim";
 import { Hasher, type RenderCache, renderStatusLine, truncateToWidth } from "../tui";
 import type { VimToolDetails } from "../vim/types";
 import type { DiffError, DiffResult } from "./diff";
+import { expandApplyPatchToEntries, expandApplyPatchToPreviewEntries } from "./modes/apply-patch";
 import { type ChunkToolEdit, parseChunkEditPath } from "./modes/chunk";
 import type { HashlineToolEdit } from "./modes/hashline";
-import type { Operation } from "./modes/patch";
+import type { Operation, PatchEditEntry } from "./modes/patch";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // LSP Batching
 // ═══════════════════════════════════════════════════════════════════════════
 
-const LSP_BATCH_TOOLS = new Set(["edit", "write"]);
-
-export interface LspBatchRequest {
-	id: string;
-	flush: boolean;
-}
-
-export function getLspBatchRequest(toolCall: ToolCallContext | undefined): LspBatchRequest | undefined {
-	if (!toolCall) {
-		return undefined;
-	}
-	const hasOtherWrites = toolCall.toolCalls.some(
-		(call, index) => index !== toolCall.index && LSP_BATCH_TOOLS.has(call.name),
-	);
-	if (!hasOtherWrites) {
-		return undefined;
-	}
-	const hasLaterWrites = toolCall.toolCalls.slice(toolCall.index + 1).some(call => LSP_BATCH_TOOLS.has(call.name));
-	return { id: toolCall.batchId, flush: !hasLaterWrites };
-}
+export { getLspBatchRequest, type LspBatchRequest };
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Details Types
@@ -97,6 +80,7 @@ interface EditRenderArgs {
 	oldText?: string;
 	newText?: string;
 	patch?: string;
+	input?: string;
 	all?: boolean;
 	// Patch mode fields
 	op?: Operation;
@@ -107,7 +91,19 @@ interface EditRenderArgs {
 	 */
 	previewDiff?: string;
 	// Hashline / chunk mode fields
-	edits?: Partial<HashlineToolEdit | ChunkToolEdit>[];
+	edits?: EditRenderEntry[];
+}
+
+type EditRenderEntry = {
+	path?: string;
+	rename?: string;
+	move?: string;
+	op?: Operation;
+};
+
+interface ApplyPatchRenderSummary {
+	entries: PatchEditEntry[];
+	error?: string;
 }
 
 function isVimRenderArgs(args: EditRenderArgs | VimRenderArgs): args is VimRenderArgs {
@@ -163,8 +159,8 @@ function filePathFromEditEntry(p: string | undefined): string | undefined {
 }
 
 /** Count distinct file paths in an edits array. */
-function countEditFiles(edits: any[]): number {
-	return new Set(edits.map((e: any) => filePathFromEditEntry(e?.path)).filter(Boolean)).size;
+function countEditFiles(edits: EditRenderEntry[]): number {
+	return new Set(edits.map(edit => filePathFromEditEntry(edit.path)).filter(Boolean)).size;
 }
 
 function countLines(text: string): number {
@@ -370,6 +366,24 @@ function getCallPreview(args: EditRenderArgs, rawPath: string, uiTheme: Theme):
 	return "";
 }
 
+const MISSING_APPLY_PATCH_END_ERROR = "The last line of the patch must be '*** End Patch'";
+
+function getApplyPatchRenderSummary(args: EditRenderArgs, isPartial: boolean): ApplyPatchRenderSummary | undefined {
+	if (typeof args.input !== "string") {
+		return undefined;
+	}
+
+	try {
+		return { entries: expandApplyPatchToEntries({ input: args.input }) };
+	} catch (err) {
+		const error = err instanceof Error ? err.message : String(err);
+		if (isPartial && error === MISSING_APPLY_PATCH_END_ERROR) {
+			return { entries: expandApplyPatchToPreviewEntries({ input: args.input }) };
+		}
+		return { entries: [], error };
+	}
+}
+
 function renderDiffSection(
 	diff: string,
 	rawPath: string,
@@ -437,21 +451,29 @@ export const editToolRenderer = {
 			return vimToolRenderer.renderCall(args, options, uiTheme);
 		}
 
+		const applyPatchSummary = getApplyPatchRenderSummary(args, options.isPartial);
+		const firstApplyPatchEntry = applyPatchSummary?.entries[0];
 		// Extract path from first edit entry when top-level path is absent (new schema)
 		const firstEdit = Array.isArray(args.edits) && args.edits.length > 0 ? args.edits[0] : undefined;
-		const rawPath = args.file_path || args.path || (firstEdit as any)?.path || "";
-		const rename = args.rename || (firstEdit as any)?.rename;
-		const op = args.op || (firstEdit as any)?.op;
+		const rawPath =
+			args.file_path || args.path || filePathFromEditEntry(firstEdit?.path) || firstApplyPatchEntry?.path || "";
+		const rename = args.rename || firstEdit?.rename || firstEdit?.move || firstApplyPatchEntry?.rename;
+		const op = args.op || firstEdit?.op || firstApplyPatchEntry?.op;
 		const { description } = formatEditDescription(rawPath, uiTheme, { rename });
 		const spinner =
 			options?.spinnerFrame !== undefined ? formatStatusIcon("running", uiTheme, options.spinnerFrame) : "";
 		let text = `${formatTitle(getOperationTitle(op), uiTheme)} ${spinner ? `${spinner} ` : ""}${description}`;
 		// Show file count hint for multi-file edits
-		const fileCount = Array.isArray(args.edits) ? countEditFiles(args.edits as any[]) : 0;
+		const fileCount = Array.isArray(args.edits)
+			? countEditFiles(args.edits)
+			: (applyPatchSummary?.entries.length ?? 0);
 		if (fileCount > 1) {
 			text += uiTheme.fg("dim", ` (+${fileCount - 1} more)`);
 		}
 		text += getCallPreview(args, rawPath, uiTheme);
+		if (applyPatchSummary?.error) {
+			text += `\n\n${uiTheme.fg("error", truncateToWidth(replaceTabs(applyPatchSummary.error), CALL_TEXT_PREVIEW_WIDTH))}`;
+		}
 
 		return new Text(text, 0, 0);
 	},
@@ -471,7 +493,7 @@ export const editToolRenderer = {
 		}
 
 		const perFileResults = result.details?.perFileResults;
-		const totalFiles = Array.isArray(args?.edits) ? countEditFiles(args!.edits as any[]) : 0;
+		const totalFiles = args?.edits ? countEditFiles(args.edits) : 0;
 		if (perFileResults && (perFileResults.length > 1 || totalFiles > 1)) {
 			return renderMultiFileResult(perFileResults, totalFiles, options, uiTheme);
 		}
@@ -491,9 +513,15 @@ function renderSingleFileResult(
 ): Component {
 	const details = result.details;
 	const isError = result.isError ?? (details && "isError" in details ? details.isError : false);
-	const rawPath = args?.file_path || args?.path || (details && "path" in details ? details.path : "") || "";
-	const op = args?.op || details?.op;
-	const rename = args?.rename || details?.move;
+	const firstEdit = args?.edits?.[0];
+	const rawPath =
+		args?.file_path ||
+		args?.path ||
+		filePathFromEditEntry(firstEdit?.path) ||
+		(details && "path" in details ? details.path : "") ||
+		"";
+	const op = args?.op || firstEdit?.op || details?.op;
+	const rename = args?.rename || firstEdit?.rename || firstEdit?.move || details?.move;
 	const { language } = formatEditDescription(rawPath, uiTheme, { rename });
 
 	const metadataLine =

package/src/extensibility/extensions/compact-handler.ts

@@ -0,0 +1,40 @@
+/**
+ * Helper for wiring the `compact` action of an {@link ExtensionContext}.
+ *
+ * Extension-facing APIs accept `string | CompactOptions`, but `AgentSession.compact`
+ * takes two positional arguments `(instructions, options)`. This helper splits the
+ * union so the same adapter can be reused by print-mode, rpc-mode, and the executor.
+ */
+import type { Model } from "@oh-my-pi/pi-ai";
+import type { CompactOptions } from "./types";
+
+interface CompactableSession {
+	compact(instructions?: string, options?: CompactOptions): Promise<unknown>;
+}
+
+export async function runExtensionCompact(
+	session: CompactableSession,
+	instructionsOrOptions: string | CompactOptions | undefined,
+): Promise<void> {
+	const instructions = typeof instructionsOrOptions === "string" ? instructionsOrOptions : undefined;
+	const options =
+		instructionsOrOptions && typeof instructionsOrOptions === "object" ? instructionsOrOptions : undefined;
+	await session.compact(instructions, options);
+}
+
+interface SetModelCapableSession {
+	modelRegistry: { getApiKey(model: Model): Promise<string | undefined> };
+	setModel(model: Model): Promise<unknown>;
+}
+
+/**
+ * Helper for wiring the `setModel` action of an {@link ExtensionContext}.
+ *
+ * Returns false when no API key is available for the requested model.
+ */
+export async function runExtensionSetModel(session: SetModelCapableSession, model: Model): Promise<boolean> {
+	const key = await session.modelRegistry.getApiKey(model);
+	if (!key) return false;
+	await session.setModel(model);
+	return true;
+}

package/src/extensibility/extensions/runner.ts

@@ -554,53 +554,35 @@ export class ExtensionRunner {
 	}
 
 	async emitUserBash(event: UserBashEvent): Promise<UserBashEventResult | undefined> {
-		const ctx = this.createContext();
-
-		for (const ext of this.extensions) {
-			const handlers = ext.handlers.get("user_bash");
-			if (!handlers || handlers.length === 0) continue;
-
-			for (const handler of handlers) {
-				try {
-					const handlerResult = await handler(event, ctx);
-					if (handlerResult) {
-						return handlerResult as UserBashEventResult;
-					}
-				} catch (err) {
-					const message = err instanceof Error ? err.message : String(err);
-					const stack = err instanceof Error ? err.stack : undefined;
-					this.emitError({
-						extensionPath: ext.path,
-						event: "user_bash",
-						error: message,
-						stack,
-					});
-				}
-			}
-		}
-
-		return undefined;
+		return this.emitUserEvent<UserBashEventResult>(event, "user_bash");
 	}
 
 	async emitUserPython(event: UserPythonEvent): Promise<UserPythonEventResult | undefined> {
+		return this.emitUserEvent<UserPythonEventResult>(event, "user_python");
+	}
+
+	private async emitUserEvent<R>(
+		event: UserBashEvent | UserPythonEvent,
+		eventName: "user_bash" | "user_python",
+	): Promise<R | undefined> {
 		const ctx = this.createContext();
 
 		for (const ext of this.extensions) {
-			const handlers = ext.handlers.get("user_python");
+			const handlers = ext.handlers.get(eventName);
 			if (!handlers || handlers.length === 0) continue;
 
 			for (const handler of handlers) {
 				try {
 					const handlerResult = await handler(event, ctx);
 					if (handlerResult) {
-						return handlerResult as UserPythonEventResult;
+						return handlerResult as R;
 					}
 				} catch (err) {
 					const message = err instanceof Error ? err.message : String(err);
 					const stack = err instanceof Error ? err.stack : undefined;
 					this.emitError({
 						extensionPath: ext.path,
-						event: "user_python",
+						event: eventName,
 						error: message,
 						stack,
 					});

package/src/extensibility/utils.ts

@@ -1,6 +1,6 @@
 import * as path from "node:path";
 import { theme } from "../modes/theme/theme";
-import { expandPath } from "../tools/path-utils";
+import { expandPath, normalizeLocalScheme } from "../tools/path-utils";
 import type { HookUIContext } from "./hooks/types";
 
 /**
@@ -11,6 +11,12 @@ import type { HookUIContext } from "./hooks/types";
  */
 export function resolvePath(filePath: string, cwd: string): string {
 	const expanded = expandPath(filePath);
+	const expandedAndNormalized = normalizeLocalScheme(expanded);
+	if (expandedAndNormalized.startsWith("local://")) {
+		throw new Error(
+			`Path "${filePath}" uses internal scheme "local://" and must be resolved through the proper protocol handler, not as a filesystem path.`,
+		);
+	}
 	if (path.isAbsolute(expanded)) {
 		return expanded;
 	}