codex-plugin-doctor 0.6.0 → 0.8.0

package/README.md

@@ -162,24 +162,30 @@ Run these from a Codex plugin package root:
 
 ```bash
 codex-plugin-doctor --version
-codex-plugin-doctor self-test
-codex-plugin-doctor init my-plugin
-codex-plugin-doctor compat .
-codex-plugin-doctor compat . --client codex
-codex-plugin-doctor compat . --client generic-mcp
+codex-plugin-doctor self-test
+codex-plugin-doctor doctor
+codex-plugin-doctor init my-plugin
+codex-plugin-doctor compat .
+codex-plugin-doctor compat . --client codex
+codex-plugin-doctor compat . --client generic-mcp
 codex-plugin-doctor compat . --client claude-desktop
 codex-plugin-doctor compat . --client claude-desktop --install-preview
 codex-plugin-doctor compat . --client claude-desktop --apply --backup
-codex-plugin-doctor compat . --client cursor
-codex-plugin-doctor compat . --client cursor --install-preview
-codex-plugin-doctor compat . --client cursor --apply --backup
-codex-plugin-doctor compat . --scorecard
-codex-plugin-doctor compat . --json
-codex-plugin-doctor compat . --json --output compatibility.json
-codex-plugin-doctor check .
-codex-plugin-doctor check . --json
-codex-plugin-doctor check . --json --output report.json
-codex-plugin-doctor check . --markdown --output report.md
+codex-plugin-doctor compat . --client cursor
+codex-plugin-doctor compat . --client cursor --install-preview
+codex-plugin-doctor compat . --client cursor --apply --backup
+codex-plugin-doctor compat . --client cline
+codex-plugin-doctor compat . --client cline --install-preview
+codex-plugin-doctor compat . --scorecard
+codex-plugin-doctor compat . --json
+codex-plugin-doctor compat . --json --output compatibility.json
+codex-plugin-doctor check .
+codex-plugin-doctor check . --profile ci
+codex-plugin-doctor check . --profile strict
+codex-plugin-doctor check . --profile publish
+codex-plugin-doctor check . --json
+codex-plugin-doctor check . --json --output report.json
+codex-plugin-doctor check . --markdown --output report.md
 codex-plugin-doctor check . --badge-json --output doctor-badge.json
 codex-plugin-doctor check . --badge-markdown
 codex-plugin-doctor check . --sarif --output results.sarif
@@ -191,22 +197,32 @@ codex-plugin-doctor check . --history validation-history.jsonl
 codex-plugin-doctor history validation-history.jsonl
 codex-plugin-doctor history validation-history.jsonl --json
 codex-plugin-doctor history validation-history.jsonl --fail-on-regression
+codex-plugin-doctor fix . --dry-run
+codex-plugin-doctor fix . --apply --backup
 codex-plugin-doctor check . --json --runtime --verbose-runtime
 ```
-
-`self-test` runs the bundled runtime-complete sample through static validation, runtime MCP probes, and the compatibility scorecard. It is the fastest post-install check after `npm install -g codex-plugin-doctor`.
-
-`compat --client claude-desktop` checks whether the MCP package can be added to the local Claude Desktop setup. On Windows it looks for `%APPDATA%\Claude\claude_desktop_config.json`; on macOS it looks for `~/Library/Application Support/Claude/claude_desktop_config.json`. A valid existing config returns `PASS`, a missing Claude Desktop install returns `WARN`, and a malformed local config returns `FAIL` so you do not add new servers into a broken config file. If the package server name already exists in Claude Desktop, the command returns `WARN` with the duplicate server name. Add `--install-preview` to print the JSON snippet that should be merged into `claude_desktop_config.json`; it does not modify files. Use `--apply --backup` only when you want the CLI to create a timestamped backup and merge the server config. Apply mode refuses to overwrite duplicate server names.
-
-`compat --client cursor` checks whether the MCP package can be added to Cursor. It prefers a project-level `.cursor/mcp.json` when one already exists in the target package, then falls back to the global `~/.cursor/mcp.json` path. A valid existing config returns `PASS`, a missing Cursor config returns `WARN`, malformed JSON returns `FAIL`, and duplicate MCP server names return `WARN`. Add `--install-preview` to print the JSON snippet that should be merged into Cursor's `mcp.json`; it does not modify files. Use `--apply --backup` only when you want the CLI to create a timestamped backup and merge the server config. Apply mode refuses to overwrite duplicate server names.
-
-`compat --scorecard` turns the compatibility matrix into a compact score summary. `PASS` maps to `100`, `WARN` maps to `70`, and `FAIL` or `SKIPPED` maps to `0`.
-
+
+`self-test` runs the bundled runtime-complete sample through static validation, runtime MCP probes, and the compatibility scorecard. It is the fastest post-install check after `npm install -g codex-plugin-doctor`.
+
+`doctor` checks the local environment, including package version, platform, Node version, npm global prefix, Codex home, and Codex plugin cache visibility.
+
+`compat --client claude-desktop` checks whether the MCP package can be added to the local Claude Desktop setup. On Windows it looks for `%APPDATA%\Claude\claude_desktop_config.json`; on macOS it looks for `~/Library/Application Support/Claude/claude_desktop_config.json`. A valid existing config returns `PASS`, a missing Claude Desktop install returns `WARN`, and a malformed local config returns `FAIL` so you do not add new servers into a broken config file. If the package server name already exists in Claude Desktop, the command returns `WARN` with the duplicate server name. Add `--install-preview` to print the JSON snippet that should be merged into `claude_desktop_config.json`; it does not modify files. Use `--apply --backup` only when you want the CLI to create a timestamped backup and merge the server config. Apply mode refuses to overwrite duplicate server names.
+
+`compat --client cursor` checks whether the MCP package can be added to Cursor. It prefers a project-level `.cursor/mcp.json` when one already exists in the target package, then falls back to the global `~/.cursor/mcp.json` path. A valid existing config returns `PASS`, a missing Cursor config returns `WARN`, malformed JSON returns `FAIL`, and duplicate MCP server names return `WARN`. Add `--install-preview` to print the JSON snippet that should be merged into Cursor's `mcp.json`; it does not modify files. Use `--apply --backup` only when you want the CLI to create a timestamped backup and merge the server config. Apply mode refuses to overwrite duplicate server names.
+
+`compat --client cline` checks whether the MCP package can be added to Cline. It uses `CLINE_DIR/data/settings/cline_mcp_settings.json` when `CLINE_DIR` is set, otherwise `~/.cline/data/settings/cline_mcp_settings.json`. Add `--install-preview` to print the JSON snippet that should be merged into `cline_mcp_settings.json`.
+
+`compat --scorecard` turns the compatibility matrix into a compact score summary. `PASS` maps to `100`, `WARN` maps to `70`, and `FAIL` or `SKIPPED` maps to `0`.
+
+`check --profile ci|strict|publish` applies named validation policies. `ci` keeps default behavior, `strict` fails on warnings, and `publish` fails on warnings while enabling runtime probing by default.
+
 `check --badge-json` emits Shields endpoint-compatible JSON such as `{"schemaVersion":1,"label":"doctor","message":"PASS","color":"brightgreen"}`. `check --badge-markdown` emits a static shields.io Markdown badge for README or release notes. Badge output is intentionally limited to single package checks, not `check --installed`.
 
 `check --history <path>` appends a compact JSONL validation snapshot after a single package check. `history <path>` reads the JSONL file and compares the latest run to the previous run, including status, finding-count deltas, and whether the latest run regressed. Add `history --json` for automation output or `history --fail-on-regression` when CI should fail after a worse latest run.
-
-Optional local policy file:
+
+`fix --dry-run` renders safe automatic fix plans without changing files. `fix --apply --backup` applies only supported safe fixes, such as manifest defaults and missing skills directories, after creating backups.
+
+Optional local policy file:
 
 ```json
 {
@@ -239,9 +255,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: Esquetta/CodexPluginDoctor@v0.6.0
+      - uses: Esquetta/CodexPluginDoctor@v0.8.0
         with:
-          version: "0.6.0"
+          version: "0.8.0"
           path: .
           runtime: "false"
 ```

package/dist/compatibility/cline-install-preview.d.ts

@@ -0,0 +1,10 @@
+import { type CompatibilityEnvironment } from "./compatibility-matrix.js";
+export interface ClineInstallPreview {
+    targetPath: string;
+    configPath: string;
+    snippet: {
+        mcpServers: Record<string, unknown>;
+    };
+}
+export declare function buildClineInstallPreview(targetPath: string, environment?: CompatibilityEnvironment): Promise<ClineInstallPreview>;
+export declare function renderClineInstallPreview(preview: ClineInstallPreview): string;

package/dist/compatibility/cline-install-preview.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { getClineMcpConfigPath, readMcpConfigPath } from "./compatibility-matrix.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRelativeLocalPath(value) {
+    return value.startsWith("./") ||
+        value.startsWith("../") ||
+        value.startsWith(".\\") ||
+        value.startsWith("..\\");
+}
+function normalizeLocalPathArgument(value, rootPath) {
+    return typeof value === "string" && isRelativeLocalPath(value)
+        ? path.resolve(rootPath, value)
+        : value;
+}
+function normalizeServerConfig(serverConfig, rootPath) {
+    if (!isRecord(serverConfig)) {
+        return serverConfig;
+    }
+    const normalized = { ...serverConfig };
+    if (typeof normalized.command === "string" && isRelativeLocalPath(normalized.command)) {
+        normalized.command = path.resolve(rootPath, normalized.command);
+    }
+    if (Array.isArray(normalized.args)) {
+        normalized.args = normalized.args.map((argument) => normalizeLocalPathArgument(argument, rootPath));
+    }
+    return normalized;
+}
+export async function buildClineInstallPreview(targetPath, environment = {}) {
+    const rootPath = path.resolve(targetPath);
+    const mcpConfigPath = await readMcpConfigPath(rootPath);
+    if (!mcpConfigPath) {
+        throw new Error("No MCP config found for install preview.");
+    }
+    const parsed = JSON.parse(await readFile(mcpConfigPath, "utf8"));
+    const servers = parsed.mcpServers;
+    if (!isRecord(servers) || Object.keys(servers).length === 0) {
+        throw new Error("MCP config does not contain a non-empty `mcpServers` object.");
+    }
+    return {
+        targetPath: rootPath,
+        configPath: getClineMcpConfigPath(environment),
+        snippet: {
+            mcpServers: Object.fromEntries(Object.entries(servers).map(([serverName, serverConfig]) => [
+                serverName,
+                normalizeServerConfig(serverConfig, rootPath)
+            ]))
+        }
+    };
+}
+export function renderClineInstallPreview(preview) {
+    return [
+        "Cline Install Preview",
+        "=====================",
+        `Target: ${preview.targetPath}`,
+        `Config: ${preview.configPath}`,
+        "",
+        "Add or merge this snippet into `cline_mcp_settings.json`:",
+        JSON.stringify(preview.snippet, null, 2),
+        "",
+        "No files were modified."
+    ].join("\n");
+}

package/dist/compatibility/compatibility-matrix.d.ts

@@ -17,5 +17,7 @@ export interface CompatibilityEnvironment {
 export declare function readMcpConfigPath(targetPath: string): Promise<string | null>;
 export declare function getClaudeDesktopConfigPath(environment?: CompatibilityEnvironment): string | null;
 export declare function getCursorMcpConfigPath(targetPath: string, environment?: CompatibilityEnvironment): Promise<string>;
+export declare function getClineMcpConfigPath(environment?: CompatibilityEnvironment): string;
+export declare function getWindsurfMcpConfigPath(environment?: CompatibilityEnvironment): string;
 export declare function buildCompatibilityMatrix(targetPath: string, environment?: CompatibilityEnvironment): Promise<CompatibilityMatrix>;
 export declare function matrixExitCode(matrix: CompatibilityMatrix): 0 | 1;

package/dist/compatibility/compatibility-matrix.js

@@ -134,6 +134,16 @@ export async function getCursorMcpConfigPath(targetPath, environment = {}) {
     }
     return path.join(getHomeDirectory(environment), ".cursor", "mcp.json");
 }
+export function getClineMcpConfigPath(environment = {}) {
+    const env = environment.env ?? process.env;
+    const clineDirectory = env.CLINE_DIR
+        ? path.resolve(env.CLINE_DIR)
+        : path.join(getHomeDirectory(environment), ".cline");
+    return path.join(clineDirectory, "data", "settings", "cline_mcp_settings.json");
+}
+export function getWindsurfMcpConfigPath(environment = {}) {
+    return path.join(getHomeDirectory(environment), ".codeium", "windsurf", "mcp_config.json");
+}
 async function checkClaudeDesktop(targetPath, genericMcpResult, environment = {}) {
     if (genericMcpResult.status !== "pass") {
         return {
@@ -286,11 +296,157 @@ async function checkCursor(targetPath, genericMcpResult, environment = {}) {
         };
     }
 }
+async function checkCline(targetPath, genericMcpResult, environment = {}) {
+    if (genericMcpResult.status !== "pass") {
+        return {
+            client: "Cline",
+            status: "skipped",
+            summary: "No valid MCP package config is available for Cline.",
+            details: ["Add a valid `.mcp.json` with a non-empty `mcpServers` object first."]
+        };
+    }
+    const configPath = getClineMcpConfigPath(environment);
+    if (!(await fileExists(configPath))) {
+        const configDirectory = path.dirname(configPath);
+        return {
+            client: "Cline",
+            status: await directoryExists(configDirectory) ? "pass" : "warn",
+            summary: await directoryExists(configDirectory)
+                ? "Cline MCP settings directory exists and a config file can be created."
+                : "Cline was not detected on this machine.",
+            details: [
+                configPath,
+                "Cline stores MCP servers in `cline_mcp_settings.json` under its settings directory."
+            ]
+        };
+    }
+    try {
+        const parsed = await readJsonFile(configPath);
+        const servers = parsed.mcpServers;
+        if (servers !== undefined && (typeof servers !== "object" ||
+            servers === null ||
+            Array.isArray(servers))) {
+            return {
+                client: "Cline",
+                status: "fail",
+                summary: "Cline MCP config has an invalid `mcpServers` shape.",
+                details: [configPath, "`mcpServers` must be an object before this package can be added safely."]
+            };
+        }
+        const packageServerNames = await readMcpServerNames(targetPath);
+        const existingServerNames = typeof servers === "object" && servers !== null
+            ? Object.keys(servers)
+            : [];
+        const duplicateServerNames = packageServerNames.filter((serverName) => existingServerNames.includes(serverName));
+        if (duplicateServerNames.length > 0) {
+            return {
+                client: "Cline",
+                status: "warn",
+                summary: "Cline already has MCP server names from this package.",
+                details: [
+                    configPath,
+                    ...duplicateServerNames.map((serverName) => `Duplicate server: ${serverName}`)
+                ]
+            };
+        }
+        return {
+            client: "Cline",
+            status: "pass",
+            summary: "Cline MCP config is valid and this package can be added.",
+            details: [
+                configPath,
+                `Source package: ${path.resolve(targetPath)}`
+            ]
+        };
+    }
+    catch {
+        return {
+            client: "Cline",
+            status: "fail",
+            summary: "Cline MCP config is not valid JSON.",
+            details: [configPath, "Repair the local Cline MCP config before adding new MCP servers."]
+        };
+    }
+}
+async function checkWindsurf(targetPath, genericMcpResult, environment = {}) {
+    if (genericMcpResult.status !== "pass") {
+        return {
+            client: "Windsurf",
+            status: "skipped",
+            summary: "No valid MCP package config is available for Windsurf.",
+            details: ["Add a valid `.mcp.json` with a non-empty `mcpServers` object first."]
+        };
+    }
+    const configPath = getWindsurfMcpConfigPath(environment);
+    if (!(await fileExists(configPath))) {
+        const configDirectory = path.dirname(configPath);
+        return {
+            client: "Windsurf",
+            status: await directoryExists(configDirectory) ? "pass" : "warn",
+            summary: await directoryExists(configDirectory)
+                ? "Windsurf MCP config directory exists and a config file can be created."
+                : "Windsurf was not detected on this machine.",
+            details: [
+                configPath,
+                "Windsurf stores Cascade MCP servers in `mcp_config.json` under `~/.codeium/windsurf`."
+            ]
+        };
+    }
+    try {
+        const parsed = await readJsonFile(configPath);
+        const servers = parsed.mcpServers;
+        if (servers !== undefined && (typeof servers !== "object" ||
+            servers === null ||
+            Array.isArray(servers))) {
+            return {
+                client: "Windsurf",
+                status: "fail",
+                summary: "Windsurf MCP config has an invalid `mcpServers` shape.",
+                details: [configPath, "`mcpServers` must be an object before this package can be added safely."]
+            };
+        }
+        const packageServerNames = await readMcpServerNames(targetPath);
+        const existingServerNames = typeof servers === "object" && servers !== null
+            ? Object.keys(servers)
+            : [];
+        const duplicateServerNames = packageServerNames.filter((serverName) => existingServerNames.includes(serverName));
+        if (duplicateServerNames.length > 0) {
+            return {
+                client: "Windsurf",
+                status: "warn",
+                summary: "Windsurf already has MCP server names from this package.",
+                details: [
+                    configPath,
+                    ...duplicateServerNames.map((serverName) => `Duplicate server: ${serverName}`)
+                ]
+            };
+        }
+        return {
+            client: "Windsurf",
+            status: "pass",
+            summary: "Windsurf MCP config is valid and this package can be added.",
+            details: [
+                configPath,
+                `Source package: ${path.resolve(targetPath)}`
+            ]
+        };
+    }
+    catch {
+        return {
+            client: "Windsurf",
+            status: "fail",
+            summary: "Windsurf MCP config is not valid JSON.",
+            details: [configPath, "Repair the local Windsurf MCP config before adding new MCP servers."]
+        };
+    }
+}
 export async function buildCompatibilityMatrix(targetPath, environment = {}) {
     const rootPath = path.resolve(targetPath);
     const genericMcpResult = await checkGenericMcp(rootPath);
     const claudeDesktopResult = await checkClaudeDesktop(rootPath, genericMcpResult, environment);
     const cursorResult = await checkCursor(rootPath, genericMcpResult, environment);
+    const clineResult = await checkCline(rootPath, genericMcpResult, environment);
+    const windsurfResult = await checkWindsurf(rootPath, genericMcpResult, environment);
     const codexResult = await validatePlugin(rootPath);
     const codexStatus = statusFromCheckResult(codexResult);
     const codexCompatibility = !await hasCodexManifest(rootPath)
@@ -313,7 +469,9 @@ export async function buildCompatibilityMatrix(targetPath, environment = {}) {
         codexCompatibility,
         genericMcpResult,
         claudeDesktopResult,
-        cursorResult
+        cursorResult,
+        clineResult,
+        windsurfResult
     ];
     return {
         targetPath: rootPath,

package/dist/compatibility/windsurf-install-preview.d.ts

@@ -0,0 +1,10 @@
+import { type CompatibilityEnvironment } from "./compatibility-matrix.js";
+export interface WindsurfInstallPreview {
+    targetPath: string;
+    configPath: string;
+    snippet: {
+        mcpServers: Record<string, unknown>;
+    };
+}
+export declare function buildWindsurfInstallPreview(targetPath: string, environment?: CompatibilityEnvironment): Promise<WindsurfInstallPreview>;
+export declare function renderWindsurfInstallPreview(preview: WindsurfInstallPreview): string;

package/dist/compatibility/windsurf-install-preview.js

@@ -0,0 +1,65 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { getWindsurfMcpConfigPath, readMcpConfigPath } from "./compatibility-matrix.js";
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isRelativeLocalPath(value) {
+    return value.startsWith("./") ||
+        value.startsWith("../") ||
+        value.startsWith(".\\") ||
+        value.startsWith("..\\");
+}
+function normalizeLocalPathArgument(value, rootPath) {
+    return typeof value === "string" && isRelativeLocalPath(value)
+        ? path.resolve(rootPath, value)
+        : value;
+}
+function normalizeServerConfig(serverConfig, rootPath) {
+    if (!isRecord(serverConfig)) {
+        return serverConfig;
+    }
+    const normalized = { ...serverConfig };
+    if (typeof normalized.command === "string" && isRelativeLocalPath(normalized.command)) {
+        normalized.command = path.resolve(rootPath, normalized.command);
+    }
+    if (Array.isArray(normalized.args)) {
+        normalized.args = normalized.args.map((argument) => normalizeLocalPathArgument(argument, rootPath));
+    }
+    return normalized;
+}
+export async function buildWindsurfInstallPreview(targetPath, environment = {}) {
+    const rootPath = path.resolve(targetPath);
+    const mcpConfigPath = await readMcpConfigPath(rootPath);
+    if (!mcpConfigPath) {
+        throw new Error("No MCP config found for install preview.");
+    }
+    const parsed = JSON.parse(await readFile(mcpConfigPath, "utf8"));
+    const servers = parsed.mcpServers;
+    if (!isRecord(servers) || Object.keys(servers).length === 0) {
+        throw new Error("MCP config does not contain a non-empty `mcpServers` object.");
+    }
+    return {
+        targetPath: rootPath,
+        configPath: getWindsurfMcpConfigPath(environment),
+        snippet: {
+            mcpServers: Object.fromEntries(Object.entries(servers).map(([serverName, serverConfig]) => [
+                serverName,
+                normalizeServerConfig(serverConfig, rootPath)
+            ]))
+        }
+    };
+}
+export function renderWindsurfInstallPreview(preview) {
+    return [
+        "Windsurf Install Preview",
+        "========================",
+        `Target: ${preview.targetPath}`,
+        `Config: ${preview.configPath}`,
+        "",
+        "Add or merge this snippet into `mcp_config.json`:",
+        JSON.stringify(preview.snippet, null, 2),
+        "",
+        "No files were modified."
+    ].join("\n");
+}

package/dist/core/environment-doctor.d.ts

@@ -0,0 +1,19 @@
+import type { CliTerminalContext } from "../run-cli.js";
+export interface EnvironmentDoctorReport {
+    schemaVersion: "1.0.0";
+    version: string;
+    platform: string;
+    node: string;
+    npmGlobalPrefix: string;
+    codexHome: {
+        status: "pass" | "warn";
+        path: string | null;
+    };
+    codexPluginCache: {
+        status: "pass" | "warn";
+        path: string | null;
+    };
+}
+export declare function renderEnvironmentDoctor(terminalContext: CliTerminalContext): Promise<string>;
+export declare function buildEnvironmentDoctorReport(terminalContext: CliTerminalContext): Promise<EnvironmentDoctorReport>;
+export declare function renderEnvironmentDoctorJson(terminalContext: CliTerminalContext): Promise<string>;

package/dist/core/environment-doctor.js

@@ -0,0 +1,62 @@
+import { access } from "node:fs/promises";
+import path from "node:path";
+import { packageVersion } from "../version.js";
+async function pathExists(targetPath) {
+    try {
+        await access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveCodexHome(env) {
+    if (env.CODEX_HOME) {
+        return path.resolve(env.CODEX_HOME);
+    }
+    if (env.USERPROFILE) {
+        return path.join(env.USERPROFILE, ".codex");
+    }
+    if (env.HOME) {
+        return path.join(env.HOME, ".codex");
+    }
+    return null;
+}
+export async function renderEnvironmentDoctor(terminalContext) {
+    const report = await buildEnvironmentDoctorReport(terminalContext);
+    return [
+        "Codex Plugin Doctor Environment",
+        "===============================",
+        `Version: ${report.version}`,
+        `Platform: ${report.platform}`,
+        `Node: ${report.node}`,
+        `npm global prefix: ${report.npmGlobalPrefix}`,
+        `Codex home: ${report.codexHome.status.toUpperCase()}${report.codexHome.path ? ` (${report.codexHome.path})` : ""}`,
+        `Codex plugin cache: ${report.codexPluginCache.status.toUpperCase()}${report.codexPluginCache.path ? ` (${report.codexPluginCache.path})` : ""}`
+    ].join("\n");
+}
+export async function buildEnvironmentDoctorReport(terminalContext) {
+    const codexHome = resolveCodexHome(terminalContext.env);
+    const codexHomeExists = codexHome ? await pathExists(codexHome) : false;
+    const pluginCache = codexHome ? path.join(codexHome, "plugins", "cache") : null;
+    const pluginCacheExists = pluginCache ? await pathExists(pluginCache) : false;
+    const npmPrefix = terminalContext.env.npm_config_prefix ?? "(unknown)";
+    return {
+        schemaVersion: "1.0.0",
+        version: packageVersion,
+        platform: terminalContext.platform ?? process.platform,
+        node: process.version,
+        npmGlobalPrefix: npmPrefix,
+        codexHome: {
+            status: codexHomeExists ? "pass" : "warn",
+            path: codexHome
+        },
+        codexPluginCache: {
+            status: pluginCacheExists ? "pass" : "warn",
+            path: pluginCache
+        }
+    };
+}
+export async function renderEnvironmentDoctorJson(terminalContext) {
+    return JSON.stringify(await buildEnvironmentDoctorReport(terminalContext), null, 2);
+}

package/dist/core/fix-plan.d.ts

@@ -0,0 +1,35 @@
+export interface FixPlanAction {
+    id: string;
+    title: string;
+    targetPath: string;
+    operation: "update-json" | "mkdir";
+    details: string;
+}
+export interface FixPlan {
+    targetPath: string;
+    actions: FixPlanAction[];
+}
+export interface ApplyFixPlanResult {
+    plan: FixPlan;
+    filesChanged: number;
+    backupDirectory: string;
+}
+export interface FixPlanJsonReport {
+    schemaVersion: "1.0.0";
+    mode: "dry-run" | "apply";
+    targetPath: string;
+    filesChanged: number;
+    backupDirectory: string | null;
+    actions: Array<FixPlanAction & {
+        relativePath: string;
+    }>;
+}
+export declare function buildFixPlan(targetPath: string): Promise<FixPlan>;
+export declare function renderFixPlan(plan: FixPlan, mode: "dry-run"): string;
+export declare function applyFixPlan(targetPath: string): Promise<ApplyFixPlanResult>;
+export declare function renderApplyFixResult(result: ApplyFixPlanResult): string;
+export declare function renderFixPlanJsonReport(plan: FixPlan, options: {
+    mode: "dry-run" | "apply";
+    filesChanged?: number;
+    backupDirectory?: string | null;
+}): string;

package/dist/core/fix-plan.js

@@ -0,0 +1,241 @@
+import { copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { validatePlugin } from "./validate-plugin.js";
+function relativeToTarget(targetPath, candidatePath) {
+    return path.relative(targetPath, candidatePath).replace(/\\/g, "/");
+}
+export async function buildFixPlan(targetPath) {
+    const result = await validatePlugin(targetPath);
+    const rootPath = result.targetPath;
+    const actions = [];
+    const findingIds = new Set(result.findings.map((finding) => finding.id));
+    const manifestPath = path.join(rootPath, ".codex-plugin", "plugin.json");
+    if (findingIds.has("plugin.manifest.version.missing") ||
+        findingIds.has("plugin.manifest.description.missing")) {
+        const fields = [
+            findingIds.has("plugin.manifest.version.missing") ? "`version`" : null,
+            findingIds.has("plugin.manifest.description.missing") ? "`description`" : null
+        ].filter(Boolean);
+        actions.push({
+            id: "manifest.safe_defaults",
+            title: "Add missing safe manifest defaults",
+            targetPath: manifestPath,
+            operation: "update-json",
+            details: `Set ${fields.join(" and ")} in ${relativeToTarget(rootPath, manifestPath)}.`
+        });
+    }
+    if (findingIds.has("plugin.skills.path.missing")) {
+        actions.push({
+            id: "skills.create_directory",
+            title: "Create missing skills directory",
+            targetPath: path.join(rootPath, "skills"),
+            operation: "mkdir",
+            details: "Create the skills directory referenced by the manifest."
+        });
+    }
+    const manifest = await readFile(manifestPath, "utf8")
+        .then((content) => JSON.parse(content))
+        .catch(() => ({}));
+    if (typeof manifest.skills === "string") {
+        const skillsPath = path.resolve(rootPath, manifest.skills);
+        if (await directoryExists(skillsPath)) {
+            for (const entry of await readdir(skillsPath, { withFileTypes: true })) {
+                if (!entry.isDirectory()) {
+                    continue;
+                }
+                const skillFilePath = path.join(skillsPath, entry.name, "SKILL.md");
+                if (!(await fileExists(skillFilePath))) {
+                    actions.push({
+                        id: "skill.scaffold_skill_md",
+                        title: `Create missing SKILL.md for ${entry.name}`,
+                        targetPath: skillFilePath,
+                        operation: "update-json",
+                        details: `Create ${relativeToTarget(rootPath, skillFilePath)} with safe frontmatter.`
+                    });
+                    continue;
+                }
+                const skillContent = await readFile(skillFilePath, "utf8");
+                const frontmatter = skillContent.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1] ?? "";
+                if (!/^name\s*:/im.test(frontmatter) || !/^description\s*:/im.test(frontmatter)) {
+                    actions.push({
+                        id: "skill.safe_frontmatter_defaults",
+                        title: `Add missing skill frontmatter defaults for ${entry.name}`,
+                        targetPath: skillFilePath,
+                        operation: "update-json",
+                        details: `Set missing name/description fields in ${relativeToTarget(rootPath, skillFilePath)}.`
+                    });
+                }
+            }
+        }
+    }
+    if (typeof manifest.mcpServers === "string") {
+        const mcpConfigPath = path.resolve(rootPath, manifest.mcpServers);
+        if (!(await fileExists(mcpConfigPath))) {
+            actions.push({
+                id: "mcp.scaffold_config",
+                title: "Create missing MCP config",
+                targetPath: mcpConfigPath,
+                operation: "update-json",
+                details: `Create ${relativeToTarget(rootPath, mcpConfigPath)} with an empty mcpServers object.`
+            });
+        }
+    }
+    return {
+        targetPath: rootPath,
+        actions
+    };
+}
+export function renderFixPlan(plan, mode) {
+    const lines = [
+        "Fix Plan",
+        "========",
+        `Mode: ${mode}`,
+        `Target: ${plan.targetPath}`
+    ];
+    if (plan.actions.length === 0) {
+        lines.push("", "No safe automatic fixes available.");
+        return lines.join("\n");
+    }
+    lines.push("", "Actions");
+    lines.push("-------");
+    plan.actions.forEach((action, index) => {
+        lines.push(`${index + 1}. ${action.title}`);
+        lines.push(`   Path: ${relativeToTarget(plan.targetPath, action.targetPath)}`);
+        lines.push(`   Operation: ${action.operation}`);
+        lines.push(`   Details: ${action.details}`);
+    });
+    lines.push("", "No files changed.");
+    return lines.join("\n");
+}
+function timestampForPath() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function defaultManifestDescription() {
+    return "Codex plugin package.";
+}
+async function fileExists(targetPath) {
+    try {
+        const details = await stat(targetPath);
+        return details.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function directoryExists(targetPath) {
+    try {
+        const details = await stat(targetPath);
+        return details.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function skillDescription(skillName) {
+    return `Use when running the ${skillName} skill.`;
+}
+function renderSkillScaffold(skillName, body = "") {
+    return [
+        "---",
+        `name: ${skillName}`,
+        `description: ${skillDescription(skillName)}`,
+        "---",
+        "",
+        body.trim() || `# ${skillName}`
+    ].join("\n") + "\n";
+}
+function replaceFrontmatter(content, skillName) {
+    const frontmatterMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    const frontmatter = frontmatterMatch?.[1] ?? "";
+    const body = frontmatterMatch ? content.slice(frontmatterMatch[0].length) : content;
+    const lines = frontmatter.split(/\r?\n/).filter((line) => line.trim());
+    const hasName = lines.some((line) => /^name\s*:/i.test(line));
+    const hasDescription = lines.some((line) => /^description\s*:/i.test(line));
+    return [
+        "---",
+        ...(hasName ? [] : [`name: ${skillName}`]),
+        ...(hasDescription ? [] : [`description: ${skillDescription(skillName)}`]),
+        ...lines,
+        "---",
+        "",
+        body.trim() || `# ${skillName}`
+    ].join("\n") + "\n";
+}
+async function backupFile(rootPath, backupDirectory, filePath) {
+    const relativePath = path.relative(rootPath, filePath);
+    const backupPath = path.join(backupDirectory, relativePath);
+    await mkdir(path.dirname(backupPath), { recursive: true });
+    await copyFile(filePath, backupPath);
+}
+export async function applyFixPlan(targetPath) {
+    const plan = await buildFixPlan(targetPath);
+    const backupDirectory = path.join(plan.targetPath, ".codex-doctor-backups", timestampForPath());
+    let filesChanged = 0;
+    for (const action of plan.actions) {
+        if (action.operation === "update-json" && action.id === "manifest.safe_defaults") {
+            await backupFile(plan.targetPath, backupDirectory, action.targetPath);
+            const manifest = JSON.parse(await readFile(action.targetPath, "utf8"));
+            if (typeof manifest.version !== "string" || manifest.version.trim() === "") {
+                manifest.version = "0.1.0";
+            }
+            if (typeof manifest.description !== "string" ||
+                manifest.description.trim() === "") {
+                manifest.description = defaultManifestDescription();
+            }
+            await writeFile(action.targetPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+            filesChanged += 1;
+            continue;
+        }
+        if (action.operation === "mkdir" && action.id === "skills.create_directory") {
+            await mkdir(action.targetPath, { recursive: true });
+            filesChanged += 1;
+            continue;
+        }
+        if (action.operation === "update-json" && action.id === "skill.scaffold_skill_md") {
+            await mkdir(path.dirname(action.targetPath), { recursive: true });
+            await writeFile(action.targetPath, renderSkillScaffold(path.basename(path.dirname(action.targetPath))), "utf8");
+            filesChanged += 1;
+            continue;
+        }
+        if (action.operation === "update-json" && action.id === "skill.safe_frontmatter_defaults") {
+            await backupFile(plan.targetPath, backupDirectory, action.targetPath);
+            await writeFile(action.targetPath, replaceFrontmatter(await readFile(action.targetPath, "utf8"), path.basename(path.dirname(action.targetPath))), "utf8");
+            filesChanged += 1;
+            continue;
+        }
+        if (action.operation === "update-json" && action.id === "mcp.scaffold_config") {
+            await mkdir(path.dirname(action.targetPath), { recursive: true });
+            await writeFile(action.targetPath, `${JSON.stringify({ mcpServers: {} }, null, 2)}\n`, "utf8");
+            filesChanged += 1;
+        }
+    }
+    return {
+        plan,
+        filesChanged,
+        backupDirectory
+    };
+}
+export function renderApplyFixResult(result) {
+    return [
+        "Fix Plan",
+        "========",
+        "Mode: apply",
+        `Target: ${result.plan.targetPath}`,
+        `Files changed: ${result.filesChanged}`,
+        `Backup: ${relativeToTarget(result.plan.targetPath, result.backupDirectory)}`
+    ].join("\n");
+}
+export function renderFixPlanJsonReport(plan, options) {
+    const report = {
+        schemaVersion: "1.0.0",
+        mode: options.mode,
+        targetPath: plan.targetPath,
+        filesChanged: options.filesChanged ?? 0,
+        backupDirectory: options.backupDirectory ?? null,
+        actions: plan.actions.map((action) => ({
+            ...action,
+            relativePath: relativeToTarget(plan.targetPath, action.targetPath)
+        }))
+    };
+    return JSON.stringify(report, null, 2);
+}

package/dist/core/init-ci.d.ts

@@ -0,0 +1,5 @@
+export interface InitCiResult {
+    rootPath: string;
+    workflowPath: string;
+}
+export declare function initCiWorkflow(targetPath: string): Promise<InitCiResult>;

package/dist/core/init-ci.js

@@ -0,0 +1,36 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { packageVersion } from "../version.js";
+function buildWorkflow() {
+    return [
+        "name: Validate Codex plugin",
+        "",
+        "on:",
+        "  pull_request:",
+        "  push:",
+        "    branches:",
+        "      - main",
+        "",
+        "jobs:",
+        "  doctor:",
+        "    runs-on: ubuntu-latest",
+        "    steps:",
+        "      - uses: actions/checkout@v4",
+        `      - uses: Esquetta/CodexPluginDoctor@v${packageVersion}`,
+        "        with:",
+        `          version: \"${packageVersion}\"`,
+        "          path: .",
+        "          runtime: \"true\"",
+        ""
+    ].join("\n");
+}
+export async function initCiWorkflow(targetPath) {
+    const rootPath = path.resolve(targetPath);
+    const workflowPath = path.join(rootPath, ".github", "workflows", "codex-plugin-doctor.yml");
+    await mkdir(path.dirname(workflowPath), { recursive: true });
+    await writeFile(workflowPath, buildWorkflow(), "utf8");
+    return {
+        rootPath,
+        workflowPath
+    };
+}

package/dist/run-cli.js

@@ -7,7 +7,12 @@ import { buildCompatibilityMatrix, matrixExitCode } from "./compatibility/compat
 import { applyInstallPreview, renderApplyInstallResult } from "./compatibility/apply-install-preview.js";
 import { buildClaudeDesktopInstallPreview, renderClaudeDesktopInstallPreview } from "./compatibility/claude-desktop-install-preview.js";
 import { buildCursorInstallPreview, renderCursorInstallPreview } from "./compatibility/cursor-install-preview.js";
+import { buildClineInstallPreview, renderClineInstallPreview } from "./compatibility/cline-install-preview.js";
+import { buildWindsurfInstallPreview, renderWindsurfInstallPreview } from "./compatibility/windsurf-install-preview.js";
 import { applyDoctorConfig, loadDoctorConfig } from "./core/doctor-config.js";
+import { applyFixPlan, buildFixPlan, renderApplyFixResult, renderFixPlanJsonReport, renderFixPlan } from "./core/fix-plan.js";
+import { renderEnvironmentDoctor, renderEnvironmentDoctorJson } from "./core/environment-doctor.js";
+import { initCiWorkflow } from "./core/init-ci.js";
 import { initPluginPackage } from "./core/init-plugin.js";
 import { runCheck } from "./index.js";
 import { renderInstalledSummary } from "./reporting/render-installed-summary.js";
@@ -34,7 +39,7 @@ const defaultIo = {
     }
 };
 function printUsage(io) {
-    io.writeStderr("Usage: codex-plugin-doctor check <path|--installed> [filter] [--json|--markdown|--badge-json|--badge-markdown] [--output <path>] [--history <path>] [--runtime] [--verbose-runtime] [--no-animations] [--ascii]\n       codex-plugin-doctor compat <path> [--client <client>] [--json] [--scorecard] [--output <path>] [--install-preview|--apply --backup]\n       codex-plugin-doctor history <history.jsonl> [--json] [--fail-on-regression]\n       codex-plugin-doctor self-test\n       codex-plugin-doctor list --installed\n       codex-plugin-doctor explain <finding-id>\n       codex-plugin-doctor --version");
+    io.writeStderr("Usage: codex-plugin-doctor check <path|--installed> [filter] [--json|--markdown|--badge-json|--badge-markdown] [--output <path>] [--history <path>] [--runtime] [--verbose-runtime] [--no-animations] [--ascii]\n       codex-plugin-doctor compat <path> [--client <client>] [--json] [--scorecard] [--output <path>] [--install-preview|--apply --backup]\n       codex-plugin-doctor fix <path> (--dry-run|--apply --backup)\n       codex-plugin-doctor history <history.jsonl> [--json] [--fail-on-regression]\n       codex-plugin-doctor doctor\n       codex-plugin-doctor init-ci [path]\n       codex-plugin-doctor self-test\n       codex-plugin-doctor list --installed\n       codex-plugin-doctor explain <finding-id>\n       codex-plugin-doctor --version");
 }
 function renderInstalledPlugins(plugins) {
     const lines = [
@@ -60,8 +65,28 @@ const compatibilityClientAliases = {
     mcp: "Generic MCP",
     "claude-desktop": "Claude Desktop",
     claude: "Claude Desktop",
-    cursor: "Cursor"
+    cursor: "Cursor",
+    cline: "Cline",
+    windsurf: "Windsurf"
 };
+const checkProfiles = ["ci", "strict", "publish"];
+function parseCheckProfile(value) {
+    if (!value) {
+        return null;
+    }
+    return checkProfiles.includes(value)
+        ? value
+        : null;
+}
+function applyCheckProfile(config, profile) {
+    if (profile === "strict" || profile === "publish") {
+        return {
+            ...config,
+            failOnWarnings: true
+        };
+    }
+    return config;
+}
 function filterCompatibilityMatrix(matrix, clientFilter) {
     const client = compatibilityClientAliases[clientFilter.toLowerCase()];
     if (!client) {
@@ -107,6 +132,12 @@ export async function runCli(args, io = defaultIo, options = {}) {
         io.writeStdout(renderInstalledPlugins(installedPlugins));
         return 0;
     }
+    if (command === "doctor") {
+        io.writeStdout(maybePath === "--json"
+            ? await renderEnvironmentDoctorJson(terminalContext)
+            : await renderEnvironmentDoctor(terminalContext));
+        return 0;
+    }
     if (command === "explain") {
         if (!maybePath || maybePath.startsWith("--")) {
             io.writeStderr("Missing finding id. Usage: codex-plugin-doctor explain <finding-id>");
@@ -169,6 +200,50 @@ export async function runCli(args, io = defaultIo, options = {}) {
         ].join("\n"));
         return 0;
     }
+    if (command === "init-ci") {
+        const targetPath = maybePath && !maybePath.startsWith("--") ? maybePath : ".";
+        const result = await initCiWorkflow(targetPath);
+        io.writeStdout([
+            "Initialized Codex Plugin Doctor workflow",
+            `Root: ${result.rootPath}`,
+            `Workflow: ${result.workflowPath}`
+        ].join("\n"));
+        return 0;
+    }
+    if (command === "fix") {
+        if (!maybePath || maybePath.startsWith("--")) {
+            io.writeStderr("Missing target path. Usage: codex-plugin-doctor fix <path> (--dry-run|--apply --backup)");
+            return 2;
+        }
+        const dryRun = remainingArgs.includes("--dry-run");
+        const apply = remainingArgs.includes("--apply");
+        const backup = remainingArgs.includes("--backup");
+        const jsonOutput = remainingArgs.includes("--json");
+        if (apply && !backup) {
+            io.writeStderr("Fix apply requires --backup.");
+            return 2;
+        }
+        if (dryRun === apply) {
+            io.writeStderr("Choose exactly one fix mode: --dry-run or --apply --backup.");
+            return 2;
+        }
+        if (dryRun) {
+            const plan = await buildFixPlan(maybePath);
+            io.writeStdout(jsonOutput
+                ? renderFixPlanJsonReport(plan, { mode: "dry-run" })
+                : renderFixPlan(plan, "dry-run"));
+            return 0;
+        }
+        const result = await applyFixPlan(maybePath);
+        io.writeStdout(jsonOutput
+            ? renderFixPlanJsonReport(result.plan, {
+                mode: "apply",
+                filesChanged: result.filesChanged,
+                backupDirectory: result.backupDirectory
+            })
+            : renderApplyFixResult(result));
+        return 0;
+    }
     if (command === "compat") {
         const targetPath = maybePath && !maybePath.startsWith("--") ? maybePath : ".";
         const compatFlags = maybePath && maybePath.startsWith("--")
@@ -193,8 +268,10 @@ export async function runCli(args, io = defaultIo, options = {}) {
         }
         if ((installPreview || applyInstall) &&
             clientFilter?.toLowerCase() !== "claude-desktop" &&
-            clientFilter?.toLowerCase() !== "cursor") {
-            io.writeStderr("--install-preview and --apply require --client claude-desktop or --client cursor.");
+            clientFilter?.toLowerCase() !== "cursor" &&
+            clientFilter?.toLowerCase() !== "cline" &&
+            clientFilter?.toLowerCase() !== "windsurf") {
+            io.writeStderr("--install-preview and --apply require --client claude-desktop, cursor, cline, or windsurf.");
             return 2;
         }
         if (installPreview && applyInstall) {
@@ -207,20 +284,41 @@ export async function runCli(args, io = defaultIo, options = {}) {
         }
         if (installPreview || applyInstall) {
             try {
-                const preview = clientFilter?.toLowerCase() === "cursor"
+                const normalizedClient = clientFilter?.toLowerCase();
+                const preview = normalizedClient === "cursor"
                     ? await buildCursorInstallPreview(targetPath, {
                         env: terminalContext.env,
                         platform: terminalContext.platform
                     })
-                    : await buildClaudeDesktopInstallPreview(targetPath, {
-                        env: terminalContext.env,
-                        platform: terminalContext.platform
-                    });
+                    : normalizedClient === "cline"
+                        ? await buildClineInstallPreview(targetPath, {
+                            env: terminalContext.env,
+                            platform: terminalContext.platform
+                        })
+                        : normalizedClient === "windsurf"
+                            ? await buildWindsurfInstallPreview(targetPath, {
+                                env: terminalContext.env,
+                                platform: terminalContext.platform
+                            })
+                            : await buildClaudeDesktopInstallPreview(targetPath, {
+                                env: terminalContext.env,
+                                platform: terminalContext.platform
+                            });
                 const report = applyInstall
-                    ? renderApplyInstallResult(await applyInstallPreview(clientFilter?.toLowerCase() === "cursor" ? "Cursor" : "Claude Desktop", preview))
-                    : clientFilter?.toLowerCase() === "cursor"
+                    ? renderApplyInstallResult(await applyInstallPreview(normalizedClient === "cursor"
+                        ? "Cursor"
+                        : normalizedClient === "cline"
+                            ? "Cline"
+                            : normalizedClient === "windsurf"
+                                ? "Windsurf"
+                                : "Claude Desktop", preview))
+                    : normalizedClient === "cursor"
                         ? renderCursorInstallPreview(preview)
-                        : renderClaudeDesktopInstallPreview(preview);
+                        : normalizedClient === "cline"
+                            ? renderClineInstallPreview(preview)
+                            : normalizedClient === "windsurf"
+                                ? renderWindsurfInstallPreview(preview)
+                                : renderClaudeDesktopInstallPreview(preview);
                 if (outputPath) {
                     await writeFile(outputPath, report, "utf8");
                 }
@@ -287,6 +385,9 @@ export async function runCli(args, io = defaultIo, options = {}) {
     const outputPath = outputIndex === -1 ? null : normalizedFlags[outputIndex + 1];
     const configIndex = normalizedFlags.indexOf("--config");
     const configPath = configIndex === -1 ? null : normalizedFlags[configIndex + 1];
+    const profileIndex = normalizedFlags.indexOf("--profile");
+    const profileName = profileIndex === -1 ? null : normalizedFlags[profileIndex + 1];
+    const checkProfile = parseCheckProfile(profileName);
     const historyIndex = normalizedFlags.indexOf("--history");
     const historyPath = historyIndex === -1 ? null : normalizedFlags[historyIndex + 1];
     if (outputIndex !== -1 && (!outputPath || outputPath.startsWith("--"))) {
@@ -297,6 +398,14 @@ export async function runCli(args, io = defaultIo, options = {}) {
         io.writeStderr("Missing path after --config.");
         return 2;
     }
+    if (profileIndex !== -1 && (!profileName || profileName.startsWith("--"))) {
+        io.writeStderr("Missing profile after --profile.");
+        return 2;
+    }
+    if (profileIndex !== -1 && !checkProfile) {
+        io.writeStderr("Unknown profile. Supported profiles: ci, strict, publish.");
+        return 2;
+    }
     if (historyIndex !== -1 && (!historyPath || historyPath.startsWith("--"))) {
         io.writeStderr("Missing path after --history.");
         return 2;
@@ -309,6 +418,7 @@ export async function runCli(args, io = defaultIo, options = {}) {
         io.writeStderr("History output requires a single package target.");
         return 2;
     }
+    const effectiveRuntimeProbeEnabled = runtimeProbeEnabled || checkProfile === "publish";
     const outputPolicy = determineOutputPolicy({
         jsonOutput: jsonOutput || badgeJsonOutput,
         markdownOutput: markdownOutput || badgeMarkdownOutput,
@@ -334,11 +444,11 @@ export async function runCli(args, io = defaultIo, options = {}) {
             checkedPlugins.push({
                 plugin,
                 result: applyDoctorConfig(await runCheckImpl(plugin.rootPath, {
-                    runtime: runtimeProbeEnabled,
-                    runtimeTranscript: runtimeProbeEnabled && verboseRuntime
+                    runtime: effectiveRuntimeProbeEnabled,
+                    runtimeTranscript: effectiveRuntimeProbeEnabled && verboseRuntime
                         ? (line) => io.writeStderr(line)
                         : undefined
-                }), config)
+                }), applyCheckProfile(config, checkProfile))
             });
         }
         const report = installedSummary
@@ -347,9 +457,9 @@ export async function runCli(args, io = defaultIo, options = {}) {
                 .map((item) => sarifOutput
                 ? renderSarifReport(item.result)
                 : markdownOutput
-                    ? buildMarkdownReport(item.result, { runtimeProbeEnabled })
+                    ? buildMarkdownReport(item.result, { runtimeProbeEnabled: effectiveRuntimeProbeEnabled })
                     : jsonOutput
-                        ? renderJsonReport(item.result, { runtimeProbeEnabled })
+                        ? renderJsonReport(item.result, { runtimeProbeEnabled: effectiveRuntimeProbeEnabled })
                         : renderTextReport(item.result, { ascii: outputPolicy.style === "ascii" }))
                 .join("\n\n");
         if (outputPath) {
@@ -364,11 +474,11 @@ export async function runCli(args, io = defaultIo, options = {}) {
         : null;
     renderer?.start("Validating package");
     const result = applyDoctorConfig(await runCheckImpl(targetPath, {
-        runtime: runtimeProbeEnabled,
-        runtimeTranscript: runtimeProbeEnabled && verboseRuntime
+        runtime: effectiveRuntimeProbeEnabled,
+        runtimeTranscript: effectiveRuntimeProbeEnabled && verboseRuntime
             ? (line) => io.writeStderr(line)
             : undefined
-    }), await loadDoctorConfig(targetPath, configPath));
+    }), applyCheckProfile(await loadDoctorConfig(targetPath, configPath), checkProfile));
     if (renderer) {
         if (result.status === "fail") {
             renderer.stopFailure("Validation failed");
@@ -378,11 +488,11 @@ export async function runCli(args, io = defaultIo, options = {}) {
         }
     }
     const report = markdownOutput
-        ? buildMarkdownReport(result, { runtimeProbeEnabled })
+        ? buildMarkdownReport(result, { runtimeProbeEnabled: effectiveRuntimeProbeEnabled })
         : sarifOutput
             ? renderSarifReport(result)
             : jsonOutput
-                ? renderJsonReport(result, { runtimeProbeEnabled })
+                ? renderJsonReport(result, { runtimeProbeEnabled: effectiveRuntimeProbeEnabled })
                 : badgeJsonOutput
                     ? renderBadgeJson(result)
                     : badgeMarkdownOutput
@@ -392,7 +502,9 @@ export async function runCli(args, io = defaultIo, options = {}) {
         await writeFile(outputPath, report, "utf8");
     }
     if (historyPath) {
-        await appendValidationHistoryEntry(historyPath, result, { runtimeProbeEnabled });
+        await appendValidationHistoryEntry(historyPath, result, {
+            runtimeProbeEnabled: effectiveRuntimeProbeEnabled
+        });
     }
     io.writeStdout(report);
     return result.exitCode;

package/package.json

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