@prometheus-ai/agent 0.5.4 → 0.5.8

package/src/extensibility/hooks/types.ts

@@ -1,8 +1,11 @@
 import type { ImageContent, Message, Model, TextContent } from "@prometheus-ai/ai";
 import type { Component, TUI } from "@prometheus-ai/tui";
+import type { logger as PiLogger } from "@prometheus-ai/utils";
+import type { z } from "zod/v4";
 import type { ModelRegistry } from "../../config/model-registry";
 import type { EditToolDetails } from "../../edit";
 import type { ExecOptions, ExecResult } from "../../exec/exec";
+import type * as PiCodingAgent from "../../index";
 import type { Theme } from "../../modes/theme/theme";
 import type { HookMessage } from "../../session/messages";
 import type { ReadonlySessionManager, SessionManager } from "../../session/session-manager";
@@ -39,6 +42,7 @@ import type {
 	TurnEndEvent,
 	TurnStartEvent,
 } from "../shared-events";
+import type * as TypeBox from "../typebox";
 
 // Re-export for backward compatibility
 export type { ExecOptions, ExecResult } from "../../exec/exec";
@@ -577,13 +581,15 @@ export interface HookAPI {
 	exec(command: string, args: string[], options?: ExecOptions): Promise<ExecResult>;
 
 	/** File logger for error/warning/debug messages */
-	logger: typeof import("@prometheus-ai/utils").logger;
+	logger: typeof PiLogger;
 	/** Injected zod-backed typebox shim (legacy/compat — prefer `zod`). */
-	typebox: typeof import("../typebox");
+	typebox: typeof TypeBox;
 	/** Injected zod module for Zod-authored hooks. */
-	zod: typeof import("zod/v4");
-	/** Injected coding-agent exports */
-	pi: typeof import("../..");
+	zod: typeof z;
+	/** Injected Prometheus coding agent exports */
+	prometheus: typeof PiCodingAgent;
+	/** Legacy alias for injected Prometheus coding agent exports */
+	pi: typeof PiCodingAgent;
 }
 
 /**

package/src/extensibility/{legacy-pi-ai-shim.ts → legacy-package-ai-shim.ts}

@@ -6,9 +6,9 @@
  * 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
+ * `Type.Object({ ... })`, so this file is served by `legacy-package-compat.ts` in
  * place of the real pi-ai entrypoint whenever a legacy extension imports the
- * bare package root. Subpath imports (`@prometheus-ai/ai/utils/oauth`, etc.)
+ * bare package root. Subpath imports (`@prometheus-ai/ai/oauth`, etc.)
  * continue to resolve directly against the bundled pi-ai package.
  *
  * The `Type` runtime is borrowed from the Zod-backed TypeBox shim that

package/src/extensibility/plugins/doctor.ts

@@ -25,7 +25,6 @@ export async function runDoctorChecks(): Promise<DoctorCheck[]> {
 	const apiKeys = [
 		{ name: "ANTHROPIC_API_KEY", description: "Anthropic API" },
 		{ name: "OPENAI_API_KEY", description: "OpenAI API" },
-		{ name: "PERPLEXITY_API_KEY", description: "Perplexity search" },
 		{ name: "EXA_API_KEY", description: "Exa search" },
 	];
 
@@ -49,7 +48,7 @@ export function formatDoctorResults(checks: DoctorCheck[]): string {
 	for (const check of checks) {
 		const icon =
 			check.status === "ok"
-				? theme.status.success
+				? theme.status.enabled
 				: check.status === "warning"
 					? theme.status.warning
 					: theme.status.error;

package/src/extensibility/plugins/installer.ts

@@ -75,7 +75,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 		name: pkg.name,
 		version: pkg.version,
 		path: path.join(PLUGINS_DIR, "node_modules", actualName),
-		manifest: pkg.prometheus || pkg.pi || { version: pkg.version },
+		manifest: pkg.prometheus || { version: pkg.version },
 		enabledFeatures: null,
 		enabled: true,
 	};
@@ -120,7 +120,7 @@ export async function listPlugins(): Promise<InstalledPlugin[]> {
 				name,
 				version: pkg.version,
 				path: pluginPath,
-				manifest: pkg.prometheus || pkg.pi || { version: pkg.version },
+				manifest: pkg.prometheus || { version: pkg.version },
 				enabledFeatures: null,
 				enabled: true,
 			});

package/src/extensibility/plugins/{legacy-pi-compat.ts → legacy-package-compat.ts}

@@ -1,60 +1,97 @@
-import * as fs from "node:fs/promises";
+import * as fs from "node:fs";
 import * as path from "node:path";
 import * as url from "node:url";
 import { isCompiledBinary } from "@prometheus-ai/utils";
 
 const IS_COMPILED_BINARY = isCompiledBinary();
 
-// Canonical scope for in-process Prometheus packages. Plugins published against any of
-// the aliased scopes below (mariozechner's original publish, earendil-works'
-// fork, or the canonical @prometheus-ai scope itself) are remapped to this scope and
-// resolved against the bundled copy that ships inside the Prometheus binary. This
+// Canonical scope for in-process Prometheus packages. Plugins published against
+// historical pi package scopes are remapped to this scope and resolved against
+// the bundled copy that ships inside the prometheus binary. This
 // keeps plugins running against the exact runtime state of the host (single
 // module registry, single tool registry, etc.) regardless of which historical
 // scope name they happened to declare in their peerDependencies.
-const CANONICAL_PROMETHEUS_SCOPE = "@prometheus-ai";
+const CANONICAL_PACKAGE_SCOPE = "@prometheus-ai";
 
 // Scopes that have historically been used to publish (or alias) the same set
-// of internal packages. `@prometheus-ai` is intentionally included so direct
-// canonical imports still pass through the same host-bundled package resolution
+// of internal pi-* packages. `@prometheus-ai` is intentionally included so
+// direct imports of old pi package basenames still pass through host resolution
 // path instead of pulling a duplicate copy from plugin node_modules.
-const PROMETHEUS_SCOPE_ALIASES = ["prometheus-ai", "prometheus", "mariozechner", "earendil-works"] as const;
-
-const LEGACY_PI_PACKAGE_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
+const LEGACY_PACKAGE_SCOPE_ALIASES = ["prometheus-ai", "Prometheus", "mariozechner", "earendil-works"] as const;
+
+// Internal pi-* package basenames and their canonical Prometheus package
+// basenames bundled inside the prometheus binary.
+const LEGACY_PACKAGE_NAMES = [
+	"pi-agent-core",
+	"agent-core",
+	"pi-ai",
+	"ai",
+	"pi-coding-agent",
+	"agent",
+	"prometheus-natives",
+	"natives",
+	"pi-tui",
+	"tui",
+	"pi-utils",
+	"utils",
+] as const;
+
+const LEGACY_PACKAGE_NAME_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
 	["pi-agent-core", "agent-core"],
+	["agent-core", "agent-core"],
 	["pi-ai", "ai"],
+	["ai", "ai"],
 	["pi-coding-agent", "agent"],
-	["pi-natives", "natives"],
+	["agent", "agent"],
 	["prometheus-natives", "natives"],
+	["natives", "natives"],
 	["pi-tui", "tui"],
+	["tui", "tui"],
 	["pi-utils", "utils"],
+	["utils", "utils"],
 ]);
 
-// Internal package basenames bundled inside the Prometheus binary.
-const PROMETHEUS_PACKAGE_NAMES = ["agent-core", "ai", "agent", "natives", "tui", "utils"] as const;
-const LEGACY_PI_PACKAGE_NAMES = [...LEGACY_PI_PACKAGE_REMAPS.keys()] as const;
-
-const PROMETHEUS_SCOPE_ALTERNATION = PROMETHEUS_SCOPE_ALIASES.join("|");
-const PROMETHEUS_PACKAGE_ALTERNATION = [...PROMETHEUS_PACKAGE_NAMES, ...LEGACY_PI_PACKAGE_NAMES].join("|");
+const LEGACY_PACKAGE_SCOPE_ALTERNATION = LEGACY_PACKAGE_SCOPE_ALIASES.join("|");
+const LEGACY_PACKAGE_ALTERNATION = LEGACY_PACKAGE_NAMES.join("|");
 
 // Upstream `@mariozechner/*` packages exposed a few subpaths at the package
 // root that we relocated under a different folder. Each entry rewrites
-// `<pkg>/<from>` -> `<pkg>/<to>` after the scope has been canonicalised, so
+// `<pkg>/<from>` → `<pkg>/<to>` after the scope has been canonicalised, so
 // plugins importing the upstream layout still resolve to a real file in our
-// bundled copy. Add new entries as `pkg/from -> pkg/to` whenever a plugin
-// surfaces another upstream-only subpath that breaks resolution.
-const PROMETHEUS_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
-	// `@mariozechner/pi-ai/oauth` re-exported `./utils/oauth/index.js`.
-	// Prometheus keeps the implementation under `ai/utils/oauth` but never added a
-	// root-level re-export, so map the upstream subpath onto it directly.
-	["pi-ai/oauth", "ai/utils/oauth"],
+// bundled copy. Entries ending in `/` rewrite the whole subtree; add new
+// `pkg/from -> pkg/to` pairs whenever an upstream-only subpath breaks resolution.
+const LEGACY_PACKAGE_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
+	["pi-ai/utils/oauth", "pi-ai/oauth"],
+	["pi-ai/utils/oauth/", "pi-ai/oauth/"],
 ]);
 
-const LEGACY_PI_SPECIFIER_FILTER = new RegExp(
-	`^@(?:${PROMETHEUS_SCOPE_ALTERNATION})/(?:${PROMETHEUS_PACKAGE_ALTERNATION})(?:/.*)?$`,
+function remapLegacyPackageSubpath(rest: string): string {
+	const exact = LEGACY_PACKAGE_SUBPATH_REMAPS.get(rest);
+	if (exact) {
+		return remapLegacyPackagePackageName(exact);
+	}
+
+	for (const [from, to] of LEGACY_PACKAGE_SUBPATH_REMAPS) {
+		if (from.endsWith("/") && rest.startsWith(from)) {
+			return remapLegacyPackagePackageName(`${to}${rest.slice(from.length)}`);
+		}
+	}
+
+	return remapLegacyPackagePackageName(rest);
+}
+
+function remapLegacyPackagePackageName(rest: string): string {
+	const slashIndex = rest.indexOf("/");
+	const packageName = slashIndex === -1 ? rest : rest.slice(0, slashIndex);
+	const suffix = slashIndex === -1 ? "" : rest.slice(slashIndex);
+	return `${LEGACY_PACKAGE_NAME_REMAPS.get(packageName) ?? packageName}${suffix}`;
+}
+
+const LEGACY_PACKAGE_SPECIFIER_FILTER = new RegExp(
+	`^@(?:${LEGACY_PACKAGE_SCOPE_ALTERNATION})/(?:${LEGACY_PACKAGE_ALTERNATION})(?:/.*)?$`,
 );
-const LEGACY_PI_IMPORT_SPECIFIER_REGEX = new RegExp(
-	`((?:from\\s+|import\\s+|import\\s*\\(\\s*)["'])(@(?:${PROMETHEUS_SCOPE_ALTERNATION})/(?:${PROMETHEUS_PACKAGE_ALTERNATION})(?:/[^"'()\\s]+)?)(["'])`,
+const LEGACY_PACKAGE_IMPORT_SPECIFIER_REGEX = new RegExp(
+	`((?:from\\s+|import\\s+|import\\s*\\(\\s*)["'])(@(?:${LEGACY_PACKAGE_SCOPE_ALTERNATION})/(?:${LEGACY_PACKAGE_ALTERNATION})(?:/[^"'()\\s]+)?)(["'])`,
 	"g",
 );
 const resolvedSpecifierFallbacks = new Map<string, string>();
@@ -113,6 +150,28 @@ export function __computeBunfsPackageRoot(metaDir: string, pathImpl: typeof path
 	return pathImpl.join(metaDir, "packages");
 }
 
+/**
+ * Compute the package root for the npm prebuilt `dist/cli.js` bundle.
+ *
+ * `bundle-dist.ts` defines `process.env.PROMETHEUS_BUNDLED="true"`; after bundling,
+ * `import.meta.dir` points at `<package>/dist`. Do not resolve the package via
+ * bare `@prometheus-ai/agent` here: from a global install Bun can pick an
+ * older cache entry, recreating mixed-runtime plugin loading.
+ */
+export function __computeBundledSelfPackageRoot(metaDir: string, pathImpl: typeof path = path): string {
+	const normalizedMetaDir = pathImpl.normalize(metaDir);
+	if (pathImpl.basename(normalizedMetaDir) === "dist") {
+		return pathImpl.resolve(metaDir, "..");
+	}
+
+	const pluginsDirSuffix = pathImpl.join("src", "extensibility", "plugins");
+	if (normalizedMetaDir.endsWith(pluginsDirSuffix)) {
+		return pathImpl.resolve(metaDir, "..", "..", "..");
+	}
+
+	return pathImpl.resolve(metaDir);
+}
+
 const BUNFS_PACKAGE_ROOT = IS_COMPILED_BINARY ? __computeBunfsPackageRoot(import.meta.dir) : null;
 
 function bunfsPath(...segments: string[]): string {
@@ -122,9 +181,22 @@ function bunfsPath(...segments: string[]): string {
 	return path.join(BUNFS_PACKAGE_ROOT, ...segments);
 }
 
+function resolveBundledSelfPackageRoot(): string | undefined {
+	if (!process.env.PROMETHEUS_BUNDLED) return undefined;
+	return __computeBundledSelfPackageRoot(import.meta.dir);
+}
+
+const BUNDLED_SELF_PACKAGE_ROOT = resolveBundledSelfPackageRoot();
+
+function sourceShimPath(file: string): string {
+	return BUNDLED_SELF_PACKAGE_ROOT
+		? path.join(BUNDLED_SELF_PACKAGE_ROOT, "src", "extensibility", file)
+		: path.resolve(import.meta.dir, "..", file);
+}
+
 const TYPEBOX_SHIM_PATH = BUNFS_PACKAGE_ROOT
 	? bunfsPath("coding-agent", "src", "extensibility", "typebox.js")
-	: path.resolve(import.meta.dir, "../typebox.ts");
+	: sourceShimPath("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`
@@ -132,20 +204,20 @@ const TYPEBOX_SHIM_PATH = BUNFS_PACKAGE_ROOT
 // 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 `@prometheus-ai/ai/utils/oauth` continue to resolve directly
+// imports such as `@prometheus-ai/ai/oauth` continue to resolve directly
 // against the bundled pi-ai package.
-const LEGACY_PI_AI_SHIM_PATH = BUNFS_PACKAGE_ROOT
-	? bunfsPath("coding-agent", "src", "extensibility", "legacy-pi-ai-shim.js")
-	: path.resolve(import.meta.dir, "../legacy-pi-ai-shim.ts");
+const LEGACY_PACKAGE_AI_SHIM_PATH = BUNFS_PACKAGE_ROOT
+	? bunfsPath("coding-agent", "src", "extensibility", "legacy-package-ai-shim.js")
+	: sourceShimPath("legacy-package-ai-shim.ts");
 
 // The coding-agent's own `./src/index.ts` cannot be listed as an extra
 // `bun --compile` entrypoint alongside the CLI entry without breaking binary
 // startup (issue #1474 follow-up). Legacy `@(scope)/pi-coding-agent` root
 // imports therefore resolve through a sibling shim whose distinct file path
 // avoids that collision while re-exporting the canonical package surface.
-const LEGACY_PI_CODING_AGENT_SHIM_PATH = BUNFS_PACKAGE_ROOT
-	? bunfsPath("coding-agent", "src", "extensibility", "legacy-pi-coding-agent-shim.js")
-	: path.resolve(import.meta.dir, "../legacy-pi-coding-agent-shim.ts");
+const LEGACY_PACKAGE_CODING_AGENT_SHIM_PATH = BUNFS_PACKAGE_ROOT
+	? bunfsPath("coding-agent", "src", "extensibility", "legacy-package-agent-shim.js")
+	: sourceShimPath("legacy-package-agent-shim.ts");
 
 // Package-root overrides. Shim entries are always applied because they replace
 // (or augment) the canonical surface even in non-compiled installs. The bunfs
@@ -154,23 +226,47 @@ const LEGACY_PI_CODING_AGENT_SHIM_PATH = BUNFS_PACKAGE_ROOT
 // `Bun.resolveSync`, and hardcoding a relative source-tree path would break
 // installs where the bundled packages live at `node_modules/@prometheus-ai/*`
 // rather than `packages/*`.
-const LEGACY_PI_PACKAGE_ROOT_OVERRIDES: Record<string, string> = {
-	[`${CANONICAL_PROMETHEUS_SCOPE}/ai`]: LEGACY_PI_AI_SHIM_PATH,
-	[`${CANONICAL_PROMETHEUS_SCOPE}/agent`]: LEGACY_PI_CODING_AGENT_SHIM_PATH,
+//
+// Every override target is validated against the on-disk filesystem at module
+// init: any entry whose file is missing (e.g. a compiled binary where Bun's
+// `--compile` quietly dropped an additional entrypoint — issue #2168) is left
+// out so `resolveCanonicalPiSpecifier` falls through to `getResolvedSpecifier`,
+// which throws under bunfs and triggers the catch in `rewriteLegacyPackageImports`.
+// That catch leaves the specifier untouched so Bun resolves the canonical
+// `@prometheus-ai/*` import from the extension's own `node_modules` instead of
+// emitting a bunfs `file://` URL to a module that isn't actually present.
+
+/**
+ * Drop overrides whose targets are missing on disk so they can fall through to
+ * the canonical-resolution path. Exported for the test seam in #2168.
+ *
+ * `pathExistsSync` defaults to `fs.existsSync`; the tests inject a stub to
+ * simulate the missing-entrypoint failure mode without touching the real FS.
+ */
+export function __validateLegacyPackagePackageRootOverrides(
+	candidates: Record<string, string>,
+	pathExistsSync: (p: string) => boolean = fs.existsSync,
+): Record<string, string> {
+	return Object.fromEntries(Object.entries(candidates).filter(([, candidate]) => pathExistsSync(candidate)));
+}
+
+const LEGACY_PACKAGE_PACKAGE_ROOT_OVERRIDES = __validateLegacyPackagePackageRootOverrides({
+	[`${CANONICAL_PACKAGE_SCOPE}/ai`]: LEGACY_PACKAGE_AI_SHIM_PATH,
+	[`${CANONICAL_PACKAGE_SCOPE}/agent`]: LEGACY_PACKAGE_CODING_AGENT_SHIM_PATH,
 	...(BUNFS_PACKAGE_ROOT
 		? {
-				[`${CANONICAL_PROMETHEUS_SCOPE}/agent-core`]: bunfsPath("agent", "src", "index.js"),
-				[`${CANONICAL_PROMETHEUS_SCOPE}/natives`]: bunfsPath("natives", "native", "index.js"),
-				[`${CANONICAL_PROMETHEUS_SCOPE}/tui`]: bunfsPath("tui", "src", "index.js"),
-				[`${CANONICAL_PROMETHEUS_SCOPE}/utils`]: bunfsPath("utils", "src", "index.js"),
+				[`${CANONICAL_PACKAGE_SCOPE}/agent-core`]: bunfsPath("agent", "src", "index.js"),
+				[`${CANONICAL_PACKAGE_SCOPE}/natives`]: bunfsPath("natives", "native", "index.js"),
+				[`${CANONICAL_PACKAGE_SCOPE}/tui`]: bunfsPath("tui", "src", "index.js"),
+				[`${CANONICAL_PACKAGE_SCOPE}/utils`]: bunfsPath("utils", "src", "index.js"),
 			}
 		: {}),
-};
+});
 
-let isLegacyPiSpecifierShimInstalled = false;
+let isLegacyPackageSpecifierShimInstalled = false;
 
-function remapLegacyPiSpecifier(specifier: string): string | null {
-	if (!LEGACY_PI_SPECIFIER_FILTER.test(specifier)) {
+function remapLegacyPackageSpecifier(specifier: string): string | null {
+	if (!LEGACY_PACKAGE_SPECIFIER_FILTER.test(specifier)) {
 		return null;
 	}
 	const slashIdx = specifier.indexOf("/", 1);
@@ -179,16 +275,8 @@ function remapLegacyPiSpecifier(specifier: string): string | null {
 		return null;
 	}
 	const rest = specifier.slice(slashIdx + 1);
-	const remappedSubpath = PROMETHEUS_SUBPATH_REMAPS.get(rest);
-	if (remappedSubpath) {
-		return `${CANONICAL_PROMETHEUS_SCOPE}/${remappedSubpath}`;
-	}
-
-	const subpathIdx = rest.indexOf("/");
-	const packageName = subpathIdx === -1 ? rest : rest.slice(0, subpathIdx);
-	const packageSubpath = subpathIdx === -1 ? "" : rest.slice(subpathIdx);
-	const canonicalPackageName = LEGACY_PI_PACKAGE_REMAPS.get(packageName) ?? packageName;
-	return `${CANONICAL_PROMETHEUS_SCOPE}/${canonicalPackageName}${packageSubpath}`;
+	const remappedSubpath = remapLegacyPackageSubpath(rest);
+	return `${CANONICAL_PACKAGE_SCOPE}/${remappedSubpath}`;
 }
 
 function getResolvedSpecifier(specifier: string): string {
@@ -211,7 +299,7 @@ function getResolvedSpecifier(specifier: string): string {
  * specifiers.
  */
 function resolveCanonicalPiSpecifier(remappedSpecifier: string): string {
-	const override = LEGACY_PI_PACKAGE_ROOT_OVERRIDES[remappedSpecifier];
+	const override = LEGACY_PACKAGE_PACKAGE_ROOT_OVERRIDES[remappedSpecifier];
 	if (override) {
 		return override;
 	}
@@ -222,11 +310,11 @@ function toImportSpecifier(resolvedPath: string): string {
 	return url.pathToFileURL(resolvedPath).href;
 }
 
-function rewriteLegacyPiImports(source: string): string {
+function rewriteLegacyPackageImports(source: string): string {
 	return source.replace(
-		LEGACY_PI_IMPORT_SPECIFIER_REGEX,
+		LEGACY_PACKAGE_IMPORT_SPECIFIER_REGEX,
 		(match, prefix: string, specifier: string, suffix: string) => {
-			const remappedSpecifier = remapLegacyPiSpecifier(specifier);
+			const remappedSpecifier = remapLegacyPackageSpecifier(specifier);
 			if (!remappedSpecifier) {
 				return match;
 			}
@@ -257,7 +345,7 @@ const TYPEBOX_IMPORT_SPECIFIER_REGEX = /((?:from\s+|import\s+|import\s*\(\s*)["'
  * natively from the extension's real on-disk location.
  */
 async function rewriteLegacyExtensionSource(source: string, importerPath: string): Promise<string> {
-	const withPi = rewriteLegacyPiImports(source);
+	const withPi = rewriteLegacyPackageImports(source);
 	const withTypeBox = withPi.replace(
 		TYPEBOX_IMPORT_SPECIFIER_REGEX,
 		(_match, prefix: string, _specifier: string, suffix: string) => {
@@ -273,7 +361,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 
 async function pathExists(p: string): Promise<boolean> {
 	try {
-		await fs.stat(p);
+		await fs.promises.stat(p);
 		return true;
 	} catch {
 		return false;
@@ -287,7 +375,7 @@ function hasSourceModuleExtension(p: string): boolean {
 
 async function resolveSourceModuleFile(basePath: string): Promise<string | null> {
 	try {
-		const stats = await fs.stat(basePath);
+		const stats = await fs.promises.stat(basePath);
 		if (stats.isFile()) {
 			// Non-source files (JSON, WASM, text assets, etc.) bypass the on-load
 			// rewrite hook so Bun's native loaders handle them; our hook would
@@ -495,7 +583,7 @@ const hookedExtensionEntries = new Set<string>();
 /** Resolve symlinks in a path, falling back to the input if realpath fails. */
 async function realpathOrSelf(p: string): Promise<string> {
 	try {
-		return await fs.realpath(p);
+		return await fs.promises.realpath(p);
 	} catch {
 		return p;
 	}
@@ -562,7 +650,7 @@ async function ensureExtensionGraphHook(entryRealPath: string): Promise<void> {
 	const alternation = [...modules].map(escapeRegExp).join("|");
 	const filter = new RegExp(`^(?:${alternation})$`);
 	Bun.plugin({
-		name: `prometheus:legacy-pi-ext:${Bun.hash(entryRealPath).toString(36)}`,
+		name: `prometheus:legacy-package-ext:${Bun.hash(entryRealPath).toString(36)}`,
 		setup(build) {
 			build.onLoad({ filter, namespace: "file" }, async args => {
 				const raw = await Bun.file(args.path).text();
@@ -582,7 +670,7 @@ async function ensureExtensionGraphHook(entryRealPath: string): Promise<void> {
  * entry's source graph rewrites only host-resolved compatibility imports in the
  * extension's own source; everything else resolves natively.
  */
-export async function loadLegacyPiModule(resolvedPath: string): Promise<unknown> {
+export async function loadLegacyPackageModule(resolvedPath: string): Promise<unknown> {
 	// Bun reports the realpath of a loaded module to `onLoad` and exposes it as
 	// `import.meta.url`. Resolve symlinks here too (macOS `/var`→`/private/var`,
 	// `bun link`/pnpm installs) so the rewrite filter matches the path Bun
@@ -606,8 +694,8 @@ function getLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
 	return "js";
 }
 
-function resolveLegacyPiSpecifier(args: { path: string; importer: string }): { path: string } | undefined {
-	const remappedSpecifier = remapLegacyPiSpecifier(args.path);
+function resolveLegacyPackageSpecifier(args: { path: string; importer: string }): { path: string } | undefined {
+	const remappedSpecifier = remapLegacyPackageSpecifier(args.path);
 	if (!remappedSpecifier) {
 		return undefined;
 	}
@@ -640,22 +728,22 @@ function resolveTypeBoxSpecifier(): { path: string } {
 	return { path: TYPEBOX_SHIM_PATH };
 }
 
-export function installLegacyPiSpecifierShim(): void {
-	if (isLegacyPiSpecifierShimInstalled) {
+export function installLegacyPackageSpecifierShim(): void {
+	if (isLegacyPackageSpecifierShimInstalled) {
 		return;
 	}
-	isLegacyPiSpecifierShimInstalled = true;
+	isLegacyPackageSpecifierShimInstalled = true;
 
 	Bun.plugin({
-		name: "prometheus:legacy-pi-shim",
+		name: "prometheus:legacy-package-shim",
 		setup(build) {
-			build.onResolve({ filter: LEGACY_PI_SPECIFIER_FILTER, namespace: "file" }, resolveLegacyPiSpecifier);
+			build.onResolve({ filter: LEGACY_PACKAGE_SPECIFIER_FILTER, namespace: "file" }, resolveLegacyPackageSpecifier);
 			build.onResolve({ filter: TYPEBOX_SPECIFIER_FILTER, namespace: "file" }, resolveTypeBoxSpecifier);
 		},
 	});
 }
 
 /** Test seam: clears the memoized canonical specifier resolutions. */
-export function __resetLegacyPiResolutionCache(): void {
+export function __resetLegacyPackageResolutionCache(): void {
 	resolvedSpecifierFallbacks.clear();
 }

package/src/extensibility/plugins/loader.ts

@@ -8,10 +8,10 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getPluginsLockfile, getPluginsNodeModules, getPluginsPackageJson, isEnoent } from "@prometheus-ai/utils";
 import { getConfigDirPaths } from "../../config";
-import { installLegacyPiSpecifierShim } from "./legacy-pi-compat";
+import { installLegacyPackageSpecifierShim } from "./legacy-package-compat";
 import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
 
-installLegacyPiSpecifierShim();
+installLegacyPackageSpecifierShim();
 
 // =============================================================================
 // Runtime Config Loading
@@ -36,7 +36,7 @@ async function loadRuntimeConfig(home?: string): Promise<PluginRuntimeConfig> {
 }
 
 /**
- * Load project-local plugin overrides from Prometheus and compatibility config directories.
+ * Load project-local plugin overrides (checks .prometheus and .prometheus directories).
  */
 async function loadProjectOverrides(cwd: string): Promise<ProjectPluginOverrides> {
 	for (const overridesPath of getConfigDirPaths("plugin-overrides.json", { user: false, cwd })) {
@@ -104,7 +104,7 @@ export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {
 			throw err;
 		}
 
-		const manifest: PluginManifest | undefined = pluginPkg.prometheus || pluginPkg.pi;
+		const manifest: PluginManifest | undefined = pluginPkg.prometheus ?? pluginPkg.pi;
 		if (!manifest) {
 			// Not a Prometheus plugin, skip
 			continue;
@@ -172,34 +172,49 @@ function resolveManifestEntryFile(joined: string): string | null {
  * Handles both single-string and string[] base entries, plus feature-specific entries.
  */
 function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "commands" | "extensions"): string[] {
-	const paths: string[] = [];
+	const resolved: string[] = [];
+	for (const entry of resolvePluginManifestEntries(plugin, key)) {
+		if (entry.resolvedPath) {
+			resolved.push(entry.resolvedPath);
+		}
+	}
+	return resolved;
+}
+
+/**
+ * Declared manifest entries paired with their resolved file path. Returns one
+ * record per declared entry — base entries first, then enabled-feature entries
+ * — so callers (e.g. install-time validation) can detect manifest entries that
+ * point at missing files instead of silently skipping them like
+ * {@link resolvePluginPaths} does.
+ */
+export function resolvePluginManifestEntries(
+	plugin: InstalledPlugin,
+	key: "tools" | "hooks" | "commands" | "extensions",
+): Array<{ entry: string; resolvedPath: string | null }> {
+	const declared: Array<{ entry: string; resolvedPath: string | null }> = [];
 	const manifest = plugin.manifest;
 
-	// Base entry (always included if exists)
+	const resolveEntry = (entry: string): { entry: string; resolvedPath: string | null } => ({
+		entry,
+		resolvedPath: resolveManifestEntryFile(path.join(plugin.path, entry)),
+	});
+
 	const base = manifest[key];
 	if (base) {
 		const entries = Array.isArray(base) ? base : [base];
 		for (const entry of entries) {
-			const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
-			if (resolved) {
-				paths.push(resolved);
-			}
+			declared.push(resolveEntry(entry));
 		}
 	}
 
-	// Feature-specific entries
 	if (manifest.features && plugin.enabledFeatures) {
 		const enabledSet = new Set(plugin.enabledFeatures);
-
 		for (const [featName, feat] of Object.entries(manifest.features)) {
 			if (!enabledSet.has(featName)) continue;
-
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
-					if (resolved) {
-						paths.push(resolved);
-					}
+					declared.push(resolveEntry(entry));
 				}
 			}
 		}
@@ -207,19 +222,15 @@ function resolvePluginPaths(plugin: InstalledPlugin, key: "tools" | "hooks" | "c
 		// null means use defaults - enable features with default: true
 		for (const [_featName, feat] of Object.entries(manifest.features)) {
 			if (!feat.default) continue;
-
 			if (feat[key]) {
 				for (const entry of feat[key]) {
-					const resolved = resolveManifestEntryFile(path.join(plugin.path, entry));
-					if (resolved) {
-						paths.push(resolved);
-					}
+					declared.push(resolveEntry(entry));
 				}
 			}
 		}
 	}
 
-	return paths;
+	return declared;
 }
 
 export function resolvePluginToolPaths(plugin: InstalledPlugin): string[] {