mono-pilot 0.2.9 → 0.2.10

package/dist/src/rules/discovery.js

@@ -0,0 +1,41 @@
+import { existsSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+export const RULES_RELATIVE_DIR = join(".pi", "rules");
+/** List *.rule.txt full paths from a directory, sorted. Returns empty array if directory is missing. */
+export async function listRuleFiles(dirPath) {
+    if (!existsSync(dirPath))
+        return [];
+    try {
+        const entries = await readdir(dirPath, { withFileTypes: true, encoding: "utf8" });
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith(".rule.txt"))
+            .map((e) => resolve(dirPath, e.name))
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Discover rule files from project (.pi/rules/) and user (~/.pi/rules/) directories.
+ * Project rules take priority: a user rule with the same basename is excluded.
+ */
+export async function discoverRules(cwd) {
+    const projectDir = resolve(cwd, RULES_RELATIVE_DIR);
+    const userDir = resolve(homedir(), RULES_RELATIVE_DIR);
+    const [projectFiles, userFiles] = await Promise.all([listRuleFiles(projectDir), listRuleFiles(userDir)]);
+    // Project rules are processed first so they claim seenNames → user duplicates are dropped
+    const seenNames = new Set();
+    const dedupeByName = (files) => files.filter((filePath) => {
+        const name = basename(filePath, ".rule.txt");
+        if (seenNames.has(name))
+            return false;
+        seenNames.add(name);
+        return true;
+    });
+    const projectRules = dedupeByName(projectFiles);
+    const userRules = dedupeByName(userFiles);
+    return { userRules, projectRules };
+}

package/dist/src/utils/mcp-client.js

@@ -1,8 +1,7 @@
 import { existsSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { isAbsolute, join, resolve } from "node:path";
-import process from "node:process";
+import { join, resolve } from "node:path";
 export const MCP_CONFIG_RELATIVE_PATH = join(".pi", "mcp.json");
 export const MCP_PROTOCOL_VERSION = "2025-03-26";
 export const MCP_CLIENT_NAME = "mono-pilot";
@@ -30,18 +29,38 @@ export function formatErrorMessage(error) {
     return String(error);
 }
 export function resolveMcpConfigPath(workspaceCwd) {
-    const envOverride = toNonEmptyString(process.env.MONOPILOT_MCP_CONFIG);
-    const candidates = [];
-    if (envOverride) {
-        candidates.push(isAbsolute(envOverride) ? resolve(envOverride) : resolve(workspaceCwd, envOverride));
-    }
-    candidates.push(resolve(workspaceCwd, MCP_CONFIG_RELATIVE_PATH));
-    candidates.push(resolve(homedir(), MCP_CONFIG_RELATIVE_PATH));
-    for (const candidate of candidates) {
-        if (existsSync(candidate))
-            return candidate;
+    const sources = resolveMcpConfigSources(workspaceCwd);
+    return sources[0]?.path;
+}
+export function getMcpConfigCandidates(workspaceCwd) {
+    return [resolve(workspaceCwd, MCP_CONFIG_RELATIVE_PATH), resolve(homedir(), MCP_CONFIG_RELATIVE_PATH)];
+}
+export function resolveMcpConfigSources(workspaceCwd) {
+    const projectPath = resolve(workspaceCwd, MCP_CONFIG_RELATIVE_PATH);
+    const userPath = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
+    const sources = [];
+    if (existsSync(projectPath))
+        sources.push({ scope: "project", path: projectPath });
+    if (existsSync(userPath))
+        sources.push({ scope: "user", path: userPath });
+    return sources;
+}
+export async function loadMcpConfig(workspaceCwd) {
+    const sources = resolveMcpConfigSources(workspaceCwd);
+    if (sources.length === 0)
+        return undefined;
+    const servers = {};
+    const sourceByServer = {};
+    for (const source of sources) {
+        const parsed = await parseMcpConfig(source.path);
+        for (const [serverName, serverConfig] of Object.entries(parsed)) {
+            if (sourceByServer[serverName])
+                continue;
+            servers[serverName] = serverConfig;
+            sourceByServer[serverName] = source;
+        }
     }
-    return undefined;
+    return { servers, sources, sourceByServer };
 }
 export async function parseMcpConfig(configPath) {
     const rawText = await readFile(configPath, "utf-8");

package/dist/tools/README.md

@@ -36,7 +36,7 @@ Tool descriptions are now loaded by the tool implementation and exposed via the
 - `subagent.ts` / `subagent-description.md` (`Subagent`)
   - Launch delegated subagent subprocesses with foreground/background and parallel orchestration.
 - `list-mcp-resources.ts` (`ListMcpResources`)
-  - Read `.pi/mcp.json` config and list MCP resources with server metadata.
+  - Read `.pi/mcp.json` (project) and `~/.pi/mcp.json` (user) configs to list MCP resources with server metadata.
 - `fetch-mcp-resource.ts` (`FetchMcpResource`)
   - Fetch a specific MCP resource by server + URI, optionally writing to workspace.
 - `list-mcp-tools.ts` (`ListMcpTools`)

package/dist/tools/call-mcp-tool.js

@@ -1,9 +1,9 @@
-import { homedir } from "node:os";
-import { resolve } from "node:path";
 import { DEFAULT_MAX_BYTES, DEFAULT_MAX_LINES, formatSize, keyHint, truncateTail, } from "@mariozechner/pi-coding-agent";
 import { Text } from "@mariozechner/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { createRpcRequestId, extractStringHeaders, formatErrorMessage, formatJsonRpcError, getHeaderKeys, inferTransport, isRecord, isServerEnabled, MCP_CONFIG_RELATIVE_PATH, parseMcpConfig, postJsonRpcRequest, resolveMcpConfigPath, toBoolean, toNonEmptyString, initializeMcpSession, } from "../src/utils/mcp-client.js";
+import { McpServerError, resolveTargetServer } from "../src/mcp/servers.js";
+import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../src/mcp/protocol.js";
+import { formatErrorMessage, getHeaderKeys, isRecord, toBoolean, toNonEmptyString } from "../src/mcp/config.js";
 const DESCRIPTION = `Call an MCP tool by server identifier and tool name with arbitrary JSON arguments. IMPORTANT: Always read the tool's schema/descriptor BEFORE calling to ensure correct parameters.
 
 Example:
@@ -45,10 +45,7 @@ async function callRemoteMcpTool(options) {
     if (!callBody || callBody.result === undefined) {
         throw new Error("MCP tools/call returned no result.");
     }
-    return {
-        result: callBody.result,
-        sessionId,
-    };
+    return { result: callBody.result, sessionId };
 }
 function normalizeServerName(value) {
     const normalized = value.trim();
@@ -142,19 +139,12 @@ function formatToolCallResultOutput(server, toolName, result) {
         lines.push(JSON.stringify(result, null, 2));
         lines.push("```");
     }
-    return {
-        text: lines.join("\n"),
-        contentItems,
-        isError,
-        hasStructuredContent,
-    };
+    return { text: lines.join("\n"), contentItems, isError, hasStructuredContent };
 }
 function getCollapsedResultText(text, expanded) {
-    if (text.length === 0) {
+    if (text.length === 0)
         return { output: text, remaining: 0 };
-    }
     const lines = text.split("\n");
-    // Use 20 lines as the standard collapse threshold
     const MAX_COLLAPSED_RESULT_LINES = 20;
     if (expanded || lines.length <= MAX_COLLAPSED_RESULT_LINES) {
         return { output: text, remaining: 0 };
@@ -217,90 +207,21 @@ export default function callMcpToolExtension(pi) {
                     isError: true,
                 };
             }
-            const configPath = resolveMcpConfigPath(ctx.cwd);
-            if (!configPath) {
-                const workspaceCandidate = resolve(ctx.cwd, MCP_CONFIG_RELATIVE_PATH);
-                const homeCandidate = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
-                const message = `MCP config not found. Checked:\n- ${workspaceCandidate}\n- ${homeCandidate}`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        server: serverName,
-                        tool_name: toolName,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            let servers;
+            let server;
+            let configPaths;
             try {
-                servers = await parseMcpConfig(configPath);
+                const result = await resolveTargetServer(ctx.cwd, serverName);
+                server = result.server;
+                configPaths = result.configPaths;
             }
             catch (error) {
                 const message = formatErrorMessage(error);
+                const transport = error instanceof McpServerError ? error.transport : undefined;
+                const paths = error instanceof McpServerError ? error.configPaths : undefined;
                 return {
                     content: [{ type: "text", text: message }],
                     details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const serverConfig = servers[serverName];
-            if (!serverConfig) {
-                const message = `MCP server '${serverName}' not found in ${configPath}.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            if (!isServerEnabled(serverConfig)) {
-                const message = `MCP server '${serverName}' is disabled in config.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        transport: inferTransport(serverConfig),
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const transport = inferTransport(serverConfig);
-            if (transport === "stdio") {
-                const command = toNonEmptyString(serverConfig.command);
-                const message = `MCP stdio transport is not supported yet in CallMcpTool.` +
-                    (command ? ` Configured command: ${command}` : "");
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        tool_name: toolName,
-                        transport,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const serverUrl = toNonEmptyString(serverConfig.url);
-            if (!serverUrl) {
-                const message = `MCP server '${serverName}' is missing a remote URL.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
+                        config_paths: paths,
                         server: serverName,
                         tool_name: toolName,
                         transport,
@@ -309,11 +230,10 @@ export default function callMcpToolExtension(pi) {
                     isError: true,
                 };
             }
-            const headers = extractStringHeaders(serverConfig.headers);
             try {
                 const remoteResult = await callRemoteMcpTool({
-                    serverUrl,
-                    serverHeaders: headers,
+                    serverUrl: server.url,
+                    serverHeaders: server.headers,
                     toolName,
                     argumentsValue,
                     signal,
@@ -331,12 +251,12 @@ export default function callMcpToolExtension(pi) {
                 return {
                     content: [{ type: "text", text: output }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         tool_name: toolName,
-                        transport,
-                        server_url: serverUrl,
-                        header_keys: getHeaderKeys(headers),
+                        transport: "remote",
+                        server_url: server.url,
+                        header_keys: getHeaderKeys(server.headers),
                         session_id: remoteResult.sessionId,
                         content_items: formatted.contentItems,
                         is_error: formatted.isError,
@@ -351,12 +271,12 @@ export default function callMcpToolExtension(pi) {
                 return {
                     content: [{ type: "text", text: `CallMcpTool failed: ${message}` }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         tool_name: toolName,
-                        transport,
-                        server_url: serverUrl,
-                        header_keys: getHeaderKeys(headers),
+                        transport: "remote",
+                        server_url: server.url,
+                        header_keys: getHeaderKeys(server.headers),
                         error: message,
                     },
                     isError: true,

package/dist/tools/fetch-mcp-resource.js

@@ -1,7 +1,9 @@
-import { homedir } from "node:os";
+import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { Type } from "@sinclair/typebox";
-import { createRpcRequestId, extractStringHeaders, formatErrorMessage, formatJsonRpcError, inferTransport, isRecord, isServerEnabled, MCP_CONFIG_RELATIVE_PATH, parseMcpConfig, postJsonRpcRequest, resolveMcpConfigPath, toNonEmptyString, initializeMcpSession, } from "../src/utils/mcp-client.js";
+import { McpServerError, resolveTargetServer } from "../src/mcp/servers.js";
+import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../src/mcp/protocol.js";
+import { formatErrorMessage, isRecord, toNonEmptyString } from "../src/mcp/config.js";
 const DESCRIPTION = `Reads a specific resource from an MCP server, identified by server name and resource URI. Optionally, set downloadPath (relative to the workspace) to save the resource to disk; when set, the resource will be downloaded and not returned to the model.`;
 const fetchMcpResourceSchema = Type.Object({
     server: Type.String({ description: "The MCP server identifier" }),
@@ -19,9 +21,7 @@ async function fetchRemoteMcpResource(options) {
             jsonrpc: "2.0",
             id: createRpcRequestId(`${options.toolCallId}:resources.read`),
             method: "resources/read",
-            params: {
-                uri: options.uri,
-            },
+            params: { uri: options.uri },
         },
         parentSignal: options.signal,
         sessionId,
@@ -104,75 +104,21 @@ export default function fetchMcpResourceExtension(pi) {
                     isError: true,
                 };
             }
-            const configPath = resolveMcpConfigPath(ctx.cwd);
-            if (!configPath) {
-                const workspaceCandidate = resolve(ctx.cwd, MCP_CONFIG_RELATIVE_PATH);
-                const homeCandidate = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
-                const message = `MCP config not found. Checked:\n- ${workspaceCandidate}\n- ${homeCandidate}`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        server: serverName,
-                        uri,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            let servers;
+            let server;
+            let configPaths;
             try {
-                servers = await parseMcpConfig(configPath);
+                const result = await resolveTargetServer(ctx.cwd, serverName);
+                server = result.server;
+                configPaths = result.configPaths;
             }
             catch (error) {
                 const message = formatErrorMessage(error);
+                const transport = error instanceof McpServerError ? error.transport : undefined;
+                const paths = error instanceof McpServerError ? error.configPaths : undefined;
                 return {
                     content: [{ type: "text", text: message }],
                     details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const serverConfig = servers[serverName];
-            if (!serverConfig) {
-                const message = `MCP server '${serverName}' not found in ${configPath}.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            if (!isServerEnabled(serverConfig)) {
-                const message = `MCP server '${serverName}' is disabled in config.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        transport: inferTransport(serverConfig),
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const transport = inferTransport(serverConfig);
-            if (transport === "stdio") {
-                const command = toNonEmptyString(serverConfig.command);
-                const message = `MCP stdio transport is not supported yet in FetchMcpResource.` +
-                    (command ? ` Configured command: ${command}` : "");
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
+                        config_paths: paths,
                         server: serverName,
                         uri,
                         transport,
@@ -181,26 +127,10 @@ export default function fetchMcpResourceExtension(pi) {
                     isError: true,
                 };
             }
-            const serverUrl = toNonEmptyString(serverConfig.url);
-            if (!serverUrl) {
-                const message = `MCP server '${serverName}' is missing a remote URL.`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        server: serverName,
-                        uri,
-                        transport,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const headers = extractStringHeaders(serverConfig.headers);
             try {
                 const contents = await fetchRemoteMcpResource({
-                    serverUrl,
-                    serverHeaders: headers,
+                    serverUrl: server.url,
+                    serverHeaders: server.headers,
                     uri,
                     signal,
                     toolCallId,
@@ -209,20 +139,19 @@ export default function fetchMcpResourceExtension(pi) {
                     return {
                         content: [{ type: "text", text: `Resource '${uri}' returned no content.` }],
                         details: {
-                            config_path: configPath,
+                            config_paths: configPaths,
                             server: serverName,
                             uri,
-                            transport,
-                            server_url: serverUrl,
+                            transport: "remote",
+                            server_url: server.url,
                             contents_count: 0,
                         },
                     };
                 }
                 if (downloadPath) {
-                    // We only support downloading the first content item currently
+                    // Only the first content item is downloaded
                     const contentToDownload = contents[0];
                     const absoluteTarget = resolve(ctx.cwd, downloadPath);
-                    const { mkdir, writeFile } = await import("node:fs/promises");
                     await mkdir(dirname(absoluteTarget), { recursive: true });
                     let bytesWritten = 0;
                     if (contentToDownload.blob !== undefined) {
@@ -245,17 +174,16 @@ export default function fetchMcpResourceExtension(pi) {
                             },
                         ],
                         details: {
-                            config_path: configPath,
+                            config_paths: configPaths,
                             server: serverName,
                             uri,
-                            transport,
-                            server_url: serverUrl,
+                            transport: "remote",
+                            server_url: server.url,
                             contents_count: contents.length,
                             downloaded_to: downloadPath,
                         },
                     };
                 }
-                // Return contents directly
                 const lines = [];
                 for (let i = 0; i < contents.length; i++) {
                     const item = contents[i];
@@ -279,11 +207,11 @@ export default function fetchMcpResourceExtension(pi) {
                 return {
                     content: [{ type: "text", text: lines.join("\n").trim() }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         uri,
-                        transport,
-                        server_url: serverUrl,
+                        transport: "remote",
+                        server_url: server.url,
                         contents_count: contents.length,
                     },
                 };
@@ -293,11 +221,11 @@ export default function fetchMcpResourceExtension(pi) {
                 return {
                     content: [{ type: "text", text: `FetchMcpResource failed: ${message}` }],
                     details: {
-                        config_path: configPath,
+                        config_paths: configPaths,
                         server: serverName,
                         uri,
-                        transport,
-                        server_url: serverUrl,
+                        transport: "remote",
+                        server_url: server.url,
                         error: message,
                     },
                     isError: true,

package/dist/tools/list-mcp-resources.js

@@ -1,7 +1,7 @@
-import { homedir } from "node:os";
-import { resolve } from "node:path";
 import { Type } from "@sinclair/typebox";
-import { createRpcRequestId, extractStringHeaders, formatErrorMessage, formatJsonRpcError, inferTransport, isRecord, isServerEnabled, MCP_CONFIG_RELATIVE_PATH, parseMcpConfig, postJsonRpcRequest, resolveMcpConfigPath, toNonEmptyString, initializeMcpSession, } from "../src/utils/mcp-client.js";
+import { resolveTargetServers } from "../src/mcp/servers.js";
+import { createRpcRequestId, formatJsonRpcError, initializeMcpSession, postJsonRpcRequest } from "../src/mcp/protocol.js";
+import { formatErrorMessage, isRecord, toNonEmptyString } from "../src/mcp/config.js";
 const DESCRIPTION = `List available resources from configured MCP servers. Each returned resource will include all standard MCP resource fields plus a 'server' field indicating which server the resource belongs to. MCP resources are _not_ the same as tools, so don't call this function to discover MCP tools.`;
 const listMcpResourcesSchema = Type.Object({
     server: Type.Optional(Type.String({
@@ -49,12 +49,9 @@ async function listRemoteMcpResources(options) {
             mimeType: toNonEmptyString(raw.mimeType),
         });
     }
-    return {
-        resources,
-        nextCursor: toNonEmptyString(resourcesBody.result.nextCursor),
-    };
+    return { resources, nextCursor: toNonEmptyString(resourcesBody.result.nextCursor) };
 }
-function normalizeServerFilter(value) {
+function normalizeOptionalString(value) {
     if (typeof value !== "string")
         return undefined;
     const normalized = value.trim();
@@ -67,9 +64,13 @@ export default function listMcpResourcesExtension(pi) {
         description: DESCRIPTION,
         parameters: listMcpResourcesSchema,
         async execute(toolCallId, params, signal, _onUpdate, ctx) {
-            let serverFilter;
+            const serverFilter = normalizeOptionalString(params.server);
+            let targetServers;
+            let sources;
             try {
-                serverFilter = normalizeServerFilter(params.server);
+                const result = await resolveTargetServers(ctx.cwd, serverFilter);
+                targetServers = result.servers;
+                sources = result.sources;
             }
             catch (error) {
                 const message = formatErrorMessage(error);
@@ -79,49 +80,6 @@ export default function listMcpResourcesExtension(pi) {
                     isError: true,
                 };
             }
-            const configPath = resolveMcpConfigPath(ctx.cwd);
-            if (!configPath) {
-                const workspaceCandidate = resolve(ctx.cwd, MCP_CONFIG_RELATIVE_PATH);
-                const homeCandidate = resolve(homedir(), MCP_CONFIG_RELATIVE_PATH);
-                const message = `MCP config not found. Checked:\n- ${workspaceCandidate}\n- ${homeCandidate}`;
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: { error: message },
-                    isError: true,
-                };
-            }
-            let servers;
-            try {
-                servers = await parseMcpConfig(configPath);
-            }
-            catch (error) {
-                const message = formatErrorMessage(error);
-                return {
-                    content: [{ type: "text", text: message }],
-                    details: {
-                        config_path: configPath,
-                        error: message,
-                    },
-                    isError: true,
-                };
-            }
-            const targetServers = [];
-            for (const [serverName, serverConfig] of Object.entries(servers)) {
-                if (serverFilter && serverName !== serverFilter)
-                    continue;
-                if (!isServerEnabled(serverConfig))
-                    continue;
-                if (inferTransport(serverConfig) !== "remote")
-                    continue;
-                const serverUrl = toNonEmptyString(serverConfig.url);
-                if (!serverUrl)
-                    continue;
-                targetServers.push({
-                    name: serverName,
-                    url: serverUrl,
-                    headers: extractStringHeaders(serverConfig.headers),
-                });
-            }
             if (targetServers.length === 0) {
                 const message = serverFilter
                     ? `No active remote MCP server found matching '${serverFilter}'.`
@@ -129,13 +87,16 @@ export default function listMcpResourcesExtension(pi) {
                 return {
                     content: [{ type: "text", text: message }],
                     details: {
-                        config_path: configPath,
+                        config_paths: sources.map((s) => s.path),
                         servers_matched: 0,
                     },
                 };
             }
             const lines = [];
-            lines.push(`MCP config: ${configPath}`);
+            lines.push("MCP config:");
+            for (const source of sources) {
+                lines.push(`- ${source.scope}: ${source.path}`);
+            }
             lines.push(`Servers matched: ${targetServers.length}`);
             if (serverFilter)
                 lines.push(`Server filter: ${serverFilter}`);
@@ -162,8 +123,7 @@ export default function listMcpResourcesExtension(pi) {
                         if (resource.mimeType)
                             lines.push(`  mimeType: ${resource.mimeType}`);
                         if (resource.description) {
-                            const descLines = resource.description.split("\n");
-                            for (const descLine of descLines) {
+                            for (const descLine of resource.description.split("\n")) {
                                 lines.push(`  ${descLine}`);
                             }
                         }
@@ -180,7 +140,7 @@ export default function listMcpResourcesExtension(pi) {
             return {
                 content: [{ type: "text", text: lines.join("\n") }],
                 details: {
-                    config_path: configPath,
+                    config_paths: sources.map((s) => s.path),
                     servers_matched: targetServers.length,
                     servers_queried: targetServers.length,
                     servers_failed: serversFailed,