@oh-my-pi/pi-coding-agent 16.1.16 → 16.1.18

package/src/cli/profile-alias.ts

@@ -198,37 +198,68 @@ export function resolveProfileAliasCommandFromProcess(
 	if (!runtime || !script || !/\.[cm]?[jt]s$/.test(script)) return DEFAULT_ALIAS_COMMAND;
 
 	const scriptPath = path.resolve(cwd, script);
-	const posix = `${quoteForShell(runtime)} ${quoteForShell(scriptPath)}`;
+	// Normalize to forward slashes for POSIX shell fields — bash/zsh/fish
+	// can't resolve backslash-separated paths, even on Windows (Git Bash, WSL).
+	const posixScriptPath = scriptPath.replace(/\\/g, "/");
+	const posixRuntime = runtime.replace(/\\/g, "/");
+	const posix = `${quoteForShell(posixRuntime)} ${quoteForShell(posixScriptPath)}`;
 	return {
-		display: `${runtime} ${scriptPath}`,
+		display: `${posixRuntime} ${posixScriptPath}`,
 		posix,
 		fish: posix,
 		powerShell: `${quoteForPowerShell(runtime)} ${quoteForPowerShell(scriptPath)}`,
 	};
 }
 
+/** Normalize backslashes to forward slashes for POSIX-shell paths.
+ *  path.posix.join only adds / separators — it preserves existing backslashes
+ *  in input segments like homeDir ("C:\Users\me"), producing mixed paths.
+ *  Windows UNC paths (\\server\share) become //server/share — path.posix.join
+ *  would collapse the leading // to /, so we restore it after joining. */
+function toPosix(p: string): string {
+	return p.replace(/\\/g, "/");
+}
+
+/** Like path.posix.join, but preserves leading // (UNC roots) which
+ *  path.posix.join collapses to a single /. */
+function posixJoinUnc(...segments: string[]): string {
+	const joined = path.posix.join(...segments);
+	// path.posix.join normalizes // at the start to /, breaking UNC roots.
+	// Restore it if any input segment started with // (a toPosix'd UNC path).
+	if (segments.some(s => s.startsWith("//") && !s.startsWith("///"))) {
+		return `/${joined}`;
+	}
+	return joined;
+}
+
 function resolveShellConfigPath(
 	shell: ProfileAliasShell,
 	homeDir: string,
 	platform: NodeJS.Platform,
 	env: NodeJS.ProcessEnv,
 ): string {
+	// POSIX shells (bash/zsh/fish) always need forward-slash config paths,
+	// even on Windows. path.posix.join adds / separators but preserves existing
+	// backslashes in input segments, so we normalize each component with toPosix.
+	// PowerShell profiles use the platform-native path.join (backslashes on
+	// Windows, forward slashes elsewhere).
+	const posixHome = toPosix(homeDir);
 	switch (shell) {
 		case "zsh":
-			return path.join(env.ZDOTDIR || homeDir, ".zshrc");
+			return posixJoinUnc(env.ZDOTDIR ? toPosix(env.ZDOTDIR) : posixHome, ".zshrc");
 		case "bash":
-			return platform === "darwin" ? path.join(homeDir, ".bash_profile") : path.join(homeDir, ".bashrc");
+			return platform === "darwin" ? posixJoinUnc(posixHome, ".bash_profile") : posixJoinUnc(posixHome, ".bashrc");
 		case "fish": {
 			// fish sources conf.d from $XDG_CONFIG_HOME/fish (default ~/.config/fish);
 			// a hard-coded ~/.config would be silently ignored when the user relocates
 			// their XDG config root, leaving the alias unsourced after a restart.
-			const configHome = env.XDG_CONFIG_HOME || path.join(homeDir, ".config");
-			return path.join(configHome, "fish", "conf.d", "omp-profiles.fish");
+			const configHome = env.XDG_CONFIG_HOME ? toPosix(env.XDG_CONFIG_HOME) : posixJoinUnc(posixHome, ".config");
+			return posixJoinUnc(configHome, "fish", "conf.d", "omp-profiles.fish");
 		}
 		case "pwsh":
 			return platform === "win32"
 				? path.join(homeDir, "Documents", "PowerShell", "Microsoft.PowerShell_profile.ps1")
-				: path.join(homeDir, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
+				: posixJoinUnc(posixHome, ".config", "powershell", "Microsoft.PowerShell_profile.ps1");
 		case "powershell":
 			return path.join(homeDir, "Documents", "WindowsPowerShell", "Microsoft.PowerShell_profile.ps1");
 	}

package/src/cli/usage-cli.ts

@@ -15,7 +15,7 @@ import {
 	type UsageReport,
 	type UsageUnit,
 } from "@oh-my-pi/pi-ai";
-import { formatDuration, formatNumber } from "@oh-my-pi/pi-utils";
+import { formatDuration, formatNumber, sanitizeText } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { ModelRegistry } from "../config/model-registry";
 import { discoverAuthStorage } from "../sdk";
@@ -450,6 +450,10 @@ export function formatUsageBreakdown(
 		lines.push(
 			`${chalk.bold.cyan(formatProviderName(provider))} ${chalk.dim(`— ${accountCount} ${accountCount === 1 ? "account" : "accounts"}`)}`,
 		);
+		// Provider-wide disclaimers render once per provider, not per limit.
+		const providerNotes = [...new Set(providerReports.flatMap(report => report.notes ?? []))];
+		for (const note of providerNotes)
+			lines.push(`  ${chalk.dim(sanitizeText(note.replace(/[\r\n]+/g, " ").replace(/\t/g, "  ")))}`);
 
 		const labelWidth = providerReports
 			.flatMap(report => report.limits)
@@ -646,6 +650,28 @@ function collectStoredAccounts(authStorage: AuthStorage): UsageAccountIdentity[]
 	return accounts;
 }
 
+/**
+ * Keep only accounts worth a usage row: those whose provider has a usage
+ * provider, so a missing report is a real gap rather than the absence of any
+ * usage concept. Providers with no usage endpoint (web-search keys, local /
+ * keyless servers, inference providers without a usage API) would only ever
+ * render as noise, so they are dropped.
+ *
+ * `hasUsageProvider` is injected (in practice {@link AuthStorage.usageProviderFor})
+ * so custom/broker resolvers stay authoritative — no provider list is duplicated
+ * here. An explicit `--provider` request bypasses the cull, so
+ * `omp usage --provider xai` can still confirm the stored credential has no
+ * usage endpoint.
+ */
+export function selectReportableAccounts(
+	accounts: UsageAccountIdentity[],
+	hasUsageProvider: (provider: string) => boolean,
+	explicitProvider?: string,
+): UsageAccountIdentity[] {
+	if (explicitProvider) return accounts;
+	return accounts.filter(account => hasUsageProvider(account.provider));
+}
+
 /** Apply a redaction mask to an optional identity field. */
 function maskIdentity(redaction: Map<string, string>, value: string | undefined): string | undefined {
 	return value === undefined ? undefined : (redaction.get(value) ?? value);
@@ -717,7 +743,12 @@ export async function runUsageCommand(cmd: UsageCommandArgs): Promise<void> {
 			(await authStorage.fetchUsageReports({
 				baseUrlResolver: provider => modelRegistry.getProviderBaseUrl(provider),
 			})) ?? [];
-		let accounts = collectStoredAccounts(authStorage);
+		const storedAccounts = collectStoredAccounts(authStorage);
+		let accounts = selectReportableAccounts(
+			storedAccounts,
+			provider => authStorage.usageProviderFor(provider) !== undefined,
+			cmd.provider,
+		);
 		let filteredReports = reports;
 		if (cmd.provider) {
 			const wanted = cmd.provider.toLowerCase();
@@ -760,9 +791,13 @@ export async function runUsageCommand(cmd: UsageCommandArgs): Promise<void> {
 
 		if (filteredReports.length === 0 && accounts.length === 0) {
 			const scope = cmd.provider ? ` for provider "${cmd.provider}"` : "";
-			process.stderr.write(
-				chalk.yellow(`No credentials found${scope}. Run \`omp\` and use /login to add accounts.\n`),
-			);
+			// Credentials exist but every one is for a provider without a usage
+			// endpoint — say so rather than implying nothing is logged in.
+			const message =
+				storedAccounts.length > 0
+					? `No usage data${scope}. Stored credentials are for providers without a usage endpoint.\n`
+					: `No credentials found${scope}. Run \`omp\` and use /login to add accounts.\n`;
+			process.stderr.write(chalk.yellow(message));
 			process.exitCode = 1;
 			return;
 		}

package/src/commands/token.ts

@@ -28,12 +28,23 @@ export default class Token extends Command {
 			description: "Force refresh the OAuth token even if it has not expired",
 			default: false,
 		}),
+		account: Flags.integer({
+			char: "a",
+			description: "Select the Nth OAuth account (1-based) in stored order instead of the round-robin default",
+		}),
+		list: Flags.boolean({
+			char: "l",
+			description: "List the provider's OAuth accounts (index + identity) and exit",
+			default: false,
+		}),
 	};
 
 	static examples = [
 		"# Get API key for Anthropic\n  omp token anthropic",
 		"# Get raw Copilot credential JSON\n  omp token github-copilot --raw",
 		"# Force refresh and get Gemini CLI token\n  omp token google-gemini-cli --force-refresh",
+		"# List Anthropic OAuth accounts\n  omp token anthropic --list",
+		"# Get the 2nd Anthropic OAuth account's token\n  omp token anthropic --account 2",
 	];
 
 	async run(): Promise<void> {
@@ -43,6 +54,49 @@ export default class Token extends Command {
 
 		const authStorage = await discoverAuthStorage();
 		try {
+			if (flags.list || flags.account !== undefined) {
+				const accounts = authStorage.listOAuthAccounts(provider);
+				if (accounts.length === 0) {
+					process.stderr.write(`${chalk.red(`No OAuth accounts found for provider "${providerName}".`)}\n`);
+					process.stderr.write("--account/--list select among OAuth accounts; this provider has none stored.\n");
+					process.exitCode = 1;
+					return;
+				}
+				if (flags.list) {
+					for (const acct of accounts) {
+						const label =
+							acct.email ??
+							acct.accountId ??
+							acct.projectId ??
+							acct.enterpriseUrl ??
+							`credential #${acct.credentialId}`;
+						process.stdout.write(`${acct.position + 1}. ${label}\n`);
+					}
+					return;
+				}
+				const n = flags.account;
+				if (n === undefined || n < 1 || n > accounts.length) {
+					process.stderr.write(
+						`${chalk.red(`Invalid --account ${n ?? "(missing)"}.`)} Provider "${providerName}" has ${accounts.length} OAuth account(s) (1-${accounts.length}).\n`,
+					);
+					process.exitCode = 1;
+					return;
+				}
+				const resolution = await authStorage.getOAuthAccessAt(provider, n - 1, {
+					forceRefresh: flags["force-refresh"],
+				});
+				if (!resolution?.ok) {
+					const reason = resolution && !resolution.ok ? resolution.error : "no OAuth credential available";
+					process.stderr.write(
+						`${chalk.red(`Could not get token for account ${n} of "${providerName}": ${reason}`)}\n`,
+					);
+					process.exitCode = 1;
+					return;
+				}
+				process.stdout.write(`${resolution.accessToken}\n`);
+				return;
+			}
+
 			const modelRegistry = new ModelRegistry(authStorage);
 
 			// Resolve the API key / token

package/src/config/model-discovery.ts

@@ -117,6 +117,11 @@ type LlamaCppDiscoveredServerMetadata = {
 	input?: ("text" | "image")[];
 };
 
+type LlamaCppModelListEntry = {
+	id: string;
+	contextWindow?: number;
+};
+
 function toPositiveNumberOrUndefined(value: unknown): number | undefined {
 	if (typeof value === "number" && Number.isFinite(value) && value > 0) {
 		return value;
@@ -162,6 +167,26 @@ function extractLlamaCppContextWindow(payload: Record<string, unknown>): number
 	return toPositiveNumberOrUndefined(payload.n_ctx);
 }
 
+function extractLlamaCppModelContextWindow(item: Record<string, unknown>): number | undefined {
+	const meta = item.meta;
+	if (!isRecord(meta)) {
+		return undefined;
+	}
+	return toPositiveNumberOrUndefined(meta.n_ctx) ?? toPositiveNumberOrUndefined(meta.n_ctx_train);
+}
+
+function parseLlamaCppModelList(payload: unknown): LlamaCppModelListEntry[] {
+	if (!isRecord(payload) || !Array.isArray(payload.data)) {
+		return [];
+	}
+	return payload.data.flatMap(item => {
+		if (!isRecord(item) || typeof item.id !== "string" || !item.id) {
+			return [];
+		}
+		return [{ id: item.id, contextWindow: extractLlamaCppModelContextWindow(item) }];
+	});
+}
+
 function extractLlamaCppInputCapabilities(payload: Record<string, unknown>): ("text" | "image")[] | undefined {
 	const modalities = payload.modalities;
 	if (!isRecord(modalities)) {
@@ -338,12 +363,13 @@ export async function discoverLlamaCppModels(
 	const [response, serverMetadata] = apiKey
 		? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
 		: await attempt(baseHeaders);
-	const payload = (await response.json()) as { data?: Array<{ id: string }> };
-	const models = payload.data ?? [];
+	const payload = (await response.json()) as unknown;
+	const models = parseLlamaCppModelList(payload);
 	const discovered: Model<Api>[] = [];
 	for (const item of models) {
-		const id = item.id;
+		const { id } = item;
 		if (!id) continue;
+		const contextWindow = item.contextWindow ?? serverMetadata?.contextWindow ?? 128000;
 		discovered.push(
 			buildModel({
 				id,
@@ -355,11 +381,8 @@ export async function discoverLlamaCppModels(
 				input: serverMetadata?.input ?? ["text"],
 				imageInputDecoder: "stb",
 				cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
-				contextWindow: serverMetadata?.contextWindow ?? 128000,
-				maxTokens: Math.min(
-					serverMetadata?.contextWindow ?? Number.POSITIVE_INFINITY,
-					DISCOVERY_DEFAULT_MAX_TOKENS,
-				),
+				contextWindow,
+				maxTokens: Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS),
 				headers,
 				compat: {
 					supportsStore: false,
@@ -372,6 +395,34 @@ export async function discoverLlamaCppModels(
 	return discovered;
 }
 
+export async function discoverLlamaCppModelContextWindow(
+	model: Pick<Model<Api>, "provider" | "id" | "baseUrl" | "headers">,
+	ctx: DiscoveryContext,
+): Promise<number | undefined> {
+	const baseUrl = normalizeLlamaCppBaseUrl(model.baseUrl);
+	const modelsUrl = `${baseUrl}/models`;
+	const baseHeaders: Record<string, string> = { ...(model.headers ?? {}) };
+	const attempt = async (headers: Record<string, string>) => {
+		const response = await ctx.fetch(modelsUrl, {
+			headers,
+			signal: AbortSignal.timeout(250),
+		});
+		if (!response.ok) {
+			return undefined;
+		}
+		const entries = parseLlamaCppModelList(await response.json());
+		return entries.find(entry => entry.id === model.id)?.contextWindow;
+	};
+	try {
+		const apiKey = await ctx.getBearerApiKeyResolver(model.provider);
+		return apiKey
+			? await withAuth(apiKey, key => attempt({ ...baseHeaders, Authorization: `Bearer ${key}` }))
+			: await attempt(baseHeaders);
+	} catch {
+		return undefined;
+	}
+}
+
 export async function discoverOpenAIModelsList(
 	providerConfig: DiscoveryProviderConfig,
 	ctx: DiscoveryContext,

package/src/config/model-registry.ts

@@ -67,6 +67,7 @@ import {
 	DISCOVERY_DEFAULT_MAX_TOKENS,
 	type DiscoveryContext,
 	type DiscoveryProviderConfig,
+	discoverLlamaCppModelContextWindow,
 	discoverModelsByProviderType,
 	getImplicitOllamaBaseUrl,
 	getOllamaContextLengthOverride,
@@ -759,6 +760,50 @@ export class ModelRegistry {
 		}
 	}
 
+	/**
+	 * Refresh dynamic metadata that can appear only after a local model loads.
+	 */
+	async refreshSelectedModelMetadata(model: Model<Api>): Promise<Model<Api>> {
+		const isLlamaCppDiscovery = this.#discoverableProviders.some(
+			providerConfig => providerConfig.provider === model.provider && providerConfig.discovery.type === "llama.cpp",
+		);
+		if (!isLlamaCppDiscovery) {
+			return model;
+		}
+		const contextWindow = await discoverLlamaCppModelContextWindow(model, this.#nonResolvingDiscoveryContext());
+		if (contextWindow === undefined) {
+			return this.find(model.provider, model.id) ?? model;
+		}
+		const current = this.find(model.provider, model.id) ?? model;
+		const override = this.#resolveLiveModelOverride(current);
+		const customModel = this.#resolveLiveCustomModelOverlay(current);
+		const patch: ModelPatch = {};
+		if (
+			override?.contextWindow === undefined &&
+			customModel?.contextWindow === undefined &&
+			current.contextWindow !== contextWindow
+		) {
+			patch.contextWindow = contextWindow;
+		}
+		const maxTokens = Math.min(contextWindow, DISCOVERY_DEFAULT_MAX_TOKENS);
+		if (
+			override?.maxTokens === undefined &&
+			customModel?.maxTokens === undefined &&
+			current.maxTokens !== maxTokens
+		) {
+			patch.maxTokens = maxTokens;
+		}
+		if (patch.contextWindow === undefined && patch.maxTokens === undefined) {
+			return current;
+		}
+		const patched = applyModelPatch(current, patch, "merge");
+		this.#models = this.#models.map(candidate =>
+			candidate.provider === current.provider && candidate.id === current.id ? patched : candidate,
+		);
+		this.#rebuildCanonicalIndex();
+		return patched;
+	}
+
 	/**
 	 * Discover models for providers registered at runtime via `fetchDynamicModels`
 	 * (extension providers). Merges the discovered catalog into the existing model
@@ -1008,7 +1053,7 @@ export class ModelRegistry {
 				provider: providerConfig.provider,
 				status: "cached",
 				optional: providerConfig.optional ?? false,
-				stale: !cache.fresh || !cache.authoritative || configStale,
+				stale: providerConfig.discovery.type === "llama.cpp" || !cache.fresh || !cache.authoritative || configStale,
 				fetchedAt: cache.updatedAt,
 				models: models.map(model => model.id),
 			});
@@ -1272,7 +1317,9 @@ export class ModelRegistry {
 		const cacheProviderId = this.#configuredDiscoveryCacheProviderId(providerConfig);
 		const cached = readModelCache<Api>(cacheProviderId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
 		const cacheOlderThanConfig = cached !== null && this.#isDiscoveryCacheOlderThanModelsConfig(cached.updatedAt);
-		const effectiveStrategy = strategy === "online-if-uncached" && cacheOlderThanConfig ? "online" : strategy;
+		const bypassFreshCache = providerConfig.discovery.type === "llama.cpp" && strategy === "online-if-uncached";
+		const effectiveStrategy =
+			strategy === "online-if-uncached" && (cacheOlderThanConfig || bypassFreshCache) ? "online" : strategy;
 		const requiresAuth = !this.#keylessProviders.has(providerConfig.provider);
 		if (requiresAuth) {
 			const apiKey = await this.#peekApiKeyForProvider(providerConfig.provider);
@@ -1335,7 +1382,7 @@ export class ModelRegistry {
 			provider: providerId,
 			status,
 			optional: providerConfig.optional ?? false,
-			stale: result.stale || status === "cached" || (cacheOlderThanConfig && status !== "ok"),
+			stale: result.stale || status === "cached" || ((cacheOlderThanConfig || bypassFreshCache) && status !== "ok"),
 			fetchedAt: discoveryError ? cached?.updatedAt : Date.now(),
 			models: result.models.map(model => model.id),
 			error: discoveryError,
@@ -1365,6 +1412,13 @@ export class ModelRegistry {
 		};
 	}
 
+	#nonResolvingDiscoveryContext(): DiscoveryContext {
+		return {
+			fetch: this.#fetch,
+			getBearerApiKeyResolver: async () => undefined,
+		};
+	}
+
 	#warnProviderDiscoveryFailure(providerConfig: DiscoveryProviderConfig, error: string): void {
 		const previous = this.#lastDiscoveryWarnings.get(providerConfig.provider);
 		if (previous === error) {
@@ -1574,6 +1628,23 @@ export class ModelRegistry {
 			return this.#applyProviderTransportOverride(model, override);
 		});
 	}
+	#resolveLiveModelOverride(model: Model<Api>): ModelOverride | undefined {
+		const providerOverrides = this.#modelOverrides.get(model.provider);
+		if (!providerOverrides) return undefined;
+		return resolveModelOverrideWithAliases(
+			providerOverrides,
+			model,
+			(provider, id) => this.find(provider, id) !== undefined,
+		);
+	}
+
+	#resolveLiveCustomModelOverlay(model: Model<Api>): CustomModelOverlay | undefined {
+		return (
+			this.#customModelOverlays.find(overlay => overlay.provider === model.provider && overlay.id === model.id) ??
+			this.#runtimeModelOverlays.find(overlay => overlay.provider === model.provider && overlay.id === model.id)
+		);
+	}
+
 	#applyModelOverrides(models: Model<Api>[], overrides: Map<string, Map<string, ModelOverride>>): Model<Api>[] {
 		if (overrides.size === 0) return models;
 		let liveKeys: Set<string> | null = null;

package/src/discovery/omp-extension-roots.ts

@@ -180,9 +180,7 @@ export async function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtens
 async function listInstalledPluginRoots(ctx: LoadContext): Promise<InjectedRoot[]> {
 	try {
 		const plugins = await getEnabledPlugins(ctx.cwd, { home: ctx.home });
-		// Installed plugins are always user-scope; project disablement is already
-		// honored by `getEnabledPlugins` via `loadProjectOverrides`.
-		return plugins.map(({ path: p }) => ({ path: p, level: "user" }));
+		return plugins.map(({ path: p, scope }) => ({ path: p, level: scope }));
 	} catch (err) {
 		logger.debug("listInstalledPluginRoots: enumeration failed", { error: String(err) });
 		return [];

package/src/extensibility/extensions/wrapper.ts

@@ -6,6 +6,7 @@ import type { ImageContent, Static, TextContent, TSchema } from "@oh-my-pi/pi-ai
 import type { Settings } from "../../config/settings";
 import type { Theme } from "../../modes/theme/theme";
 import { type ApprovalMode, formatApprovalPrompt, requiresApproval } from "../../tools/approval";
+import { normalizeToolEventInput } from "../tool-event-input";
 import { applyToolProxy } from "../tool-proxy";
 import type { ExtensionRunner } from "./runner";
 import type { RegisteredTool, ToolCallEventResult } from "./types";
@@ -185,7 +186,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 					type: "tool_call",
 					toolName: this.tool.name,
 					toolCallId,
-					input: params as Record<string, unknown>,
+					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
 				})) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
@@ -220,7 +221,7 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 				type: "tool_result",
 				toolName: this.tool.name,
 				toolCallId,
-				input: params as Record<string, unknown>,
+				input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
 				content: result.content,
 				details: result.details,
 				isError: !!executionError,

package/src/extensibility/hooks/tool-wrapper.ts

@@ -3,6 +3,7 @@
  */
 import type { AgentTool, AgentToolContext, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import type { Static, TSchema } from "@oh-my-pi/pi-ai";
+import { normalizeToolEventInput } from "../tool-event-input";
 import { applyToolProxy } from "../tool-proxy";
 import type { HookRunner } from "./runner";
 import type { ToolCallEventResult, ToolResultEventResult } from "./types";
@@ -46,7 +47,7 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 					type: "tool_call",
 					toolName: this.tool.name,
 					toolCallId,
-					input: params as Record<string, unknown>,
+					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
 				})) as ToolCallEventResult | undefined;
 
 				if (callResult?.block) {
@@ -72,7 +73,7 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 					type: "tool_result",
 					toolName: this.tool.name,
 					toolCallId,
-					input: params as Record<string, unknown>,
+					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
 					content: result.content,
 					details: result.details,
 					isError: false,
@@ -95,7 +96,7 @@ export class HookToolWrapper<TParameters extends TSchema = TSchema, TDetails = u
 					type: "tool_result",
 					toolName: this.tool.name,
 					toolCallId,
-					input: params as Record<string, unknown>,
+					input: normalizeToolEventInput(this.tool.name, params as Record<string, unknown>),
 					content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
 					details: undefined,
 					isError: true,

package/src/extensibility/plugins/legacy-pi-bundled-registry.ts

@@ -0,0 +1,40 @@
+/**
+ * Static handles on every bundled `@oh-my-pi/pi-*` surface a legacy extension
+ * may import. Loaded lazily by `legacy-pi-compat.ts` in compiled-binary mode
+ * (issue #3423) and re-exported through the `omp-legacy-pi-bundled:` virtual
+ * namespace — bunfs paths cannot be resolved at runtime on Bun 1.3.14+, so
+ * the only way to re-route extension imports onto the host's in-process copy
+ * is via live module references captured at compile time.
+ *
+ * This module is split out from `legacy-pi-compat.ts` so dev/test runs that
+ * touch the compat layer never trigger the cascade through
+ * `legacy-pi-coding-agent-shim.ts → ../index → export/html/...` (which
+ * requires generated artifacts that only exist after a `bun run build`).
+ *
+ * The bundler reaches every entry below via standard static-import analysis,
+ * so the matching `--compile` extras can be dropped from
+ * `scripts/build-binary.ts`.
+ */
+import * as bundledPiAgentCore from "@oh-my-pi/pi-agent-core";
+import * as bundledPiNatives from "@oh-my-pi/pi-natives";
+import * as bundledPiTui from "@oh-my-pi/pi-tui";
+import * as bundledPiUtils from "@oh-my-pi/pi-utils";
+import * as bundledLegacyPiAiShim from "../legacy-pi-ai-shim";
+import * as bundledLegacyPiCodingAgentShim from "../legacy-pi-coding-agent-shim";
+import * as bundledTypeBoxShim from "../typebox";
+
+/**
+ * Canonical specifier → live module namespace. Keys MUST match the right-hand
+ * side of `bundledRegistryVirtualSpecifier(...)` calls in
+ * `legacy-pi-compat.ts`; the synthesizer enumerates each namespace's own
+ * enumerable exports at extension load time.
+ */
+export const BUNDLED_PI_REGISTRY: Readonly<Record<string, Readonly<Record<string, unknown>>>> = {
+	"@oh-my-pi/pi-agent-core": bundledPiAgentCore,
+	"@oh-my-pi/pi-ai": bundledLegacyPiAiShim,
+	"@oh-my-pi/pi-coding-agent": bundledLegacyPiCodingAgentShim,
+	"@oh-my-pi/pi-natives": bundledPiNatives,
+	"@oh-my-pi/pi-tui": bundledPiTui,
+	"@oh-my-pi/pi-utils": bundledPiUtils,
+	typebox: bundledTypeBoxShim,
+};