@oh-my-pi/pi-coding-agent 2.3.1337 → 3.1.1337

package/src/core/mcp/config.ts

@@ -1,130 +1,16 @@
 /**
  * MCP configuration loader.
  *
- * Loads .mcp.json files from project root with environment variable expansion.
- * Supports ${VAR} and ${VAR:-default} syntax.
+ * Uses the capability system to load MCP servers from multiple sources.
  */
 
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type { MCPConfigFile, MCPServerConfig } from "./types";
-
-/** Environment variable expansion pattern: ${VAR} or ${VAR:-default} */
-const ENV_VAR_PATTERN = /\$\{([^}:]+)(?::-([^}]*))?\}/g;
-
-/**
- * Expand environment variables in a string.
- * Supports ${VAR} and ${VAR:-default} syntax.
- */
-export function expandEnvVars(value: string, extraEnv?: Record<string, string>): string {
-	return value.replace(ENV_VAR_PATTERN, (_, varName: string, defaultValue?: string) => {
-		const envValue = extraEnv?.[varName] ?? process.env[varName];
-		if (envValue !== undefined) {
-			return envValue;
-		}
-		if (defaultValue !== undefined) {
-			return defaultValue;
-		}
-		// If no value and no default, leave the placeholder (will likely cause an error later)
-		return `\${${varName}}`;
-	});
-}
-
-/**
- * Recursively expand environment variables in an object.
- */
-function expandEnvVarsInObject<T>(obj: T, extraEnv?: Record<string, string>): T {
-	if (typeof obj === "string") {
-		return expandEnvVars(obj, extraEnv) as T;
-	}
-	if (Array.isArray(obj)) {
-		return obj.map((item) => expandEnvVarsInObject(item, extraEnv)) as T;
-	}
-	if (obj !== null && typeof obj === "object") {
-		const result: Record<string, unknown> = {};
-		for (const [key, value] of Object.entries(obj)) {
-			result[key] = expandEnvVarsInObject(value, extraEnv);
-		}
-		return result as T;
-	}
-	return obj;
-}
-
-/**
- * Load and parse an .mcp.json file.
- * Returns null if file doesn't exist or is invalid.
- */
-export function loadMCPConfigFile(filePath: string, extraEnv?: Record<string, string>): MCPConfigFile | null {
-	if (!existsSync(filePath)) {
-		return null;
-	}
-
-	try {
-		const content = readFileSync(filePath, "utf-8");
-		const parsed = JSON.parse(content) as MCPConfigFile;
-
-		// Expand environment variables in server configs
-		if (parsed.mcpServers) {
-			parsed.mcpServers = expandEnvVarsInObject(parsed.mcpServers, extraEnv);
-		}
-
-		return parsed;
-	} catch (error) {
-		console.error(`Warning: Failed to parse ${filePath}: ${error}`);
-		return null;
-	}
-}
-
-/**
- * Configuration locations (in order of priority, later overrides earlier).
- */
-export interface MCPConfigLocations {
-	/** User-level config: ~/.pi/mcp.json or ~/.claude.json */
-	user?: string;
-	/** Project-level config: <cwd>/.mcp.json */
-	project?: string;
-}
-
-/**
- * Get standard MCP config file paths.
- */
-export function getMCPConfigPaths(cwd: string): MCPConfigLocations {
-	const home = homedir();
-
-	// Project-level: check both mcp.json and .mcp.json (prefer mcp.json if both exist)
-	const mcpJson = join(cwd, "mcp.json");
-	const dotMcpJson = join(cwd, ".mcp.json");
-	const projectPath = existsSync(mcpJson) ? mcpJson : dotMcpJson;
-
-	return {
-		// User-level: ~/.pi/mcp.json (our standard)
-		user: join(home, ".pi", "mcp.json"),
-		// Project-level: mcp.json or .mcp.json at project root
-		project: projectPath,
-	};
-}
-
-/**
- * Merge MCP configs from multiple sources.
- * Later sources override earlier ones for servers with same name.
- */
-export function mergeMCPConfigs(...configs: (MCPConfigFile | null)[]): Record<string, MCPServerConfig> {
-	const result: Record<string, MCPServerConfig> = {};
-
-	for (const config of configs) {
-		if (config?.mcpServers) {
-			Object.assign(result, config.mcpServers);
-		}
-	}
-
-	return result;
-}
+import { mcpCapability } from "../../capability/mcp";
+import type { MCPServer } from "../../discovery";
+import { load } from "../../discovery";
+import type { MCPServerConfig } from "./types";
 
 /** Options for loading MCP configs */
 export interface LoadMCPConfigsOptions {
-	/** Additional environment variables for expansion */
-	extraEnv?: Record<string, string>;
 	/** Whether to load project-level config (default: true) */
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
@@ -137,43 +23,87 @@ export interface LoadMCPConfigsResult {
 	configs: Record<string, MCPServerConfig>;
 	/** Extracted Exa API keys (if any were filtered) */
 	exaApiKeys: string[];
+	/** Source metadata for each server */
+	sources: Record<string, import("../../capability/types").SourceMeta>;
 }
 
 /**
- * Load all MCP server configs from standard locations.
- * Returns merged config with project overriding user.
- *
- * @param cwd Working directory (project root)
- * @param options Load options or extraEnv for backwards compatibility
+ * Convert canonical MCPServer to legacy MCPServerConfig.
  */
-export function loadAllMCPConfigs(
-	cwd: string,
-	options?: LoadMCPConfigsOptions | Record<string, string>,
-): LoadMCPConfigsResult {
-	// Support old signature: loadAllMCPConfigs(cwd, extraEnv)
-	const opts: LoadMCPConfigsOptions =
-		options && ("extraEnv" in options || "enableProjectConfig" in options || "filterExa" in options)
-			? (options as LoadMCPConfigsOptions)
-			: { extraEnv: options as Record<string, string> | undefined };
+function convertToLegacyConfig(server: MCPServer): MCPServerConfig {
+	// Determine transport type
+	const transport = server.transport ?? (server.command ? "stdio" : server.url ? "http" : "stdio");
+
+	if (transport === "stdio") {
+		const config: MCPServerConfig = {
+			type: "stdio" as const,
+			command: server.command ?? "",
+		};
+		if (server.args) config.args = server.args;
+		if (server.env) config.env = server.env;
+		return config;
+	}
 
-	const enableProjectConfig = opts.enableProjectConfig ?? true;
-	const filterExa = opts.filterExa ?? true;
+	if (transport === "http") {
+		const config: MCPServerConfig = {
+			type: "http" as const,
+			url: server.url ?? "",
+		};
+		if (server.headers) config.headers = server.headers;
+		return config;
+	}
+
+	if (transport === "sse") {
+		const config: MCPServerConfig = {
+			type: "sse" as const,
+			url: server.url ?? "",
+		};
+		if (server.headers) config.headers = server.headers;
+		return config;
+	}
 
-	const paths = getMCPConfigPaths(cwd);
+	// Fallback to stdio
+	return {
+		type: "stdio" as const,
+		command: server.command ?? "",
+	};
+}
 
-	const userConfig = paths.user ? loadMCPConfigFile(paths.user, opts.extraEnv) : null;
-	const projectConfig = enableProjectConfig && paths.project ? loadMCPConfigFile(paths.project, opts.extraEnv) : null;
+/**
+ * Load all MCP server configs from standard locations.
+ * Uses the capability system for multi-source discovery.
+ *
+ * @param cwd Working directory (project root)
+ * @param options Load options
+ */
+export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOptions): Promise<LoadMCPConfigsResult> {
+	const enableProjectConfig = options?.enableProjectConfig ?? true;
+	const filterExa = options?.filterExa ?? true;
+
+	// Load MCP servers via capability system
+	const result = await load<MCPServer>(mcpCapability.id, { cwd });
+
+	// Filter out project-level configs if disabled
+	const servers = enableProjectConfig
+		? result.items
+		: result.items.filter((server) => server._source.level !== "project");
+
+	// Convert to legacy format and preserve source metadata
+	const configs: Record<string, MCPServerConfig> = {};
+	const sources: Record<string, import("../../capability/types").SourceMeta> = {};
+	for (const server of servers) {
+		configs[server.name] = convertToLegacyConfig(server);
+		sources[server.name] = server._source;
+	}
 
-	let configs = mergeMCPConfigs(userConfig, projectConfig);
-	let exaApiKeys: string[] = [];
+	const exaApiKeys: string[] = [];
 
 	if (filterExa) {
-		const result = filterExaMCPServers(configs);
-		configs = result.configs;
-		exaApiKeys = result.exaApiKeys;
+		const filterResult = filterExaMCPServers(configs, sources);
+		return { configs: filterResult.configs, exaApiKeys: filterResult.exaApiKeys, sources: filterResult.sources };
 	}
 
-	return { configs, exaApiKeys };
+	return { configs, exaApiKeys, sources };
 }
 
 /** Pattern to match Exa MCP servers */
@@ -249,14 +179,20 @@ export interface ExaFilterResult {
 	configs: Record<string, MCPServerConfig>;
 	/** Extracted Exa API keys (if any) */
 	exaApiKeys: string[];
+	/** Source metadata for remaining servers */
+	sources: Record<string, import("../../capability/types").SourceMeta>;
 }
 
 /**
  * Filter out Exa MCP servers and extract their API keys.
  * Since we have native Exa integration, we don't need the MCP server.
  */
-export function filterExaMCPServers(configs: Record<string, MCPServerConfig>): ExaFilterResult {
+export function filterExaMCPServers(
+	configs: Record<string, MCPServerConfig>,
+	sources: Record<string, import("../../capability/types").SourceMeta>,
+): ExaFilterResult {
 	const filtered: Record<string, MCPServerConfig> = {};
+	const filteredSources: Record<string, import("../../capability/types").SourceMeta> = {};
 	const exaApiKeys: string[] = [];
 
 	for (const [name, config] of Object.entries(configs)) {
@@ -268,10 +204,13 @@ export function filterExaMCPServers(configs: Record<string, MCPServerConfig>): E
 			}
 		} else {
 			filtered[name] = config;
+			if (sources[name]) {
+				filteredSources[name] = sources[name];
+			}
 		}
 	}
 
-	return { configs: filtered, exaApiKeys };
+	return { configs: filtered, exaApiKeys, sources: filteredSources };
 }
 
 /**
@@ -282,6 +221,15 @@ export function validateServerConfig(name: string, config: MCPServerConfig): str
 
 	const serverType = config.type ?? "stdio";
 
+	// Check for conflicting transport fields
+	const hasCommand = "command" in config && config.command;
+	const hasUrl = "url" in config && (config as { url?: string }).url;
+	if (hasCommand && hasUrl) {
+		errors.push(
+			`Server "${name}": both "command" and "url" are set - server should be either stdio (command) OR http/sse (url), not both`,
+		);
+	}
+
 	if (serverType === "stdio") {
 		const stdioConfig = config as { command?: string };
 		if (!stdioConfig.command) {

package/src/core/mcp/index.ts

@@ -11,14 +11,10 @@ export { callTool, connectToServer, disconnectServer, listTools, serverSupportsT
 // Config
 export type { ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config";
 export {
-	expandEnvVars,
 	extractExaApiKey,
 	filterExaMCPServers,
-	getMCPConfigPaths,
 	isExaMCPServer,
 	loadAllMCPConfigs,
-	loadMCPConfigFile,
-	mergeMCPConfigs,
 	validateServerConfig,
 } from "./config";
 // Loader (for SDK integration)

package/src/core/mcp/loader.ts

@@ -6,6 +6,7 @@
 
 import type { LoadedCustomTool } from "../custom-tools/types";
 import { type MCPLoadResult, MCPManager } from "./manager";
+import { parseMCPToolName } from "./tool-bridge";
 
 /** Result from loading MCP tools */
 export interface MCPToolsLoadResult {
@@ -23,8 +24,6 @@ export interface MCPToolsLoadResult {
 
 /** Options for loading MCP tools */
 export interface MCPToolsLoadOptions {
-	/** Additional environment variables for expansion */
-	extraEnv?: Record<string, string>;
 	/** Called when starting to connect to servers */
 	onConnecting?: (serverNames: string[]) => void;
 	/** Whether to load project-level config (default: true) */
@@ -37,28 +36,18 @@ export interface MCPToolsLoadOptions {
  * Discover and load MCP tools from .mcp.json files.
  *
  * @param cwd Working directory (project root)
- * @param options Load options including extraEnv and progress callbacks
+ * @param options Load options including progress callbacks
  * @returns MCP tools in LoadedCustomTool format for integration
  */
-export async function discoverAndLoadMCPTools(
-	cwd: string,
-	options?: MCPToolsLoadOptions | Record<string, string>,
-): Promise<MCPToolsLoadResult> {
-	// Support old signature: discoverAndLoadMCPTools(cwd, extraEnv)
-	const opts: MCPToolsLoadOptions =
-		options && ("extraEnv" in options || "onConnecting" in options || "enableProjectConfig" in options)
-			? (options as MCPToolsLoadOptions)
-			: { extraEnv: options as Record<string, string> | undefined };
-
+export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult> {
 	const manager = new MCPManager(cwd);
 
 	let result: MCPLoadResult;
 	try {
 		result = await manager.discoverAndConnect({
-			extraEnv: opts.extraEnv,
-			onConnecting: opts.onConnecting,
-			enableProjectConfig: opts.enableProjectConfig,
-			filterExa: opts.filterExa,
+			onConnecting: options?.onConnecting,
+			enableProjectConfig: options?.enableProjectConfig,
+			filterExa: options?.filterExa,
 		});
 	} catch (error) {
 		// If discovery fails entirely, return empty result
@@ -73,11 +62,26 @@ export async function discoverAndLoadMCPTools(
 	}
 
 	// Convert MCP tools to LoadedCustomTool format
-	const loadedTools: LoadedCustomTool[] = result.tools.map((tool) => ({
-		path: `mcp:${tool.name}`,
-		resolvedPath: `mcp:${tool.name}`,
-		tool: tool as any, // MCPToolDetails is compatible with CustomTool<TSchema, any>
-	}));
+	const loadedTools: LoadedCustomTool[] = result.tools.map((tool) => {
+		// Parse the MCP tool name to get server name
+		const parsed = parseMCPToolName(tool.name);
+		const serverName = parsed?.serverName;
+
+		// Get provider info from manager's connection if available
+		const connection = serverName ? manager.getConnection(serverName) : undefined;
+		const provider = connection?._source?.provider;
+
+		// Format path with provider info if available
+		// Format: "mcp:serverName via providerName" (e.g., "mcp:agentx via Claude Code")
+		const path =
+			provider && serverName ? `mcp:${serverName} via ${connection._source!.providerName}` : `mcp:${tool.name}`;
+
+		return {
+			path,
+			resolvedPath: `mcp:${tool.name}`,
+			tool: tool as any, // MCPToolDetails is compatible with CustomTool<TSchema, any>
+		};
+	});
 
 	// Convert error map to array format
 	const errors: Array<{ path: string; error: string }> = [];

package/src/core/mcp/manager.ts

@@ -8,7 +8,7 @@
 import type { TSchema } from "@sinclair/typebox";
 import type { CustomTool } from "../custom-tools/types";
 import { connectToServer, disconnectServer, listTools } from "./client";
-import { type LoadMCPConfigsOptions, loadAllMCPConfigs, validateServerConfig } from "./config";
+import { loadAllMCPConfigs, validateServerConfig } from "./config";
 import type { MCPToolDetails } from "./tool-bridge";
 import { createMCPTools } from "./tool-bridge";
 import type { MCPServerConfig, MCPServerConnection } from "./types";
@@ -26,7 +26,11 @@ export interface MCPLoadResult {
 }
 
 /** Options for discovering and connecting to MCP servers */
-export interface MCPDiscoverOptions extends LoadMCPConfigsOptions {
+export interface MCPDiscoverOptions {
+	/** Whether to load project-level config (default: true) */
+	enableProjectConfig?: boolean;
+	/** Whether to filter out Exa MCP servers (default: true) */
+	filterExa?: boolean;
 	/** Called when starting to connect to servers */
 	onConnecting?: (serverNames: string[]) => void;
 }
@@ -46,26 +50,12 @@ export class MCPManager {
 	 * Discover and connect to all MCP servers from .mcp.json files.
 	 * Returns tools and any connection errors.
 	 */
-	async discoverAndConnect(
-		extraEnvOrOptions?: Record<string, string> | MCPDiscoverOptions,
-		onConnecting?: (serverNames: string[]) => void,
-	): Promise<MCPLoadResult> {
-		// Support old signature: discoverAndConnect(extraEnv, onConnecting)
-		const opts: MCPDiscoverOptions =
-			extraEnvOrOptions &&
-			("extraEnv" in extraEnvOrOptions ||
-				"enableProjectConfig" in extraEnvOrOptions ||
-				"filterExa" in extraEnvOrOptions ||
-				"onConnecting" in extraEnvOrOptions)
-				? (extraEnvOrOptions as MCPDiscoverOptions)
-				: { extraEnv: extraEnvOrOptions as Record<string, string> | undefined, onConnecting };
-
-		const { configs, exaApiKeys } = loadAllMCPConfigs(this.cwd, {
-			extraEnv: opts.extraEnv,
-			enableProjectConfig: opts.enableProjectConfig,
-			filterExa: opts.filterExa,
+	async discoverAndConnect(options?: MCPDiscoverOptions): Promise<MCPLoadResult> {
+		const { configs, exaApiKeys, sources } = await loadAllMCPConfigs(this.cwd, {
+			enableProjectConfig: options?.enableProjectConfig,
+			filterExa: options?.filterExa,
 		});
-		const result = await this.connectServers(configs, opts.onConnecting);
+		const result = await this.connectServers(configs, sources, options?.onConnecting);
 		result.exaApiKeys = exaApiKeys;
 		return result;
 	}
@@ -76,6 +66,7 @@ export class MCPManager {
 	 */
 	async connectServers(
 		configs: Record<string, MCPServerConfig>,
+		sources: Record<string, import("../../capability/types").SourceMeta>,
 		onConnecting?: (serverNames: string[]) => void,
 	): Promise<MCPLoadResult> {
 		const errors = new Map<string, string>();
@@ -115,6 +106,10 @@ export class MCPManager {
 		const results = await Promise.allSettled(
 			connectionTasks.map(async ({ name, config }) => {
 				const connection = await connectToServer(name, config);
+				// Attach source metadata to connection
+				if (sources[name]) {
+					connection._source = sources[name];
+				}
 				const serverTools = await listTools(connection);
 				return { name, connection, serverTools };
 			}),
@@ -229,12 +224,12 @@ export class MCPManager {
  */
 export async function createMCPManager(
 	cwd: string,
-	extraEnv?: Record<string, string>,
+	options?: MCPDiscoverOptions,
 ): Promise<{
 	manager: MCPManager;
 	result: MCPLoadResult;
 }> {
 	const manager = new MCPManager(cwd);
-	const result = await manager.discoverAndConnect(extraEnv);
+	const result = await manager.discoverAndConnect(options);
 	return { manager, result };
 }

package/src/core/mcp/tool-bridge.ts

@@ -19,6 +19,10 @@ export interface MCPToolDetails {
 	isError?: boolean;
 	/** Raw content from MCP response */
 	rawContent?: MCPContent[];
+	/** Provider ID (e.g., "claude", "mcp-json") */
+	provider?: string;
+	/** Provider display name (e.g., "Claude Code", "MCP Config") */
+	providerName?: string;
 }
 
 /**
@@ -74,7 +78,7 @@ export function parseMCPToolName(name: string): { serverName: string; toolName:
 	if (!name.startsWith("mcp_")) return null;
 
 	const rest = name.slice(4);
-	const underscoreIdx = rest.indexOf("_");
+	const underscoreIdx = rest.lastIndexOf("_");
 	if (underscoreIdx === -1) return null;
 
 	return {
@@ -109,6 +113,8 @@ export function createMCPTool(
 					mcpToolName: tool.name,
 					isError: result.isError,
 					rawContent: result.content,
+					provider: connection._source?.provider,
+					providerName: connection._source?.providerName,
 				};
 
 				if (result.isError) {
@@ -130,6 +136,8 @@ export function createMCPTool(
 						serverName: connection.name,
 						mcpToolName: tool.name,
 						isError: true,
+						provider: connection._source?.provider,
+						providerName: connection._source?.providerName,
 					},
 				};
 			}

package/src/core/mcp/types.ts

@@ -217,6 +217,8 @@ export interface MCPServerConnection {
 	capabilities: MCPServerCapabilities;
 	/** Cached tools (populated on demand) */
 	tools?: MCPToolDefinition[];
+	/** Source metadata (for display) */
+	_source?: import("../../capability/types").SourceMeta;
 }
 
 /** MCP tool with server context */

package/src/core/model-registry.ts

@@ -15,6 +15,7 @@ import {
 import { type Static, Type } from "@sinclair/typebox";
 import AjvModule from "ajv";
 import type { AuthStorage } from "./auth-storage";
+import { logger } from "./logger";
 
 const Ajv = (AjvModule as any).default || AjvModule;
 
@@ -92,9 +93,15 @@ export class ModelRegistry {
 	private customProviderApiKeys: Map<string, string> = new Map();
 	private loadError: string | undefined = undefined;
 
+	/**
+	 * @param authStorage - Auth storage for API key resolution
+	 * @param modelsJsonPath - Primary path for models.json
+	 * @param fallbackPaths - Additional paths to check (legacy support)
+	 */
 	constructor(
 		readonly authStorage: AuthStorage,
 		private modelsJsonPath: string | undefined = undefined,
+		private fallbackPaths: string[] = [],
 	) {
 		// Set up fallback resolver for custom provider API keys
 		this.authStorage.setFallbackResolver((provider) => {
@@ -133,15 +140,25 @@ export class ModelRegistry {
 			builtInModels.push(...(providerModels as Model<Api>[]));
 		}
 
-		// Load custom models from models.json (if path provided)
+		// Load custom models from models.json (check primary path, then fallbacks)
 		let customModels: Model<Api>[] = [];
-		if (this.modelsJsonPath) {
-			const result = this.loadCustomModels(this.modelsJsonPath);
-			if (result.error) {
-				this.loadError = result.error;
-				// Keep built-in models even if custom models failed to load
-			} else {
-				customModels = result.models;
+		const pathsToCheck = this.modelsJsonPath ? [this.modelsJsonPath, ...this.fallbackPaths] : this.fallbackPaths;
+
+		if (pathsToCheck.length > 0) {
+			logger.debug("ModelRegistry.loadModels checking paths", { paths: pathsToCheck });
+		}
+
+		for (const modelsPath of pathsToCheck) {
+			if (existsSync(modelsPath)) {
+				logger.debug("ModelRegistry.loadModels loading", { path: modelsPath });
+				const result = this.loadCustomModels(modelsPath);
+				if (result.error) {
+					this.loadError = result.error;
+					// Keep built-in models even if custom models failed to load
+				} else {
+					customModels = result.models;
+				}
+				break; // Use first existing file
 			}
 		}
 

package/src/core/plugins/installer.ts

@@ -39,7 +39,7 @@ export async function installPlugin(packageName: string): Promise<InstalledPlugi
 	// Initialize package.json if it doesn't exist
 	const pkgJsonPath = join(PLUGINS_DIR, "package.json");
 	if (!(await Bun.file(pkgJsonPath).exists())) {
-		await Bun.write(pkgJsonPath, JSON.stringify({ name: "pi-plugins", private: true, dependencies: {} }, null, 2));
+		await Bun.write(pkgJsonPath, JSON.stringify({ name: "omp-plugins", private: true, dependencies: {} }, null, 2));
 	}
 
 	// Run npm install in plugins directory

package/src/core/plugins/loader.ts

@@ -7,7 +7,12 @@
 
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getPluginsLockfile, getPluginsNodeModules, getPluginsPackageJson, getProjectPluginOverrides } from "./paths";
+import {
+	getAllProjectPluginOverridePaths,
+	getPluginsLockfile,
+	getPluginsNodeModules,
+	getPluginsPackageJson,
+} from "./paths";
 import type { InstalledPlugin, PluginManifest, PluginRuntimeConfig, ProjectPluginOverrides } from "./types";
 
 // =============================================================================
@@ -30,18 +35,19 @@ function loadRuntimeConfig(): PluginRuntimeConfig {
 }
 
 /**
- * Load project-local plugin overrides.
+ * Load project-local plugin overrides (checks .omp and .pi directories).
  */
 function loadProjectOverrides(cwd: string): ProjectPluginOverrides {
-	const overridesPath = getProjectPluginOverrides(cwd);
-	if (!existsSync(overridesPath)) {
-		return {};
-	}
-	try {
-		return JSON.parse(readFileSync(overridesPath, "utf-8"));
-	} catch {
-		return {};
+	for (const overridesPath of getAllProjectPluginOverridePaths(cwd)) {
+		if (existsSync(overridesPath)) {
+			try {
+				return JSON.parse(readFileSync(overridesPath, "utf-8"));
+			} catch {
+				// Continue to next path
+			}
+		}
 	}
+	return {};
 }
 
 // =============================================================================
@@ -79,7 +85,7 @@ export function getEnabledPlugins(cwd: string): InstalledPlugin[] {
 		const manifest: PluginManifest | undefined = pluginPkg.omp || pluginPkg.pi;
 
 		if (!manifest) {
-			// Not a pi plugin, skip
+			// Not an omp plugin, skip
 			continue;
 		}
 

package/src/core/plugins/manager.ts

@@ -110,7 +110,7 @@ export class PluginManager {
 				pkgJsonPath,
 				JSON.stringify(
 					{
-						name: "pi-plugins",
+						name: "omp-plugins",
 						private: true,
 						dependencies: {},
 					},
@@ -516,7 +516,7 @@ export class PluginManager {
 				status: hasManifest ? "ok" : "warning",
 				message: hasManifest
 					? `v${pluginPkg.version}${pluginPkg.description ? ` - ${pluginPkg.description}` : ""}`
-					: `v${pluginPkg.version} - No omp/pi manifest (not a pi plugin)`,
+					: `v${pluginPkg.version} - No omp/pi manifest (not an omp plugin)`,
 			});
 
 			// Check tools path exists if specified