codex-plugin-doctor 1.52.0 → 1.53.0

package/README.md

@@ -78,21 +78,25 @@ 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`
-
-### 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
-```
+- 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 `--runtime --allow-network`. Loopback 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 protocol and OAuth metadata-discovery requests, redacts report output, and applies SSRF controls. It does not authenticate or follow redirects.
 
-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).
+Remote transport reliability adds one bounded SSE GET after initialization. HTTP `200` must be `text/event-stream`; HTTP `405` is compliant when the endpoint does not offer server-to-client SSE. At most one SSE resume and one session restart are attempted, and no remote response content is retained. This is a bounded readiness check, not a live interoperability, delivery-guarantee, or load-test claim.
 
-Output formats:
+`--allow-session-lifecycle` is disabled by default and is state-changing: only after a valid `MCP-Session-Id` it permits one bounded session `DELETE`. `--require-remote-reliability` is a strict result gate: it fails unless every attempted remote reliability scorecard passes. Local-only runs are unaffected. It grants no network consent, so `--runtime --allow-network` (and loopback consent when applicable) remain required. See [Remote MCP Readiness](./docs/architecture/remote-mcp-readiness.md) and [Remote MCP Transport Reliability](./docs/architecture/remote-mcp-transport-reliability.md).
+
+Output formats:
 
 - human text output
 - JSON reports
@@ -438,9 +442,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: Esquetta/CodexPluginDoctor@v1.52.0
+      - uses: Esquetta/CodexPluginDoctor@v1.53.0
         with:
-          version: "1.52.0"
+          version: "1.53.0"
           path: .
           runtime: "true"
           policy: codex-publish

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

@@ -7,6 +7,7 @@ const DEFAULT_MAX_RESPONSE_BYTES = 1_024 * 1_024;
 const allowedRequestHeaders = new Set([
     "accept",
     "content-type",
+    "last-event-id",
     "mcp-protocol-version",
     "mcp-session-id",
     "user-agent"
@@ -137,7 +138,7 @@ export async function requestBoundedHttp(rawUrl, options = {}) {
         let response;
         let settled = false;
         const timeout = setTimeout(() => {
-            fail(new BoundedHttpError("REMOTE_HTTP_TIMEOUT", "Remote HTTP request timed out."));
+            fail(new BoundedHttpError("REMOTE_HTTP_TIMEOUT", "Remote HTTP request timed out.", response?.statusCode, response ? selectSafeHeaders(response.headers) : undefined));
         }, remainingMs);
         const fail = (error) => {
             if (settled) {

package/dist/core/doctor-export-bundle.js

@@ -16,7 +16,9 @@ export function redactValue(value) {
     if (typeof value === "object" && value !== null) {
         return Object.fromEntries(Object.entries(value).map(([key, nestedValue]) => [
             key,
-            redactValue(nestedValue)
+            /^(?:mcp[-_]?session[-_]?id|session[-_]?id|last[-_]?event[-_]?id|event[-_]?id|retry|(?:sse[-_]?)?data)$/i.test(key)
+                ? "[REDACTED_SECRET]"
+                : redactValue(nestedValue)
         ]));
     }
     return value;

package/dist/core/output-contract.js

@@ -5,6 +5,10 @@ const runtimeCapabilityStatusSchema = {
     type: "string",
     enum: ["pass", "fail", "warn", "skipped", "unsupported"]
 };
+const remoteTransportReliabilityStatusSchema = {
+    type: "string",
+    enum: ["pass", "warn", "fail", "skipped"]
+};
 const runtimeConformanceSchema = {
     type: "object",
     properties: {
@@ -35,6 +39,28 @@ const runtimeConformanceSchema = {
     ],
     additionalProperties: false
 };
+const remoteTransportReliabilitySchema = {
+    type: "object",
+    properties: {
+        getSse: remoteTransportReliabilityStatusSchema,
+        sessionPropagation: remoteTransportReliabilityStatusSchema,
+        resumability: remoteTransportReliabilityStatusSchema,
+        disconnectSafety: remoteTransportReliabilityStatusSchema,
+        sessionRestart: remoteTransportReliabilityStatusSchema,
+        termination: remoteTransportReliabilityStatusSchema,
+        overall: remoteTransportReliabilityStatusSchema
+    },
+    required: [
+        "getSse",
+        "sessionPropagation",
+        "resumability",
+        "disconnectSafety",
+        "sessionRestart",
+        "termination",
+        "overall"
+    ],
+    additionalProperties: false
+};
 const remoteRuntimeScorecardSchema = {
     type: "object",
     properties: {
@@ -48,6 +74,7 @@ const remoteRuntimeScorecardSchema = {
         },
         protocolHeaders: runtimeCapabilityStatusSchema,
         authorization: runtimeCapabilityStatusSchema,
+        reliability: remoteTransportReliabilitySchema,
         overall: {
             type: "string",
             enum: ["pass", "warn", "fail", "skipped"]

package/dist/core/release-check.d.ts

@@ -43,6 +43,8 @@ export interface BuildReleaseCheckOptions {
     runtime?: boolean;
     allowNetwork?: boolean;
     allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
+    requireRemoteReliability?: boolean;
     runtimeSandbox?: RuntimeSandboxMode;
     runCheck?: (targetPath: string, options: CheckOptions) => Promise<CheckResult>;
 }

package/dist/core/release-check.js

@@ -108,6 +108,8 @@ export async function buildReleaseCheck(targetPath, options = {}) {
         runtime: runtimeProbeEnabled,
         ...(options.allowNetwork ? { allowNetwork: true } : {}),
         ...(options.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+        ...(options.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+        ...(options.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
         ...(options.runtimeSandbox ? { runtimeSandbox: options.runtimeSandbox } : {})
     });
     const securityResult = await buildSecurityAudit(resolvedPath);

package/dist/core/release-evidence.d.ts

@@ -113,6 +113,8 @@ export interface BuildDoctorReleaseEvidenceOptions {
     runtime?: boolean;
     allowNetwork?: boolean;
     allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
+    requireRemoteReliability?: boolean;
     sandbox?: RuntimeSandboxMode;
     environment?: CompatibilityEnvironment;
     runCheck?: (targetPath: string, options?: CheckOptions) => Promise<CheckResult>;

package/dist/core/release-evidence.js

@@ -308,6 +308,8 @@ export async function buildDoctorReleaseEvidenceReport(targetPath, options) {
             runtime: true,
             ...(options.allowNetwork ? { allowNetwork: true } : {}),
             ...(options.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+            ...(options.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+            ...(options.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
             ...(options.sandbox ? { runtimeSandbox: options.sandbox } : {})
         }
         : {};

package/dist/core/remote-mcp-probe.d.ts

@@ -8,6 +8,7 @@ export interface RemoteMcpProbeOptions {
     requestTimeoutMs?: number;
     lookup?: RemoteLookup;
     request?: RemoteMcpRequest;
+    allowSessionLifecycle?: boolean;
 }
 export interface RemoteMcpProbeResult {
     findings: Finding[];

package/dist/core/remote-mcp-probe.js

@@ -1,6 +1,7 @@
 import { BoundedHttpError, requestBoundedHttp } from "./bounded-http-client.js";
 import { RemoteNetworkPolicyError } from "./remote-network-policy.js";
 import { checkRemoteOAuthReadiness } from "./remote-oauth-readiness.js";
+import { probeRemoteTransportReliability } from "./remote-transport-reliability.js";
 import { inspectRemoteMcpUrl } from "./remote-url-policy.js";
 import { packageVersion } from "../version.js";
 const MCP_PROTOCOL_VERSION = "2025-11-25";
@@ -85,6 +86,9 @@ function isValidInitializeResponse(message) {
         typeof message.result.serverInfo.name === "string" &&
         typeof message.result.serverInfo.version === "string");
 }
+function isInitializedNotificationAcknowledged(response) {
+    return response.statusCode === 202 && response.body.length === 0;
+}
 function validSessionId(value) {
     return value !== null && /^[\x21-\x7e]+$/.test(value);
 }
@@ -210,7 +214,7 @@ export async function probeRemoteMcpServer(serverName, rawUrl, options = {}) {
                 ...(sessionId === null ? {} : { "MCP-Session-Id": sessionId })
             }
         });
-        if (initializedResponse.statusCode < 200 || initializedResponse.statusCode >= 300) {
+        if (!isInitializedNotificationAcknowledged(initializedResponse)) {
             scorecard.protocolHeaders = "fail";
             findings.push(failure("plugin.runtime.remote.initialized.failed", `The remote MCP server \`${serverName}\` did not acknowledge the initialized notification.`, "The MCP session may not be ready for subsequent protocol traffic.", "Accept a successful HTTP response to notifications/initialized at the same MCP endpoint."));
             return finalize(scorecard, findings);
@@ -222,5 +226,59 @@ export async function probeRemoteMcpServer(serverName, rawUrl, options = {}) {
         return finalize(scorecard, findings);
     }
     scorecard.protocolHeaders = "pass";
+    const reliability = await probeRemoteTransportReliability({
+        rawUrl,
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        request,
+        requestTimeoutMs: options.requestTimeoutMs,
+        requestOptions: {
+            allowLocalNetwork: options.allowLocalNetwork,
+            lookup: options.lookup
+        },
+        sessionId,
+        allowSessionLifecycle: options.allowSessionLifecycle,
+        reinitialize: async (requestWithinBudget) => {
+            const restartInitialize = await requestWithinBudget({
+                method: "POST",
+                body: initializeBody,
+                headers: {
+                    Accept: "application/json, text/event-stream",
+                    "Content-Type": "application/json"
+                },
+                stopAfter: (body) => findSseInitializeResponse(body) !== null
+            });
+            if (restartInitialize.statusCode !== 200) {
+                throw new Error("restart initialize failed");
+            }
+            const restartContentType = mediaType(responseHeader(restartInitialize.headers, "content-type"));
+            if (restartContentType !== "application/json" && restartContentType !== "text/event-stream") {
+                throw new Error("restart initialize content type invalid");
+            }
+            const replacementSessionId = responseHeader(restartInitialize.headers, "mcp-session-id");
+            if (replacementSessionId !== null && !validSessionId(replacementSessionId)) {
+                throw new Error("restart session invalid");
+            }
+            const restartMessage = parseInitializeResponse(restartInitialize.body, restartContentType);
+            if (!restartMessage || !isValidInitializeResponse(restartMessage)) {
+                throw new Error("restart initialize result invalid");
+            }
+            const restartInitialized = await requestWithinBudget({
+                method: "POST",
+                body: JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized" }),
+                headers: {
+                    Accept: "application/json, text/event-stream",
+                    "Content-Type": "application/json",
+                    "MCP-Protocol-Version": MCP_PROTOCOL_VERSION,
+                    ...(replacementSessionId === null ? {} : { "MCP-Session-Id": replacementSessionId })
+                }
+            });
+            if (!isInitializedNotificationAcknowledged(restartInitialized)) {
+                throw new Error("restart initialized failed");
+            }
+            return replacementSessionId;
+        }
+    });
+    scorecard.reliability = reliability.scorecard;
+    findings.push(...reliability.findings);
     return finalize(scorecard, findings);
 }

package/dist/core/remote-transport-reliability.d.ts

@@ -0,0 +1,18 @@
+import { type BoundedHttpRequestOptions, type BoundedHttpResponse } from "./bounded-http-client.js";
+import type { Finding, RemoteTransportReliabilityScorecard } from "../domain/types.js";
+export interface RemoteTransportReliabilityResult {
+    findings: Finding[];
+    scorecard: RemoteTransportReliabilityScorecard;
+}
+export type RemoteTransportReliabilityRequest = (options: BoundedHttpRequestOptions) => Promise<BoundedHttpResponse>;
+export interface RemoteTransportReliabilityOptions {
+    rawUrl: string;
+    protocolVersion: string;
+    request: (rawUrl: string, options?: BoundedHttpRequestOptions) => Promise<BoundedHttpResponse>;
+    requestTimeoutMs?: number;
+    requestOptions?: Pick<BoundedHttpRequestOptions, "allowLocalNetwork" | "lookup">;
+    sessionId: string | null;
+    allowSessionLifecycle?: boolean;
+    reinitialize: (request: RemoteTransportReliabilityRequest) => Promise<string | null>;
+}
+export declare function probeRemoteTransportReliability(options: RemoteTransportReliabilityOptions): Promise<RemoteTransportReliabilityResult>;

package/dist/core/remote-transport-reliability.js

@@ -0,0 +1,243 @@
+import { BoundedHttpError } from "./bounded-http-client.js";
+import { observeFirstSseEvent } from "./sse-observation.js";
+const DEFAULT_RELIABILITY_TIMEOUT_MS = 3_000;
+const MAX_RELIABILITY_REQUESTS = 6;
+function createScorecard() {
+    return {
+        getSse: "skipped",
+        sessionPropagation: "skipped",
+        resumability: "skipped",
+        disconnectSafety: "skipped",
+        sessionRestart: "skipped",
+        termination: "skipped",
+        overall: "skipped"
+    };
+}
+function finding(id, severity, message, suggestedFix) {
+    return {
+        id,
+        severity,
+        message,
+        impact: "Remote MCP transport reliability could not be verified within the configured safety bounds.",
+        suggestedFix
+    };
+}
+function responseHeader(headers, name) {
+    const value = headers[name];
+    return typeof value === "string" ? value : null;
+}
+function mediaType(value) {
+    return value?.split(";", 1)[0]?.trim().toLowerCase() ?? null;
+}
+function validSessionId(value) {
+    return value !== null && /^[\x21-\x7e]+$/.test(value);
+}
+function wait(delayMs) {
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}
+function finalize(scorecard, findings) {
+    const statuses = Object.entries(scorecard)
+        .filter(([name]) => name !== "overall")
+        .map(([, status]) => status);
+    scorecard.overall = statuses.includes("fail")
+        ? "fail"
+        : statuses.includes("warn")
+            ? "warn"
+            : statuses.includes("pass")
+                ? "pass"
+                : "skipped";
+    return { findings, scorecard };
+}
+function isSseTimeout(error) {
+    return error instanceof BoundedHttpError
+        && error.code === "REMOTE_HTTP_TIMEOUT"
+        && error.statusCode === 200
+        && mediaType(responseHeader(error.headers ?? {}, "content-type")) === "text/event-stream";
+}
+function classifySseResponse(response, failurePrefix, findings) {
+    if (response.statusCode !== 200) {
+        findings.push(finding(`plugin.runtime.remote.reliability.${failurePrefix}.status`, "fail", "The remote MCP endpoint returned an unsupported SSE transport status.", "Return HTTP 200 for an accepted SSE transport request."));
+        return null;
+    }
+    if (mediaType(responseHeader(response.headers, "content-type")) !== "text/event-stream") {
+        findings.push(finding(`plugin.runtime.remote.reliability.${failurePrefix}.content_type`, "fail", "The remote MCP endpoint returned a non-SSE media type for an SSE transport request.", "Return text/event-stream for accepted SSE transport requests."));
+        return null;
+    }
+    return observeFirstSseEvent(response.body);
+}
+export async function probeRemoteTransportReliability(options) {
+    const scorecard = createScorecard();
+    const findings = [];
+    const timeoutMs = options.requestTimeoutMs ?? DEFAULT_RELIABILITY_TIMEOUT_MS;
+    const deadline = Date.now() + Math.min(timeoutMs, DEFAULT_RELIABILITY_TIMEOUT_MS);
+    let currentSessionId = options.sessionId;
+    let requestCount = 0;
+    let restarted = false;
+    const requestWithinBudget = async (requestOptions) => {
+        if (requestCount >= MAX_RELIABILITY_REQUESTS) {
+            throw new Error("reliability request ceiling reached");
+        }
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0) {
+            throw new BoundedHttpError("REMOTE_HTTP_TIMEOUT", "Remote reliability deadline elapsed.");
+        }
+        requestCount += 1;
+        return options.request(options.rawUrl, {
+            ...requestOptions,
+            ...options.requestOptions,
+            timeoutMs: Math.max(1, Math.min(remainingMs, DEFAULT_RELIABILITY_TIMEOUT_MS))
+        });
+    };
+    const send = async (method, extraHeaders = {}, stopAfter) => {
+        let sessionRestarted = false;
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+            const sessionId = currentSessionId;
+            const headers = {
+                Accept: "text/event-stream",
+                "MCP-Protocol-Version": options.protocolVersion,
+                ...(sessionId === null ? {} : { "MCP-Session-Id": sessionId }),
+                ...(sessionRestarted ? {} : extraHeaders)
+            };
+            if (sessionId !== null) {
+                scorecard.sessionPropagation = "pass";
+            }
+            let response;
+            try {
+                response = await requestWithinBudget({
+                    method,
+                    headers,
+                    stopAfter
+                });
+            }
+            catch (error) {
+                return { error };
+            }
+            if (method === "GET" && sessionId !== null && response.statusCode === 404) {
+                if (restarted) {
+                    scorecard.sessionRestart = "fail";
+                    return { restartFailed: true };
+                }
+                restarted = true;
+                sessionRestarted = true;
+                currentSessionId = null;
+                try {
+                    const replacementSessionId = await options.reinitialize(requestWithinBudget);
+                    if (replacementSessionId !== null && !validSessionId(replacementSessionId)) {
+                        throw new Error("invalid replacement session");
+                    }
+                    currentSessionId = replacementSessionId;
+                    scorecard.sessionRestart = "pass";
+                }
+                catch {
+                    scorecard.sessionRestart = "fail";
+                    return { restartFailed: true };
+                }
+                continue;
+            }
+            return { response, sessionRestarted };
+        }
+        return { restartFailed: true };
+    };
+    const first = await send("GET", {}, (body) => observeFirstSseEvent(body).complete);
+    if (first.restartFailed) {
+        findings.push(finding("plugin.runtime.remote.reliability.session_restart.failed", "fail", "The remote MCP session expired and could not be restarted within the bounded probe.", "Accept a fresh initialize sequence after an expired MCP session."));
+        return finalize(scorecard, findings);
+    }
+    if (first.error) {
+        if (isSseTimeout(first.error)) {
+            scorecard.getSse = "warn";
+            scorecard.disconnectSafety = "warn";
+            findings.push(finding("plugin.runtime.remote.reliability.get.inconclusive", "warn", "The remote MCP SSE stream did not produce a complete event before the bounded observation deadline.", "Emit complete SSE event frames promptly when server-to-client streaming is supported."));
+            return finalize(scorecard, findings);
+        }
+        scorecard.getSse = "fail";
+        findings.push(finding("plugin.runtime.remote.reliability.get.failed", "fail", "The remote MCP SSE transport request could not be completed.", "Keep the Streamable HTTP transport reachable within the configured request bounds."));
+        return finalize(scorecard, findings);
+    }
+    const firstResponse = first.response;
+    if (!firstResponse) {
+        scorecard.getSse = "fail";
+        return finalize(scorecard, findings);
+    }
+    if (firstResponse.statusCode === 405) {
+        scorecard.getSse = "pass";
+    }
+    else {
+        const observation = classifySseResponse(firstResponse, "get", findings);
+        if (observation === null) {
+            scorecard.getSse = "fail";
+            return finalize(scorecard, findings);
+        }
+        if (!observation.complete) {
+            scorecard.getSse = "warn";
+            scorecard.disconnectSafety = "warn";
+            findings.push(finding("plugin.runtime.remote.reliability.get.inconclusive", "warn", "The remote MCP SSE response ended before a complete event could be observed.", "Emit complete SSE event frames when server-to-client streaming is supported."));
+            return finalize(scorecard, findings);
+        }
+        if (observation.malformed) {
+            scorecard.getSse = "fail";
+            scorecard.disconnectSafety = "fail";
+            findings.push(finding("plugin.runtime.remote.reliability.get.malformed", "fail", "The remote MCP endpoint emitted malformed SSE event framing.", "Return complete SSE events with valid id and retry fields."));
+            return finalize(scorecard, findings);
+        }
+        scorecard.getSse = "pass";
+        scorecard.disconnectSafety = "pass";
+        if (observation.eventId !== null) {
+            const remainingMs = deadline - Date.now();
+            if (observation.retryMs !== null) {
+                if (observation.retryMs >= remainingMs) {
+                    scorecard.resumability = "warn";
+                    findings.push(finding("plugin.runtime.remote.reliability.resume.inconclusive", "warn", "The remote MCP SSE retry delay exceeded the remaining bounded observation deadline.", "Advertise an SSE retry delay that fits within the configured probe deadline."));
+                    return finalize(scorecard, findings);
+                }
+                await wait(observation.retryMs);
+            }
+            const resumed = await send("GET", { "Last-Event-ID": observation.eventId }, (body) => observeFirstSseEvent(body).complete);
+            if (resumed.restartFailed) {
+                findings.push(finding("plugin.runtime.remote.reliability.session_restart.failed", "fail", "The remote MCP session expired during SSE resumability validation and could not be restarted.", "Accept one fresh initialize sequence after an expired MCP session."));
+                return finalize(scorecard, findings);
+            }
+            if (resumed.error) {
+                scorecard.resumability = isSseTimeout(resumed.error) ? "warn" : "fail";
+                findings.push(finding(isSseTimeout(resumed.error)
+                    ? "plugin.runtime.remote.reliability.resume.inconclusive"
+                    : "plugin.runtime.remote.reliability.resume.failed", isSseTimeout(resumed.error) ? "warn" : "fail", "The remote MCP SSE resume request could not be completed within the bounded probe.", "Accept one bounded SSE reconnect using Last-Event-ID."));
+                return finalize(scorecard, findings);
+            }
+            if (!resumed.response) {
+                scorecard.resumability = "fail";
+                return finalize(scorecard, findings);
+            }
+            if (resumed.sessionRestarted) {
+                scorecard.resumability = "skipped";
+            }
+            else {
+                const resumeObservation = classifySseResponse(resumed.response, "resume", findings);
+                if (resumeObservation === null || resumeObservation.malformed) {
+                    scorecard.resumability = "fail";
+                    if (resumeObservation?.malformed) {
+                        findings.push(finding("plugin.runtime.remote.reliability.resume.malformed", "fail", "The remote MCP endpoint emitted malformed SSE framing after a resume request.", "Return complete SSE events with valid id and retry fields after reconnecting."));
+                    }
+                    return finalize(scorecard, findings);
+                }
+                scorecard.resumability = resumeObservation.complete ? "pass" : "warn";
+                if (!resumeObservation.complete) {
+                    findings.push(finding("plugin.runtime.remote.reliability.resume.inconclusive", "warn", "The remote MCP SSE resume response ended before a complete event could be observed.", "Emit complete SSE events after accepting a reconnect."));
+                    return finalize(scorecard, findings);
+                }
+            }
+        }
+    }
+    if (!options.allowSessionLifecycle || currentSessionId === null) {
+        return finalize(scorecard, findings);
+    }
+    const terminated = await send("DELETE");
+    if (terminated.restartFailed || terminated.error || !terminated.response
+        || (terminated.response.statusCode !== 405 && (terminated.response.statusCode < 200 || terminated.response.statusCode >= 300))) {
+        scorecard.termination = "fail";
+        findings.push(finding("plugin.runtime.remote.reliability.termination.failed", "fail", "The remote MCP session could not be terminated with the approved lifecycle request.", "Return a successful response or HTTP 405 for a bounded MCP session DELETE request."));
+        return finalize(scorecard, findings);
+    }
+    scorecard.termination = "pass";
+    return finalize(scorecard, findings);
+}

package/dist/core/runtime-probe.d.ts

@@ -1,4 +1,4 @@
-import type { DiscoveredPackage, RuntimeProbeResult, RuntimeSandboxMode } from "../domain/types.js";
+import type { DiscoveredPackage, RuntimeProbeResult, RuntimeSandboxMode, RuntimeScorecard } from "../domain/types.js";
 import { type RemoteMcpRequest } from "./remote-mcp-probe.js";
 import type { RemoteLookup } from "./remote-network-policy.js";
 export declare function probeRuntime(discoveredPackage: DiscoveredPackage, options?: RuntimeProbeOptions): Promise<RuntimeProbeResult>;
@@ -8,8 +8,10 @@ export interface RuntimeProbeOptions {
     transcript?: (line: string) => void;
     allowNetwork?: boolean;
     allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
     remoteRequestTimeoutMs?: number;
     remoteLookup?: RemoteLookup;
     remoteRequest?: RemoteMcpRequest;
 }
+export declare function remoteReliabilityGatePassed(scorecard: RuntimeScorecard | undefined): boolean;
 export declare function probeRuntimeConfig(rootPath: string, mcpConfigPath: string, options?: RuntimeProbeOptions): Promise<RuntimeProbeResult>;

package/dist/core/runtime-probe.js

@@ -345,6 +345,17 @@ function mergeRemoteRuntimeScorecards(left, right) {
         "present-valid": 1,
         absent: 0
     };
+    const reliability = left.reliability && right.reliability
+        ? {
+            getSse: worstRuntimeStatus(left.reliability.getSse, right.reliability.getSse),
+            sessionPropagation: worstRuntimeStatus(left.reliability.sessionPropagation, right.reliability.sessionPropagation),
+            resumability: worstRuntimeStatus(left.reliability.resumability, right.reliability.resumability),
+            disconnectSafety: worstRuntimeStatus(left.reliability.disconnectSafety, right.reliability.disconnectSafety),
+            sessionRestart: worstRuntimeStatus(left.reliability.sessionRestart, right.reliability.sessionRestart),
+            termination: worstRuntimeStatus(left.reliability.termination, right.reliability.termination),
+            overall: worstRuntimeStatus(left.reliability.overall, right.reliability.overall)
+        }
+        : left.reliability ?? right.reliability;
     return {
         transport: worstRuntimeStatus(left.transport, right.transport),
         networkSafety: worstRuntimeStatus(left.networkSafety, right.networkSafety),
@@ -355,7 +366,8 @@ function mergeRemoteRuntimeScorecards(left, right) {
             : right.session,
         protocolHeaders: worstRuntimeStatus(left.protocolHeaders, right.protocolHeaders),
         authorization: worstRuntimeStatus(left.authorization, right.authorization),
-        overall: worstRuntimeStatus(left.overall, right.overall)
+        overall: worstRuntimeStatus(left.overall, right.overall),
+        ...(reliability ? { reliability } : {})
     };
 }
 function supportsTasksListProbe(protocolVersion, capabilities) {
@@ -1251,6 +1263,10 @@ export async function probeRuntime(discoveredPackage, options = {}) {
     }
     return probeRuntimeConfig(rootPath, manifest.mcpServers, options);
 }
+export function remoteReliabilityGatePassed(scorecard) {
+    return scorecard !== undefined &&
+        (scorecard.remote === undefined || scorecard.remote.reliability?.overall === "pass");
+}
 export async function probeRuntimeConfig(rootPath, mcpConfigPath, options = {}) {
     const resolvedRootPath = path.resolve(rootPath);
     const resolvedMcpConfigPath = path.resolve(resolvedRootPath, mcpConfigPath);
@@ -1296,6 +1312,7 @@ export async function probeRuntimeConfig(rootPath, mcpConfigPath, options = {})
             const remote = await probeRemoteMcpServer(serverName, url, {
                 allowNetwork: options.allowNetwork,
                 allowLocalNetwork: options.allowLocalNetwork,
+                allowSessionLifecycle: options.allowSessionLifecycle,
                 requestTimeoutMs: options.remoteRequestTimeoutMs,
                 lookup: options.remoteLookup,
                 request: options.remoteRequest

package/dist/core/sse-observation.d.ts

@@ -0,0 +1,7 @@
+export interface SseObservation {
+    complete: boolean;
+    eventId: string | null;
+    retryMs: number | null;
+    malformed: boolean;
+}
+export declare function observeFirstSseEvent(body: Buffer): SseObservation;

package/dist/core/sse-observation.js

@@ -0,0 +1,67 @@
+const MAX_SSE_FIELD_BYTES = 1_024;
+function isSafeEventId(value) {
+    return value.length > 0
+        && value.length <= MAX_SSE_FIELD_BYTES
+        && value.every((byte) => byte >= 0x21 && byte <= 0x7e);
+}
+function parseRetry(value) {
+    if (value.length === 0 || value.length > MAX_SSE_FIELD_BYTES) {
+        return null;
+    }
+    for (const byte of value) {
+        if (byte < 0x30 || byte > 0x39) {
+            return null;
+        }
+    }
+    const retryMs = Number(value.toString("ascii"));
+    return Number.isSafeInteger(retryMs) ? retryMs : null;
+}
+export function observeFirstSseEvent(body) {
+    let eventId = null;
+    let retryMs = null;
+    let malformed = false;
+    let lineStart = 0;
+    for (let index = 0; index < body.length; index += 1) {
+        if (body[index] !== 0x0a && body[index] !== 0x0d) {
+            continue;
+        }
+        const line = body.subarray(lineStart, index);
+        if (body[index] === 0x0d && body[index + 1] === 0x0a) {
+            index += 1;
+        }
+        lineStart = index + 1;
+        if (line.length === 0) {
+            return {
+                complete: true,
+                eventId: malformed ? null : eventId,
+                retryMs: malformed ? null : retryMs,
+                malformed
+            };
+        }
+        if (line[0] === 0x3a) {
+            continue;
+        }
+        const separator = line.indexOf(0x3a);
+        const field = separator === -1 ? line : line.subarray(0, separator);
+        const valueStart = separator === -1 ? line.length : separator + 1;
+        const value = line.subarray(valueStart + (line[valueStart] === 0x20 ? 1 : 0));
+        if (field.equals(Buffer.from("id"))) {
+            if (value.length === 0) {
+                eventId = null;
+            }
+            else if (isSafeEventId(value)) {
+                eventId = value.toString("ascii");
+            }
+            else {
+                malformed = true;
+            }
+        }
+        else if (field.equals(Buffer.from("retry"))) {
+            const parsedRetryMs = parseRetry(value);
+            if (parsedRetryMs !== null) {
+                retryMs = parsedRetryMs;
+            }
+        }
+    }
+    return { complete: false, eventId: null, retryMs: null, malformed: false };
+}

package/dist/core/validate-plugin.js

@@ -3,7 +3,7 @@ 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";
+import { probeRuntime, remoteReliabilityGatePassed } from "./runtime-probe.js";
 function buildFailure(id, message, impact, suggestedFix, evidence) {
     return {
         id,
@@ -446,7 +446,8 @@ export async function validatePlugin(targetPath, options = {}) {
             sandbox: options.runtimeSandbox,
             transcript: options.runtimeTranscript,
             allowNetwork: options.allowNetwork,
-            allowLocalNetwork: options.allowLocalNetwork
+            allowLocalNetwork: options.allowLocalNetwork,
+            allowSessionLifecycle: options.allowSessionLifecycle
         })
         : null;
     const findings = [
@@ -454,7 +455,7 @@ export async function validatePlugin(targetPath, options = {}) {
         ...(runtimeResult?.findings ?? [])
     ];
     const fingerprintedFindings = withFindingFingerprints(findings, discoveredPackage.rootPath);
-    const hasFailures = fingerprintedFindings.some((finding) => finding.severity === "fail");
+    const hasFailures = fingerprintedFindings.some((finding) => finding.severity === "fail") || (options.requireRemoteReliability === true && !remoteReliabilityGatePassed(runtimeResult?.scorecard));
     const hasWarnings = fingerprintedFindings.some((finding) => finding.severity === "warn");
     if (!hasFailures && !hasWarnings) {
         return {

package/dist/domain/types.d.ts

@@ -43,6 +43,8 @@ export interface CheckOptions {
     runtime?: boolean;
     allowNetwork?: boolean;
     allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
+    requireRemoteReliability?: boolean;
     runtimeTranscript?: (line: string) => void;
     runtimeStartupTimeoutMs?: number;
     runtimeSandbox?: RuntimeSandboxMode;
@@ -103,8 +105,19 @@ export interface RemoteRuntimeScorecard {
     session: "absent" | "present-valid" | "present-invalid";
     protocolHeaders: RuntimeCapabilityStatus;
     authorization: RuntimeCapabilityStatus;
+    reliability?: RemoteTransportReliabilityScorecard;
     overall: "pass" | "warn" | "fail" | "skipped";
 }
+export type RemoteTransportReliabilityStatus = "pass" | "warn" | "fail" | "skipped";
+export interface RemoteTransportReliabilityScorecard {
+    getSse: RemoteTransportReliabilityStatus;
+    sessionPropagation: RemoteTransportReliabilityStatus;
+    resumability: RemoteTransportReliabilityStatus;
+    disconnectSafety: RemoteTransportReliabilityStatus;
+    sessionRestart: RemoteTransportReliabilityStatus;
+    termination: RemoteTransportReliabilityStatus;
+    overall: RemoteTransportReliabilityStatus;
+}
 export type McpConformanceProfile = "legacy" | "2025-11-25" | "future-compatible";
 export interface RuntimeConformanceScorecard {
     protocolVersion: string | null;

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

@@ -17,6 +17,8 @@ export interface GenericMcpDoctorOptions {
     runtime?: boolean;
     allowNetwork?: boolean;
     allowLocalNetwork?: boolean;
+    allowSessionLifecycle?: boolean;
+    requireRemoteReliability?: boolean;
     runtimeStartupTimeoutMs?: number;
 }
 export declare function buildGenericMcpDoctor(targetPath: string, environment?: CompatibilityEnvironment, options?: GenericMcpDoctorOptions): Promise<GenericMcpDoctorReport>;

package/dist/mcp/generic-mcp-doctor.js

@@ -2,7 +2,7 @@ import { realpath, stat } from "node:fs/promises";
 import path from "node:path";
 import { buildCompatibilityMatrix, readMcpConfigPath } from "../compatibility/compatibility-matrix.js";
 import { readJsonFile } from "../core/read-json-file.js";
-import { probeRuntimeConfig } from "../core/runtime-probe.js";
+import { probeRuntimeConfig, remoteReliabilityGatePassed } from "../core/runtime-probe.js";
 import { formatFindingFingerprintLine, withFindingFingerprints } from "../reporting/finding-fingerprint.js";
 import { auditMcpServerConfig, buildSecurityAuditFromFindings } from "../security/security-audit.js";
 function buildFinding(severity, id, message, impact, suggestedFix, evidence) {
@@ -142,11 +142,14 @@ export async function buildGenericMcpDoctor(targetPath, environment = {}, option
         ? await probeRuntimeConfig(canonicalRootPath, canonicalMcpConfigPath, {
             startupTimeoutMs: options.runtimeStartupTimeoutMs,
             allowNetwork: options.allowNetwork,
-            allowLocalNetwork: options.allowLocalNetwork
+            allowLocalNetwork: options.allowLocalNetwork,
+            allowSessionLifecycle: options.allowSessionLifecycle
         })
         : null;
     const fingerprintedFindings = withFindingFingerprints([...staticFindings, ...(runtimeResult?.findings ?? [])], rootPath);
-    const status = mergeReportStatus(fingerprintedFindings, security);
+    const status = options.requireRemoteReliability === true && !remoteReliabilityGatePassed(runtimeResult?.scorecard)
+        ? "fail"
+        : mergeReportStatus(fingerprintedFindings, security);
     return {
         targetPath: rootPath,
         status,

package/dist/reporting/render-markdown-report.js

@@ -42,6 +42,19 @@ function appendRuntimeScorecard(lines, result) {
         lines.push(`| Protocol headers | ${remote.protocolHeaders.toUpperCase()} |`);
         lines.push(`| Authorization | ${remote.authorization.toUpperCase()} |`);
         lines.push(`| Overall | ${remote.overall.toUpperCase()} |`);
+        if (remote.reliability) {
+            const reliability = remote.reliability;
+            lines.push("", "## Remote Transport Reliability", "");
+            lines.push("| Check | Status |");
+            lines.push("| --- | --- |");
+            lines.push(`| GET SSE | ${reliability.getSse.toUpperCase()} |`);
+            lines.push(`| Session propagation | ${reliability.sessionPropagation.toUpperCase()} |`);
+            lines.push(`| Resumability | ${reliability.resumability.toUpperCase()} |`);
+            lines.push(`| Disconnect safety | ${reliability.disconnectSafety.toUpperCase()} |`);
+            lines.push(`| Session restart | ${reliability.sessionRestart.toUpperCase()} |`);
+            lines.push(`| Termination | ${reliability.termination.toUpperCase()} |`);
+            lines.push(`| Overall | ${reliability.overall.toUpperCase()} |`);
+        }
     }
 }
 export function buildMarkdownReport(result, options) {

package/dist/reporting/render-text-report.js

@@ -59,6 +59,17 @@ function appendRuntimeScorecard(lines, result) {
         lines.push(`protocol headers: ${remote.protocolHeaders}`);
         lines.push(`authorization: ${remote.authorization}`);
         lines.push(`overall: ${remote.overall}`);
+        if (remote.reliability) {
+            const reliability = remote.reliability;
+            lines.push("", "Remote Transport Reliability", "----------------------------");
+            lines.push(`GET SSE: ${reliability.getSse}`);
+            lines.push(`Session propagation: ${reliability.sessionPropagation}`);
+            lines.push(`Resumability: ${reliability.resumability}`);
+            lines.push(`Disconnect safety: ${reliability.disconnectSafety}`);
+            lines.push(`Session restart: ${reliability.sessionRestart}`);
+            lines.push(`Termination: ${reliability.termination}`);
+            lines.push(`Overall: ${reliability.overall}`);
+        }
     }
 }
 export function renderTextReport(result, options = {}) {

package/dist/rules/rule-catalog.js

@@ -556,6 +556,114 @@ export const ruleCatalog = [
         why: "Authorization readiness cannot be confirmed without bounded metadata responses.",
         fix: "Make protected-resource and authorization-server metadata available over HTTPS.",
         example: "Return application/json discovery metadata."
+    },
+    {
+        id: "plugin.runtime.remote.reliability.get.status",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP endpoint rejected the SSE transport request.",
+        why: "Clients cannot rely on server-to-client streaming when an accepted SSE request does not return the expected status.",
+        fix: "Return HTTP 200 with a valid SSE response, or HTTP 405 when GET streaming is not supported.",
+        example: "HTTP/1.1 405 Method Not Allowed"
+    },
+    {
+        id: "plugin.runtime.remote.reliability.get.content_type",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP endpoint returned a non-SSE media type for GET streaming.",
+        why: "Clients cannot interpret a successful streaming response unless it is declared as Server-Sent Events.",
+        fix: "Return Content-Type: text/event-stream for accepted GET streaming requests.",
+        example: "Content-Type: text/event-stream"
+    },
+    {
+        id: "plugin.runtime.remote.reliability.get.inconclusive",
+        category: "runtime",
+        defaultSeverity: "warn",
+        summary: "The remote MCP GET streaming check was inconclusive.",
+        why: "A bounded probe could not observe a complete SSE event, so streaming reliability remains uncertain.",
+        fix: "Emit complete SSE event frames promptly when server-to-client streaming is supported.",
+        example: "id: event-1\n\ndata: {}\n\n"
+    },
+    {
+        id: "plugin.runtime.remote.reliability.get.failed",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP GET streaming request could not be completed.",
+        why: "Clients cannot rely on server-to-client streaming when a bounded transport request fails.",
+        fix: "Keep the Streamable HTTP transport reachable within the configured request bounds.",
+        example: "Complete the GET request before the runtime timeout."
+    },
+    {
+        id: "plugin.runtime.remote.reliability.get.malformed",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP endpoint emitted malformed SSE framing.",
+        why: "Malformed event framing prevents clients from safely processing stream progress or reconnecting.",
+        fix: "Return complete SSE events with valid id and retry fields.",
+        example: "id: event-1\n\nevent: message\n\ndata: {}\n\n"
+    },
+    {
+        id: "plugin.runtime.remote.reliability.resume.status",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP endpoint rejected the SSE resume request.",
+        why: "Clients cannot resume a dropped stream when the reconnect response has an unexpected status.",
+        fix: "Return HTTP 200 for an accepted Last-Event-ID reconnect request.",
+        example: "HTTP/1.1 200 OK"
+    },
+    {
+        id: "plugin.runtime.remote.reliability.resume.content_type",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP endpoint returned a non-SSE media type for a resume request.",
+        why: "Clients cannot process a resumed stream unless it is declared as Server-Sent Events.",
+        fix: "Return Content-Type: text/event-stream after accepting a Last-Event-ID reconnect request.",
+        example: "Content-Type: text/event-stream"
+    },
+    {
+        id: "plugin.runtime.remote.reliability.resume.inconclusive",
+        category: "runtime",
+        defaultSeverity: "warn",
+        summary: "The remote MCP SSE resume check was inconclusive.",
+        why: "A bounded probe could not confirm a complete resumed event, so reconnect reliability remains uncertain.",
+        fix: "Emit complete SSE event frames after accepting a reconnect.",
+        example: "Return one complete SSE event after a Last-Event-ID request."
+    },
+    {
+        id: "plugin.runtime.remote.reliability.resume.failed",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP SSE resume request could not be completed.",
+        why: "Clients cannot recover from a dropped stream when a bounded reconnect fails.",
+        fix: "Accept one bounded SSE reconnect using Last-Event-ID.",
+        example: "Honor the Last-Event-ID header on one reconnect."
+    },
+    {
+        id: "plugin.runtime.remote.reliability.resume.malformed",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP endpoint emitted malformed SSE framing after reconnecting.",
+        why: "Malformed resumed events prevent clients from safely continuing stream processing.",
+        fix: "Return complete SSE events with valid id and retry fields after reconnecting.",
+        example: "Return a complete event frame after reconnecting."
+    },
+    {
+        id: "plugin.runtime.remote.reliability.session_restart.failed",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP session could not be restarted.",
+        why: "Clients cannot recover from an expired MCP session when a fresh initialization sequence fails.",
+        fix: "Accept a fresh initialize sequence after an expired MCP session.",
+        example: "Return a valid initialize response after HTTP 404 for a session-bound request."
+    },
+    {
+        id: "plugin.runtime.remote.reliability.termination.failed",
+        category: "runtime",
+        defaultSeverity: "fail",
+        summary: "The remote MCP session could not be terminated.",
+        why: "A server that advertises session lifecycle support must safely handle the approved termination request.",
+        fix: "Return a successful response or HTTP 405 for a bounded MCP session DELETE request.",
+        example: "HTTP/1.1 204 No Content"
     }
 ];
 export function findRuleDefinition(id) {

package/dist/run-cli.js

@@ -102,6 +102,8 @@ function parseRuntimeSandbox(flags, options = { requireRuntime: true }) {
 function parseRemoteNetworkFlags(flags, runtime) {
     let allowNetwork = false;
     let allowLocalNetwork = false;
+    let allowSessionLifecycle = false;
+    let requireRemoteReliability = false;
     for (let index = 0; index < flags.length; index += 1) {
         const flag = flags[index];
         if (flag === "--allow-network") {
@@ -120,23 +122,55 @@ function parseRemoteNetworkFlags(flags, runtime) {
             }
             allowLocalNetwork = true;
         }
-        else if (flag?.startsWith("--allow-network=") || flag?.startsWith("--allow-local-network=")) {
+        else if (flag === "--allow-session-lifecycle") {
+            if (allowSessionLifecycle)
+                return new CliUsageError("Duplicate runtime remote flag: --allow-session-lifecycle.");
+            if (flags[index + 1] && !flags[index + 1].startsWith("--")) {
+                return new CliUsageError("--allow-session-lifecycle does not accept a value.");
+            }
+            allowSessionLifecycle = true;
+        }
+        else if (flag === "--require-remote-reliability") {
+            if (requireRemoteReliability)
+                return new CliUsageError("Duplicate runtime remote flag: --require-remote-reliability.");
+            if (flags[index + 1] && !flags[index + 1].startsWith("--")) {
+                return new CliUsageError("--require-remote-reliability does not accept a value.");
+            }
+            requireRemoteReliability = true;
+        }
+        else if (flag?.startsWith("--allow-network=") ||
+            flag?.startsWith("--allow-local-network=") ||
+            flag?.startsWith("--allow-session-lifecycle=") ||
+            flag?.startsWith("--require-remote-reliability=")) {
             return new CliUsageError(`${flag.split("=", 1)[0]} does not accept a value.`);
         }
     }
+    if (allowSessionLifecycle && !runtime) {
+        return new CliUsageError("--allow-session-lifecycle requires --runtime.");
+    }
+    if (requireRemoteReliability && !runtime) {
+        return new CliUsageError("--require-remote-reliability requires --runtime and --allow-network.");
+    }
     if ((allowNetwork || allowLocalNetwork) && !runtime) {
         return new CliUsageError("--allow-network requires --runtime.");
     }
     if (allowLocalNetwork && !allowNetwork) {
         return new CliUsageError("--allow-local-network requires --allow-network.");
     }
-    return { allowNetwork, allowLocalNetwork };
+    if (allowSessionLifecycle && !allowNetwork) {
+        return new CliUsageError("--allow-session-lifecycle requires --allow-network.");
+    }
+    if (requireRemoteReliability && !allowNetwork) {
+        return new CliUsageError("--require-remote-reliability requires --runtime and --allow-network.");
+    }
+    return { allowNetwork, allowLocalNetwork, allowSessionLifecycle, requireRemoteReliability };
 }
 function printUsage(io) {
     io.writeStderr("Usage: codex-plugin-doctor check <path|--installed> [filter] [--policy codex-publish|mcp-strict|security] [--compat] [--json|--markdown|--badge-json|--badge-markdown] [--output <path>] [--history <path>] [--runtime [--allow-network [--allow-local-network]]] [--sandbox docker] [--require-runtime-approval --runtime-approval-digest <digest>] [--verbose-runtime] [--explain] [--no-animations] [--ascii] [--changed-since <ref>]\n       codex-plugin-doctor audit --installed [filter] [--policy codex-publish|mcp-strict|security] [--security] [--compat] [--json] [--output <path>] [--cache] [--changed]\n       codex-plugin-doctor audit deps <path> [--policy codex-publish|mcp-strict|security] [--recommend] [--json|--sarif] [--output <path>]\n       codex-plugin-doctor mcp <path> [--runtime [--allow-network [--allow-local-network]]] [--json] [--output <path>]\n       codex-plugin-doctor security <path> [--policy security] [--json|--scorecard]\n       codex-plugin-doctor compat <path> [--all|--client <client>] [--json] [--scorecard] [--output <path>] [--install-preview|--apply --backup]\n       codex-plugin-doctor suppress add <path> [--fingerprint <sha256> --reason <text> --expires-at YYYY-MM-DD] [--config <path>] [--json]\n       codex-plugin-doctor suppress list <path> [--config <path>] [--json]\n       codex-plugin-doctor suppress remove <path> [--fingerprint <sha256>|--index <n>] [--config <path>] [--json]\n       codex-plugin-doctor fix <path> (--dry-run|--interactive --backup|--apply --backup)\n       codex-plugin-doctor history <history.jsonl> [--json] [--fail-on-regression]\n       codex-plugin-doctor watch <path> [--runtime] [--json] [--output <path>] [--debounce-ms <ms>] [--max-iterations <n>] [--fail-fast] [--accumulate-json <path>]\n       codex-plugin-doctor doctor [npm <package>|contract|corpus [--manifest <corpus.json>] [--json] [--output <path>]|corpus metrics --manifest <corpus.json> [--json|--markdown] [--output <path>] [--min-precision <0..1>] [--min-recall <0..1>] [--max-false-positive-rate <0..1>]|runtime-plan <path> [--sandbox docker] [--json|--markdown] [--output <path>]|runtime-policy <path> [--sandbox docker] [--json] [--output <path>]|review-bundle <path> --output <dir> --sign-key-env NAME [--json] [--allow-dirty] [--allow-untagged]|review-bundle verify <bundle-dir> --target <path> --sign-key-env NAME [--json] [--output <path>] [--failures-only]|review-bundle diff --before <dir> --after <dir> [--json]|attest <path> [--sign-key-env NAME]|attest verify <attestation.json> --target <path> --sign-key-env NAME|release-evidence <path> --sign-key-env NAME [--runtime [--allow-network [--allow-local-network]]] [--sandbox docker] [--allow-dirty] [--allow-untagged] [--require-runtime-approval --runtime-approval-digest <digest>]|release-evidence verify <evidence.json> --target <path> --sign-key-env NAME|release-evidence asset <path> --tag <tag> --output <evidence.json> --sign-key-env NAME [--runtime [--allow-network [--allow-local-network]]] [--sandbox docker] [--allow-dirty] [--allow-untagged] [--require-runtime-approval --runtime-approval-digest <digest>] [--upload]|mcp <path> [--runtime [--allow-network [--allow-local-network]]]|inspector <path>|diff --before <path> --after <path>|recommend <path>|trust <path>|perf <path> [--max-total-ms <ms>] [--max-stage-ms stage=ms]|export --bundle <path>|snapshot|clients|--json|--update-check]\n       codex-plugin-doctor init [path] [--template skill-only|mcp-stdio|mcp-http|full-runtime]\n       codex-plugin-doctor init-ci [path]\n       codex-plugin-doctor init-git-hooks [path] [--force] [--json]\n       codex-plugin-doctor init-git-hooks [path] --remove [--json]\n       codex-plugin-doctor completion bash|zsh|fish\n       codex-plugin-doctor config validate <path> [--json]\n       codex-plugin-doctor release check <path> [--json] [--runtime [--allow-network [--allow-local-network]]] [--sandbox docker]\n       codex-plugin-doctor self-test\n       codex-plugin-doctor list --installed\n       codex-plugin-doctor explain <finding-id>\n       codex-plugin-doctor --version\n\nFirst run:\n       codex-plugin-doctor doctor\n       codex-plugin-doctor self-test\n       codex-plugin-doctor init my-plugin\n       codex-plugin-doctor check . --runtime --explain");
     io.writeStderr("Corpus quality regression: codex-plugin-doctor doctor corpus metrics diff --before <metrics.json> --after <metrics.json> [--fail-on-regression] [--json|--markdown] [--output <path>]");
     io.writeStderr("Suppression governance: codex-plugin-doctor suppress list <path> [--fail-on-expired] [--fail-on-invalid] [--warn-expiring-within-days <days>]\n       codex-plugin-doctor suppress prune <path> [--apply] [--json]");
     io.writeStderr("Baseline gating: codex-plugin-doctor baseline create <path> --output <path> [--runtime]\n       codex-plugin-doctor check <path> --baseline <path>");
+    io.writeStderr("Remote MCP runtime flags (check, mcp, release check, and doctor release-evidence): --runtime --allow-network [--allow-local-network] [--allow-session-lifecycle] [--require-remote-reliability]\n       --allow-session-lifecycle requires --runtime --allow-network and can terminate a remote session.\n       --require-remote-reliability requires --runtime --allow-network, blocks non-pass reliability, and does not grant network consent.");
 }
 const suppressUsageText = [
     "Usage:",
@@ -687,6 +721,8 @@ function buildGenericMcpDoctorCommandArgs(commandTarget, flags) {
     let runtime = false;
     let allowNetwork = false;
     let allowLocalNetwork = false;
+    let allowSessionLifecycle = false;
+    let requireRemoteReliability = false;
     for (let index = 0; index < flags.length; index += 1) {
         const flag = flags[index];
         if (flag === "--runtime") {
@@ -715,6 +751,26 @@ function buildGenericMcpDoctorCommandArgs(commandTarget, flags) {
             allowLocalNetwork = true;
             continue;
         }
+        if (flag === "--allow-session-lifecycle") {
+            if (flags[index + 1] && !flags[index + 1].startsWith("--")) {
+                return "--allow-session-lifecycle does not accept a value.";
+            }
+            allowSessionLifecycle = true;
+            continue;
+        }
+        if (flag === "--require-remote-reliability") {
+            if (flags[index + 1] && !flags[index + 1].startsWith("--")) {
+                return "--require-remote-reliability does not accept a value.";
+            }
+            requireRemoteReliability = true;
+            continue;
+        }
+        if (flag.startsWith("--allow-network=") ||
+            flag.startsWith("--allow-local-network=") ||
+            flag.startsWith("--allow-session-lifecycle=") ||
+            flag.startsWith("--require-remote-reliability=")) {
+            return `${flag.split("=", 1)[0]} does not accept a value.`;
+        }
         if (flag === "--output") {
             if (outputPath !== null) {
                 return "Duplicate MCP flag: --output.";
@@ -740,8 +796,10 @@ function buildGenericMcpDoctorCommandArgs(commandTarget, flags) {
         jsonOutput,
         outputPath,
         runtime,
-        allowNetwork,
-        allowLocalNetwork
+        allowNetwork: remoteNetwork.allowNetwork,
+        allowLocalNetwork: remoteNetwork.allowLocalNetwork,
+        allowSessionLifecycle,
+        requireRemoteReliability
     };
 }
 function parsePerformanceThresholds(flags) {
@@ -1031,7 +1089,9 @@ export async function runCli(args, io = defaultIo, options = {}) {
             }, {
                 runtime: parsedMcpArgs.runtime,
                 allowNetwork: parsedMcpArgs.allowNetwork,
-                allowLocalNetwork: parsedMcpArgs.allowLocalNetwork
+                allowLocalNetwork: parsedMcpArgs.allowLocalNetwork,
+                allowSessionLifecycle: parsedMcpArgs.allowSessionLifecycle,
+                requireRemoteReliability: parsedMcpArgs.requireRemoteReliability
             });
             const renderedReport = parsedMcpArgs.jsonOutput
                 ? renderGenericMcpDoctorJson(report)
@@ -1344,6 +1404,8 @@ export async function runCli(args, io = defaultIo, options = {}) {
                     runtime,
                     ...(remoteNetwork.allowNetwork ? { allowNetwork: true } : {}),
                     ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+                    ...(remoteNetwork.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+                    ...(remoteNetwork.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
                     ...(runtimeSandbox ? { sandbox: runtimeSandbox } : {}),
                     environment: {
                         env: terminalContext.env,
@@ -1507,6 +1569,8 @@ export async function runCli(args, io = defaultIo, options = {}) {
                 runtime,
                 ...(remoteNetwork.allowNetwork ? { allowNetwork: true } : {}),
                 ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+                ...(remoteNetwork.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+                ...(remoteNetwork.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
                 ...(runtimeSandbox ? { sandbox: runtimeSandbox } : {}),
                 environment: {
                     env: terminalContext.env,
@@ -2332,7 +2396,9 @@ export async function runCli(args, io = defaultIo, options = {}) {
         }, {
             runtime: parsedMcpArgs.runtime,
             allowNetwork: parsedMcpArgs.allowNetwork,
-            allowLocalNetwork: parsedMcpArgs.allowLocalNetwork
+            allowLocalNetwork: parsedMcpArgs.allowLocalNetwork,
+            allowSessionLifecycle: parsedMcpArgs.allowSessionLifecycle,
+            requireRemoteReliability: parsedMcpArgs.requireRemoteReliability
         });
         const renderedReport = parsedMcpArgs.jsonOutput
             ? renderGenericMcpDoctorJson(report)
@@ -2653,6 +2719,8 @@ export async function runCli(args, io = defaultIo, options = {}) {
             runtime: runtimeProbeEnabled,
             ...(remoteNetwork.allowNetwork ? { allowNetwork: true } : {}),
             ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+            ...(remoteNetwork.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+            ...(remoteNetwork.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
             ...(runtimeSandbox ? { runtimeSandbox } : {}),
             runCheck: options.runCheckImpl
         });
@@ -2867,6 +2935,8 @@ export async function runCli(args, io = defaultIo, options = {}) {
                     runtime: effectiveRuntimeProbeEnabled,
                     ...(remoteNetwork.allowNetwork ? { allowNetwork: true } : {}),
                     ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+                    ...(remoteNetwork.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+                    ...(remoteNetwork.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
                     runtimeTranscript: effectiveRuntimeProbeEnabled && verboseRuntime
                         ? (line) => io.writeStderr(line)
                         : undefined
@@ -2938,7 +3008,9 @@ export async function runCli(args, io = defaultIo, options = {}) {
                 const pluginResult = applyDoctorConfig(await runCheckImpl(pluginRoot, {
                     runtime: effectiveRuntimeProbeEnabled,
                     ...(remoteNetwork.allowNetwork ? { allowNetwork: true } : {}),
-                    ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {})
+                    ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+                    ...(remoteNetwork.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+                    ...(remoteNetwork.requireRemoteReliability ? { requireRemoteReliability: true } : {})
                 }), applyPolicyToDoctorConfig(applyCheckProfile(await loadDoctorConfig(pluginRoot, configPath), checkProfile), policy));
                 io.writeStdout(`\n${pluginResult.targetPath}: ${pluginResult.status.toUpperCase()}`);
                 validatedCount += 1;
@@ -2962,6 +3034,8 @@ export async function runCli(args, io = defaultIo, options = {}) {
         runtime: effectiveRuntimeProbeEnabled,
         ...(remoteNetwork.allowNetwork ? { allowNetwork: true } : {}),
         ...(remoteNetwork.allowLocalNetwork ? { allowLocalNetwork: true } : {}),
+        ...(remoteNetwork.allowSessionLifecycle ? { allowSessionLifecycle: true } : {}),
+        ...(remoteNetwork.requireRemoteReliability ? { requireRemoteReliability: true } : {}),
         ...(runtimeSandbox ? { runtimeSandbox } : {}),
         ...(effectiveRuntimeProbeEnabled && verboseRuntime
             ? { runtimeTranscript: (line) => io.writeStderr(line) }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-plugin-doctor",
-  "version": "1.52.0",
+  "version": "1.53.0",
   "description": "CLI-first validator for Codex plugins, skills, and MCP package surfaces with runtime MCP protocol validation.",
   "type": "module",
   "main": "./dist/index.js",