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

package/src/config/model-registry.ts

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

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

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

package/src/extensibility/extensions/wrapper.ts

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

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

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

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

@@ -93,14 +93,22 @@ const TYPEBOX_SPECIFIER_FILTER = /^(?:@sinclair\/typebox|typebox)$/;
 // so they keep working when on-disk layout differs from the monorepo tree.
 /**
  * Compute the bunfs package root from the compiled binary's `import.meta.dir`
- * (or any stand-in supplied by tests). Bun 1.3 reports the bunfs mount root
- * (`/$bunfs/root` or `<drive>:\~BUN\root`) for imported modules as well as the
- * entrypoint, so the normal path is `<root>/packages`.
+ * (or any stand-in supplied by tests). Bun compiled binaries report one of:
  *
- * The suffix branch preserves correctness if a future Bun release switches to
- * module-specific `import.meta.dir` values inside compiled binaries, matching
- * the source layout:
- * `<bunfs>/packages/coding-agent/src/extensibility/plugins`.
+ * - the bunfs mount root itself — `/$bunfs/root` or `<drive>:\~BUN\root` (Bun
+ *   1.2.x and early 1.3.x). Append `packages` for the canonical layout.
+ * - the bunfs mount root followed by the binary's basename — `//root/<bin>`
+ *   on POSIX or `<drive>:\~BUN\root\<bin>.exe` on Windows (observed on Bun
+ *   1.3.14 with the cross-compiled `omp-darwin-arm64` release asset — issue
+ *   #3329). The trailing segment is stripped so the result still lands on
+ *   `<root>/packages`.
+ * - the module's own source directory if a future Bun release switches to
+ *   module-specific `import.meta.dir` values:
+ *   `<bunfs>/packages/coding-agent/src/extensibility/plugins`.
+ * The bunfs-root-with-binary branch slices the original `metaDir`, and
+ * `bunfsPath` uses a matching double-slash-preserving join, so the bunfs-native
+ * prefix is preserved verbatim — `path.posix.join` collapses `//root` to
+ * `/root`, but Bun's bunfs lookup is keyed on the exact `//root` form.
  *
  * Exported for tests; production callers use `BUNFS_PACKAGE_ROOT` below.
  */
@@ -110,6 +118,10 @@ export function __computeBunfsPackageRoot(metaDir: string, pathImpl: typeof path
 	if (normalizedMetaDir.endsWith(pluginsDirSuffix)) {
 		return pathImpl.resolve(metaDir, "..", "..", "..", "..");
 	}
+	const parent = pathImpl.dirname(metaDir);
+	if (pathImpl.basename(pathImpl.normalize(parent)) === "root") {
+		return `${parent + pathImpl.sep}packages`;
+	}
 	return pathImpl.join(metaDir, "packages");
 }
 
@@ -137,11 +149,31 @@ export function __computeBundledSelfPackageRoot(metaDir: string, pathImpl: typeo
 
 const BUNFS_PACKAGE_ROOT = IS_COMPILED_BINARY ? __computeBunfsPackageRoot(import.meta.dir) : null;
 
+/**
+ * Join a computed bunfs package root with descendants without collapsing
+ * Bun's POSIX `//root` mount prefix.
+ *
+ * Exported for tests; production callers use `bunfsPath` below.
+ */
+export function __joinBunfsPath(root: string, segments: readonly string[], pathImpl: typeof path = path): string {
+	const joined = pathImpl.join(root, ...segments);
+	const doubleRootPrefix = pathImpl.sep + pathImpl.sep;
+	const tripleRootPrefix = doubleRootPrefix + pathImpl.sep;
+	if (
+		root.startsWith(doubleRootPrefix) &&
+		!root.startsWith(tripleRootPrefix) &&
+		!joined.startsWith(doubleRootPrefix)
+	) {
+		return pathImpl.sep + joined;
+	}
+	return joined;
+}
+
 function bunfsPath(...segments: string[]): string {
 	if (!BUNFS_PACKAGE_ROOT) {
 		throw new Error("bunfsPath is only valid in compiled-binary mode");
 	}
-	return path.join(BUNFS_PACKAGE_ROOT, ...segments);
+	return __joinBunfsPath(BUNFS_PACKAGE_ROOT, segments);
 }
 
 function resolveBundledSelfPackageRoot(): string | undefined {

package/src/extensibility/plugins/loader.ts

@@ -6,12 +6,18 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { getPluginsLockfile, getPluginsNodeModules, getPluginsPackageJson, isEnoent } from "@oh-my-pi/pi-utils";
+import { getPluginsDir, getPluginsLockfile, isEnoent } from "@oh-my-pi/pi-utils";
 import { getConfigDirPaths } from "../../config";
+import { resolveActiveProjectRegistryPath } from "../../discovery/helpers";
 import { installLegacyPiSpecifierShim } from "./legacy-pi-compat";
 import { normalizePluginRuntimeConfig } from "./runtime-config";
 import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
 
+/** Installed plugin plus the root scope that supplied its runtime metadata. */
+export interface ScopedInstalledPlugin extends InstalledPlugin {
+	scope: "user" | "project";
+}
+
 installLegacyPiSpecifierShim();
 
 // =============================================================================
@@ -51,38 +57,38 @@ async function loadProjectOverrides(cwd: string): Promise<ProjectPluginOverrides
 	return {};
 }
 /**
- * Get list of enabled plugins with their resolved configurations.
- *
- * Respects both global runtime config and project overrides. Iterates the
- * union of `<plugins>/package.json#dependencies` (`bun install`-installed
- * packages) and `<plugins>/omp-plugins.lock.json#plugins` (so locally
- * `plugin link`-symlinked extensions, which never get a dependency entry,
- * are still discovered). The optional `home` parameter pins the plugins
- * root for callers that need to enumerate plugins relative to a non-default
- * home (tests with a tempdir, discovery loaders threaded with
- * `LoadContext.home`).
+ * Per-root enumeration of plugins from `<root>/node_modules`,
+ * `<root>/package.json#dependencies`, and `<root>/omp-plugins.lock.json#plugins`.
+ * Honors `projectOverrides.disabled` and `projectOverrides.features`. Returns an
+ * empty array when the root has no `node_modules` yet.
  */
-export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {}): Promise<InstalledPlugin[]> {
-	const { home } = opts;
-
-	const nodeModulesPath = getPluginsNodeModules(home);
-	if (!fs.existsSync(nodeModulesPath)) {
-		return [];
-	}
+async function collectPluginsAtRoot(
+	root: string,
+	projectOverrides: ProjectPluginOverrides,
+	scope: ScopedInstalledPlugin["scope"],
+): Promise<ScopedInstalledPlugin[]> {
+	const nodeModulesPath = path.join(root, "node_modules");
+	if (!fs.existsSync(nodeModulesPath)) return [];
 
 	let depsKeys: string[] = [];
-	const pkgJsonPath = getPluginsPackageJson(home);
+	const pkgJsonPath = path.join(root, "package.json");
 	try {
 		const pkg: { dependencies?: Record<string, string> } = await Bun.file(pkgJsonPath).json();
 		depsKeys = Object.keys(pkg.dependencies ?? {});
 	} catch (err) {
-		// Linked-only setups may have no `<plugins>/package.json` yet — that's
+		// Linked-only setups may have no `<root>/package.json` yet — that's
 		// fine, the lockfile still records the link.
 		if (!isEnoent(err)) throw err;
 	}
 
-	const runtimeConfig = await loadRuntimeConfig(home);
-	const projectOverrides = await loadProjectOverrides(cwd);
+	const lockPath = path.join(root, "omp-plugins.lock.json");
+	let runtimeConfig: PluginRuntimeConfig;
+	try {
+		runtimeConfig = normalizePluginRuntimeConfig(await Bun.file(lockPath).json());
+	} catch (err) {
+		if (!isEnoent(err)) throw err;
+		runtimeConfig = normalizePluginRuntimeConfig({});
+	}
 
 	// Union: dependencies (npm/marketplace installs) ∪ runtime-config plugins
 	// (links + already-recorded installs). Set preserves first-seen order,
@@ -92,7 +98,7 @@ export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {
 		names.add(name);
 	}
 
-	const plugins: InstalledPlugin[] = [];
+	const plugins: ScopedInstalledPlugin[] = [];
 	for (const name of names) {
 		const pluginPkgPath = path.join(nodeModulesPath, name, "package.json");
 		let pluginPkg: { version: string; omp?: PluginManifest; pi?: PluginManifest };
@@ -130,6 +136,7 @@ export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {
 			name,
 			version: pluginPkg.version,
 			path: path.join(nodeModulesPath, name),
+			scope,
 			manifest,
 			enabledFeatures,
 			enabled: true,
@@ -139,6 +146,47 @@ export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {
 	return plugins;
 }
 
+/**
+ * Get list of enabled plugins with their resolved configurations.
+ *
+ * Enumerates two plugin roots in order: the user root
+ * (`getPluginsDir(home)`) and, when a project anchor (`.omp/` or `.git/`)
+ * exists at or above `cwd`, the project root
+ * (`<projectAnchor>/.omp/plugins`). Each root contributes the union of its
+ * `package.json#dependencies` and `omp-plugins.lock.json#plugins`. Project
+ * entries shadow user entries with the same package name, matching the
+ * shadow semantics of `MarketplaceManager.listInstalledPlugins`.
+ *
+ * The optional `home` parameter pins the user plugins root for callers that
+ * need to enumerate plugins relative to a non-default home (tests with a
+ * tempdir, discovery loaders threaded with `LoadContext.home`).
+ */
+export async function getEnabledPlugins(cwd: string, opts: { home?: string } = {}): Promise<ScopedInstalledPlugin[]> {
+	const { home } = opts;
+	const projectOverrides = await loadProjectOverrides(cwd);
+
+	const userRoot = getPluginsDir(home);
+	const userPlugins = await collectPluginsAtRoot(userRoot, projectOverrides, "user");
+
+	let projectPlugins: ScopedInstalledPlugin[] = [];
+	const projectRegistryPath = await resolveActiveProjectRegistryPath(cwd);
+	if (projectRegistryPath) {
+		const projectRoot = path.dirname(projectRegistryPath);
+		if (projectRoot !== userRoot) {
+			projectPlugins = await collectPluginsAtRoot(projectRoot, projectOverrides, "project");
+		}
+	}
+
+	if (projectPlugins.length === 0) return userPlugins;
+	if (userPlugins.length === 0) return projectPlugins;
+
+	// Project entries shadow user entries with the same package name.
+	const merged = new Map<string, ScopedInstalledPlugin>();
+	for (const plugin of userPlugins) merged.set(plugin.name, plugin);
+	for (const plugin of projectPlugins) merged.set(plugin.name, plugin);
+	return Array.from(merged.values());
+}
+
 // =============================================================================
 // Path Resolution
 // =============================================================================

package/src/extensibility/plugins/marketplace/manager.ts

@@ -11,6 +11,8 @@ import * as os from "node:os";
 import * as path from "node:path";
 
 import { isEnoent, logger, pathIsWithin } from "@oh-my-pi/pi-utils";
+import { normalizePluginRuntimeConfig } from "../runtime-config";
+import type { PluginRuntimeConfig } from "../types";
 
 import { cachePlugin } from "./cache";
 import { classifySource, fetchMarketplace, parseMarketplaceCatalog, promoteCloneToCache } from "./fetcher";
@@ -38,6 +40,16 @@ import type {
 } from "./types";
 import { buildPluginId, parsePluginId } from "./types";
 
+const RUNTIME_PACKAGE_NAME_RE = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+const MAX_RUNTIME_PACKAGE_NAME_LENGTH = 214;
+
+function assertRuntimePackageName(name: string): string {
+	if (name.length > MAX_RUNTIME_PACKAGE_NAME_LENGTH || !RUNTIME_PACKAGE_NAME_RE.test(name)) {
+		throw new Error(`Invalid marketplace plugin package name: ${JSON.stringify(name)}`);
+	}
+	return name;
+}
+
 // ── Options ──────────────────────────────────────────────────────────────────
 
 export interface MarketplaceManagerOptions {
@@ -298,6 +310,9 @@ export class MarketplaceManager {
 			}
 		}
 
+		const packageName = await this.#resolvePluginPackageName(cachePath, name);
+		const previousPackageNames = await this.#resolveInstalledPackageNames(existing ?? [], name);
+
 		// Only now clean up old entries — new cache succeeded, so it is safe to remove old ones.
 		if (existing && existing.length > 0) {
 			// Remove from scope-appropriate registry first, then cross-check refs before disk deletion.
@@ -337,6 +352,13 @@ export class MarketplaceManager {
 		const newInstReg = addInstalledPlugin(freshInstReg, pluginId, installedEntry);
 		await writeInstalledPluginsRegistry(registryPath, newInstReg);
 
+		for (const previousPackageName of previousPackageNames) {
+			if (previousPackageName !== packageName) {
+				await this.#removeRuntimePlugin(scope, previousPackageName);
+			}
+		}
+		await this.#registerRuntimePlugin(scope, packageName, cachePath, version, wasDisabled ? false : undefined);
+
 		this.#clearCache();
 
 		logger.debug("Plugin installed", { pluginId, version, cachePath });
@@ -434,6 +456,7 @@ export class MarketplaceManager {
 		const targetEntries = targetScope === "project" ? projectEntries! : userEntries!;
 		const targetReg = targetScope === "project" ? projectReg : userReg;
 		const registryPath = this.#registryPath(targetScope);
+		const packageNames = await this.#resolveInstalledPackageNames(targetEntries, parsed.name);
 
 		const updatedReg = removeInstalledPlugin(targetReg, pluginId);
 		await writeInstalledPluginsRegistry(registryPath, updatedReg);
@@ -453,6 +476,10 @@ export class MarketplaceManager {
 			}
 		}
 
+		for (const packageName of packageNames) {
+			await this.#removeRuntimePlugin(targetScope, packageName);
+		}
+
 		this.#clearCache();
 
 		logger.debug("Plugin uninstalled", { pluginId, scope: targetScope });
@@ -539,6 +566,12 @@ export class MarketplaceManager {
 		};
 		await writeInstalledPluginsRegistry(registryPath, updated);
 
+		const fallbackName = parsePluginId(pluginId)?.name ?? pluginId;
+		const packageNames = await this.#resolveInstalledPackageNames(entries, fallbackName);
+		for (const packageName of packageNames) {
+			await this.#setRuntimePluginEnabled(targetScope, packageName, enabled);
+		}
+
 		this.#clearCache();
 
 		logger.debug("Plugin enabled state changed", { pluginId, enabled, scope: targetScope });
@@ -701,6 +734,107 @@ export class MarketplaceManager {
 
 	// ── Private helpers ───────────────────────────────────────────────────────
 
+	#runtimeRoot(scope: "user" | "project"): string {
+		return path.dirname(this.#registryPath(scope));
+	}
+
+	#nodeModulesPath(scope: "user" | "project"): string {
+		return path.join(this.#runtimeRoot(scope), "node_modules");
+	}
+
+	#runtimeLockPath(scope: "user" | "project"): string {
+		return path.join(this.#runtimeRoot(scope), "omp-plugins.lock.json");
+	}
+
+	async #loadRuntimeConfig(scope: "user" | "project"): Promise<PluginRuntimeConfig> {
+		try {
+			return normalizePluginRuntimeConfig(await Bun.file(this.#runtimeLockPath(scope)).json());
+		} catch (err) {
+			if (isEnoent(err)) return normalizePluginRuntimeConfig({});
+			logger.warn("Failed to load marketplace plugin runtime config", {
+				path: this.#runtimeLockPath(scope),
+				error: String(err),
+			});
+			return normalizePluginRuntimeConfig({});
+		}
+	}
+
+	async #writeRuntimeConfig(scope: "user" | "project", config: PluginRuntimeConfig): Promise<void> {
+		await Bun.write(this.#runtimeLockPath(scope), JSON.stringify(config, null, 2));
+	}
+
+	async #resolvePluginPackageName(installPath: string, fallbackName: string): Promise<string> {
+		try {
+			const pkg: { name?: unknown } = await Bun.file(path.join(installPath, "package.json")).json();
+			const name = typeof pkg.name === "string" && pkg.name.length > 0 ? pkg.name : fallbackName;
+			return assertRuntimePackageName(name);
+		} catch (err) {
+			if (isEnoent(err)) return assertRuntimePackageName(fallbackName);
+			throw err;
+		}
+	}
+
+	#runtimePackagePath(scope: "user" | "project", packageName: string): string {
+		const nodeModules = path.resolve(this.#nodeModulesPath(scope));
+		const linkPath = path.resolve(nodeModules, assertRuntimePackageName(packageName));
+		const relative = path.relative(nodeModules, linkPath);
+		if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative)) {
+			throw new Error(`Marketplace plugin package path escapes node_modules: ${JSON.stringify(packageName)}`);
+		}
+		return linkPath;
+	}
+
+	async #resolveInstalledPackageNames(
+		entries: readonly InstalledPluginEntry[],
+		fallbackName: string,
+	): Promise<Set<string>> {
+		const packageNames = new Set<string>();
+		for (const entry of entries) {
+			packageNames.add(await this.#resolvePluginPackageName(entry.installPath, fallbackName));
+		}
+		return packageNames;
+	}
+
+	async #registerRuntimePlugin(
+		scope: "user" | "project",
+		packageName: string,
+		cachePath: string,
+		version: string,
+		enabled: boolean | undefined,
+	): Promise<void> {
+		const linkPath = this.#runtimePackagePath(scope, packageName);
+		await fs.mkdir(path.dirname(linkPath), { recursive: true });
+		await fs.rm(linkPath, { recursive: true, force: true });
+		await fs.symlink(cachePath, linkPath, process.platform === "win32" ? "junction" : "dir");
+
+		const config = await this.#loadRuntimeConfig(scope);
+		const previous = config.plugins[packageName];
+		config.plugins[packageName] = {
+			version,
+			enabledFeatures: previous?.enabledFeatures ?? null,
+			enabled: enabled ?? previous?.enabled ?? true,
+		};
+		await this.#writeRuntimeConfig(scope, config);
+	}
+
+	async #removeRuntimePlugin(scope: "user" | "project", packageName: string): Promise<void> {
+		await fs.rm(this.#runtimePackagePath(scope, packageName), { recursive: true, force: true });
+
+		const config = await this.#loadRuntimeConfig(scope);
+		delete config.plugins[packageName];
+		delete config.settings[packageName];
+		await this.#writeRuntimeConfig(scope, config);
+	}
+
+	async #setRuntimePluginEnabled(scope: "user" | "project", packageName: string, enabled: boolean): Promise<void> {
+		const config = await this.#loadRuntimeConfig(scope);
+		const previous = config.plugins[packageName];
+		if (!previous) return;
+
+		config.plugins[packageName] = { ...previous, enabled };
+		await this.#writeRuntimeConfig(scope, config);
+	}
+
 	#registryPath(scope: "user" | "project"): string {
 		if (scope === "project") {
 			if (!this.#opts.projectInstalledRegistryPath) {

package/src/extensibility/tool-event-input.ts

@@ -0,0 +1,57 @@
+const HASHLINE_FILE_PREFIX = "¶";
+const HASHLINE_FILE_TAG_RE = /#[0-9a-fA-F]{4}$/u;
+
+function stringField(input: Record<string, unknown>, key: string): string | undefined {
+	const value = input[key];
+	return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function normalizeHashlineHeaderPath(body: string): string | undefined {
+	const trimmed = body.trim();
+	if (trimmed.length === 0) return undefined;
+	const hashStart = HASHLINE_FILE_TAG_RE.exec(trimmed)?.index;
+	const rawPath = hashStart === undefined ? trimmed : trimmed.slice(0, hashStart);
+	if (rawPath.length < 2) return rawPath.length > 0 ? rawPath : undefined;
+	const first = rawPath[0];
+	const last = rawPath[rawPath.length - 1];
+	if ((first === '"' || first === "'") && first === last) return rawPath.slice(1, -1);
+	return rawPath;
+}
+
+function extractHashlinePaths(input: string): string[] {
+	const paths: string[] = [];
+	const stripped = input.startsWith("\uFEFF") ? input.slice(1) : input;
+	for (const rawLine of stripped.split("\n")) {
+		const line = rawLine.replace(/\r$/, "").trimStart();
+		if (!line.startsWith(HASHLINE_FILE_PREFIX)) continue;
+		let prefixEnd = 0;
+		while (prefixEnd < line.length && line[prefixEnd] === HASHLINE_FILE_PREFIX) prefixEnd++;
+		const path = normalizeHashlineHeaderPath(line.slice(prefixEnd));
+		if (path) paths.push(path);
+	}
+	return paths;
+}
+
+/** Adds derived compatibility fields to tool event input without changing tool execution parameters. */
+export function normalizeToolEventInput(toolName: string, input: Record<string, unknown>): Record<string, unknown> {
+	if (toolName !== "edit" || stringField(input, "path")) return input;
+
+	// Hashline edit mode: the only authoritative target list is the parsed
+	// `¶PATH#TAG` headers inside `input`/`_input`. Trusting a passthrough
+	// `_path` here would let a model-supplied field override the real edit
+	// target and bypass extension gates that allowlist by path.
+	const rawInput = stringField(input, "input") ?? stringField(input, "_input");
+	if (rawInput !== undefined) {
+		const hashlinePaths = extractHashlinePaths(rawInput);
+		if (hashlinePaths.length === 0) return input;
+		if (hashlinePaths.length === 1) return { ...input, path: hashlinePaths[0], paths: hashlinePaths };
+		return { ...input, paths: hashlinePaths };
+	}
+
+	// Replace/patch modes: `path` is the real parameter; some hosts forward
+	// it as `_path` after schema normalization, so propagate it for gates.
+	const directPath = stringField(input, "_path");
+	if (directPath) return { ...input, path: directPath };
+
+	return input;
+}