codex-plugin-doctor 1.50.0 → 1.52.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 Furkan Tasci
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 Furkan Tasci
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -78,10 +78,21 @@ Runtime MCP validation with `--runtime`:
 - paginated list responses
 - runtime capability scorecard
 - redacted verbose transcript with `--verbose-runtime`
-- optional runtime approval gating with a precomputed `doctor runtime-plan` digest
-- optional Docker isolation for local Node.js stdio servers with `--sandbox docker`
-
-Output formats:
+- optional runtime approval gating with a precomputed `doctor runtime-plan` digest
+- optional Docker isolation for local Node.js stdio servers with `--sandbox docker`
+
+### Remote MCP Readiness
+
+Remote MCP runtime probing is disabled until you explicitly pass `--allow-network`. Local endpoints also require `--allow-local-network`:
+
+```bash
+codex-plugin-doctor check ./remote-mcp --runtime --allow-network
+codex-plugin-doctor check ./remote-mcp --runtime --allow-network --allow-local-network
+```
+
+The probe makes only bounded, read-only protocol and OAuth metadata-discovery requests, redacts report output, and applies SSRF controls. It does not authenticate or follow redirects. See [Remote MCP Readiness](./docs/architecture/remote-mcp-readiness.md).
+
+Output formats:
 
 - human text output
 - JSON reports
@@ -427,9 +438,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: Esquetta/CodexPluginDoctor@v1.50.0
+      - uses: Esquetta/CodexPluginDoctor@v1.52.0
         with:
-          version: "1.50.0"
+          version: "1.52.0"
           path: .
           runtime: "true"
           policy: codex-publish

package/dist/core/bounded-http-client.d.ts

@@ -0,0 +1,23 @@
+import { type RemoteLookup } from "./remote-network-policy.js";
+export interface BoundedHttpRequestOptions {
+    allowLocalNetwork?: boolean;
+    lookup?: RemoteLookup;
+    timeoutMs?: number;
+    maxResponseBytes?: number;
+    method?: string;
+    body?: string | Buffer;
+    headers?: Record<string, string | undefined>;
+    stopAfter?: (body: Buffer) => boolean;
+}
+export interface BoundedHttpResponse {
+    statusCode: number;
+    headers: Record<string, string | string[]>;
+    body: Buffer;
+}
+export declare class BoundedHttpError extends Error {
+    readonly code: "REMOTE_HTTP_ENCODING_UNSUPPORTED" | "REMOTE_HTTP_HEADER_FORBIDDEN" | "REMOTE_HTTP_OPTIONS_INVALID" | "REMOTE_HTTP_PEER_MISMATCH" | "REMOTE_HTTP_REDIRECT" | "REMOTE_HTTP_REQUEST_FAILED" | "REMOTE_HTTP_RESPONSE_TOO_LARGE" | "REMOTE_HTTP_STOP_CONDITION_FAILED" | "REMOTE_HTTP_TIMEOUT" | "REMOTE_HTTP_URL_CREDENTIALS" | "REMOTE_HTTP_URL_UNSUPPORTED";
+    readonly statusCode?: number | undefined;
+    readonly headers?: Record<string, string | string[]> | undefined;
+    constructor(code: "REMOTE_HTTP_ENCODING_UNSUPPORTED" | "REMOTE_HTTP_HEADER_FORBIDDEN" | "REMOTE_HTTP_OPTIONS_INVALID" | "REMOTE_HTTP_PEER_MISMATCH" | "REMOTE_HTTP_REDIRECT" | "REMOTE_HTTP_REQUEST_FAILED" | "REMOTE_HTTP_RESPONSE_TOO_LARGE" | "REMOTE_HTTP_STOP_CONDITION_FAILED" | "REMOTE_HTTP_TIMEOUT" | "REMOTE_HTTP_URL_CREDENTIALS" | "REMOTE_HTTP_URL_UNSUPPORTED", message: string, statusCode?: number | undefined, headers?: Record<string, string | string[]> | undefined);
+}
+export declare function requestBoundedHttp(rawUrl: string, options?: BoundedHttpRequestOptions): Promise<BoundedHttpResponse>;

package/dist/core/bounded-http-client.js

@@ -0,0 +1,240 @@
+import * as http from "node:http";
+import * as https from "node:https";
+import { BlockList, isIP } from "node:net";
+import { resolveRemoteTarget } from "./remote-network-policy.js";
+const DEFAULT_TIMEOUT_MS = 3_000;
+const DEFAULT_MAX_RESPONSE_BYTES = 1_024 * 1_024;
+const allowedRequestHeaders = new Set([
+    "accept",
+    "content-type",
+    "mcp-protocol-version",
+    "mcp-session-id",
+    "user-agent"
+]);
+const safeResponseHeaders = new Set([
+    "content-type",
+    "www-authenticate",
+    "mcp-session-id",
+    "mcp-protocol-version",
+    "location"
+]);
+export class BoundedHttpError extends Error {
+    code;
+    statusCode;
+    headers;
+    constructor(code, message, statusCode, headers) {
+        super(message);
+        this.code = code;
+        this.statusCode = statusCode;
+        this.headers = headers;
+        this.name = "BoundedHttpError";
+    }
+}
+function validateHeaders(headers) {
+    const validated = {};
+    for (const [name, value] of Object.entries(headers ?? {})) {
+        if (value === undefined) {
+            continue;
+        }
+        const normalizedName = name.toLowerCase();
+        if (!allowedRequestHeaders.has(normalizedName)) {
+            throw new BoundedHttpError("REMOTE_HTTP_HEADER_FORBIDDEN", `Remote HTTP request header is not allowed: ${normalizedName}.`);
+        }
+        if (normalizedName in validated || typeof value !== "string") {
+            throw new BoundedHttpError("REMOTE_HTTP_HEADER_FORBIDDEN", `Remote HTTP request header must be a single valid string: ${normalizedName}.`);
+        }
+        try {
+            http.validateHeaderValue(normalizedName, value);
+        }
+        catch {
+            throw new BoundedHttpError("REMOTE_HTTP_HEADER_FORBIDDEN", `Remote HTTP request header must be a single valid string: ${normalizedName}.`);
+        }
+        validated[normalizedName] = value;
+    }
+    return validated;
+}
+function validateOptions(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const maxResponseBytes = options.maxResponseBytes ?? DEFAULT_MAX_RESPONSE_BYTES;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > DEFAULT_TIMEOUT_MS
+        || !Number.isInteger(maxResponseBytes) || maxResponseBytes < 1 || maxResponseBytes > DEFAULT_MAX_RESPONSE_BYTES) {
+        throw new BoundedHttpError("REMOTE_HTTP_OPTIONS_INVALID", "Remote HTTP request options are invalid.");
+    }
+    return { timeoutMs, maxResponseBytes };
+}
+async function resolveWithinDeadline(url, options, timeoutMs) {
+    let timer;
+    try {
+        return await Promise.race([
+            resolveRemoteTarget(url, {
+                allowLocalNetwork: options.allowLocalNetwork,
+                lookup: options.lookup
+            }),
+            new Promise((_resolve, reject) => {
+                timer = setTimeout(() => {
+                    reject(new BoundedHttpError("REMOTE_HTTP_TIMEOUT", "Remote HTTP request timed out."));
+                }, timeoutMs);
+            })
+        ]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+}
+function selectSafeHeaders(headers) {
+    const selected = {};
+    for (const name of safeResponseHeaders) {
+        const value = headers[name];
+        if (value !== undefined) {
+            selected[name] = value;
+        }
+    }
+    return selected;
+}
+function hasIdentityContentEncoding(headers) {
+    const value = headers["content-encoding"];
+    const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
+    return values.every((entry) => entry.toLowerCase() === "identity");
+}
+function matchesTargetPeer(target, remoteAddress) {
+    if (remoteAddress === undefined || isIP(remoteAddress) === 0) {
+        return false;
+    }
+    const peers = new BlockList();
+    peers.addAddress(target.address, target.family === 4 ? "ipv4" : "ipv6");
+    if (target.family === 4) {
+        peers.addAddress(`::ffff:${target.address}`, "ipv6");
+    }
+    return peers.check(remoteAddress, isIP(remoteAddress) === 4 ? "ipv4" : "ipv6");
+}
+export async function requestBoundedHttp(rawUrl, options = {}) {
+    let url;
+    try {
+        url = new URL(rawUrl);
+    }
+    catch {
+        throw new BoundedHttpError("REMOTE_HTTP_URL_UNSUPPORTED", "Remote HTTP URL must be absolute HTTP or HTTPS.");
+    }
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new BoundedHttpError("REMOTE_HTTP_URL_UNSUPPORTED", "Remote HTTP URL must be absolute HTTP or HTTPS.");
+    }
+    if (url.username || url.password) {
+        throw new BoundedHttpError("REMOTE_HTTP_URL_CREDENTIALS", "Remote HTTP URL must not include credentials.");
+    }
+    const { timeoutMs, maxResponseBytes } = validateOptions(options);
+    const headers = validateHeaders(options.headers);
+    const deadline = Date.now() + timeoutMs;
+    const target = await resolveWithinDeadline(url, options, timeoutMs);
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0) {
+        throw new BoundedHttpError("REMOTE_HTTP_TIMEOUT", "Remote HTTP request timed out.");
+    }
+    const transport = url.protocol === "https:" ? https : http;
+    return new Promise((resolve, reject) => {
+        let request;
+        let response;
+        let settled = false;
+        const timeout = setTimeout(() => {
+            fail(new BoundedHttpError("REMOTE_HTTP_TIMEOUT", "Remote HTTP request timed out."));
+        }, remainingMs);
+        const fail = (error) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            response?.destroy();
+            request?.destroy();
+            reject(error);
+        };
+        const complete = (body) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timeout);
+            response?.destroy();
+            request?.destroy();
+            resolve({
+                statusCode: response?.statusCode ?? 0,
+                headers: response ? selectSafeHeaders(response.headers) : {},
+                body
+            });
+        };
+        try {
+            request = transport.request({
+                protocol: url.protocol,
+                hostname: url.hostname,
+                port: url.port || undefined,
+                path: `${url.pathname}${url.search}`,
+                method: options.method ?? "GET",
+                headers,
+                agent: false,
+                lookup: (_hostname, lookupOptions, callback) => {
+                    if (lookupOptions.all) {
+                        callback(null, [{ address: target.address, family: target.family }]);
+                        return;
+                    }
+                    callback(null, target.address, target.family);
+                }
+            });
+        }
+        catch {
+            fail(new BoundedHttpError("REMOTE_HTTP_REQUEST_FAILED", "Remote HTTP request failed."));
+            return;
+        }
+        request.once("error", () => {
+            fail(new BoundedHttpError("REMOTE_HTTP_REQUEST_FAILED", "Remote HTTP request failed."));
+        });
+        request.once("response", (incoming) => {
+            response = incoming;
+            const safeHeaders = selectSafeHeaders(incoming.headers);
+            if (!matchesTargetPeer(target, incoming.socket.remoteAddress)) {
+                fail(new BoundedHttpError("REMOTE_HTTP_PEER_MISMATCH", "Remote HTTP peer did not match the resolved target."));
+                return;
+            }
+            if ((incoming.statusCode ?? 0) >= 300 && (incoming.statusCode ?? 0) < 400) {
+                fail(new BoundedHttpError("REMOTE_HTTP_REDIRECT", "Remote HTTP redirects are not allowed.", incoming.statusCode, safeHeaders));
+                return;
+            }
+            if (!hasIdentityContentEncoding(incoming.headers)) {
+                fail(new BoundedHttpError("REMOTE_HTTP_ENCODING_UNSUPPORTED", "Remote HTTP response content encoding must be identity."));
+                return;
+            }
+            const chunks = [];
+            let receivedBytes = 0;
+            incoming.on("data", (chunk) => {
+                receivedBytes += chunk.length;
+                if (receivedBytes > maxResponseBytes) {
+                    fail(new BoundedHttpError("REMOTE_HTTP_RESPONSE_TOO_LARGE", "Remote HTTP response exceeded the configured size limit."));
+                    return;
+                }
+                chunks.push(chunk);
+                const body = Buffer.concat(chunks);
+                let shouldStop;
+                try {
+                    shouldStop = options.stopAfter?.(body) ?? false;
+                }
+                catch {
+                    fail(new BoundedHttpError("REMOTE_HTTP_STOP_CONDITION_FAILED", "Remote HTTP stop condition failed."));
+                    return;
+                }
+                if (shouldStop) {
+                    complete(body);
+                    return;
+                }
+            });
+            incoming.once("error", () => {
+                fail(new BoundedHttpError("REMOTE_HTTP_REQUEST_FAILED", "Remote HTTP request failed."));
+            });
+            incoming.once("end", () => {
+                if (!settled) {
+                    complete(Buffer.concat(chunks));
+                }
+            });
+        });
+        request.end(options.body);
+    });
+}

package/dist/core/mcp-conformance.d.ts

@@ -0,0 +1,2 @@
+import type { McpConformanceObservation, McpConformanceResult } from "../domain/types.js";
+export declare function evaluateMcpConformance(observation: McpConformanceObservation): McpConformanceResult;

package/dist/core/mcp-conformance.js

@@ -0,0 +1,215 @@
+const LATEST_PROTOCOL_VERSION = "2025-11-25";
+const LEGACY_PROTOCOL_VERSIONS = new Set([
+    "2024-11-05",
+    "2025-03-26",
+    "2025-06-18"
+]);
+const CANONICAL_SCHEMA_DIALECT = "https://json-schema.org/draft/2020-12/schema";
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildFinding(id, severity, message, impact, suggestedFix, evidence) {
+    return {
+        id,
+        severity,
+        message,
+        impact,
+        suggestedFix,
+        ...(evidence ? { evidence } : {})
+    };
+}
+function classifyProtocolVersion(protocolVersion) {
+    if (LEGACY_PROTOCOL_VERSIONS.has(protocolVersion)) {
+        return "legacy";
+    }
+    if (protocolVersion === LATEST_PROTOCOL_VERSION) {
+        return "2025-11-25";
+    }
+    if (/^\d{4}-\d{2}-\d{2}$/.test(protocolVersion) && protocolVersion > LATEST_PROTOCOL_VERSION) {
+        return "future-compatible";
+    }
+    return "legacy";
+}
+function addTaskCapabilityFailure(findings, field) {
+    findings.push(buildFinding("mcp.conformance.tasks.capability_invalid", "fail", `The Tasks capability field \`${field}\` must be an object when present.`, "Codex cannot safely determine whether the server supports task-aware tool calls.", `Return an object for \`${field}\`, or omit the capability until it is implemented.`, { field }));
+}
+function getTaskToolsCallCapabilityState(capabilities, findings) {
+    if (!isPlainObject(capabilities)) {
+        addTaskCapabilityFailure(findings, "capabilities");
+        return "malformed";
+    }
+    const tasks = capabilities.tasks;
+    if (tasks === undefined) {
+        return "missing";
+    }
+    if (!isPlainObject(tasks)) {
+        addTaskCapabilityFailure(findings, "capabilities.tasks");
+        return "malformed";
+    }
+    for (const key of ["list", "cancel"]) {
+        if (tasks[key] !== undefined && !isPlainObject(tasks[key])) {
+            addTaskCapabilityFailure(findings, `capabilities.tasks.${key}`);
+        }
+    }
+    const requests = tasks.requests;
+    if (requests === undefined) {
+        return "missing";
+    }
+    if (!isPlainObject(requests)) {
+        addTaskCapabilityFailure(findings, "capabilities.tasks.requests");
+        return "malformed";
+    }
+    const tools = requests.tools;
+    if (tools === undefined) {
+        return "missing";
+    }
+    if (!isPlainObject(tools)) {
+        addTaskCapabilityFailure(findings, "capabilities.tasks.requests.tools");
+        return "malformed";
+    }
+    const call = tools.call;
+    if (call === undefined) {
+        return "missing";
+    }
+    if (!isPlainObject(call)) {
+        addTaskCapabilityFailure(findings, "capabilities.tasks.requests.tools.call");
+        return "malformed";
+    }
+    return "present-valid";
+}
+function collectTaskDeclarationFindings(observation, taskCallCapabilityState, findings) {
+    for (const tool of observation.tools) {
+        let taskSupport = "forbidden";
+        if (tool.execution !== undefined) {
+            if (!isPlainObject(tool.execution)) {
+                findings.push(buildFinding("mcp.conformance.tasks.task_support_invalid", "fail", `Tool \`${tool.name}\` has a non-object execution declaration.`, "Codex cannot safely interpret the tool's task support contract.", "Return an object for `execution` with taskSupport set to required, optional, or forbidden.", { toolName: tool.name }));
+                continue;
+            }
+            taskSupport = tool.execution.taskSupport ?? "forbidden";
+        }
+        if (taskSupport !== "required" &&
+            taskSupport !== "optional" &&
+            taskSupport !== "forbidden") {
+            findings.push(buildFinding("mcp.conformance.tasks.task_support_invalid", "fail", `Tool \`${tool.name}\` declares an unsupported taskSupport value.`, "Codex cannot determine whether task-aware tool calls are required or optional.", "Set execution.taskSupport to required, optional, or forbidden.", { toolName: tool.name }));
+            continue;
+        }
+        if (taskSupport !== "forbidden" && taskCallCapabilityState === "missing") {
+            findings.push(buildFinding("mcp.conformance.tasks.capability_mismatch", "fail", `Tool \`${tool.name}\` declares task support without tasks.requests.tools.call capability.`, "Codex may attempt task-aware tool calls that the server did not advertise as supported.", "Advertise capabilities.tasks.requests.tools.call as an object, or set execution.taskSupport to forbidden.", { toolName: tool.name, taskSupport }));
+        }
+    }
+}
+function isAbsoluteUri(value) {
+    try {
+        return new URL(value).protocol.length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+function collectSchemaFindings(observation, findings) {
+    for (const tool of observation.tools) {
+        const schemas = [
+            ["inputSchema", tool.inputSchema]
+        ];
+        if (tool.outputSchema !== undefined) {
+            schemas.push(["outputSchema", tool.outputSchema]);
+        }
+        for (const [schemaName, schema] of schemas) {
+            if (!isPlainObject(schema)) {
+                findings.push(buildFinding("mcp.conformance.schema.dialect_invalid", "fail", `Tool \`${tool.name}\` has a non-object ${schemaName} container.`, "Codex cannot interpret a tool schema that is not represented as an object.", `Return an object for ${schemaName}.`, { toolName: tool.name, schema: schemaName }));
+                continue;
+            }
+            const dialect = schema.$schema;
+            if (dialect === undefined) {
+                continue;
+            }
+            if (typeof dialect !== "string" || !isAbsoluteUri(dialect)) {
+                findings.push(buildFinding("mcp.conformance.schema.dialect_invalid", "fail", `Tool \`${tool.name}\` has an invalid ${schemaName} $schema URI.`, "Codex cannot reliably select a schema dialect for this tool.", `Omit $schema or provide an absolute URI in ${schemaName}.`, { toolName: tool.name, schema: schemaName }));
+                continue;
+            }
+            if (dialect !== CANONICAL_SCHEMA_DIALECT && dialect !== `${CANONICAL_SCHEMA_DIALECT}#`) {
+                findings.push(buildFinding("mcp.conformance.schema.dialect_unsupported", "warn", `Tool \`${tool.name}\` uses a non-canonical ${schemaName} $schema dialect.`, "The schema may be valid, but its dialect is outside the validator's latest compatibility baseline.", `Use ${CANONICAL_SCHEMA_DIALECT} or omit $schema.`, { toolName: tool.name, schema: schemaName }));
+            }
+        }
+    }
+}
+function collectTasksListFinding(observation, findings) {
+    if (!observation || observation.status === "skipped") {
+        return "skipped";
+    }
+    if (observation.status === "pass") {
+        return "pass";
+    }
+    const timeout = observation.failure === "timeout";
+    findings.push(buildFinding(timeout
+        ? "mcp.conformance.tasks_list.timeout"
+        : "mcp.conformance.tasks_list.invalid", "fail", timeout
+        ? "The server did not complete tasks/list within the observation window."
+        : "The server returned an invalid tasks/list observation.", "Codex cannot rely on task discovery when tasks/list cannot complete with a valid response.", timeout
+        ? "Reduce tasks/list latency and verify pagination completes."
+        : "Return a valid tasks/list response with well-formed task items and pagination."));
+    return "fail";
+}
+function statusForFindings(findings) {
+    if (findings.some((finding) => finding.severity === "fail")) {
+        return "fail";
+    }
+    if (findings.some((finding) => finding.severity === "warn")) {
+        return "warn";
+    }
+    return "pass";
+}
+function overallStatus(scorecard, findings) {
+    const statuses = [
+        scorecard.capabilityConsistency,
+        scorecard.taskDeclarations,
+        scorecard.tasksList,
+        scorecard.schemaDialect
+    ];
+    if (statuses.includes("fail") || findings.some((finding) => finding.severity === "fail")) {
+        return "fail";
+    }
+    if (statuses.includes("warn") || findings.some((finding) => finding.severity === "warn")) {
+        return "warn";
+    }
+    return "pass";
+}
+export function evaluateMcpConformance(observation) {
+    const profile = classifyProtocolVersion(observation.protocolVersion);
+    const findings = [];
+    const scorecard = {
+        protocolVersion: observation.protocolVersion,
+        profile,
+        capabilityConsistency: "skipped",
+        taskDeclarations: "skipped",
+        tasksList: "skipped",
+        schemaDialect: "skipped",
+        overall: "pass"
+    };
+    if (profile === "future-compatible") {
+        findings.push(buildFinding("mcp.conformance.protocol.unknown_newer", "warn", `The server advertises newer MCP protocol version \`${observation.protocolVersion}\`.`, "The validator applies the 2025-11-25 structural baseline, which may not cover newer protocol requirements.", "Confirm the server's newer protocol changes remain compatible with the 2025-11-25 MCP contract.", { protocolVersion: observation.protocolVersion }));
+    }
+    if (profile === "legacy") {
+        scorecard.overall = overallStatus(scorecard, findings);
+        return { findings, scorecard };
+    }
+    if (!observation.skipToolDerivedChecks) {
+        const capabilityFindings = [];
+        const taskCallCapabilityState = getTaskToolsCallCapabilityState(observation.capabilities, capabilityFindings);
+        findings.push(...capabilityFindings);
+        scorecard.capabilityConsistency = statusForFindings(capabilityFindings);
+        const declarationFindings = [];
+        collectTaskDeclarationFindings(observation, taskCallCapabilityState, declarationFindings);
+        findings.push(...declarationFindings);
+        scorecard.taskDeclarations = statusForFindings(declarationFindings);
+    }
+    scorecard.tasksList = collectTasksListFinding(observation.tasksList, findings);
+    if (!observation.skipToolDerivedChecks) {
+        const schemaFindings = [];
+        collectSchemaFindings(observation, schemaFindings);
+        findings.push(...schemaFindings);
+        scorecard.schemaDialect = statusForFindings(schemaFindings);
+    }
+    scorecard.overall = overallStatus(scorecard, findings);
+    return { findings, scorecard };
+}