codex-plugin-doctor 1.50.0 → 1.52.0

package/dist/core/runtime-probe.js

@@ -1,8 +1,10 @@
 import { execFile, spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
-import { readFile, stat } from "node:fs/promises";
+import { readFile, realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import readline from "node:readline";
+import { evaluateMcpConformance } from "./mcp-conformance.js";
+import { probeRemoteMcpServer } from "./remote-mcp-probe.js";
 import { buildRuntimeLaunch, DOCKER_RUNTIME_STARTUP_TIMEOUT_MS, RuntimeSandboxError } from "./runtime-sandbox.js";
 import { formatRequestTranscript as formatRequestTranscriptForLog, formatResponseTranscript as formatResponseTranscriptForLog } from "./runtime-transcript.js";
 const MCP_PROTOCOL_VERSION = "2025-11-25";
@@ -12,6 +14,7 @@ const MAX_TOOL_CALL_CONTENT_LENGTH = 4096;
 const MAX_RESOURCE_READ_CONTENT_LENGTH = 4096;
 const MAX_PROMPT_GET_CONTENT_LENGTH = 4096;
 const DOCKER_CLEANUP_TIMEOUT_MS = 5_000;
+const MAX_RUNTIME_PAGINATION_PAGES = 100;
 function buildNativeRuntimeLaunch(input) {
     return {
         ...input,
@@ -33,7 +36,16 @@ function createRuntimeScorecard() {
         resourceRead: "unsupported",
         resourceTemplatesList: "unsupported",
         promptsList: "unsupported",
-        promptGet: "unsupported"
+        promptGet: "unsupported",
+        conformance: {
+            protocolVersion: null,
+            profile: null,
+            capabilityConsistency: "skipped",
+            taskDeclarations: "skipped",
+            tasksList: "skipped",
+            schemaDialect: "skipped",
+            overall: "skipped"
+        }
     };
 }
 function buildFailure(id, message, impact, suggestedFix, evidence) {
@@ -57,6 +69,16 @@ function buildWarning(id, message, impact, suggestedFix, evidence) {
     };
 }
 function methodForRuntimeFinding(id) {
+    if (id.startsWith("mcp.conformance.protocol.") ||
+        id.startsWith("mcp.conformance.tasks.capability_")) {
+        return "initialize";
+    }
+    if (id.startsWith("mcp.conformance.tasks.task_support_") ||
+        id.startsWith("mcp.conformance.schema.")) {
+        return "tools/list";
+    }
+    if (id.startsWith("mcp.conformance.tasks_list."))
+        return "tasks/list";
     if (id.includes(".initialize."))
         return "initialize";
     if (id.includes(".tools_list."))
@@ -81,9 +103,9 @@ function withRuntimeEvidence(finding, serverName) {
     return {
         ...finding,
         evidence: {
+            ...(finding.evidence ?? {}),
             serverName,
-            method: methodForRuntimeFinding(finding.id),
-            ...(finding.evidence ?? {})
+            method: methodForRuntimeFinding(finding.id)
         }
     };
 }
@@ -228,15 +250,7 @@ function isPathWithinRoot(rootPath, candidatePath) {
     return (relativePath === "" ||
         (!relativePath.startsWith("..") && !path.isAbsolute(relativePath)));
 }
-async function loadMcpServers(discoveredPackage) {
-    const { manifest, rootPath } = discoveredPackage;
-    if (!manifest.mcpServers) {
-        return null;
-    }
-    const mcpConfigPath = path.resolve(rootPath, manifest.mcpServers);
-    if (!isPathWithinRoot(rootPath, mcpConfigPath)) {
-        return null;
-    }
+async function loadMcpServers(mcpConfigPath) {
     const exists = await fileExists(mcpConfigPath);
     if (!exists) {
         return null;
@@ -276,6 +290,80 @@ function hasPromptsCapability(message) {
     const capabilities = getCapabilities(message);
     return capabilities !== null && isPlainObject(capabilities.prompts);
 }
+function worstRuntimeStatus(left, right) {
+    const severity = {
+        fail: 4,
+        warn: 3,
+        pass: 2,
+        skipped: 1,
+        unsupported: 0
+    };
+    return severity[left] >= severity[right] ? left : right;
+}
+function mergeRuntimeScorecards(left, right) {
+    const leftConformance = left.conformance;
+    const rightConformance = right.conformance;
+    const conformance = leftConformance && rightConformance
+        ? {
+            protocolVersion: leftConformance.protocolVersion === null
+                ? rightConformance.protocolVersion
+                : rightConformance.protocolVersion === null ||
+                    leftConformance.protocolVersion === rightConformance.protocolVersion
+                    ? leftConformance.protocolVersion
+                    : null,
+            profile: leftConformance.profile === null
+                ? rightConformance.profile
+                : rightConformance.profile === null || leftConformance.profile === rightConformance.profile
+                    ? leftConformance.profile
+                    : null,
+            capabilityConsistency: worstRuntimeStatus(leftConformance.capabilityConsistency, rightConformance.capabilityConsistency),
+            taskDeclarations: worstRuntimeStatus(leftConformance.taskDeclarations, rightConformance.taskDeclarations),
+            tasksList: worstRuntimeStatus(leftConformance.tasksList, rightConformance.tasksList),
+            schemaDialect: worstRuntimeStatus(leftConformance.schemaDialect, rightConformance.schemaDialect),
+            overall: worstRuntimeStatus(leftConformance.overall, rightConformance.overall)
+        }
+        : leftConformance ?? rightConformance;
+    const remote = left.remote && right.remote
+        ? mergeRemoteRuntimeScorecards(left.remote, right.remote)
+        : left.remote ?? right.remote;
+    return {
+        initialize: worstRuntimeStatus(left.initialize, right.initialize),
+        toolsList: worstRuntimeStatus(left.toolsList, right.toolsList),
+        toolsCall: worstRuntimeStatus(left.toolsCall, right.toolsCall),
+        resourcesList: worstRuntimeStatus(left.resourcesList, right.resourcesList),
+        resourceRead: worstRuntimeStatus(left.resourceRead, right.resourceRead),
+        resourceTemplatesList: worstRuntimeStatus(left.resourceTemplatesList, right.resourceTemplatesList),
+        promptsList: worstRuntimeStatus(left.promptsList, right.promptsList),
+        promptGet: worstRuntimeStatus(left.promptGet, right.promptGet),
+        ...(conformance ? { conformance } : {}),
+        ...(remote ? { remote } : {})
+    };
+}
+function mergeRemoteRuntimeScorecards(left, right) {
+    const sessionSeverity = {
+        "present-invalid": 2,
+        "present-valid": 1,
+        absent: 0
+    };
+    return {
+        transport: worstRuntimeStatus(left.transport, right.transport),
+        networkSafety: worstRuntimeStatus(left.networkSafety, right.networkSafety),
+        initialize: worstRuntimeStatus(left.initialize, right.initialize),
+        contentType: worstRuntimeStatus(left.contentType, right.contentType),
+        session: sessionSeverity[left.session] >= sessionSeverity[right.session]
+            ? left.session
+            : right.session,
+        protocolHeaders: worstRuntimeStatus(left.protocolHeaders, right.protocolHeaders),
+        authorization: worstRuntimeStatus(left.authorization, right.authorization),
+        overall: worstRuntimeStatus(left.overall, right.overall)
+    };
+}
+function supportsTasksListProbe(protocolVersion, capabilities) {
+    if (protocolVersion < MCP_PROTOCOL_VERSION || !isPlainObject(capabilities.tasks)) {
+        return false;
+    }
+    return isPlainObject(capabilities.tasks.list);
+}
 function getNextCursor(result) {
     if (result.nextCursor === undefined) {
         return null;
@@ -294,13 +382,14 @@ function extractToolsPage(message) {
     for (const tool of tools) {
         if (!isPlainObject(tool) ||
             typeof tool.name !== "string" ||
-            !isPlainObject(tool.inputSchema) ||
-            tool.inputSchema.type !== "object") {
+            !("inputSchema" in tool)) {
             return null;
         }
         parsedTools.push({
             name: tool.name,
-            inputSchema: tool.inputSchema
+            inputSchema: tool.inputSchema,
+            ...(tool.outputSchema === undefined ? {} : { outputSchema: tool.outputSchema }),
+            ...(tool.execution === undefined ? {} : { execution: tool.execution })
         });
     }
     const nextCursor = getNextCursor(message.result);
@@ -472,16 +561,55 @@ function findCallableTool(tools) {
         if (isDestructiveTool(tool)) {
             continue;
         }
-        const args = buildToolArguments(tool);
+        if (!isPlainObject(tool.inputSchema) || tool.inputSchema.type !== "object") {
+            continue;
+        }
+        const callableTool = {
+            name: tool.name,
+            inputSchema: tool.inputSchema
+        };
+        const args = buildToolArguments(callableTool);
         if (args !== undefined) {
             return {
-                tool,
+                tool: callableTool,
                 args
             };
         }
     }
     return null;
 }
+function hasValidToolInputSchemas(tools) {
+    return tools.every((tool) => isPlainObject(tool.inputSchema) && tool.inputSchema.type === "object");
+}
+async function resolveRuntimeCwd(rootPath, configuredCwd) {
+    const resolvedCwd = typeof configuredCwd === "string"
+        ? path.resolve(rootPath, configuredCwd)
+        : rootPath;
+    try {
+        const [canonicalCwd, details] = await Promise.all([
+            realpath(resolvedCwd),
+            stat(resolvedCwd)
+        ]);
+        return details.isDirectory() && isPathWithinRoot(rootPath, canonicalCwd)
+            ? canonicalCwd
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function isProtocolVersion(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    if (!match) {
+        return false;
+    }
+    const [year, month, day] = match.slice(1).map(Number);
+    const date = new Date(0);
+    date.setUTCFullYear(year, month - 1, day);
+    return (date.getUTCFullYear() === year &&
+        date.getUTCMonth() === month - 1 &&
+        date.getUTCDate() === day);
+}
 function buildPromptArguments(prompt) {
     if (!prompt.arguments || prompt.arguments.length === 0) {
         return undefined;
@@ -744,7 +872,12 @@ async function probeCommandServer(input) {
         const fetchPaginated = async (input) => {
             let cursor = null;
             const items = [];
+            const seenCursors = new Set();
+            let pageCount = 0;
             do {
+                if (pageCount >= MAX_RUNTIME_PAGINATION_PAGES) {
+                    return null;
+                }
                 const response = await sendRequest(input.method, cursor ? { cursor } : undefined, input.timeoutFinding);
                 transcript?.(formatResponseTranscriptForLog(input.method, response));
                 if (isErrorResponse(response)) {
@@ -759,10 +892,81 @@ async function probeCommandServer(input) {
                     return null;
                 }
                 items.push(...page.items);
+                pageCount += 1;
+                if (page.nextCursor && seenCursors.has(page.nextCursor)) {
+                    return null;
+                }
+                if (page.nextCursor) {
+                    seenCursors.add(page.nextCursor);
+                }
                 cursor = page.nextCursor;
             } while (cursor);
             return items;
         };
+        const observeTasksList = async () => {
+            let cursor = null;
+            const seenCursors = new Set();
+            let itemCount = 0;
+            let pageCount = 0;
+            try {
+                do {
+                    if (pageCount >= MAX_RUNTIME_PAGINATION_PAGES) {
+                        return {
+                            status: "fail",
+                            itemCount,
+                            pageCount,
+                            failure: "invalid"
+                        };
+                    }
+                    const response = await sendRequest("tasks/list", cursor ? { cursor } : undefined, buildFailure("mcp.conformance.tasks_list.timeout", `The MCP server \`${serverName}\` did not answer the tasks/list request in time.`, "Codex cannot safely inspect task discovery when the server does not complete tasks/list.", "Reduce tasks/list latency and verify pagination completes."));
+                    if (isErrorResponse(response) || !isPlainObject(response.result)) {
+                        return {
+                            status: "fail",
+                            itemCount,
+                            pageCount,
+                            failure: "invalid"
+                        };
+                    }
+                    const tasks = response.result.tasks;
+                    const nextCursor = getNextCursor(response.result);
+                    if (!Array.isArray(tasks) ||
+                        !tasks.every(isPlainObject) ||
+                        nextCursor === "__invalid__") {
+                        return {
+                            status: "fail",
+                            itemCount,
+                            pageCount,
+                            failure: "invalid"
+                        };
+                    }
+                    itemCount += tasks.length;
+                    pageCount += 1;
+                    if (nextCursor && seenCursors.has(nextCursor)) {
+                        return {
+                            status: "fail",
+                            itemCount,
+                            pageCount,
+                            failure: "invalid"
+                        };
+                    }
+                    if (nextCursor) {
+                        seenCursors.add(nextCursor);
+                    }
+                    cursor = nextCursor;
+                } while (cursor);
+            }
+            catch (error) {
+                return {
+                    status: "fail",
+                    itemCount,
+                    pageCount,
+                    failure: isFinding(error) && error.id === "mcp.conformance.tasks_list.timeout"
+                        ? "timeout"
+                        : "invalid"
+                };
+            }
+            return { status: "pass", itemCount, pageCount };
+        };
         child.stderr?.on("data", (chunk) => {
             if (stderrPreview.length >= 160) {
                 return;
@@ -835,6 +1039,7 @@ async function probeCommandServer(input) {
             }
             const result = initializeResponse.result;
             if (typeof result.protocolVersion !== "string" ||
+                !isProtocolVersion(result.protocolVersion) ||
                 !isPlainObject(result.capabilities) ||
                 !isPlainObject(result.serverInfo) ||
                 typeof result.serverInfo.name !== "string" ||
@@ -845,43 +1050,79 @@ async function probeCommandServer(input) {
             }
             scorecard.initialize = "pass";
             sendNotification("notifications/initialized");
+            let tools = [];
+            let toolTerminalFinding = null;
+            let canEvaluateConformance = true;
             if (!hasToolsCapability(initializeResponse)) {
                 scorecard.toolsList = "unsupported";
                 scorecard.toolsCall = "unsupported";
-                settle(buildWarning("plugin.runtime.tools.unsupported", `The MCP server \`${serverName}\` does not advertise tools capability.`, "Codex cannot use `tools/list` for deeper validation if the server does not declare tools support.", "Expose `capabilities.tools` during initialize if this server is expected to provide tools."));
-                return;
-            }
-            const tools = await fetchPaginated({
-                method: "tools/list",
-                timeoutFinding: buildFailure("plugin.runtime.tools_list.timeout", `The MCP server \`${serverName}\` did not answer the tools/list request in time.`, "A server that cannot return its tool catalog in time will feel broken or invisible in Codex.", "Inspect the tool discovery path and reduce latency before returning the tool list."),
-                extractPage: extractToolsPage
-            });
-            if (!tools) {
-                scorecard.toolsList = "fail";
-                settle(buildFailure("plugin.runtime.tools_list.invalid", `The MCP server \`${serverName}\` returned an invalid tools/list result.`, "Codex cannot safely consume malformed tool definitions from `tools/list`.", "Return a `tools` array where every tool has a string `name` and an object-shaped `inputSchema` with `type: \"object\"`."));
-                return;
-            }
-            scorecard.toolsList = "pass";
-            const callableTool = findCallableTool(tools);
-            if (!callableTool) {
-                scorecard.toolsCall = "skipped";
-                settle(buildWarning("plugin.runtime.tool_call.skipped", `The MCP server \`${serverName}\` does not expose a safely callable tool for probing.`, "The validator confirmed tool discovery but could not safely perform a non-destructive `tools/call` probe.", "Expose at least one non-destructive tool with a JSON schema the validator can generate arguments for."));
-                return;
+                warnings.push(buildWarning("plugin.runtime.tools.unsupported", `The MCP server \`${serverName}\` does not advertise tools capability.`, "Codex cannot use `tools/list` for deeper validation if the server does not declare tools support.", "Expose `capabilities.tools` during initialize if this server is expected to provide tools."));
             }
             else {
-                const toolCallResponse = await sendRequest("tools/call", {
-                    name: callableTool.tool.name,
-                    arguments: callableTool.args
-                }, buildFailure("plugin.runtime.tool_call.timeout", `The MCP server \`${serverName}\` did not answer the tools/call request in time.`, "A server that cannot complete a basic tool invocation in time will feel broken in real Codex usage.", "Inspect the selected tool implementation and reduce its response latency.", { toolName: callableTool.tool.name }));
-                if (isErrorResponse(toolCallResponse) || !isValidCallToolResult(toolCallResponse)) {
-                    scorecard.toolsCall = "fail";
-                    settle(buildFailure("plugin.runtime.tool_call.invalid", `The MCP server \`${serverName}\` returned an invalid tools/call result.`, "Codex cannot safely consume malformed tool call results from the server.", "Return a CallToolResult with a `content` array containing valid MCP content blocks.", { toolName: callableTool.tool.name }));
-                    return;
+                const listedTools = await fetchPaginated({
+                    method: "tools/list",
+                    timeoutFinding: buildFailure("plugin.runtime.tools_list.timeout", `The MCP server \`${serverName}\` did not answer the tools/list request in time.`, "A server that cannot return its tool catalog in time will feel broken or invisible in Codex.", "Inspect the tool discovery path and reduce latency before returning the tool list."),
+                    extractPage: extractToolsPage
+                });
+                if (!listedTools) {
+                    canEvaluateConformance = false;
+                    scorecard.toolsList = "fail";
+                    toolTerminalFinding = buildFailure("plugin.runtime.tools_list.invalid", `The MCP server \`${serverName}\` returned an invalid tools/list result.`, "Codex cannot safely consume malformed tool definitions from `tools/list`.", "Return a `tools` array where every tool has a string `name` and an object-shaped `inputSchema` with `type: \"object\"`.");
+                }
+                else {
+                    tools = listedTools;
+                    if (!hasValidToolInputSchemas(tools)) {
+                        canEvaluateConformance = false;
+                        scorecard.toolsList = "fail";
+                        toolTerminalFinding = buildFailure("plugin.runtime.tools_list.invalid", `The MCP server \`${serverName}\` returned an invalid tools/list result.`, "Codex cannot safely consume malformed tool definitions from `tools/list`.", "Return a `tools` array where every tool has a string `name` and an object-shaped `inputSchema` with `type: \"object\"`.");
+                    }
+                    else {
+                        scorecard.toolsList = "pass";
+                    }
+                }
+                const callableTool = toolTerminalFinding ? null : findCallableTool(tools);
+                if (!toolTerminalFinding && !callableTool) {
+                    scorecard.toolsCall = "skipped";
+                    toolTerminalFinding = buildWarning("plugin.runtime.tool_call.skipped", `The MCP server \`${serverName}\` does not expose a safely callable tool for probing.`, "The validator confirmed tool discovery but could not safely perform a non-destructive `tools/call` probe.", "Expose at least one non-destructive tool with a JSON schema the validator can generate arguments for.");
                 }
-                scorecard.toolsCall = "pass";
-                warnings.push(...collectOversizedToolCallWarnings(toolCallResponse, {
-                    toolName: callableTool.tool.name
-                }));
+                else if (callableTool) {
+                    const toolCallResponse = await sendRequest("tools/call", {
+                        name: callableTool.tool.name,
+                        arguments: callableTool.args
+                    }, buildFailure("plugin.runtime.tool_call.timeout", `The MCP server \`${serverName}\` did not answer the tools/call request in time.`, "A server that cannot complete a basic tool invocation in time will feel broken in real Codex usage.", "Inspect the selected tool implementation and reduce its response latency.", { toolName: callableTool.tool.name }));
+                    if (isErrorResponse(toolCallResponse) || !isValidCallToolResult(toolCallResponse)) {
+                        scorecard.toolsCall = "fail";
+                        toolTerminalFinding = buildFailure("plugin.runtime.tool_call.invalid", `The MCP server \`${serverName}\` returned an invalid tools/call result.`, "Codex cannot safely consume malformed tool call results from the server.", "Return a CallToolResult with a `content` array containing valid MCP content blocks.", { toolName: callableTool.tool.name });
+                    }
+                    if (!toolTerminalFinding) {
+                        scorecard.toolsCall = "pass";
+                        warnings.push(...collectOversizedToolCallWarnings(toolCallResponse, {
+                            toolName: callableTool.tool.name
+                        }));
+                    }
+                }
+            }
+            const tasksList = supportsTasksListProbe(result.protocolVersion, result.capabilities)
+                ? await observeTasksList()
+                : {
+                    status: "skipped",
+                    itemCount: 0,
+                    pageCount: 0
+                };
+            if (canEvaluateConformance || tasksList.status !== "skipped") {
+                const conformance = evaluateMcpConformance({
+                    protocolVersion: result.protocolVersion,
+                    capabilities: result.capabilities,
+                    tools: tools,
+                    tasksList,
+                    skipToolDerivedChecks: !canEvaluateConformance
+                });
+                scorecard.conformance = conformance.scorecard;
+                warnings.push(...conformance.findings);
+            }
+            if (toolTerminalFinding) {
+                settle(toolTerminalFinding);
+                return;
             }
             if (!hasResourcesCapability(initializeResponse)) {
                 scorecard.resourcesList = "unsupported";
@@ -1001,8 +1242,40 @@ async function probeCommandServer(input) {
     });
 }
 export async function probeRuntime(discoveredPackage, options = {}) {
+    const { manifest, rootPath } = discoveredPackage;
+    if (!manifest.mcpServers) {
+        return {
+            findings: [],
+            scorecard: createRuntimeScorecard()
+        };
+    }
+    return probeRuntimeConfig(rootPath, manifest.mcpServers, options);
+}
+export async function probeRuntimeConfig(rootPath, mcpConfigPath, options = {}) {
+    const resolvedRootPath = path.resolve(rootPath);
+    const resolvedMcpConfigPath = path.resolve(resolvedRootPath, mcpConfigPath);
     const startupTimeoutMs = options.startupTimeoutMs ?? 400;
-    const servers = await loadMcpServers(discoveredPackage);
+    let canonicalRootPath;
+    let canonicalMcpConfigPath;
+    try {
+        [canonicalRootPath, canonicalMcpConfigPath] = await Promise.all([
+            realpath(resolvedRootPath),
+            realpath(resolvedMcpConfigPath)
+        ]);
+    }
+    catch {
+        return {
+            findings: [],
+            scorecard: createRuntimeScorecard()
+        };
+    }
+    if (!isPathWithinRoot(canonicalRootPath, canonicalMcpConfigPath)) {
+        return {
+            findings: [],
+            scorecard: createRuntimeScorecard()
+        };
+    }
+    const servers = await loadMcpServers(canonicalMcpConfigPath);
     if (!servers) {
         return {
             findings: [],
@@ -1012,31 +1285,63 @@ export async function probeRuntime(discoveredPackage, options = {}) {
     const findings = [];
     let scorecard = createRuntimeScorecard();
     let execution;
+    let hasProbedServer = false;
     for (const [serverName, config] of Object.entries(servers)) {
         if (!isPlainObject(config)) {
             continue;
         }
-        const command = config.command;
-        if (typeof command !== "string") {
-            continue;
+        const url = config.url;
+        let result;
+        if (typeof url === "string") {
+            const remote = await probeRemoteMcpServer(serverName, url, {
+                allowNetwork: options.allowNetwork,
+                allowLocalNetwork: options.allowLocalNetwork,
+                requestTimeoutMs: options.remoteRequestTimeoutMs,
+                lookup: options.remoteLookup,
+                request: options.remoteRequest
+            });
+            const remoteScorecard = createRuntimeScorecard();
+            remoteScorecard.remote = remote.scorecard;
+            result = {
+                findings: remote.findings.map((finding) => withRuntimeEvidence(finding, serverName)),
+                scorecard: remoteScorecard
+            };
         }
-        const args = Array.isArray(config.args)
-            ? config.args.filter((value) => typeof value === "string")
-            : [];
-        const cwd = typeof config.cwd === "string"
-            ? path.resolve(discoveredPackage.rootPath, config.cwd)
-            : discoveredPackage.rootPath;
-        const result = await probeCommandServer({
-            serverName,
-            packageRoot: discoveredPackage.rootPath,
-            command,
-            args,
-            cwd,
-            startupTimeoutMs,
-            sandbox: options.sandbox,
-            transcript: options.transcript
-        });
-        scorecard = result.scorecard;
+        else {
+            const command = config.command;
+            if (typeof command !== "string") {
+                continue;
+            }
+            const args = Array.isArray(config.args)
+                ? config.args.filter((value) => typeof value === "string")
+                : [];
+            const cwd = await resolveRuntimeCwd(canonicalRootPath, config.cwd);
+            result = cwd === null
+                ? (() => {
+                    const invalidCwdScorecard = createRuntimeScorecard();
+                    invalidCwdScorecard.initialize = "fail";
+                    return {
+                        findings: [
+                            withRuntimeEvidence(buildFailure("plugin.runtime.startup.invalid_cwd", `The MCP server \`${serverName}\` has an invalid runtime working directory.`, "Runtime validation must not start a server from a missing, non-directory, or out-of-package working directory.", "Set the MCP server cwd to an existing directory inside the plugin package root, or remove it."), serverName)
+                        ],
+                        scorecard: invalidCwdScorecard
+                    };
+                })()
+                : await probeCommandServer({
+                    serverName,
+                    packageRoot: canonicalRootPath,
+                    command,
+                    args,
+                    cwd,
+                    startupTimeoutMs,
+                    sandbox: options.sandbox,
+                    transcript: options.transcript
+                });
+        }
+        scorecard = hasProbedServer
+            ? mergeRuntimeScorecards(scorecard, result.scorecard)
+            : result.scorecard;
+        hasProbedServer = true;
         execution = result.execution ?? execution;
         if (result.findings.length > 0) {
             findings.push(...result.findings);

package/dist/core/runtime-transcript.js

@@ -73,15 +73,20 @@ export function formatRequestTranscript(method, params) {
     if (!params) {
         return `-> ${method}`;
     }
+    if (method === "tasks/list" && params.cursor !== undefined) {
+        return '-> tasks/list {"cursor":"[CURSOR]"}';
+    }
     return `-> ${method} ${JSON.stringify(sanitizeTranscriptValue(params))}`;
 }
 export function formatResponseTranscript(method, message) {
     const error = getErrorObject(message);
     if (error) {
         const code = typeof error.code === "number" ? error.code : "?";
-        const messageText = typeof error.message === "string"
-            ? sanitizeTranscriptValue(error.message, ["error", "message"])
-            : "error";
+        const messageText = method === "tasks/list"
+            ? "[REDACTED]"
+            : typeof error.message === "string"
+                ? sanitizeTranscriptValue(error.message, ["error", "message"])
+                : "error";
         return `<- ${method} error ${JSON.stringify({
             code,
             message: messageText
@@ -129,6 +134,11 @@ export function formatResponseTranscript(method, message) {
                 prompts: Array.isArray(result.prompts) ? result.prompts.length : 0,
                 nextCursor: typeof result.nextCursor === "string" ? "[CURSOR]" : undefined
             })}`;
+        case "tasks/list":
+            return `<- tasks/list ${JSON.stringify({
+                tasks: Array.isArray(result.tasks) ? result.tasks.length : 0,
+                nextCursor: typeof result.nextCursor === "string" ? "[CURSOR]" : undefined
+            })}`;
         case "prompts/get":
             return `<- prompts/get ${JSON.stringify({
                 messages: Array.isArray(result.messages) ? result.messages.length : 0

package/dist/core/validate-plugin.js

@@ -2,6 +2,7 @@ import { readFile, readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { withFindingFingerprints } from "../reporting/finding-fingerprint.js";
 import { discoverPackage } from "./discover-package.js";
+import { inspectRemoteMcpUrl } from "./remote-url-policy.js";
 import { probeRuntime } from "./runtime-probe.js";
 function buildFailure(id, message, impact, suggestedFix, evidence) {
     return {
@@ -23,6 +24,16 @@ function buildWarning(id, message, impact, suggestedFix, evidence) {
         ...(evidence ? { evidence } : {})
     };
 }
+function remoteUrlIssueFindingId(issue) {
+    return issue === "insecure_non_loopback"
+        ? "plugin.security.insecure_http_url"
+        : `plugin.security.remote_mcp_url.${issue}`;
+}
+function remoteUrlIssueMessage(issue) {
+    return issue === "insecure_non_loopback"
+        ? "uses an insecure public HTTP URL"
+        : `uses a remote MCP URL with ${issue.replaceAll("_", " ")}`;
+}
 async function directoryExists(targetPath) {
     try {
         const details = await stat(targetPath);
@@ -376,6 +387,24 @@ async function validateMcpConfig(discoveredPackage) {
                 field: "transport"
             }));
         }
+        if (typeof command === "string" && typeof url === "string") {
+            findings.push(buildFailure("plugin.mcp.server.transport.conflict", `The MCP server \`${serverName}\` must not define both \`command\` and \`url\`.`, "A server with two transports cannot be selected deterministically by MCP clients.", `Keep either \`command\` or \`url\` for the \`${serverName}\` entry in \`${mcpConfigPath}\`.`, {
+                configPath: relativePackagePath(rootPath, mcpConfigPath),
+                serverName,
+                field: "transport"
+            }));
+        }
+        if (typeof url === "string") {
+            const inspection = inspectRemoteMcpUrl(url);
+            for (const issue of inspection.issues) {
+                findings.push(buildFailure(remoteUrlIssueFindingId(issue), `The MCP server \`${serverName}\` ${remoteUrlIssueMessage(issue)}.`, "Unsafe or ambiguous remote transport configuration can expose credentials or prevent reliable MCP connectivity.", "Use an absolute HTTPS URL without credentials, query parameters, fragments, or numeric IP literals; HTTP is only supported for localhost development.", {
+                    configPath: relativePackagePath(rootPath, mcpConfigPath),
+                    serverName,
+                    field: "url",
+                    url: inspection.sanitizedUrl
+                }));
+            }
+        }
         if (isPlainObject(env)) {
             for (const [envKey, envValue] of Object.entries(env)) {
                 if (isSensitiveKey(envKey) &&
@@ -415,7 +444,9 @@ export async function validatePlugin(targetPath, options = {}) {
         ? await probeRuntime(discoveredPackage, {
             startupTimeoutMs: options.runtimeStartupTimeoutMs,
             sandbox: options.runtimeSandbox,
-            transcript: options.runtimeTranscript
+            transcript: options.runtimeTranscript,
+            allowNetwork: options.allowNetwork,
+            allowLocalNetwork: options.allowLocalNetwork
         })
         : null;
     const findings = [