@oh-my-pi/pi-coding-agent 15.12.4 → 15.13.0

package/src/eval/js/shared/prelude.txt

@@ -1,33 +1,85 @@
 if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.__omp_js_prelude_loaded__ = true;
 
+	const isNil = value => value === undefined || value === null;
 	const isPlainObject = value => value !== null && typeof value === "object" && !Array.isArray(value);
-	const optionsArg = (name, value, rest, example) => {
-		if (rest.length > 0) {
-			throw new TypeError(
-				`${name}() takes options as a single trailing object literal, not positional arguments (got ${rest.length + 1} extra args). Pass them as ${name}(..., ${example}).`,
-			);
+	const positionalOptions = (name, args, keys, example) => {
+		for (let index = keys.length; index < args.length; index++) {
+			if (!isNil(args[index])) {
+				throw new TypeError(
+					`${name}() accepts at most ${keys.length} positional optional args; got ${args.length}. Pass ${name}(..., ${example}) for named options.`,
+				);
+			}
+		}
+		const options = {};
+		for (let index = 0; index < keys.length && index < args.length; index++) {
+			const value = args[index];
+			if (!isNil(value)) options[keys[index]] = value;
+		}
+		return options;
+	};
+	const optionsArg = (name, value, rest, keys, example) => {
+		if (isNil(value)) return positionalOptions(name, [value, ...rest], keys, example);
+		if (isPlainObject(value)) {
+			if (rest.some(arg => !isNil(arg))) {
+				throw new TypeError(
+					`${name}() takes either a single trailing options object like ${example} or positional optional args; do not mix both forms.`,
+				);
+			}
+			return value;
 		}
-		if (value === undefined || value === null) return {};
-		if (!isPlainObject(value)) {
-			const kind = Array.isArray(value) ? "an array" : typeof value;
+		if (typeof value === "object") {
+			const kind = Array.isArray(value) ? "an array" : value.constructor?.name ?? "object";
 			throw new TypeError(
-				`${name}() options must be a trailing object literal like ${example}, not ${kind}. JS helpers never take positional options.`,
+				`${name}() options must be a plain object like ${example}, null/undefined, or positional optional args, not ${kind}.`,
 			);
 		}
-		return value;
+		return positionalOptions(name, [value, ...rest], keys, example);
 	};
 	const callHelper = (name, ...args) => globalThis.__omp_helpers__[name](...args);
+	const hasScheme = path => typeof path === "string" && /^[A-Za-z][A-Za-z0-9+.-]*:\/\//.test(path);
+	const shouldDelegateRead = path => hasScheme(path) && !path.toLowerCase().startsWith("local://");
+	const withReadLineSelector = (path, options) => {
+		const offset = typeof options.offset === "number" ? options.offset : 1;
+		const limit = typeof options.limit === "number" ? options.limit : undefined;
+		if (offset <= 1 && limit === undefined) return path;
+		if (limit !== undefined && limit <= 0) return null;
+		const start = Math.max(1, offset);
+		if (limit === undefined) return `${path}:${start}-`;
+		return `${path}:${start}-${start + limit - 1}`;
+	};
+	const readToolText = async path => {
+		const res = await globalThis.__omp_call_tool__("read", { path });
+		return res && typeof res === "object" && "text" in res ? res.text : res;
+	};
 
-	const read = (path, opts, ...rest) => callHelper("read", path, optionsArg("read", opts, rest, "{ offset, limit }"));
+
+	const read = async (path, opts, ...rest) => {
+		const options = optionsArg("read", opts, rest, ["offset", "limit"], "{ offset, limit }");
+		if (shouldDelegateRead(path)) {
+			const toolPath = withReadLineSelector(path, options);
+			return toolPath === null ? "" : readToolText(toolPath);
+		}
+		return callHelper("read", path, options);
+	};
 	const write = async (path, data) => callHelper("writeFile", path, data);
 	const append = (path, content) => callHelper("append", path, content);
-	const sort = (text, opts, ...rest) => callHelper("sortText", text, optionsArg("sort", opts, rest, "{ reverse, unique }"));
-	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, "{ count }"));
+	const sort = (text, opts, ...rest) =>
+		callHelper("sortText", text, optionsArg("sort", opts, rest, ["reverse", "unique"], "{ reverse, unique }"));
+	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, ["count"], "{ count }"));
 	const counter = (items, opts, ...rest) =>
-		callHelper("counter", items, optionsArg("counter", opts, rest, "{ limit, reverse }"));
+		callHelper("counter", items, optionsArg("counter", opts, rest, ["limit", "reverse"], "{ limit, reverse }"));
 	const diff = (a, b) => callHelper("diff", a, b);
-	const tree = (path = ".", opts, ...rest) => callHelper("tree", path, optionsArg("tree", opts, rest, "{ maxDepth, showHidden }"));
+	const tree = (path = ".", opts, ...rest) => {
+		if (isPlainObject(path) && opts === undefined && rest.length === 0) {
+			return callHelper("tree", ".", path);
+		}
+		return callHelper(
+			"tree",
+			isNil(path) ? "." : path,
+			optionsArg("tree", opts, rest, ["maxDepth", "showHidden"], "{ maxDepth, showHidden }"),
+		);
+	};
 	const env = (key, value) => callHelper("env", key, value);
 
 	const tool = new Proxy(
@@ -58,14 +110,14 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	const hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 
 	const completion = async (prompt, opts, ...rest) => {
-		const o = optionsArg("completion", opts, rest, "{ model, system, schema }");
+		const o = optionsArg("completion", opts, rest, ["model", "system", "schema"], "{ model, system, schema }");
 		const res = await globalThis.__omp_call_tool__("__completion__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;
 	};
 
 	const agent = async (prompt, opts, ...rest) => {
-		const o = optionsArg("agent", opts, rest, "{ agentType, model, label, schema }");
+		const o = optionsArg("agent", opts, rest, ["agentType", "model", "label", "schema"], "{ agentType, model, label, schema }");
 		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...o });
 		const text = res && typeof res === "object" ? res.text : res;
 		return hasOwn(o, "schema") ? JSON.parse(text) : text;

package/src/export/html/index.ts

@@ -3,12 +3,9 @@ import * as path from "node:path";
 import type { AgentState } from "@oh-my-pi/pi-agent-core";
 import { APP_NAME, isEnoent } from "@oh-my-pi/pi-utils";
 import { getResolvedThemeColors, getThemeExportColors } from "../../modes/theme/theme";
-import {
-	loadEntriesFromFile,
-	type SessionEntry,
-	type SessionHeader,
-	SessionManager,
-} from "../../session/session-manager";
+import type { SessionEntry, SessionHeader } from "../../session/session-entries";
+import { loadEntriesFromFile } from "../../session/session-loader";
+import { SessionManager } from "../../session/session-manager";
 import templateCss from "./template.css" with { type: "text" };
 import templateHtml from "./template.html" with { type: "text" };
 import templateJs from "./template.js" with { type: "text" };

package/src/extensibility/extensions/model-api.ts

@@ -0,0 +1,41 @@
+/**
+ * Model query facade exposed to extensions as `ctx.models`.
+ *
+ * Read-only: lets an extension select a model the same way core does — list
+ * authenticated models, read the session model, resolve a model string or role
+ * alias, and compare model families — without touching the mutable registry or
+ * duplicating resolution/family heuristics.
+ */
+import type { Api, Model } from "@oh-my-pi/pi-ai";
+import { modelFamilyToken } from "@oh-my-pi/pi-catalog/identity";
+import type { ModelRegistry } from "../../config/model-registry";
+import { getModelMatchPreferences, resolveModelRoleValue } from "../../config/model-resolver";
+import type { Settings } from "../../config/settings";
+import type { ExtensionModelQuery } from "./types";
+
+/**
+ * Build the `ctx.models` facade. `getModel` is read lazily so `current()` always
+ * reflects the live session model (it can change mid-session via `/model`).
+ */
+export function createExtensionModelQuery(
+	modelRegistry: ModelRegistry,
+	settings: Settings | undefined,
+	getModel: () => Model | undefined,
+): ExtensionModelQuery {
+	return {
+		list: () => modelRegistry.getAvailable(),
+		current: () => getModel(),
+		// resolveModelRoleValue expands a role alias (`pi/slow`) to its full configured
+		// priority list and tries each pattern — the same path core selection uses — so a
+		// fallback model lower in the list still resolves. Plain model strings pass through
+		// as a single pattern.
+		resolve: (spec: string): Model<Api> | undefined =>
+			resolveModelRoleValue(spec, modelRegistry.getAvailable(), {
+				settings,
+				matchPreferences: getModelMatchPreferences(settings),
+				modelRegistry,
+			}).model,
+		family: (model: Model<Api>): string =>
+			modelFamilyToken(modelRegistry.getCanonicalId(model) ?? model.id) || model.provider.toLowerCase(),
+	};
+}

package/src/extensibility/extensions/runner.ts

@@ -6,9 +6,11 @@ import type { CredentialDisabledEvent, ImageContent, Model, ProviderResponseMeta
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import { logger } from "@oh-my-pi/pi-utils";
 import type { ModelRegistry } from "../../config/model-registry";
+import type { Settings } from "../../config/settings";
 import type { MemoryRuntimeContext } from "../../memory-backend";
 import { type Theme, theme } from "../../modes/theme/theme";
 import type { SessionManager } from "../../session/session-manager";
+import { createExtensionModelQuery } from "./model-api";
 import type {
 	AfterProviderResponseEvent,
 	AssistantThinkingRenderer,
@@ -207,6 +209,7 @@ export class ExtensionRunner {
 		private readonly sessionManager: SessionManager,
 		private readonly modelRegistry: ModelRegistry,
 		getMemory?: () => MemoryRuntimeContext | undefined,
+		private readonly settings?: Settings,
 	) {
 		this.#uiContext = noOpUIContext;
 		this.#getMemoryFn = getMemory;
@@ -479,6 +482,7 @@ export class ExtensionRunner {
 			get model() {
 				return getModel();
 			},
+			models: createExtensionModelQuery(this.modelRegistry, this.settings, getModel),
 			isIdle: () => this.#isIdleFn(),
 			abort: () => this.#abortFn(),
 			hasPendingMessages: () => this.#hasPendingMessagesFn(),

package/src/extensibility/extensions/types.ts

@@ -56,6 +56,7 @@ import type {
 	SearchToolInput,
 	WriteToolInput,
 } from "../../tools";
+import type { ApprovalMode } from "../../tools/approval";
 import type { EventBus } from "../../utils/event-bus";
 import type {
 	AgentEndEvent,
@@ -293,6 +294,32 @@ export interface CompactOptions {
 // surface (model registry, system prompt, shutdown, full session manager
 // access). Field overlap is incidental; merging into a base would require
 // hooks to widen their public contract.
+/**
+ * Read-only model query facade exposed at `ctx.models`. Lets an extension select a
+ * model the same way core does — list authenticated models, read the session model,
+ * resolve a model string or role alias, and compare model families — without reaching
+ * into the mutable registry or re-implementing matching/family heuristics.
+ */
+export interface ExtensionModelQuery {
+	/** Authenticated models available this session (the same set `--model` selection sees). */
+	list(): Model[];
+	/** The current session model, if one is set. */
+	current(): Model | undefined;
+	/**
+	 * Resolve a model string (`provider/id`, bare id) or role alias (`pi/slow`, a
+	 * configured role) to a Model, using the same settings-backed aliases and match
+	 * preferences as core selection. Thinking/routing suffixes are accepted and resolved
+	 * to the base model (pass effort separately). Returns undefined when nothing matches.
+	 */
+	resolve(spec: string): Model | undefined;
+	/**
+	 * Opaque lineage token for "are these the same family?" comparisons — every Claude
+	 * point release shares a token, Claude and GPT differ. Backed by catalog canonical
+	 * identity. Compare it; do not persist it (the vocabulary tracks new releases).
+	 */
+	family(model: Model): string;
+}
+
 export interface ExtensionContext {
 	/** UI methods for user interaction */
 	ui: ExtensionUIContext;
@@ -310,6 +337,8 @@ export interface ExtensionContext {
 	modelRegistry: ModelRegistry;
 	/** Current model (may be undefined) */
 	model: Model | undefined;
+	/** Read-only model query facade: list / current / resolve / family. */
+	models: ExtensionModelQuery;
 	/** Whether the agent is idle (not streaming) */
 	isIdle(): boolean;
 	/** Abort the current agent operation */
@@ -608,6 +637,24 @@ export interface InputEvent {
 // Tool Events
 // ============================================================================
 
+export interface ToolApprovalRequestedEvent {
+	type: "tool_approval_requested";
+	sessionId: string;
+	toolCallId: string;
+	toolName: string;
+	reason?: string;
+	approvalMode: ApprovalMode;
+}
+
+export interface ToolApprovalResolvedEvent {
+	type: "tool_approval_resolved";
+	sessionId: string;
+	toolCallId: string;
+	toolName: string;
+	approved: boolean;
+	reason?: string;
+}
+
 interface ToolCallEventBase {
 	type: "tool_call";
 	toolCallId: string;
@@ -775,7 +822,9 @@ export type ExtensionEvent =
 	| UserPythonEvent
 	| InputEvent
 	| ToolCallEvent
-	| ToolResultEvent;
+	| ToolResultEvent
+	| ToolApprovalRequestedEvent
+	| ToolApprovalResolvedEvent;
 
 // ============================================================================
 // Event Results
@@ -946,6 +995,8 @@ export interface ExtensionAPI {
 	on(event: "goal_updated", handler: ExtensionHandler<GoalUpdatedEvent>): void;
 	on(event: "credential_disabled", handler: ExtensionHandler<CredentialDisabledEvent>): void;
 	on(event: "input", handler: ExtensionHandler<InputEvent, InputEventResult>): void;
+	on(event: "tool_approval_requested", handler: ExtensionHandler<ToolApprovalRequestedEvent>): void;
+	on(event: "tool_approval_resolved", handler: ExtensionHandler<ToolApprovalResolvedEvent>): void;
 	on(event: "tool_call", handler: ExtensionHandler<ToolCallEvent, ToolCallEventResult>): void;
 	on(event: "tool_result", handler: ExtensionHandler<ToolResultEvent, ToolResultEventResult>): void;
 	on(event: "user_bash", handler: ExtensionHandler<UserBashEvent, UserBashEventResult>): void;

package/src/extensibility/extensions/wrapper.ts

@@ -121,8 +121,36 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 		const approvalCheck = requiresApproval(this.tool, params, approvalMode, userPolicies);
 
 		if (approvalCheck.required) {
+			const hasApprovalHandlers =
+				this.runner.hasHandlers("tool_approval_requested") || this.runner.hasHandlers("tool_approval_resolved");
+			const sessionId = context?.sessionManager?.getSessionId() ?? "";
+			if (hasApprovalHandlers) {
+				await this.runner.emit({
+					type: "tool_approval_requested",
+					sessionId,
+					toolName: this.tool.name,
+					toolCallId,
+					...(approvalCheck.reason ? { reason: approvalCheck.reason } : {}),
+					approvalMode,
+				});
+			}
+
+			const resolveApproval = async (approved: boolean, reason?: string) => {
+				if (!hasApprovalHandlers) return;
+				await this.runner.emit({
+					type: "tool_approval_resolved",
+					sessionId,
+					toolName: this.tool.name,
+					toolCallId,
+					approved,
+					...(reason ? { reason } : {}),
+				});
+			};
+
 			// Check if UI is available
 			if (!this.runner.hasUI()) {
+				const reason = "no interactive UI available";
+				await resolveApproval(false, reason);
 				throw new Error(
 					`Tool "${this.tool.name}" requires approval but no interactive UI available.\n` +
 						`Options:\n` +
@@ -133,11 +161,19 @@ export class ExtensionToolWrapper<TParameters extends TSchema = TSchema, TDetail
 			}
 
 			const uiContext = this.runner.getUIContext();
-			const choice = await uiContext.select(formatApprovalPrompt(this.tool, params, approvalCheck.reason), [
-				"Approve",
-				"Deny",
-			]);
-			if (choice !== "Approve") {
+			let choice: string | undefined;
+			try {
+				choice = await uiContext.select(formatApprovalPrompt(this.tool, params, approvalCheck.reason), [
+					"Approve",
+					"Deny",
+				]);
+			} catch (err) {
+				await resolveApproval(false, err instanceof Error ? err.message : "approval aborted");
+				throw err;
+			}
+			const approved = choice === "Approve";
+			await resolveApproval(approved, approved ? undefined : "denied by user");
+			if (!approved) {
 				throw new Error(`Tool call denied by user: ${this.tool.name}`);
 			}
 		}

package/src/extensibility/hooks/index.ts

@@ -1,4 +1,5 @@
-export type { ReadonlySessionManager, UsageStatistics } from "../../session/session-manager";
+export type { UsageStatistics } from "../../session/session-entries";
+export type { ReadonlySessionManager } from "../../session/session-manager";
 export * from "./loader";
 export * from "./runner";
 export * from "./tool-wrapper";

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

@@ -30,16 +30,28 @@ const PI_PACKAGE_ALTERNATION = PI_PACKAGE_NAMES.join("|");
 // root that we relocated under a different folder. Each entry rewrites
 // `<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.
+// bundled copy. Entries ending in `/` rewrite the whole subtree; add new
+// `pkg/from -> pkg/to` pairs whenever an upstream-only subpath breaks resolution.
 const PI_SUBPATH_REMAPS: ReadonlyMap<string, string> = new Map<string, string>([
-	// (currently empty) Upstream `@mariozechner/pi-ai/oauth` re-exported
-	// `./utils/oauth/index.js`. Our pi-ai now exposes the same surface at the
-	// real `@oh-my-pi/pi-ai/oauth` export, so the legacy subpath canonicalizes
-	// straight to it with no rewrite. Add `from -> to` entries here whenever a
-	// future upstream-only subpath surfaces that breaks resolution.
+	["pi-ai/utils/oauth", "pi-ai/oauth"],
+	["pi-ai/utils/oauth/", "pi-ai/oauth/"],
 ]);
 
+function remapLegacyPiSubpath(rest: string): string {
+	const exact = PI_SUBPATH_REMAPS.get(rest);
+	if (exact) {
+		return exact;
+	}
+
+	for (const [from, to] of PI_SUBPATH_REMAPS) {
+		if (from.endsWith("/") && rest.startsWith(from)) {
+			return `${to}${rest.slice(from.length)}`;
+		}
+	}
+
+	return rest;
+}
+
 const LEGACY_PI_SPECIFIER_FILTER = new RegExp(`^@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/.*)?$`);
 const LEGACY_PI_IMPORT_SPECIFIER_REGEX = new RegExp(
 	`((?:from\\s+|import\\s+|import\\s*\\(\\s*)["'])(@(?:${PI_SCOPE_ALTERNATION})/(?:${PI_PACKAGE_ALTERNATION})(?:/[^"'()\\s]+)?)(["'])`,
@@ -101,6 +113,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.PI_BUNDLED="true"`; after bundling,
+ * `import.meta.dir` points at `<package>/dist`. Do not resolve the package via
+ * bare `@oh-my-pi/pi-coding-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 {
@@ -112,11 +146,7 @@ function bunfsPath(...segments: string[]): string {
 
 function resolveBundledSelfPackageRoot(): string | undefined {
 	if (!process.env.PI_BUNDLED) return undefined;
-	try {
-		return path.dirname(Bun.resolveSync("@oh-my-pi/pi-coding-agent/package.json", import.meta.dir));
-	} catch {
-		return undefined;
-	}
+	return __computeBundledSelfPackageRoot(import.meta.dir);
 }
 
 const BUNDLED_SELF_PACKAGE_ROOT = resolveBundledSelfPackageRoot();
@@ -208,7 +238,7 @@ function remapLegacyPiSpecifier(specifier: string): string | null {
 		return null;
 	}
 	const rest = specifier.slice(slashIdx + 1);
-	const remappedSubpath = PI_SUBPATH_REMAPS.get(rest) ?? rest;
+	const remappedSubpath = remapLegacyPiSubpath(rest);
 	return `${CANONICAL_PI_SCOPE}/${remappedSubpath}`;
 }
 

package/src/extensibility/plugins/loader.ts

@@ -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[] {