codex-plugin-doctor 1.49.0 → 1.51.0

package/dist/core/runtime-probe.js

@@ -1,8 +1,9 @@
 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 { 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 +13,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 +35,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 +68,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 +102,9 @@ function withRuntimeEvidence(finding, serverName) {
     return {
         ...finding,
         evidence: {
+            ...(finding.evidence ?? {}),
             serverName,
-            method: methodForRuntimeFinding(finding.id),
-            ...(finding.evidence ?? {})
+            method: methodForRuntimeFinding(finding.id)
         }
     };
 }
@@ -228,15 +249,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 +289,57 @@ 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;
+    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 } : {})
+    };
+}
+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 +358,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 +537,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 +848,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 +868,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 +1015,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 +1026,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";
+                    }
                 }
-                scorecard.toolsCall = "pass";
-                warnings.push(...collectOversizedToolCallWarnings(toolCallResponse, {
-                    toolName: callableTool.tool.name
-                }));
+                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.");
+                }
+                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 +1218,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,6 +1261,7 @@ 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;
@@ -1023,20 +1273,32 @@ export async function probeRuntime(discoveredPackage, options = {}) {
         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;
+        const cwd = await resolveRuntimeCwd(canonicalRootPath, config.cwd);
+        const 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/domain/types.d.ts

@@ -90,6 +90,40 @@ export interface RuntimeScorecard {
     resourceTemplatesList: RuntimeCapabilityStatus;
     promptsList: RuntimeCapabilityStatus;
     promptGet: RuntimeCapabilityStatus;
+    conformance?: RuntimeConformanceScorecard;
+}
+export type McpConformanceProfile = "legacy" | "2025-11-25" | "future-compatible";
+export interface RuntimeConformanceScorecard {
+    protocolVersion: string | null;
+    profile: McpConformanceProfile | null;
+    capabilityConsistency: RuntimeCapabilityStatus;
+    taskDeclarations: RuntimeCapabilityStatus;
+    tasksList: RuntimeCapabilityStatus;
+    schemaDialect: RuntimeCapabilityStatus;
+    overall: "pass" | "warn" | "fail" | "skipped";
+}
+export interface McpToolObservation {
+    name: string;
+    inputSchema: unknown;
+    outputSchema?: unknown;
+    execution?: unknown;
+}
+export interface TasksListObservation {
+    status: "pass" | "fail" | "skipped";
+    itemCount: number;
+    pageCount: number;
+    failure?: "timeout" | "invalid";
+}
+export interface McpConformanceObservation {
+    protocolVersion: string;
+    capabilities: unknown;
+    tools: McpToolObservation[];
+    tasksList?: TasksListObservation;
+    skipToolDerivedChecks?: boolean;
+}
+export interface McpConformanceResult {
+    findings: Finding[];
+    scorecard: RuntimeConformanceScorecard;
 }
 export interface RuntimeProbeResult {
     findings: Finding[];

package/dist/mcp/generic-mcp-doctor.d.ts

@@ -1,5 +1,5 @@
 import { type CompatibilityEnvironment, type CompatibilityMatrix } from "../compatibility/compatibility-matrix.js";
-import type { Finding } from "../domain/types.js";
+import type { Finding, RuntimeExecutionEvidence, RuntimeScorecard } from "../domain/types.js";
 import { type SecurityAudit } from "../security/security-audit.js";
 export interface GenericMcpDoctorReport {
     targetPath: string;
@@ -10,7 +10,13 @@ export interface GenericMcpDoctorReport {
     findings: Finding[];
     security: SecurityAudit;
     compatibility: CompatibilityMatrix;
+    runtimeScorecard?: RuntimeScorecard;
+    runtimeExecution?: RuntimeExecutionEvidence;
 }
-export declare function buildGenericMcpDoctor(targetPath: string, environment?: CompatibilityEnvironment): Promise<GenericMcpDoctorReport>;
+export interface GenericMcpDoctorOptions {
+    runtime?: boolean;
+    runtimeStartupTimeoutMs?: number;
+}
+export declare function buildGenericMcpDoctor(targetPath: string, environment?: CompatibilityEnvironment, options?: GenericMcpDoctorOptions): Promise<GenericMcpDoctorReport>;
 export declare function renderGenericMcpDoctorJson(report: GenericMcpDoctorReport): string;
 export declare function renderGenericMcpDoctor(report: GenericMcpDoctorReport): string;