@oh-my-pi/pi-coding-agent 15.5.4 → 15.5.7

package/src/config/settings-schema.ts

@@ -2036,6 +2036,15 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"tts.enabled": {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "tools",
+			label: "Text-to-Speech",
+			description: "Enable the tts tool for xAI Grok Voice speech synthesis",
+		},
+	},
 	"recipe.enabled": {
 		type: "boolean",
 		default: true,
@@ -2698,7 +2707,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"providers.image": {
 		type: "enum",
-		values: ["auto", "openai", "gemini", "openrouter"] as const,
+		values: ["auto", "openai", "antigravity", "xai", "gemini", "openrouter"] as const,
 		default: "auto",
 		ui: {
 			tab: "providers",
@@ -2708,9 +2717,19 @@ export const SETTINGS_SCHEMA = {
 				{
 					value: "auto",
 					label: "Auto",
-					description: "Priority: GPT model image tool > Antigravity > OpenRouter > Gemini",
+					description: "Priority: GPT model image tool > Antigravity > xAI > OpenRouter > Gemini",
 				},
 				{ value: "openai", label: "OpenAI", description: "Uses the active GPT Responses/Codex model" },
+				{
+					value: "antigravity",
+					label: "Antigravity",
+					description: "Requires google-antigravity OAuth",
+				},
+				{
+					value: "xai",
+					label: "xAI Grok Imagine",
+					description: "Requires xAI Grok OAuth or XAI_API_KEY",
+				},
 				{ value: "gemini", label: "Gemini", description: "Requires GEMINI_API_KEY" },
 				{ value: "openrouter", label: "OpenRouter", description: "Requires OPENROUTER_API_KEY" },
 			],
@@ -2748,6 +2767,28 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"providers.openrouterVariant": {
+		type: "enum",
+		values: ["default", "nitro", "floor", "online", "exacto"] as const,
+		default: "default",
+		ui: {
+			tab: "providers",
+			label: "OpenRouter Routing",
+			description:
+				"Default routing-variant suffix appended to OpenRouter model IDs (overridden when the selector already names a variant)",
+			options: [
+				{ value: "default", label: "Default", description: "No suffix; use OpenRouter's default routing" },
+				{ value: "nitro", label: ":nitro", description: "Prioritize throughput / lowest latency" },
+				{ value: "floor", label: ":floor", description: "Prioritize cheapest available provider" },
+				{ value: "online", label: ":online", description: "Enable OpenRouter's web-search plugin" },
+				{
+					value: "exacto",
+					label: ":exacto",
+					description: "Cherry-picked high-quality providers (only defined for select models)",
+				},
+			],
+		},
+	},
 	"providers.parallelFetch": {
 		type: "boolean",
 		default: true,

package/src/edit/diff.ts

@@ -58,7 +58,7 @@ function formatNumberedDiffLine(prefix: "+" | "-" | " ", lineNum: number, conten
  * Generate a unified diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
-export function generateDiffString(oldContent: string, newContent: string, contextLines = 4): DiffResult {
+export function generateDiffString(oldContent: string, newContent: string, contextLines = 2): DiffResult {
 	const parts = Diff.diffLines(oldContent, newContent);
 	const output: string[] = [];
 
@@ -119,8 +119,9 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 					linesToShow = raw.slice(0, contextLimit);
 				}
 
+				// Leading-skip placeholder is omitted: the first emitted line's
+				// number already conveys that earlier lines were trimmed.
 				if (leadingSkip > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
 					oldLineNum += leadingSkip;
 					newLineNum += leadingSkip;
 				}
@@ -143,8 +144,9 @@ export function generateDiffString(oldContent: string, newContent: string, conte
 					}
 				}
 
+				// Trailing-skip placeholder is omitted for the same reason: the
+				// final emitted line's number tells the reader the file continues.
 				if (trailingSkip > 0) {
-					output.push(formatNumberedDiffLine(" ", oldLineNum, "..."));
 					oldLineNum += trailingSkip;
 					newLineNum += trailingSkip;
 				}

package/src/edit/hashline/diff.ts

@@ -10,7 +10,6 @@
  * and no auto-generated-file refusal — those belong on the write path.
  */
 import {
-	applyEdits,
 	computeFileHash,
 	Patch as HashlinePatch,
 	normalizeToLF,
@@ -24,6 +23,12 @@ import { readEditFileText } from "../read-file";
 
 export interface HashlineDiffOptions {
 	autoDropPureInsertDuplicates?: boolean;
+	/**
+	 * Use the streaming-tolerant applier ({@link PatchSection.applyPartialTo})
+	 * so trailing in-flight ops do not throw or emit phantom edits. Streaming
+	 * preview path only.
+	 */
+	streaming?: boolean;
 }
 
 async function readSectionText(absolutePath: string, sectionPath: string): Promise<string> {
@@ -62,7 +67,9 @@ export async function computeHashlineSectionDiff(
 		const normalized = normalizeToLF(content);
 		const hashError = validateSectionHash(section, normalized);
 		if (hashError) return { error: hashError };
-		const result = applyEdits(normalized, [...section.edits], options);
+		const result = options.streaming
+			? section.applyPartialTo(normalized, options)
+			: section.applyTo(normalized, options);
 		if (normalized === result.text) return { error: `No changes would be made to ${section.path}.` };
 		return generateDiffString(normalized, result.text);
 	} catch (err) {
@@ -71,13 +78,13 @@ export async function computeHashlineSectionDiff(
 }
 
 export async function computeHashlineDiff(
-	input: { input: string; path?: string },
+	input: { input: string },
 	cwd: string,
 	options: HashlineDiffOptions = {},
 ): Promise<{ diff: string; firstChangedLine: number | undefined } | { error: string }> {
 	let patch: Patch;
 	try {
-		patch = HashlinePatch.parse(input.input, { cwd, path: input.path });
+		patch = HashlinePatch.parse(input.input, { cwd });
 	} catch (err) {
 		return { error: err instanceof Error ? err.message : String(err) };
 	}

package/src/edit/hashline/execute.ts

@@ -1,6 +1,6 @@
 /**
  * Coding-agent runner that drives the hashline {@link Patcher} on behalf of
- * the `edit` tool. Converts a `{input, path?}` tool-call payload into a
+ * the `edit` tool. Converts a `{input}` tool-call payload into a
  * fully-applied patch, wraps the result in the agent's
  * {@link AgentToolResult} shape, and attaches LSP diagnostics + `outputMeta`
  * for the renderer.
@@ -31,7 +31,6 @@ import { type HashlineParams, hashlineEditParamsSchema } from "./params";
 export interface ExecuteHashlineSingleOptions {
 	session: ToolSession;
 	input: string;
-	path?: string;
 	signal?: AbortSignal;
 	batchRequest?: LspBatchRequest;
 	writethrough: WritethroughCallback;
@@ -91,16 +90,10 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 
 	const warningsBlock = result.warnings.length > 0 ? `\n\nWarnings:\n${result.warnings.join("\n")}` : "";
 	const previewBlock = preview.preview ? `\n${preview.preview}` : "";
-	const headline = preview.preview
-		? `${result.path}:`
-		: result.op === "create"
-			? `Created ${result.path}`
-			: `Updated ${result.path}`;
-
 	const firstChangedLine = result.firstChangedLine ?? diff.firstChangedLine;
 	return {
 		toolResult: {
-			content: [{ type: "text", text: `${headline}\n${result.header}${previewBlock}${warningsBlock}` }],
+			content: [{ type: "text", text: `${result.header}${previewBlock}${warningsBlock}` }],
 			details: {
 				diff: diff.diff,
 				firstChangedLine,
@@ -122,7 +115,7 @@ function renderSection(result: PatchSectionResult, diagnostics: FileDiagnosticsR
 export async function executeHashlineSingle(
 	options: ExecuteHashlineSingleOptions,
 ): Promise<AgentToolResult<EditToolDetails, typeof hashlineEditParamsSchema>> {
-	const patch = Patch.parse(options.input, { cwd: options.session.cwd, path: options.path });
+	const patch = Patch.parse(options.input, { cwd: options.session.cwd });
 	if (patch.sections.length === 0) {
 		throw new Error("No hashline sections found in input.");
 	}

package/src/edit/hashline/params.ts

@@ -1,11 +1,18 @@
 /**
  * Zod schema for the `edit` tool's hashline mode payload. The schema is
  * deliberately permissive (`.passthrough()`) so providers can attach extra
- * keys without rejection; only `input` is required and `path` is an
- * optional fallback used when the input lacks a `¶PATH#HASH` header.
+ * keys without rejection; only `input` is required. `_input` is accepted as a
+ * provider-emitted alias for `input`.
  */
 import * as z from "zod/v4";
 
-export const hashlineEditParamsSchema = z.object({ input: z.string(), path: z.string().optional() }).passthrough();
+export const hashlineEditParamsSchema = z.preprocess(raw => {
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+
+	const record = raw as Record<string, unknown>;
+	if (typeof record.input === "string" || typeof record._input !== "string") return raw;
+
+	return { ...record, input: record._input };
+}, z.object({ input: z.string() }).passthrough());
 
 export type HashlineParams = z.infer<typeof hashlineEditParamsSchema>;

package/src/edit/index.ts

@@ -262,19 +262,17 @@ async function executeSinglePathEntries(
 
 function extractApprovalPath(args: unknown): string {
 	const record = args && typeof args === "object" ? (args as Record<string, unknown>) : {};
-	const targetPath = record.path;
-	if (typeof targetPath === "string" && targetPath.length > 0) {
-		return targetPath;
-	}
-
 	const input = typeof record.input === "string" ? record.input : undefined;
-	if (!input) return "(unknown)";
+	if (input) {
+		const hashlineMatch = /^(?:¶|§|@)([^\s#]+)/m.exec(input);
+		if (hashlineMatch?.[1]) return hashlineMatch[1];
 
-	const hashlineMatch = /^(?:¶|§|@)([^\s#]+)/m.exec(input);
-	if (hashlineMatch?.[1]) return hashlineMatch[1];
+		const applyPatchMatch = /^\*\*\* (?:Add|Update|Delete) File:\s*(.+)$/m.exec(input);
+		if (applyPatchMatch?.[1]) return applyPatchMatch[1].trim();
+	}
 
-	const applyPatchMatch = /^\*\*\* (?:Add|Update|Delete) File:\s*(.+)$/m.exec(input);
-	return applyPatchMatch?.[1]?.trim() || "(unknown)";
+	const targetPath = record.path;
+	return typeof targetPath === "string" && targetPath.length > 0 ? targetPath : "(unknown)";
 }
 
 export class EditTool implements AgentTool<TInput> {
@@ -430,11 +428,10 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					_onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { input, path } = params as HashlineParams & { path?: string };
+					const { input } = params as HashlineParams;
 					return executeHashlineSingle({
 						session: tool.session,
 						input,
-						path,
 						signal,
 						batchRequest,
 						writethrough: tool.#writethrough,

package/src/edit/renderer.ts

@@ -235,14 +235,21 @@ function renderPlainTextPreview(text: string, uiTheme: Theme, filePath?: string)
 
 function formatStreamingDiff(diff: string, rawPath: string, uiTheme: Theme, label = "streaming"): string {
 	if (!diff) return "";
-	const lines = diff.split("\n");
-	const total = lines.length;
-	const displayLines = lines.slice(-EDIT_STREAMING_PREVIEW_LINES);
-	const hidden = total - displayLines.length;
+	// Hunk-aware truncation keeps the change rows themselves visible and
+	// trims surrounding context proportionally so a multi-hunk diff doesn't
+	// turn into just the tail of the last hunk while streaming.
+	const {
+		text: truncatedDiff,
+		hiddenHunks,
+		hiddenLines,
+	} = truncateDiffByHunk(diff, PREVIEW_LIMITS.DIFF_COLLAPSED_HUNKS, EDIT_STREAMING_PREVIEW_LINES);
 	let text = "\n\n";
-	text += renderDiffColored(displayLines.join("\n"), { filePath: rawPath });
-	if (hidden > 0) {
-		text += uiTheme.fg("dim", `\n… (${label} +${hidden} lines)`);
+	text += renderDiffColored(truncatedDiff, { filePath: rawPath });
+	if (hiddenHunks > 0 || hiddenLines > 0) {
+		const remainder: string[] = [];
+		if (hiddenHunks > 0) remainder.push(`${hiddenHunks} more hunks`);
+		if (hiddenLines > 0) remainder.push(`${hiddenLines} more lines`);
+		text += uiTheme.fg("dim", `\n… (${label} +${remainder.join(", ")})`);
 	} else {
 		text += uiTheme.fg("dim", `\n(${label})`);
 	}

package/src/edit/streaming.ts

@@ -20,11 +20,8 @@ import {
 	END_PATCH_MARKER,
 	type PatchSection as HashlineInputSection,
 	Patch as HashlinePatch,
-	Tokenizer as HashlineTokenizer,
 } from "@oh-my-pi/hashline";
-import { sanitizeText } from "@oh-my-pi/pi-utils";
 import type { Theme } from "../modes/theme/theme";
-import { replaceTabs, truncateToWidth } from "../tools/render-utils";
 import { type EditMode, resolveEditMode } from "../utils/edit-mode";
 import { computeEditDiff, type DiffError, type DiffResult } from "./diff";
 import { computeHashlineDiff, computeHashlineSectionDiff } from "./hashline/diff";
@@ -73,48 +70,6 @@ export interface EditStreamingStrategy<Args = unknown> {
 	renderStreamingFallback(args: Args, uiTheme: Theme): string;
 }
 
-const STREAMING_FALLBACK_LINES = 12;
-const STREAMING_FALLBACK_WIDTH = 80;
-
-// Streaming-preview classification reuses one tokenizer instance for the
-// stateless predicates and `tokenize`/`tokenizeAll` helpers; instances are
-// cheap, but keeping a single module-level reference matches the rest of
-// the hashline package.
-const HASHLINE_TOKENIZER = new HashlineTokenizer();
-
-function trimHashlineStreamingSyntax(lines: string[]): string[] {
-	let index = lines.findIndex(line => line.trim().length > 0);
-	if (index === -1) return [];
-
-	if (HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "envelope-begin") {
-		index++;
-		while (index < lines.length && lines[index].trim().length === 0) index++;
-	}
-	if (index < lines.length && HASHLINE_TOKENIZER.tokenize(lines[index]).kind === "header") {
-		index++;
-	}
-
-	return lines.slice(index).filter(line => !HASHLINE_TOKENIZER.isEnvelopeMarker(line));
-}
-
-function renderHashlineInputFallback(input: string, uiTheme: Theme): string {
-	const lines = trimHashlineStreamingSyntax(sanitizeText(input).split("\n"));
-	if (!lines.some(line => line.trim().length > 0)) return "";
-
-	const displayLines = lines.slice(-STREAMING_FALLBACK_LINES);
-	const hidden = lines.length - displayLines.length;
-	let text = "\n\n";
-	text += displayLines
-		.map(line => uiTheme.fg("toolOutput", truncateToWidth(replaceTabs(line), STREAMING_FALLBACK_WIDTH)))
-		.join("\n");
-	if (hidden > 0) {
-		text += uiTheme.fg("dim", `\n… (streaming +${hidden} lines)`);
-	} else {
-		text += uiTheme.fg("dim", "\n(streaming)");
-	}
-	return text;
-}
-
 // -----------------------------------------------------------------------------
 // Partial-JSON handling
 // -----------------------------------------------------------------------------
@@ -273,7 +228,6 @@ const patchStrategy: EditStreamingStrategy<PatchArgs> = {
 
 interface HashlineArgs {
 	input?: string;
-	path?: string;
 	__partialJson?: string;
 }
 
@@ -353,75 +307,6 @@ function buildApplyPatchNaturalOrderPreviews(input: string): PerFileDiffPreview[
 	return previews.length > 0 ? previews : null;
 }
 
-/**
- * Hashline equivalent: emit each payload line as a `+added` line in the
- * order the model typed it. We deliberately omit op headers and removal
- * targets from the streaming preview because their content lives in the file
- * and would require a costly re-apply per tick; the complete unified diff is
- * shown once streaming finishes.
- */
-function buildHashlineNaturalOrderPreviews(
-	input: string,
-	defaultPath: string | undefined,
-): PerFileDiffPreview[] | null {
-	const groups = new Map<string, string[]>();
-	let currentPath = defaultPath ?? "";
-	const ensure = (sectionPath: string): string[] => {
-		let bucket = groups.get(sectionPath);
-		if (!bucket) {
-			bucket = [];
-			groups.set(sectionPath, bucket);
-		}
-		return bucket;
-	};
-
-	// Per-call instance: the streaming preview re-runs each tick with the
-	// cumulative input, and we need the line counter to start at 1. A
-	// dedicated tokenizer keeps the shared HASHLINE_TOKENIZER above free
-	// for stateless predicate use elsewhere in this module.
-	const streamer = new HashlineTokenizer();
-	for (const token of streamer.tokenizeAll(input)) {
-		switch (token.kind) {
-			case "envelope-begin":
-			case "envelope-end":
-			case "abort":
-			case "op-delete":
-				continue;
-			case "blank":
-			case "raw":
-				continue;
-			case "header":
-				currentPath = token.path;
-				if (currentPath) ensure(currentPath);
-				continue;
-			case "op-insert":
-			case "op-replace":
-				// Inline body on the op line itself (`N↓payload`, `A-B:payload`) is
-				// payload content that just happens to share a line with the op
-				// header — render it the same as a standalone payload token so
-				// the very first character the model types after the sigil shows
-				// up in the streaming preview. Without this, the preview is
-				// empty until a newline arrives, and the renderer falls back to
-				// raw input ("A-B: bla bla bla") instead of "+ bla bla bla".
-				if (!currentPath || token.inlineBody === undefined) continue;
-				ensure(currentPath).push(`+${token.inlineBody}`);
-				continue;
-			case "payload":
-				if (!currentPath) continue;
-				ensure(currentPath).push(`+${token.text}`);
-				continue;
-		}
-	}
-
-	if (groups.size === 0) return null;
-	const previews: PerFileDiffPreview[] = [];
-	for (const [sectionPath, body] of groups) {
-		if (body.length === 0) continue;
-		previews.push({ path: sectionPath, diff: body.join("\n") });
-	}
-	return previews.length > 0 ? previews : null;
-}
-
 const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 	extractCompleteEdits(args) {
 		return args;
@@ -430,25 +315,21 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		if (typeof args.input !== "string" || args.input.length === 0) return null;
 		const input = trimTrailingPartialLine(args.input, ctx.isStreaming);
 		if (input.length === 0) return null;
-		if (ctx.isStreaming) {
-			// Skip the costly per-tick re-apply and avoid `Diff.structuredPatch`
-			// reordering by showing payload lines in input order.
-			return buildHashlineNaturalOrderPreviews(input, args.path);
-		}
 		ctx.signal.throwIfAborted();
 
 		let sections: readonly HashlineInputSection[];
 		try {
-			sections = HashlinePatch.parse(input, { cwd: ctx.cwd, path: args.path }).sections;
+			sections = HashlinePatch.parse(input, { cwd: ctx.cwd }).sections;
 		} catch {
-			// Single-section fallback keeps the original error rendering for the
-			// "haven't typed `¶ PATH` yet" case.
-			const result = await computeHashlineDiff({ input, path: args.path }, ctx.cwd, {
+			// While streaming, the trailing op may still be mid-typed and fail
+			// to parse; suppress until the next chunk arrives. Once args are
+			// complete, surface the error so the model sees what went wrong.
+			if (ctx.isStreaming) return null;
+			const result = await computeHashlineDiff({ input }, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
 			});
 			ctx.signal.throwIfAborted();
-			if ("error" in result && !args.path) return [{ path: "", error: result.error }];
-			return [toPerFilePreview(args.path ?? "", result)];
+			return [toPerFilePreview("", result)];
 		}
 		if (sections.length === 0) return null;
 
@@ -467,6 +348,7 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 			const section = sectionsToProcess[i];
 			const result = await computeHashlineSectionDiff(section, ctx.cwd, {
 				autoDropPureInsertDuplicates: ctx.hashlineAutoDropPureInsertDuplicates,
+				streaming: ctx.isStreaming,
 			});
 			ctx.signal.throwIfAborted();
 			// In a multi-section preview, ignore parse/apply errors from the
@@ -479,8 +361,13 @@ const hashlineStrategy: EditStreamingStrategy<HashlineArgs> = {
 		}
 		return previews.length > 0 ? previews : null;
 	},
-	renderStreamingFallback(args, uiTheme) {
-		return typeof args.input === "string" ? renderHashlineInputFallback(args.input, uiTheme) : "";
+	renderStreamingFallback() {
+		// Never leak raw hashline syntax (`64:`, `|payload`, `¶path#hash`)
+		// to the user — the streaming preview already projects every
+		// parseable op onto the real file via applyPartialTo, and an
+		// unparseable trailing chunk renders as "no preview yet" rather
+		// than a sigil dump.
+		return "";
 	},
 };
 

package/src/extensibility/legacy-pi-ai-shim.ts

@@ -0,0 +1,24 @@
+/**
+ * Compatibility shim for legacy extensions importing the package root of
+ * `@oh-my-pi/pi-ai` (or one of its aliased scopes like `@earendil-works/pi-ai`
+ * or `@mariozechner/pi-ai`).
+ *
+ * pi-ai 15.1.0 removed the historical TypeBox root exports (`Type`, plus the
+ * runtime-relevant half of the `Static`/`TSchema` pair) from the package
+ * entrypoint. Legacy extensions still author parameter schemas as
+ * `Type.Object({ ... })`, so this file is served by `legacy-pi-compat.ts` in
+ * place of the real pi-ai entrypoint whenever a legacy extension imports the
+ * bare package root. Subpath imports (`@oh-my-pi/pi-ai/utils/oauth`, etc.)
+ * continue to resolve directly against the bundled pi-ai package.
+ *
+ * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that
+ * already serves bare `@sinclair/typebox` imports for the same extension
+ * class, keeping the legacy-compat surface internally consistent.
+ *
+ * Type-level `Static` and `TSchema` continue to come from pi-ai's own
+ * `types.ts` via the `export *` below — pi-ai still exports both as types,
+ * only the runtime `Type` builder was removed.
+ */
+
+export * from "@oh-my-pi/pi-ai";
+export { Type } from "./typebox";

package/src/extensibility/plugins/legacy-pi-compat.ts

@@ -2,6 +2,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as url from "node:url";
+import { isCompiledBinary } from "@oh-my-pi/pi-utils";
 
 // Canonical scope for in-process pi packages. Plugins published against any of
 // the aliased scopes below (mariozechner's original publish, earendil-works'
@@ -56,7 +57,34 @@ const resolvedSpecifierFallbacks = new Map<string, string>();
 // relying on them must vendor `@sinclair/typebox` directly.
 const TYPEBOX_SPECIFIER = "@sinclair/typebox";
 const TYPEBOX_SPECIFIER_FILTER = /^@sinclair\/typebox$/;
-const TYPEBOX_SHIM_PATH = path.resolve(import.meta.dir, "../typebox.ts");
+
+// In-process compat shim paths. In dev `import.meta.dir` is the source folder of
+// this file, so the dev branches resolve to the real `.ts` source. In compiled
+// binaries `import.meta.dir` collapses to `/$bunfs/root`, so the runtime cannot
+// recover the source layout that way; instead, each shim file is registered as
+// a `--compile` entrypoint in `scripts/build-binary.ts`, which Bun emits into
+// bunfs at a deterministic `--root`-relative path with a `.js` extension. The
+// literals below must stay in sync with that listing — if either path drifts,
+// every legacy plugin loading the shim fails with a missing-module error in
+// release builds (without affecting `bun test`/dev).
+const TYPEBOX_SHIM_PATH = isCompiledBinary()
+	? "/$bunfs/root/packages/coding-agent/src/extensibility/typebox.js"
+	: path.resolve(import.meta.dir, "../typebox.ts");
+
+// Legacy extensions historically imported `Type` (and `Static`/`TSchema`) from
+// the package root of `@(scope)/pi-ai`. pi-ai 15.1.0 removed the runtime `Type`
+// export (see `packages/ai/CHANGELOG.md`), so the bare canonical specifier no
+// longer satisfies those imports. The override below redirects only the bare
+// pi-ai package root onto a sibling shim that re-exports the canonical surface
+// plus the borrowed `Type` runtime from the Zod-backed TypeBox shim. Subpath
+// imports such as `@oh-my-pi/pi-ai/utils/oauth` continue to resolve directly
+// against the bundled pi-ai package.
+const LEGACY_PI_AI_SHIM_PATH = isCompiledBinary()
+	? "/$bunfs/root/packages/coding-agent/src/extensibility/legacy-pi-ai-shim.js"
+	: path.resolve(import.meta.dir, "../legacy-pi-ai-shim.ts");
+const LEGACY_PI_PACKAGE_ROOT_OVERRIDES: Record<string, string> = {
+	[`${CANONICAL_PI_SCOPE}/pi-ai`]: LEGACY_PI_AI_SHIM_PATH,
+};
 
 let isLegacyPiSpecifierShimInstalled = false;
 
@@ -85,6 +113,22 @@ function getResolvedSpecifier(specifier: string): string {
 	return resolved;
 }
 
+/**
+ * Resolve a canonical `@oh-my-pi/*` specifier to a filesystem path, preferring
+ * a bundled compat shim when one is registered for the package root.
+ *
+ * Falls back to `getResolvedSpecifier` (which may throw under compiled binary
+ * mode); callers handle that the same way they would for non-overridden
+ * specifiers.
+ */
+function resolveCanonicalPiSpecifier(remappedSpecifier: string): string {
+	const override = LEGACY_PI_PACKAGE_ROOT_OVERRIDES[remappedSpecifier];
+	if (override) {
+		return override;
+	}
+	return getResolvedSpecifier(remappedSpecifier);
+}
+
 function toImportSpecifier(resolvedPath: string): string {
 	return url.pathToFileURL(resolvedPath).href;
 }
@@ -99,7 +143,7 @@ function rewriteLegacyPiImports(source: string): string {
 			}
 
 			try {
-				return `${prefix}${toImportSpecifier(getResolvedSpecifier(remappedSpecifier))}${suffix}`;
+				return `${prefix}${toImportSpecifier(resolveCanonicalPiSpecifier(remappedSpecifier))}${suffix}`;
 			} catch {
 				// Resolution failed — typically in compiled binary mode where
 				// Bun.resolveSync cannot walk up from /$bunfs/root to find the
@@ -250,7 +294,7 @@ function resolveLegacyPiSpecifier(args: { path: string; importer: string }): { p
 	// Primary: resolve the canonical @oh-my-pi/* specifier from the host binary
 	// location. Works in dev mode and in source-link installs.
 	try {
-		return { path: getResolvedSpecifier(remappedSpecifier) };
+		return { path: resolveCanonicalPiSpecifier(remappedSpecifier) };
 	} catch {
 		// Fallback for compiled binary mode: the bundled packages live inside
 		// /$bunfs/root and aren't reachable by filesystem resolution. Try the