@oh-my-pi/pi-coding-agent 14.7.8 → 14.8.0

package/CHANGELOG.md

@@ -2,6 +2,19 @@
 
 ## [Unreleased]
 
+## [14.8.0] - 2026-05-09
+### Added
+
+- Added hashline stale-anchor recovery by replaying edits against a session-scoped `read`/`search` snapshot and 3-way-merging them onto the current file when anchors no longer match
+
+### Fixed
+
+- Fixed legacy pi extensions failing to import their own bare-specifier dependencies (e.g. `import x from "pkg"`): files loaded via the `omp-legacy-pi-file:` namespace now pre-resolve bare imports against the extension's directory so the extension's own `node_modules` is honored.
+
+### Changed
+
+- Changed hashline success output to include a warning when stale-anchor recovery is used
+
 ## [14.7.8] - 2026-05-08
 
 ### Fixed

package/README.md

@@ -12,6 +12,7 @@ Package-specific references:
 - [MCP runtime lifecycle](../../docs/mcp-runtime-lifecycle.md)
 - [MCP server/tool authoring](../../docs/mcp-server-tool-authoring.md)
 - [DEVELOPMENT](./DEVELOPMENT.md)
+- [RenderMermaid guide](../../docs/render-mermaid.md)
 
 ## Memory backends
 

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "14.7.8",
+	"version": "14.8.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -46,12 +46,12 @@
 	"dependencies": {
 		"@agentclientprotocol/sdk": "0.21.0",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/omp-stats": "14.7.8",
-		"@oh-my-pi/pi-agent-core": "14.7.8",
-		"@oh-my-pi/pi-ai": "14.7.8",
-		"@oh-my-pi/pi-natives": "14.7.8",
-		"@oh-my-pi/pi-tui": "14.7.8",
-		"@oh-my-pi/pi-utils": "14.7.8",
+		"@oh-my-pi/omp-stats": "14.8.0",
+		"@oh-my-pi/pi-agent-core": "14.8.0",
+		"@oh-my-pi/pi-ai": "14.8.0",
+		"@oh-my-pi/pi-natives": "14.8.0",
+		"@oh-my-pi/pi-tui": "14.8.0",
+		"@oh-my-pi/pi-utils": "14.8.0",
 		"@puppeteer/browsers": "^2.13.0",
 		"@sinclair/typebox": "^0.34.49",
 		"@types/turndown": "5.0.6",

package/src/commit/agentic/index.ts

@@ -266,10 +266,11 @@ async function runSplitCommit(
 		throw new Error(order.error);
 	}
 
+	const stagedDiff = await git.diff(ctx.cwd, { cached: true });
 	await git.stage.reset(ctx.cwd);
 	for (const commitIndex of order) {
 		const commit = plan.commits[commitIndex];
-		await git.stage.hunks(ctx.cwd, commit.changes);
+		await git.stage.hunks(ctx.cwd, commit.changes, { rawDiff: stagedDiff, diffCached: true });
 		const analysis: ConventionalAnalysis = {
 			type: commit.type,
 			scope: commit.scope,

package/src/config/model-registry.ts

@@ -257,7 +257,12 @@ const ModelOverrideSchema = Type.Object({
 type ModelOverride = Static<typeof ModelOverrideSchema>;
 
 const ProviderDiscoverySchema = Type.Object({
-	type: Type.Union([Type.Literal("ollama"), Type.Literal("llama.cpp"), Type.Literal("lm-studio")]),
+	type: Type.Union([
+		Type.Literal("ollama"),
+		Type.Literal("llama.cpp"),
+		Type.Literal("lm-studio"),
+		Type.Literal("openai-models-list"),
+	]),
 });
 
 const ProviderAuthSchema = Type.Union([Type.Literal("apiKey"), Type.Literal("none"), Type.Literal("oauth")]);
@@ -435,7 +440,7 @@ interface DiscoveryProviderConfig {
 	optional?: boolean;
 }
 
-export type ProviderDiscoveryStatus = "idle" | "ok" | "cached" | "unavailable" | "unauthenticated";
+export type ProviderDiscoveryStatus = "idle" | "ok" | "empty" | "cached" | "unavailable" | "unauthenticated";
 
 export interface ProviderDiscoveryState {
 	provider: string;
@@ -1378,11 +1383,13 @@ export class ModelRegistry {
 			? result.models.length > 0
 				? "cached"
 				: "unavailable"
-			: result.models.length > 0 && strategy !== "offline"
-				? "ok"
-				: cached
+			: strategy === "offline"
+				? cached
 					? "cached"
-					: "idle";
+					: "idle"
+				: result.models.length > 0
+					? "ok"
+					: "empty";
 		this.#providerDiscoveryStates.set(providerId, {
 			provider: providerId,
 			status,
@@ -1411,7 +1418,8 @@ export class ModelRegistry {
 			case "llama.cpp":
 				return this.#discoverLlamaCppModels(providerConfig);
 			case "lm-studio":
-				return this.#discoverLmStudioModels(providerConfig);
+			case "openai-models-list":
+				return this.#discoverOpenAIModelsList(providerConfig);
 		}
 	}
 
@@ -1706,8 +1714,8 @@ export class ModelRegistry {
 		return this.#applyProviderModelOverrides(providerConfig.provider, discovered);
 	}
 
-	async #discoverLmStudioModels(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
-		const baseUrl = this.#normalizeLmStudioBaseUrl(providerConfig.baseUrl);
+	async #discoverOpenAIModelsList(providerConfig: DiscoveryProviderConfig): Promise<Model<Api>[]> {
+		const baseUrl = this.#normalizeOpenAIModelsListBaseUrl(providerConfig.baseUrl);
 		const modelsUrl = `${baseUrl}/models`;
 
 		const headers: Record<string, string> = { ...(providerConfig.headers ?? {}) };
@@ -1777,7 +1785,7 @@ export class ModelRegistry {
 		}
 	}
 
-	#normalizeLmStudioBaseUrl(baseUrl?: string): string {
+	#normalizeOpenAIModelsListBaseUrl(baseUrl?: string): string {
 		const defaultBaseUrl = "http://127.0.0.1:1234/v1";
 		const raw = baseUrl || defaultBaseUrl;
 		try {

package/src/edit/file-read-cache.ts

@@ -0,0 +1,95 @@
+/**
+ * Per-session cache of file contents as they were rendered to the model by
+ * the `read` and `search` tools in the current agent session.
+ *
+ * Used by hashline-mode anchor-stale recovery: if the model authored anchors
+ * against a version of the file that no longer matches what is on disk —
+ * because a subagent, the user, a linter, or a formatter modified the file
+ * between the read and the edit — we replay the edits against the cached
+ * pre-edit snapshot and 3-way-merge the result onto the live file.
+ *
+ * Scoped per `ToolSession`: the cache lives on the session object itself, so
+ * different sessions never share snapshots and entries get reclaimed when
+ * the session goes out of scope. Each session keeps a small LRU window of
+ * paths; the cache always reflects what *this* session most recently saw,
+ * so it stays correct by construction even when this session writes the
+ * file itself — the next read after the write refreshes the entry.
+ */
+import { LRUCache } from "lru-cache/raw";
+import type { ToolSession } from "../tools";
+
+const MAX_PATHS_PER_SESSION = 30;
+
+export interface FileReadSnapshot {
+	/** 1-indexed line number → exact line content as observed by `read`/`search`. */
+	lines: Map<number, string>;
+	recordedAt: number;
+}
+
+export class FileReadCache {
+	#snapshots = new LRUCache<string, FileReadSnapshot>({ max: MAX_PATHS_PER_SESSION });
+
+	/** Look up the most recent snapshot for `absPath`, or `null` if absent. */
+	get(absPath: string): FileReadSnapshot | null {
+		return this.#snapshots.get(absPath) ?? null;
+	}
+
+	/** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
+	recordContiguous(absPath: string, startLine: number, lines: readonly string[]): void {
+		if (lines.length === 0) return;
+		const entries: Array<readonly [number, string]> = lines.map((line, idx) => [startLine + idx, line] as const);
+		this.#record(absPath, entries);
+	}
+
+	/** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
+	recordSparse(absPath: string, entries: Iterable<readonly [number, string]>): void {
+		const arr = Array.from(entries);
+		if (arr.length === 0) return;
+		this.#record(absPath, arr);
+	}
+
+	/** Drop the snapshot for a single path. */
+	invalidate(absPath: string): void {
+		this.#snapshots.delete(absPath);
+	}
+
+	/** Drop every snapshot. */
+	clear(): void {
+		this.#snapshots.clear();
+	}
+
+	#record(absPath: string, entries: ReadonlyArray<readonly [number, string]>): void {
+		const existing = this.#snapshots.get(absPath);
+		if (existing && hasConflict(existing.lines, entries)) {
+			// File content has changed since we last recorded. Drop the stale
+			// snapshot and start fresh with whatever we just observed.
+			this.#snapshots.set(absPath, { lines: new Map(entries), recordedAt: Date.now() });
+			return;
+		}
+		if (existing) {
+			for (const [lineNum, content] of entries) existing.lines.set(lineNum, content);
+			existing.recordedAt = Date.now();
+			// `get` above already touched LRU recency for this key.
+			return;
+		}
+		this.#snapshots.set(absPath, { lines: new Map(entries), recordedAt: Date.now() });
+	}
+}
+
+function hasConflict(existing: Map<number, string>, incoming: ReadonlyArray<readonly [number, string]>): boolean {
+	for (const [lineNum, content] of incoming) {
+		const prior = existing.get(lineNum);
+		if (prior !== undefined && prior !== content) return true;
+	}
+	return false;
+}
+
+/**
+ * Look up (or lazily create) the file-read cache attached to a session. The
+ * cache is stored as `session.fileReadCache` so it lives exactly as long as
+ * the session itself.
+ */
+export function getFileReadCache(session: ToolSession): FileReadCache {
+	if (!session.fileReadCache) session.fileReadCache = new FileReadCache();
+	return session.fileReadCache;
+}

package/src/edit/index.ts

@@ -33,6 +33,7 @@ import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, t
 export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/edit-mode";
 export * from "./apply-patch";
 export * from "./diff";
+export * from "./file-read-cache";
 export * from "./line-hash";
 
 // Resolve the `$HFMT$` and `$HSEP$` placeholders in the hashline Lark grammar.

package/src/edit/modes/hashline.ts

@@ -31,6 +31,7 @@ import * as path from "node:path";
 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 * as Diff from "diff";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import { assertEditableFileContent } from "../../tools/auto-generated-guard";
@@ -40,6 +41,7 @@ import { resolveToCwd } from "../../tools/path-utils";
 import { enforcePlanModeWrite, resolvePlanPath } from "../../tools/plan-mode-guard";
 import { formatCodeFrameLine } from "../../tools/render-utils";
 import { generateDiffString } from "../diff";
+import { type FileReadCache, getFileReadCache } from "../file-read-cache";
 import {
 	computeLineHash,
 	describeAnchorExamples,
@@ -1540,6 +1542,89 @@ export function applyHashlineEdits(
 	};
 }
 
+// ───────────────────────────────────────────────────────────────────────────
+// 11b. Anchor-stale recovery via cached read snapshots
+//
+// When `applyHashlineEdits` rejects because some anchors no longer match the
+// current on-disk content, the model may still have authored those anchors
+// against a real, valid version of the file — one that was just rendered to
+// it by the `read` or `search` tool, before something else (a subagent, a
+// linter, the user) modified the file out-of-band.
+//
+// The cache in `file-read-cache.ts` keeps a small LRU snapshot of those
+// rendered lines. We use it to reconstruct that "previous version", re-apply
+// the edits against it, and then 3-way-merge the resulting diff back onto
+// the live file. If the merge cleanly lands, that becomes our output. If
+// it doesn't (or the cache doesn't even cover the failing anchors), we
+// surface the original mismatch error so the model sees the truth.
+// ───────────────────────────────────────────────────────────────────────────
+
+export interface HashlineRecoveryArgs {
+	cache: FileReadCache;
+	absolutePath: string;
+	currentText: string;
+	edits: HashlineEdit[];
+	options: HashlineApplyOptions;
+}
+
+export interface HashlineRecoveryResult {
+	lines: string;
+	firstChangedLine: number | undefined;
+	warnings: string[];
+}
+
+const HASHLINE_RECOVERY_FUZZ_FACTOR = 3;
+
+const HASHLINE_RECOVERY_WARNING =
+	"Recovered from stale anchors using a previous read snapshot (file changed externally between read and edit).";
+
+/**
+ * Attempt to recover from a `HashlineMismatchError` by replaying the edits
+ * against a cached pre-edit snapshot of the file and 3-way-merging the result
+ * onto the current on-disk content. Returns `null` when no recovery is
+ * possible — callers should propagate the original mismatch error in that
+ * case.
+ */
+export function tryRecoverHashlineWithCache(args: HashlineRecoveryArgs): HashlineRecoveryResult | null {
+	const { cache, absolutePath, currentText, edits, options } = args;
+	const snapshot = cache.get(absolutePath);
+	if (!snapshot || snapshot.lines.size === 0) return null;
+
+	const overlaid = currentText.split("\n");
+	let maxCachedLine = 0;
+	for (const lineNum of snapshot.lines.keys()) {
+		if (lineNum > maxCachedLine) maxCachedLine = lineNum;
+	}
+	while (overlaid.length < maxCachedLine) overlaid.push("");
+	for (const [lineNum, content] of snapshot.lines) {
+		overlaid[lineNum - 1] = content;
+	}
+	const previousText = overlaid.join("\n");
+	if (previousText === currentText) return null;
+
+	let applied: HashlineApplyResult;
+	try {
+		applied = applyHashlineEdits(previousText, edits, options);
+	} catch (err) {
+		if (err instanceof HashlineMismatchError) return null;
+		throw err;
+	}
+	if (applied.lines === previousText) return null;
+
+	const patch = Diff.structuredPatch("file", "file", previousText, applied.lines, "", "", { context: 3 });
+	const merged = Diff.applyPatch(currentText, patch, { fuzzFactor: HASHLINE_RECOVERY_FUZZ_FACTOR });
+	if (typeof merged !== "string" || merged === currentText) return null;
+
+	const mergedDiff = generateDiffString(currentText, merged);
+	const recoveryWarnings = [HASHLINE_RECOVERY_WARNING, ...(applied.warnings ?? [])];
+
+	return {
+		lines: merged,
+		firstChangedLine: mergedDiff.firstChangedLine ?? applied.firstChangedLine,
+		warnings: recoveryWarnings,
+	};
+}
+
 // ───────────────────────────────────────────────────────────────────────────
 // 12. Input splitting
 //
@@ -1751,6 +1836,39 @@ function getEditDetails(result: AgentToolResult<EditToolDetails>): EditToolDetai
 	return result.details ?? { diff: "" };
 }
 
+/**
+ * Apply hashline edits with anchor-stale recovery: on `HashlineMismatchError`,
+ * consult the read-snapshot cache for the file and 3-way-merge the edits onto
+ * the current text. If recovery succeeds, return the merged result with a
+ * synthetic warning. Otherwise re-throw the original mismatch error.
+ */
+function applyHashlineEditsWithRecovery(
+	session: ToolSession,
+	absolutePath: string,
+	text: string,
+	edits: HashlineEdit[],
+	options: HashlineApplyOptions,
+): HashlineApplyResult {
+	try {
+		return applyHashlineEdits(text, edits, options);
+	} catch (err) {
+		if (!(err instanceof HashlineMismatchError)) throw err;
+		const recovered = tryRecoverHashlineWithCache({
+			cache: getFileReadCache(session),
+			absolutePath,
+			currentText: text,
+			edits,
+			options,
+		});
+		if (!recovered) throw err;
+		return {
+			lines: recovered.lines,
+			firstChangedLine: recovered.firstChangedLine,
+			warnings: recovered.warnings,
+		};
+	}
+}
+
 /**
  * Run all the front-end checks (notebook guard, parse, plan-mode check, file
  * load, edit application) without writing. Used to fail fast before applying
@@ -1769,7 +1887,13 @@ async function preflightHashlineSection(options: ExecuteHashlineSingleOptions &
 
 	const { text } = stripBom(source.rawContent);
 	const normalized = normalizeToLF(text);
-	const result = applyHashlineEdits(normalized, edits, getHashlineApplyOptions(session));
+	const result = applyHashlineEditsWithRecovery(
+		session,
+		absolutePath,
+		normalized,
+		edits,
+		getHashlineApplyOptions(session),
+	);
 	if (normalized === result.lines) throw new Error(formatNoChangeDiagnostic(sectionPath));
 }
 
@@ -1797,7 +1921,13 @@ async function executeHashlineSection(
 	const { bom, text } = stripBom(source.rawContent);
 	const originalEnding = detectLineEnding(text);
 	const originalNormalized = normalizeToLF(text);
-	const result = applyHashlineEdits(originalNormalized, edits, getHashlineApplyOptions(session));
+	const result = applyHashlineEditsWithRecovery(
+		session,
+		absolutePath,
+		originalNormalized,
+		edits,
+		getHashlineApplyOptions(session),
+	);
 
 	if (originalNormalized === result.lines) {
 		return {
@@ -1820,6 +1950,11 @@ async function executeHashlineSection(
 		dst => (dst === absolutePath ? beginDeferredDiagnosticsForPath(absolutePath) : undefined),
 	);
 	invalidateFsScanAfterWrite(absolutePath);
+	// The post-edit content is the freshest, most authoritative "model view"
+	// of the file: the model just received it back as the diff/preview. Cache
+	// it so a follow-up edit anchored against this state can still recover
+	// if the file is touched out-of-band before the next edit lands.
+	getFileReadCache(session).recordContiguous(absolutePath, 1, result.lines.split("\n"));
 
 	const diffResult = generateDiffString(originalNormalized, result.lines);
 	const meta = outputMeta()

package/src/extensibility/extensions/loader.ts

@@ -17,7 +17,9 @@ import type { ExecOptions } from "../../exec/exec";
 import { execCommand } from "../../exec/exec";
 import type { CustomMessage } from "../../session/messages";
 import { EventBus } from "../../utils/event-bus";
+import { installLegacyPiSpecifierShim } from "../plugins/legacy-pi-compat";
 import { getAllPluginExtensionPaths } from "../plugins/loader";
+
 import { resolvePath } from "../utils";
 import type {
 	Extension,
@@ -31,6 +33,8 @@ import type {
 	ToolDefinition,
 } from "./types";
 
+installLegacyPiSpecifierShim();
+
 type HandlerFn = (...args: unknown[]) => Promise<unknown>;
 
 export class ExtensionRuntimeNotInitializedError extends Error {
@@ -267,9 +271,8 @@ async function loadExtension(
 	runtime: IExtensionRuntime,
 ): Promise<{ extension: Extension | null; error: string | null }> {
 	const resolvedPath = resolvePath(extensionPath, cwd);
-
 	try {
-		const module = await import(resolvedPath);
+		const module = await import(`omp-legacy-pi-file:${resolvedPath}`);
 		const factory = (module.default ?? module) as ExtensionFactory;
 
 		if (typeof factory !== "function") {

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

@@ -0,0 +1,166 @@
+import * as path from "node:path";
+
+const LEGACY_PI_PACKAGE_MAP = {
+	"@mariozechner/pi-agent-core": "@oh-my-pi/pi-agent-core",
+	"@mariozechner/pi-ai": "@oh-my-pi/pi-ai",
+	"@mariozechner/pi-coding-agent": "@oh-my-pi/pi-coding-agent",
+	"@mariozechner/pi-tui": "@oh-my-pi/pi-tui",
+} as const;
+
+const LEGACY_PI_CODING_AGENT_SUBPATH_MAP = {
+	"extensibility/extensions": "@oh-my-pi/pi-coding-agent/extensibility/extensions",
+	"extensibility/hooks": "@oh-my-pi/pi-coding-agent/extensibility/hooks",
+} as const;
+
+const LEGACY_PI_SPECIFIER_FILTER = /^@mariozechner\/pi-(agent-core|ai|coding-agent|tui)(\/.*)?$/;
+const LEGACY_PI_IMPORT_SPECIFIER_REGEX =
+	/((?:from\s+|import\s*\(\s*)["'])(@mariozechner\/pi-(?:agent-core|ai|coding-agent|tui)(?:\/[^"'()\s]+)?)(["'])/g;
+const LEGACY_PI_FILE_PREFIX = "omp-legacy-pi-file:";
+const LEGACY_PI_FILE_NAMESPACE = "omp-legacy-pi-file";
+const resolvedSpecifierFallbacks = new Map<string, string>();
+
+let isLegacyPiSpecifierShimInstalled = false;
+
+function remapLegacyPiSpecifier(specifier: string): string | null {
+	const [legacyScope, packageName, ...subpathParts] = specifier.split("/");
+	const legacyPackageName = `${legacyScope}/${packageName}`;
+	const mappedPackageName = LEGACY_PI_PACKAGE_MAP[legacyPackageName as keyof typeof LEGACY_PI_PACKAGE_MAP];
+	if (!mappedPackageName) {
+		return null;
+	}
+	if (subpathParts.length === 0) {
+		return mappedPackageName;
+	}
+
+	const subpath = subpathParts.join("/");
+	if (legacyPackageName === "@mariozechner/pi-coding-agent") {
+		return (
+			LEGACY_PI_CODING_AGENT_SUBPATH_MAP[subpath as keyof typeof LEGACY_PI_CODING_AGENT_SUBPATH_MAP] ??
+			`${mappedPackageName}/${subpath}`
+		);
+	}
+
+	return `${mappedPackageName}/${subpath}`;
+}
+
+function getResolvedSpecifier(specifier: string): string {
+	const cached = resolvedSpecifierFallbacks.get(specifier);
+	if (cached) {
+		return cached;
+	}
+
+	const resolved = Bun.resolveSync(specifier, import.meta.dir);
+	resolvedSpecifierFallbacks.set(specifier, resolved);
+	return resolved;
+}
+
+function rewriteLegacyPiImports(source: string): string {
+	return source.replace(
+		LEGACY_PI_IMPORT_SPECIFIER_REGEX,
+		(match, prefix: string, specifier: string, suffix: string) => {
+			const remappedSpecifier = remapLegacyPiSpecifier(specifier);
+			if (!remappedSpecifier) {
+				return match;
+			}
+
+			return `${prefix}${getResolvedSpecifier(remappedSpecifier)}${suffix}`;
+		},
+	);
+}
+
+// Match `from "..."`, `from '...'`, `import("...")`, `import('...')` import specifiers.
+const ANY_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s*\(\s*)["'])([^"']+)(["'])/g;
+
+/**
+ * Resolves bare module specifiers in a legacy-namespaced extension source file
+ * to absolute paths anchored at the extension's own directory. Without this,
+ * imports inside files loaded via the `omp-legacy-pi-file:` namespace bypass
+ * Node-style node_modules lookup, so an extension cannot use its own deps.
+ * Relative paths and already-resolved absolute paths are left untouched.
+ */
+function rewriteBareImportsForLegacyExtension(source: string, importerPath: string): string {
+	const importerDir = path.dirname(importerPath);
+	return source.replace(ANY_IMPORT_SPECIFIER_REGEX, (match, prefix: string, specifier: string, suffix: string) => {
+		// Skip relative, absolute, URL-style, and already-resolved Node specifiers.
+		if (
+			specifier.startsWith(".") ||
+			specifier.startsWith("/") ||
+			specifier.startsWith("node:") ||
+			specifier.includes("://")
+		) {
+			return match;
+		}
+		try {
+			const resolved = Bun.resolveSync(specifier, importerDir);
+			return `${prefix}${resolved}${suffix}`;
+		} catch {
+			return match;
+		}
+	});
+}
+
+function getLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
+	if (path.endsWith(".tsx")) {
+		return "tsx";
+	}
+	if (path.endsWith(".jsx")) {
+		return "jsx";
+	}
+	if (path.endsWith(".ts") || path.endsWith(".mts") || path.endsWith(".cts")) {
+		return "ts";
+	}
+	return "js";
+}
+
+function resolveLegacyPiSpecifier(args: { path: string }): { path: string } | undefined {
+	const remappedSpecifier = remapLegacyPiSpecifier(args.path);
+	if (!remappedSpecifier) {
+		return undefined;
+	}
+
+	return {
+		path: getResolvedSpecifier(remappedSpecifier),
+	};
+}
+
+export function installLegacyPiSpecifierShim(): void {
+	if (isLegacyPiSpecifierShimInstalled) {
+		return;
+	}
+	isLegacyPiSpecifierShimInstalled = true;
+
+	Bun.plugin({
+		name: "omp:legacy-pi-shim",
+		setup(build) {
+			build.onResolve({ filter: LEGACY_PI_SPECIFIER_FILTER, namespace: "file" }, resolveLegacyPiSpecifier);
+			build.onResolve(
+				{ filter: LEGACY_PI_SPECIFIER_FILTER, namespace: LEGACY_PI_FILE_NAMESPACE },
+				resolveLegacyPiSpecifier,
+			);
+
+			build.onResolve({ filter: /^omp-legacy-pi-file:/, namespace: "file" }, args => ({
+				path: args.path.slice(LEGACY_PI_FILE_PREFIX.length),
+				namespace: LEGACY_PI_FILE_NAMESPACE,
+			}));
+
+			build.onResolve({ filter: /^(?:\.{1,2}\/|\/)/, namespace: LEGACY_PI_FILE_NAMESPACE }, args => ({
+				path: args.path.startsWith("/") ? args.path : Bun.resolveSync(args.path, path.dirname(args.importer)),
+				namespace: LEGACY_PI_FILE_NAMESPACE,
+			}));
+
+			build.onLoad({ filter: /\.[cm]?[jt]sx?$/, namespace: LEGACY_PI_FILE_NAMESPACE }, async args => {
+				const raw = await Bun.file(args.path).text();
+				// Bare specifiers (e.g. "lodash", "@scope/pkg/sub") imported from a legacy-namespaced
+				// extension file would otherwise bypass Node-style node_modules lookup because the
+				// importer lives in a custom namespace. Pre-resolve them to absolute paths so the
+				// extension's own node_modules are honored.
+				const withLegacyRemap = rewriteLegacyPiImports(raw);
+				const withBareResolved = rewriteBareImportsForLegacyExtension(withLegacyRemap, args.path);
+				return {
+					contents: withBareResolved,
+					loader: getLoader(args.path),
+				};
+			});
+		},
+	});
+}

package/src/extensibility/plugins/loader.ts

@@ -8,8 +8,11 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getPluginsLockfile, getPluginsNodeModules, getPluginsPackageJson, isEnoent } from "@oh-my-pi/pi-utils";
 import { getConfigDirPaths } from "../../config";
+import { installLegacyPiSpecifierShim } from "./legacy-pi-compat";
 import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
 
+installLegacyPiSpecifierShim();
+
 // =============================================================================
 // Runtime Config Loading
 // =============================================================================
@@ -41,11 +44,6 @@ async function loadProjectOverrides(cwd: string): Promise<ProjectPluginOverrides
 	}
 	return {};
 }
-
-// =============================================================================
-// Plugin Discovery
-// =============================================================================
-
 /**
  * Get list of enabled plugins with their resolved configurations.
  * Respects both global runtime config and project overrides.
@@ -69,7 +67,6 @@ export async function getEnabledPlugins(cwd: string): Promise<InstalledPlugin[]>
 	const runtimeConfig = await loadRuntimeConfig();
 	const projectOverrides = await loadProjectOverrides(cwd);
 	const plugins: InstalledPlugin[] = [];
-
 	for (const [name] of Object.entries(deps)) {
 		const pluginPkgPath = path.join(nodeModulesPath, name, "package.json");
 		let pluginPkg: { version: string; omp?: PluginManifest; pi?: PluginManifest };
@@ -103,7 +100,6 @@ export async function getEnabledPlugins(cwd: string): Promise<InstalledPlugin[]>
 
 		// Resolve enabled features (project overrides take precedence)
 		const enabledFeatures = projectOverrides.features?.[name] ?? runtimeState?.enabledFeatures ?? null;
-
 		plugins.push({
 			name,
 			version: pluginPkg.version,