oh-my-codex-pennix 0.18.13

package/dist/cli/doctor.js

@@ -0,0 +1,1956 @@
+/**
+ * omx doctor - Validate oh-my-codex installation
+ */
+import { existsSync, readFileSync } from "fs";
+import { mkdtemp, readdir, readFile, rm } from "fs/promises";
+import { spawnSync } from "child_process";
+import { basename, join } from "path";
+import { tmpdir } from "os";
+import { codexHome, codexConfigPath, codexPromptsDir, userSkillsDir, projectSkillsDir, omxStateDir, detectLegacySkillRootOverlap, codexAgentsDir, } from "../utils/paths.js";
+import { classifySpawnError, spawnPlatformCommandSync, } from "../utils/platform-command.js";
+import { getCatalogExpectations } from "./catalog-contract.js";
+import { parse as parseToml } from "@iarna/toml";
+import { getBuiltinExploreHarnessUnsupportedReason, resolvePackagedExploreHarnessCommand, EXPLORE_BIN_ENV, } from "./explore.js";
+import { getPackageRoot } from "../utils/package.js";
+import { hasLegacyOmxTeamRunTable, getModelContextRecommendation, } from "../config/generator.js";
+import { MANAGED_HOOK_EVENTS, buildManagedCodexNativeHookCommand, discoverCodexHookConfigPaths, getManagedCodexHookCommandsForEvent, getMissingManagedCodexHookEvents, } from "../config/codex-hooks.js";
+import { OMX_FIRST_PARTY_MCP_SERVER_NAMES } from "../config/omx-first-party-mcp.js";
+import { getDefaultBridge, isBridgeEnabled } from "../runtime/bridge.js";
+import { OMX_EXPLORE_CMD_ENV, isExploreCommandRoutingEnabled, } from "../hooks/explore-routing.js";
+import { OMX_LORE_COMMIT_GUARD_ENV, isLoreCommitGuardEnabled, } from "../config/commit-lore-guard.js";
+import { isLeaderRuntimeStale } from "../team/leader-activity.js";
+import { triagePrompt } from "../hooks/triage-heuristic.js";
+import { readTriageConfig } from "../hooks/triage-config.js";
+import { readPersistedSetupPreferences, } from "./setup-preferences.js";
+import { OMX_LOCAL_MARKETPLACE_NAME, OMX_LOCAL_PLUGIN_CONFIG_KEY, discoverOmxPluginCacheDirs, expectedPackagedOmxSkillNames, packagedOmxPluginVersion, pluginHookCacheMatchesPackaged, readOmxPluginCacheState, resolvePackagedOmxMarketplace, } from "./plugin-marketplace.js";
+import { hasOmxAgentsContract } from "../utils/agents-md.js";
+import { OMX_DEFAULT_SPARK_MODEL_ENV, OMX_SPARK_MODEL_ENV, getCodexConfigRootModelProvider, getEnvConfiguredSparkDefaultModel, getMainDefaultModel, getSparkDefaultModel, getStandardDefaultModel, } from "../config/models.js";
+import { AGENT_DEFINITIONS } from "../agents/definitions.js";
+import { getInstallableNativeAgentNames } from "../agents/policy.js";
+import { readCatalogManifest } from "../catalog/reader.js";
+async function resolveDoctorScope(cwd) {
+    const persisted = await readPersistedSetupPreferences(cwd);
+    if (persisted?.scope) {
+        const inferred = await inferPluginInstallModeFromConfigForScope(cwd, persisted.scope);
+        return {
+            scope: persisted.scope,
+            source: "persisted",
+            installMode: persisted.installMode ?? inferred?.installMode,
+            mcpMode: persisted.mcpMode ?? inferred?.mcpMode ?? "none",
+        };
+    }
+    const inferredUser = await inferPluginInstallModeFromConfigForScope(cwd, "user");
+    if (inferredUser)
+        return inferredUser;
+    const inferredProject = await inferPluginInstallModeFromConfigForScope(cwd, "project");
+    if (inferredProject)
+        return inferredProject;
+    return { scope: "user", source: "default" };
+}
+async function inferPluginInstallModeFromConfigForScope(cwd, scope) {
+    const configPath = scope === "project" ? join(cwd, ".codex", "config.toml") : codexConfigPath();
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const configContent = await readFile(configPath, "utf-8");
+        if (!configEnablesPluginScopedHooks(configContent))
+            return null;
+        const { marketplace, plugin } = getParsedPluginMarketplaceConfig(configContent);
+        if (!marketplace || marketplace.source_type !== "local")
+            return null;
+        if (!(await isTrustedOmxPluginMarketplaceSource(marketplace.source)))
+            return null;
+        if (plugin?.enabled !== true)
+            return null;
+        return {
+            scope,
+            source: "config",
+            installMode: "plugin",
+            mcpMode: inferPluginMcpModeFromConfig(configContent),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function isTrustedOmxPluginMarketplaceSource(source) {
+    if (source === getPackageRoot())
+        return true;
+    if (typeof source !== "string" || source.length === 0)
+        return false;
+    try {
+        const packageJson = JSON.parse(await readFile(join(source, "package.json"), "utf-8"));
+        return packageJson.name === "oh-my-codex";
+    }
+    catch {
+        return false;
+    }
+}
+function inferPluginMcpModeFromConfig(configContent) {
+    const states = OMX_FIRST_PARTY_MCP_SERVER_NAMES.map((serverName) => pluginMcpServerEnabled(configContent, serverName));
+    return states.length > 0 && states.every((state) => state === true)
+        ? "compat"
+        : "none";
+}
+function resolveDoctorPaths(cwd, scope) {
+    if (scope === "project") {
+        const codexHomeDir = join(cwd, ".codex");
+        return {
+            codexHomeDir,
+            configPath: join(codexHomeDir, "config.toml"),
+            hooksPath: join(codexHomeDir, "hooks.json"),
+            promptsDir: join(codexHomeDir, "prompts"),
+            skillsDir: projectSkillsDir(cwd),
+            agentsDir: codexAgentsDir(codexHomeDir),
+            stateDir: omxStateDir(cwd),
+        };
+    }
+    return {
+        codexHomeDir: codexHome(),
+        configPath: codexConfigPath(),
+        hooksPath: join(codexHome(), "hooks.json"),
+        promptsDir: codexPromptsDir(),
+        skillsDir: userSkillsDir(),
+        agentsDir: codexAgentsDir(),
+        stateDir: omxStateDir(cwd),
+    };
+}
+export async function doctor(options = {}) {
+    if (options.team) {
+        await doctorTeam();
+        return;
+    }
+    const cwd = process.cwd();
+    const scopeResolution = await resolveDoctorScope(cwd);
+    const paths = resolveDoctorPaths(cwd, scopeResolution.scope);
+    const scopeSourceMessage = scopeResolution.source === "persisted"
+        ? " (from .omx/setup-scope.json)"
+        : scopeResolution.source === "config"
+            ? " (inferred from Codex plugin config)"
+            : "";
+    console.log("oh-my-codex doctor");
+    console.log("==================\n");
+    console.log(`Resolved setup scope: ${scopeResolution.scope}${scopeSourceMessage}`);
+    if (scopeResolution.installMode) {
+        console.log(`Resolved setup install mode: ${scopeResolution.installMode}${scopeSourceMessage}`);
+    }
+    if (scopeResolution.mcpMode) {
+        console.log(`Resolved setup MCP mode: ${scopeResolution.mcpMode}${scopeSourceMessage}`);
+    }
+    console.log();
+    const checks = [];
+    // Check 1: Codex CLI installed
+    checks.push(checkCodexCli());
+    // Check 2: Node.js version
+    checks.push(checkNodeVersion());
+    // Check 2.5: Explore harness readiness
+    checks.push(checkExploreHarness());
+    // Check 3: Codex home directory
+    checks.push(checkDirectory("Codex home", paths.codexHomeDir));
+    // Check 4: Config file
+    checks.push(await checkConfig(paths.configPath));
+    // Check 4.1: Model context recommendation
+    const contextRecommendationCheck = await checkModelContextRecommendation(paths.configPath);
+    if (contextRecommendationCheck)
+        checks.push(contextRecommendationCheck);
+    // Check 4.25: Native hooks coverage
+    checks.push(await checkNativeHooks(paths.hooksPath, paths.configPath, {
+        codexHomeDir: paths.codexHomeDir,
+        installMode: scopeResolution.installMode,
+    }));
+    checks.push(await checkNativeHookDistSmoke());
+    if (options.verbose) {
+        const postCompactRuntimeCheck = await checkNativePostCompactHookRuntime(paths.hooksPath, cwd, paths.codexHomeDir);
+        if (postCompactRuntimeCheck)
+            checks.push(postCompactRuntimeCheck);
+    }
+    const runtimeMirrorCheck = await checkNativeHookRuntimeMirrors(cwd, paths.hooksPath);
+    if (runtimeMirrorCheck)
+        checks.push(runtimeMirrorCheck);
+    // Check 4.5: Explore routing default
+    checks.push(await checkExploreRouting(paths.configPath));
+    // Check 4.6: Lore commit guard default
+    checks.push(await checkLoreCommitGuard(paths.configPath));
+    // Check 5: Prompts installed
+    checks.push(await checkPrompts(paths.promptsDir, scopeResolution.installMode));
+    // Check 6: Skills installed
+    checks.push(await checkSkills(paths, scopeResolution.installMode));
+    // Check 6.25: Native reviewer roles required by RALPLAN/Autopilot
+    const nativeReviewerRolesCheck = checkNativeReviewerRoles(paths, scopeResolution.installMode);
+    if (nativeReviewerRolesCheck)
+        checks.push(nativeReviewerRolesCheck);
+    // Check 6.4: Spark/model lane routing (issue #2757)
+    checks.push(checkSparkRouting(paths));
+    // Check 6.5: Legacy/current skill-root overlap
+    if (scopeResolution.scope === "user") {
+        checks.push(await checkLegacySkillRootOverlap());
+    }
+    // Check 7: AGENTS.md in project
+    checks.push(checkAgentsMd(scopeResolution.scope, paths.codexHomeDir, scopeResolution.installMode));
+    // Check 8: State directory
+    checks.push(checkDirectory("State dir", paths.stateDir));
+    // Check 9: MCP servers configured
+    checks.push(await checkMcpServers(paths.configPath, scopeResolution.installMode, scopeResolution.mcpMode));
+    // Check 10: Prompt triage
+    checks.push(checkPromptTriage());
+    // Print results
+    let passCount = 0;
+    let warnCount = 0;
+    let failCount = 0;
+    for (const check of checks) {
+        const icon = check.status === "pass"
+            ? "[OK]"
+            : check.status === "warn"
+                ? "[!!]"
+                : "[XX]";
+        console.log(`  ${icon} ${check.name}: ${check.message}`);
+        if (check.status === "pass")
+            passCount++;
+        else if (check.status === "warn")
+            warnCount++;
+        else
+            failCount++;
+    }
+    console.log(`\nResults: ${passCount} passed, ${warnCount} warnings, ${failCount} failed`);
+    if (failCount > 0) {
+        console.log('\nRun "omx setup" to fix installation issues.');
+    }
+    else if (warnCount > 0) {
+        console.log('\nReview warnings above. Use "omx setup --force" only when a warning recommends full replacement; for AGENTS.md preservation prefer "omx setup --merge-agents".');
+    }
+    else {
+        console.log("\nAll checks passed! oh-my-codex is ready.");
+    }
+}
+async function doctorTeam() {
+    console.log("oh-my-codex doctor --team");
+    console.log("=========================\n");
+    const issues = await collectTeamDoctorIssues(process.cwd());
+    if (issues.length === 0) {
+        console.log("  [OK] team diagnostics: no issues");
+        console.log("\nAll team checks passed.");
+        return;
+    }
+    const failureCount = issues.filter((issue) => issue.severity === "fail").length;
+    const warningCount = issues.length - failureCount;
+    for (const issue of issues) {
+        const icon = issue.severity === "warn" ? "[!!]" : "[XX]";
+        console.log(`  ${icon} ${issue.code}: ${issue.message}`);
+    }
+    console.log(`\nResults: ${warningCount} warnings, ${failureCount} failed`);
+    // Ensure non-zero exit for `omx doctor --team` failures.
+    if (failureCount > 0)
+        process.exitCode = 1;
+}
+async function collectTeamDoctorIssues(cwd) {
+    const issues = [];
+    const stateDir = omxStateDir(cwd);
+    const teamsRoot = join(stateDir, "team");
+    const nowMs = Date.now();
+    const lagThresholdMs = 60_000;
+    const shutdownThresholdMs = 30_000;
+    const leaderStaleThresholdMs = 180_000;
+    // Rust-first: if the runtime bridge is enabled, use Rust-authored readiness
+    // and authority as the semantic truth source for runtime health.
+    if (isBridgeEnabled()) {
+        const bridge = getDefaultBridge(stateDir);
+        const readiness = bridge.readReadiness();
+        const authority = bridge.readAuthority();
+        if (readiness && !readiness.ready) {
+            for (const reason of readiness.reasons) {
+                issues.push({
+                    code: "resume_blocker",
+                    message: `runtime not ready: ${reason}`,
+                    severity: "fail",
+                });
+            }
+        }
+        if (authority?.stale) {
+            issues.push({
+                code: "stale_leader",
+                message: `authority stale (owner: ${authority.owner ?? "unknown"}): ${authority.stale_reason ?? "unknown reason"}`,
+                severity: "fail",
+            });
+        }
+    }
+    const teamDirs = [];
+    if (existsSync(teamsRoot)) {
+        const entries = await readdir(teamsRoot, { withFileTypes: true });
+        for (const e of entries) {
+            if (e.isDirectory())
+                teamDirs.push(e.name);
+        }
+    }
+    const tmuxSessions = listTeamTmuxSessions();
+    const tmuxUnavailable = tmuxSessions === null;
+    const knownTeamSessions = new Set();
+    for (const teamName of teamDirs) {
+        const teamDir = join(teamsRoot, teamName);
+        const manifestPath = join(teamDir, "manifest.v2.json");
+        const configPath = join(teamDir, "config.json");
+        let tmuxSession = `omx-team-${teamName}`;
+        let workerLaunchMode = "interactive";
+        let promptWorkers = [];
+        if (existsSync(manifestPath)) {
+            try {
+                const raw = await readFile(manifestPath, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.tmux_session === "string" &&
+                    parsed.tmux_session.trim() !== "") {
+                    tmuxSession = parsed.tmux_session;
+                }
+                if (parsed.policy?.worker_launch_mode === "prompt") {
+                    workerLaunchMode = "prompt";
+                }
+                if (Array.isArray(parsed.workers))
+                    promptWorkers = parsed.workers;
+            }
+            catch {
+                // ignore malformed manifest
+            }
+        }
+        else if (existsSync(configPath)) {
+            try {
+                const raw = await readFile(configPath, "utf-8");
+                const parsed = JSON.parse(raw);
+                if (typeof parsed.tmux_session === "string" &&
+                    parsed.tmux_session.trim() !== "") {
+                    tmuxSession = parsed.tmux_session;
+                }
+                if (parsed.worker_launch_mode === "prompt") {
+                    workerLaunchMode = "prompt";
+                }
+                if (Array.isArray(parsed.workers))
+                    promptWorkers = parsed.workers;
+            }
+            catch {
+                // ignore malformed config
+            }
+        }
+        knownTeamSessions.add(tmuxSession);
+        if (workerLaunchMode === "prompt") {
+            for (const worker of promptWorkers) {
+                const pid = worker.pid ?? 0;
+                if (Number.isFinite(pid) && pid > 0 && isPidAlive(pid)) {
+                    issues.push({
+                        code: "prompt_resume_unavailable",
+                        message: `${teamName}/${worker.name ?? "unknown"} pid ${pid} appears to be running, but doctor cannot verify that the PID still belongs to the original prompt-mode worker after CLI restart; if this is the original worker, shut it down or start a new team`,
+                        severity: "warn",
+                    });
+                }
+            }
+        }
+        else if (!tmuxUnavailable && !tmuxSessions.has(tmuxSession)) {
+            // resume_blocker: only meaningful if tmux is available to query for interactive teams.
+            issues.push({
+                code: "resume_blocker",
+                message: `${teamName} references missing tmux session ${tmuxSession}`,
+                severity: "fail",
+            });
+        }
+        // delayed_status_lag + slow_shutdown checks
+        const workersRoot = join(teamDir, "workers");
+        if (!existsSync(workersRoot))
+            continue;
+        const workers = await readdir(workersRoot, { withFileTypes: true });
+        for (const worker of workers) {
+            if (!worker.isDirectory())
+                continue;
+            const workerDir = join(workersRoot, worker.name);
+            const statusPath = join(workerDir, "status.json");
+            const heartbeatPath = join(workerDir, "heartbeat.json");
+            const shutdownReqPath = join(workerDir, "shutdown-request.json");
+            const shutdownAckPath = join(workerDir, "shutdown-ack.json");
+            if (existsSync(statusPath) && existsSync(heartbeatPath)) {
+                try {
+                    const [statusRaw, hbRaw] = await Promise.all([
+                        readFile(statusPath, "utf-8"),
+                        readFile(heartbeatPath, "utf-8"),
+                    ]);
+                    const status = JSON.parse(statusRaw);
+                    const hb = JSON.parse(hbRaw);
+                    const lastTurnMs = hb.last_turn_at
+                        ? Date.parse(hb.last_turn_at)
+                        : NaN;
+                    if (status.state === "working" &&
+                        Number.isFinite(lastTurnMs) &&
+                        nowMs - lastTurnMs > lagThresholdMs) {
+                        issues.push({
+                            code: "delayed_status_lag",
+                            message: `${teamName}/${worker.name} working with stale heartbeat`,
+                            severity: "fail",
+                        });
+                    }
+                }
+                catch {
+                    // ignore malformed files
+                }
+            }
+            if (existsSync(shutdownReqPath) && !existsSync(shutdownAckPath)) {
+                try {
+                    const reqRaw = await readFile(shutdownReqPath, "utf-8");
+                    const req = JSON.parse(reqRaw);
+                    const reqMs = req.requested_at ? Date.parse(req.requested_at) : NaN;
+                    if (Number.isFinite(reqMs) && nowMs - reqMs > shutdownThresholdMs) {
+                        issues.push({
+                            code: "slow_shutdown",
+                            message: `${teamName}/${worker.name} has stale shutdown request without ack`,
+                            severity: "fail",
+                        });
+                    }
+                }
+                catch {
+                    // ignore malformed files
+                }
+            }
+        }
+    }
+    // stale_leader: team has active workers but leader has no recent activity
+    const hudStatePath = join(stateDir, "hud-state.json");
+    const leaderActivityPath = join(stateDir, "leader-runtime-activity.json");
+    if ((existsSync(hudStatePath) || existsSync(leaderActivityPath)) &&
+        teamDirs.length > 0) {
+        try {
+            const leaderIsStale = await isLeaderRuntimeStale(stateDir, leaderStaleThresholdMs, nowMs);
+            if (leaderIsStale && !tmuxUnavailable) {
+                // Check if any team tmux session has live worker panes
+                for (const teamName of teamDirs) {
+                    const session = knownTeamSessions.has(`omx-team-${teamName}`)
+                        ? `omx-team-${teamName}`
+                        : [...knownTeamSessions].find((s) => s.includes(teamName));
+                    if (!session || !tmuxSessions.has(session))
+                        continue;
+                    issues.push({
+                        code: "stale_leader",
+                        message: `${teamName} has active tmux session but leader has no recent activity`,
+                        severity: "fail",
+                    });
+                }
+            }
+        }
+        catch {
+            // ignore malformed HUD state
+        }
+    }
+    // orphan_tmux_session: session exists but no matching team state
+    if (!tmuxUnavailable) {
+        for (const session of tmuxSessions) {
+            if (!knownTeamSessions.has(session)) {
+                issues.push({
+                    code: "orphan_tmux_session",
+                    message: `${session} exists without matching team state (possibly external project)`,
+                    severity: "warn",
+                });
+            }
+        }
+    }
+    return dedupeIssues(issues);
+}
+function isPidAlive(pid) {
+    if (!Number.isFinite(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        if (err.code === 'ESRCH')
+            return false;
+        return false;
+    }
+}
+function dedupeIssues(issues) {
+    const seen = new Set();
+    const out = [];
+    for (const issue of issues) {
+        const key = `${issue.code}:${issue.message}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(issue);
+    }
+    return out;
+}
+function listTeamTmuxSessions() {
+    const { result: res } = spawnPlatformCommandSync("tmux", ["list-sessions", "-F", "#{session_name}"], { encoding: "utf-8" });
+    if (res.error) {
+        // tmux binary unavailable or not executable.
+        return null;
+    }
+    if (res.status !== 0) {
+        const stderr = (res.stderr || "").toLowerCase();
+        // tmux installed but no server/session is running.
+        if (stderr.includes("no server running") ||
+            stderr.includes("failed to connect to server")) {
+            return new Set();
+        }
+        return null;
+    }
+    const sessions = (res.stdout || "")
+        .split("\n")
+        .map((s) => s.trim())
+        .filter((s) => s.startsWith("omx-team-"));
+    return new Set(sessions);
+}
+function checkCodexCli() {
+    const { result } = spawnPlatformCommandSync("codex", ["--version"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (result.error) {
+        const code = result.error.code;
+        const kind = classifySpawnError(result.error);
+        if (kind === "missing") {
+            return {
+                name: "Codex CLI",
+                status: "fail",
+                message: "not found - install from https://github.com/openai/codex",
+            };
+        }
+        if (kind === "blocked") {
+            return {
+                name: "Codex CLI",
+                status: "fail",
+                message: `found but could not be executed in this environment (${code || "blocked"})`,
+            };
+        }
+        return {
+            name: "Codex CLI",
+            status: "fail",
+            message: `probe failed - ${result.error.message}`,
+        };
+    }
+    if (result.status === 0) {
+        const version = (result.stdout || "").trim();
+        return {
+            name: "Codex CLI",
+            status: "pass",
+            message: `installed (${version})`,
+        };
+    }
+    const stderr = (result.stderr || "").trim();
+    return {
+        name: "Codex CLI",
+        status: "fail",
+        message: stderr !== ""
+            ? `probe failed - ${stderr}`
+            : `probe failed with exit ${result.status}`,
+    };
+}
+function checkNodeVersion() {
+    const major = parseInt(process.versions.node.split(".")[0] ?? "0", 10);
+    if (isNaN(major)) {
+        return {
+            name: "Node.js",
+            status: "fail",
+            message: `v${process.versions.node} (unable to parse major version)`,
+        };
+    }
+    if (major >= 20) {
+        return {
+            name: "Node.js",
+            status: "pass",
+            message: `v${process.versions.node}`,
+        };
+    }
+    return {
+        name: "Node.js",
+        status: "fail",
+        message: `v${process.versions.node} (need >= 20)`,
+    };
+}
+export function checkExploreHarness(platform = process.platform, env = process.env) {
+    const packageRoot = getPackageRoot();
+    const manifestPath = join(packageRoot, "crates", "omx-explore", "Cargo.toml");
+    if (!existsSync(manifestPath)) {
+        return {
+            name: "Explore Harness",
+            status: "warn",
+            message: "Rust harness sources not found in this install (omx explore unavailable until packaged or OMX_EXPLORE_BIN is set)",
+        };
+    }
+    const override = env[EXPLORE_BIN_ENV]?.trim();
+    if (override) {
+        const resolved = join(packageRoot, override);
+        if (existsSync(override) || existsSync(resolved)) {
+            return {
+                name: "Explore Harness",
+                status: "pass",
+                message: `${EXPLORE_BIN_ENV} configured (${override})`,
+            };
+        }
+        return {
+            name: "Explore Harness",
+            status: "warn",
+            message: `OMX_EXPLORE_BIN is set but path was not found (${override})`,
+        };
+    }
+    const unsupportedReason = getBuiltinExploreHarnessUnsupportedReason(platform, env);
+    if (unsupportedReason) {
+        return {
+            name: "Explore Harness",
+            status: "warn",
+            message: unsupportedReason,
+        };
+    }
+    const packaged = resolvePackagedExploreHarnessCommand(packageRoot);
+    if (packaged) {
+        return {
+            name: "Explore Harness",
+            status: "pass",
+            message: `ready (packaged native binary: ${packaged.command})`,
+        };
+    }
+    const { result } = spawnPlatformCommandSync("cargo", ["--version"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+    if (result.error) {
+        const kind = classifySpawnError(result.error);
+        if (kind === "missing") {
+            return {
+                name: "Explore Harness",
+                status: "warn",
+                message: `Rust harness sources are packaged, but no compatible packaged prebuilt or cargo was found (install Rust or set ${EXPLORE_BIN_ENV} for omx explore)`,
+            };
+        }
+        return {
+            name: "Explore Harness",
+            status: "warn",
+            message: `Rust harness sources are packaged, but cargo probe failed (${result.error.message})`,
+        };
+    }
+    if (result.status === 0) {
+        const version = (result.stdout || "").trim();
+        return {
+            name: "Explore Harness",
+            status: "pass",
+            message: `ready (${version || "cargo available"})`,
+        };
+    }
+    return {
+        name: "Explore Harness",
+        status: "warn",
+        message: `Rust harness sources are packaged, but cargo probe failed with exit ${result.status} (install Rust or set ${EXPLORE_BIN_ENV})`,
+    };
+}
+function checkDirectory(name, path) {
+    if (existsSync(path)) {
+        return { name, status: "pass", message: path };
+    }
+    return { name, status: "warn", message: `${path} (not created yet)` };
+}
+function validateToml(content) {
+    try {
+        parseToml(content);
+        return null;
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        return "unknown TOML parse error";
+    }
+}
+async function checkConfig(configPath) {
+    if (!existsSync(configPath)) {
+        return { name: "Config", status: "warn", message: "config.toml not found" };
+    }
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const tomlError = validateToml(content);
+        if (tomlError) {
+            const hint = tomlError.includes("Can't redefine existing key") ||
+                tomlError.includes("duplicate") ||
+                tomlError.includes("[tui]")
+                ? "possible duplicate TOML table such as [tui]"
+                : "invalid TOML syntax";
+            return {
+                name: "Config",
+                status: "fail",
+                message: `invalid config.toml (${hint})`,
+            };
+        }
+        if (hasLegacyOmxTeamRunTable(content)) {
+            return {
+                name: "Config",
+                status: "warn",
+                message: 'retired [mcp_servers.omx_team_run] table still present; run "omx setup --force" to repair the config',
+            };
+        }
+        const hasOmx = content.includes("omx_") || content.includes("oh-my-codex");
+        if (hasOmx) {
+            return {
+                name: "Config",
+                status: "pass",
+                message: "config.toml has OMX entries",
+            };
+        }
+        return {
+            name: "Config",
+            status: "warn",
+            message: 'config.toml exists but no OMX entries yet (expected before first setup; run "omx setup --force" once)',
+        };
+    }
+    catch {
+        return {
+            name: "Config",
+            status: "fail",
+            message: "cannot read config.toml",
+        };
+    }
+}
+function formatContextRecommendationWarning(configuredValues, recommendedContextWindow, recommendedAutoCompactLimit) {
+    return `${configuredValues.join(", ")} exceeds the OMX setup recommendation for gpt-5.5 (${recommendedContextWindow} / ${recommendedAutoCompactLimit}); doctor does not rewrite user config, so lower these values or verify your active Codex runtime/provider behavior if this customization is intentional`;
+}
+async function checkModelContextRecommendation(configPath) {
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const parsed = parseToml(content);
+        const model = parsed.model;
+        if (typeof model !== "string")
+            return null;
+        const recommendation = getModelContextRecommendation(model);
+        if (!recommendation)
+            return null;
+        const configuredValues = [];
+        const contextWindow = parsed.model_context_window;
+        if (typeof contextWindow === "number" &&
+            contextWindow > recommendation.modelContextWindow) {
+            configuredValues.push(`model_context_window=${contextWindow}`);
+        }
+        const autoCompactLimit = parsed.model_auto_compact_token_limit;
+        if (typeof autoCompactLimit === "number" &&
+            autoCompactLimit > recommendation.modelAutoCompactTokenLimit) {
+            configuredValues.push(`model_auto_compact_token_limit=${autoCompactLimit}`);
+        }
+        if (configuredValues.length === 0)
+            return null;
+        return {
+            name: "Model context recommendation",
+            status: "warn",
+            message: formatContextRecommendationWarning(configuredValues, recommendation.modelContextWindow, recommendation.modelAutoCompactTokenLimit),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function checkExploreRouting(configPath) {
+    const envValue = process.env[OMX_EXPLORE_CMD_ENV];
+    if (typeof envValue === "string") {
+        if (isExploreCommandRoutingEnabled(process.env)) {
+            return {
+                name: "Explore routing",
+                status: "warn",
+                message: "deprecated compatibility routing enabled by environment override; remove USE_OMX_EXPLORE_CMD or set it to 0 and use normal Codex repo inspection or omx sparkshell instead",
+            };
+        }
+        return {
+            name: "Explore routing",
+            status: "pass",
+            message: "deprecated compatibility routing disabled by environment override (recommended)",
+        };
+    }
+    if (!existsSync(configPath)) {
+        return {
+            name: "Explore routing",
+            status: "pass",
+            message: "deprecated by default (config.toml not found yet)",
+        };
+    }
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const parsed = parseToml(content);
+        const configuredValue = parsed?.shell_environment_policy?.set?.USE_OMX_EXPLORE_CMD ??
+            parsed?.env?.USE_OMX_EXPLORE_CMD;
+        if (typeof configuredValue === "string") {
+            if (isExploreCommandRoutingEnabled({
+                USE_OMX_EXPLORE_CMD: configuredValue,
+            })) {
+                return {
+                    name: "Explore routing",
+                    status: "warn",
+                    message: 'deprecated compatibility routing enabled in config.toml; set USE_OMX_EXPLORE_CMD = "0" under [shell_environment_policy.set] and use normal Codex repo inspection or omx sparkshell instead',
+                };
+            }
+            return {
+                name: "Explore routing",
+                status: "pass",
+                message: "deprecated compatibility routing disabled in config.toml (recommended)",
+            };
+        }
+        return {
+            name: "Explore routing",
+            status: "pass",
+            message: "deprecated by default",
+        };
+    }
+    catch {
+        return {
+            name: "Explore routing",
+            status: "fail",
+            message: "cannot read config.toml for explore routing check",
+        };
+    }
+}
+const LORE_COMMIT_GUARD_EXPLICIT_OPT_OUT_VALUES = new Set([
+    "0",
+    "false",
+    "no",
+    "off",
+]);
+async function checkLoreCommitGuard(configPath) {
+    const envValue = process.env[OMX_LORE_COMMIT_GUARD_ENV];
+    if (typeof envValue === "string") {
+        if (isLoreCommitGuardEnabled(process.env)) {
+            return {
+                name: "Lore commit guard",
+                status: "pass",
+                message: "enabled by environment opt-in",
+            };
+        }
+        if (!isExplicitLoreCommitGuardOptOut(envValue)) {
+            return {
+                name: "Lore commit guard",
+                status: "warn",
+                message: "invalid environment value; Lore commit enforcement is disabled until OMX_LORE_COMMIT_GUARD is set to 1, true, yes, or on",
+            };
+        }
+        return {
+            name: "Lore commit guard",
+            status: "pass",
+            message: "disabled by environment/default opt-out; enable with OMX_LORE_COMMIT_GUARD=1",
+        };
+    }
+    if (!existsSync(configPath)) {
+        return {
+            name: "Lore commit guard",
+            status: "pass",
+            message: "disabled by default (config.toml not found yet)",
+        };
+    }
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const parsed = parseToml(content);
+        const configuredValue = parsed?.shell_environment_policy?.set?.[OMX_LORE_COMMIT_GUARD_ENV] ??
+            parsed?.env?.[OMX_LORE_COMMIT_GUARD_ENV];
+        if (typeof configuredValue === "string") {
+            if (isLoreCommitGuardEnabled({
+                [OMX_LORE_COMMIT_GUARD_ENV]: configuredValue,
+            })) {
+                return {
+                    name: "Lore commit guard",
+                    status: "pass",
+                    message: "enabled by config.toml opt-in",
+                };
+            }
+            if (!isExplicitLoreCommitGuardOptOut(configuredValue)) {
+                return {
+                    name: "Lore commit guard",
+                    status: "warn",
+                    message: 'invalid config.toml value; Lore commit enforcement is disabled until OMX_LORE_COMMIT_GUARD = "1" (or true/yes/on) is set under [shell_environment_policy.set]',
+                };
+            }
+            return {
+                name: "Lore commit guard",
+                status: "pass",
+                message: 'disabled in config.toml/default opt-out; set OMX_LORE_COMMIT_GUARD = "1" under [shell_environment_policy.set] to enable Lore commit enforcement',
+            };
+        }
+        return {
+            name: "Lore commit guard",
+            status: "pass",
+            message: "disabled by default",
+        };
+    }
+    catch {
+        return {
+            name: "Lore commit guard",
+            status: "fail",
+            message: "cannot read config.toml for Lore commit guard check",
+        };
+    }
+}
+function isExplicitLoreCommitGuardOptOut(value) {
+    return LORE_COMMIT_GUARD_EXPLICIT_OPT_OUT_VALUES.has(value.trim().toLowerCase());
+}
+function isEnabledTomlValue(value) {
+    return value === true || (typeof value === "string" && ["1", "true", "yes", "on"].includes(value.trim().toLowerCase()));
+}
+function configHasOmxEntries(configContent) {
+    return configContent.includes("omx_") || configContent.includes("oh-my-codex");
+}
+function configEnablesPluginScopedHooks(configContent) {
+    try {
+        const parsed = parseToml(configContent);
+        return isEnabledTomlValue(parsed.plugin_hooks) || isEnabledTomlValue(parsed.features?.plugin_hooks);
+    }
+    catch {
+        return /^\s*plugin_hooks\s*=\s*(?:true|1|"true"|"1"|"yes"|"on")\s*$/m.test(configContent);
+    }
+}
+function pluginHooksJsonHasNativeCoverage(content) {
+    try {
+        const parsed = JSON.parse(content);
+        if (!parsed || typeof parsed !== "object" || typeof parsed.hooks !== "object" || parsed.hooks === null) {
+            return false;
+        }
+        return MANAGED_HOOK_EVENTS.every((eventName) => {
+            const entries = parsed.hooks?.[eventName];
+            if (!Array.isArray(entries))
+                return false;
+            return entries.some((entry) => {
+                if (!entry || typeof entry !== "object")
+                    return false;
+                const hooks = entry.hooks;
+                if (!Array.isArray(hooks))
+                    return false;
+                return hooks.some((hook) => {
+                    if (!hook || typeof hook !== "object")
+                        return false;
+                    const command = hook.command;
+                    return typeof command === "string" && command.includes("codex-native-hook.mjs");
+                });
+            });
+        });
+    }
+    catch {
+        return null;
+    }
+}
+async function checkPluginScopedNativeHooks(codexHomeDir, setupHooksPath) {
+    const setupHooksPathDescription = existsSync(setupHooksPath)
+        ? `existing hooks.json at ${setupHooksPath} is treated as user-owned because plugin-scoped hooks are enabled`
+        : `setup-owned hooks.json is intentionally absent at ${setupHooksPath}`;
+    const packagedMarketplace = await resolvePackagedOmxMarketplace(getPackageRoot());
+    if (!packagedMarketplace) {
+        return {
+            name: "Native hooks",
+            status: "warn",
+            message: `plugin-scoped hooks are enabled and ${setupHooksPathDescription}, but packaged ${OMX_LOCAL_MARKETPLACE_NAME} metadata was not found`,
+        };
+    }
+    const version = await packagedOmxPluginVersion(packagedMarketplace);
+    const expectedCacheDir = version
+        ? join(codexHomeDir, "plugins", "cache", OMX_LOCAL_MARKETPLACE_NAME, "oh-my-codex", version)
+        : join(codexHomeDir, "plugins", "cache", OMX_LOCAL_MARKETPLACE_NAME, "oh-my-codex", "<version>");
+    const expectedHooksPath = join(expectedCacheDir, "hooks", "hooks.json");
+    const expectedHookLauncherPath = join(expectedCacheDir, "hooks", "codex-native-hook.mjs");
+    const expectedPinnedLauncherPath = join(expectedCacheDir, "hooks", "omx-command.json");
+    const state = await readOmxPluginCacheState(expectedCacheDir);
+    if (!state) {
+        return {
+            name: "Native hooks",
+            status: "warn",
+            message: `plugin-scoped hooks are enabled, but the expected Codex plugin cache manifest is missing at ${join(expectedCacheDir, ".codex-plugin", "plugin.json")}; ${setupHooksPathDescription}; run "omx setup --plugin --force" to refresh the plugin cache`,
+        };
+    }
+    if (state.hooksPointer !== "./hooks/hooks.json") {
+        return {
+            name: "Native hooks",
+            status: "warn",
+            message: `plugin-scoped hooks are enabled, but the Codex plugin cache manifest points hooks to ${String(state.hooksPointer)} instead of ./hooks/hooks.json at ${expectedHooksPath}; run "omx setup --plugin --force" to refresh the plugin cache`,
+        };
+    }
+    for (const expectedPath of [expectedHooksPath, expectedHookLauncherPath, expectedPinnedLauncherPath]) {
+        if (!existsSync(expectedPath)) {
+            return {
+                name: "Native hooks",
+                status: "warn",
+                message: `plugin-scoped hooks are enabled, but expected plugin hook file is missing at ${expectedPath}; ${setupHooksPathDescription}; run "omx setup --plugin --force" to refresh the plugin cache`,
+            };
+        }
+    }
+    if (!(await pluginHookCacheMatchesPackaged(expectedCacheDir, packagedMarketplace))) {
+        return {
+            name: "Native hooks",
+            status: "warn",
+            message: `plugin-scoped hooks are enabled, but cached plugin hook files or pinned hook launcher in ${expectedCacheDir} do not match the packaged plugin; ${setupHooksPathDescription}; run "omx setup --plugin --force" to refresh the plugin cache`,
+        };
+    }
+    let hookContent;
+    try {
+        hookContent = await readFile(expectedHooksPath, "utf-8");
+    }
+    catch {
+        return {
+            name: "Native hooks",
+            status: "fail",
+            message: `cannot read plugin-scoped hooks.json at ${expectedHooksPath}`,
+        };
+    }
+    const hasCoverage = pluginHooksJsonHasNativeCoverage(hookContent);
+    if (hasCoverage === null) {
+        return {
+            name: "Native hooks",
+            status: "fail",
+            message: `invalid plugin-scoped hooks.json at ${expectedHooksPath}`,
+        };
+    }
+    if (!hasCoverage) {
+        return {
+            name: "Native hooks",
+            status: "warn",
+            message: `plugin-scoped hooks.json at ${expectedHooksPath} is missing OMX native coverage for one or more events; run "omx setup --plugin --force" to refresh the plugin cache`,
+        };
+    }
+    const smokeCwd = await mkdtemp(join(tmpdir(), "omx-doctor-plugin-hook-"));
+    try {
+        const payload = JSON.stringify({
+            hook_event_name: "UserPromptSubmit",
+            session_id: "omx-doctor-plugin-hook-smoke",
+            transcript_path: join(smokeCwd, "nonexistent-transcript.jsonl"),
+            cwd: smokeCwd,
+            prompt: "doctor plugin hook smoke test",
+        });
+        const result = spawnSync(process.execPath, [expectedHookLauncherPath], {
+            cwd: smokeCwd,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                OMX_NATIVE_HOOK_DOCTOR_SMOKE: "1",
+                OMX_ROOT: join(smokeCwd, ".omx-doctor-root"),
+                OMX_SESSION_ID: "omx-doctor-plugin-hook-smoke",
+                OMX_SOURCE_CWD: smokeCwd,
+                OMX_STARTUP_CWD: smokeCwd,
+            },
+            input: payload,
+            timeout: 5_000,
+        });
+        if (result.error) {
+            return {
+                name: "Native hooks",
+                status: "fail",
+                message: `plugin-scoped native hook smoke failed to run from ${expectedHookLauncherPath} (${result.error.message})`,
+            };
+        }
+        if (result.status !== 0) {
+            const detail = (result.stderr || result.stdout || `exit ${result.status}`).trim();
+            return {
+                name: "Native hooks",
+                status: "fail",
+                message: `plugin-scoped native hook smoke failed from ${expectedHookLauncherPath} (${detail})`,
+            };
+        }
+    }
+    finally {
+        await rm(smokeCwd, { recursive: true, force: true });
+    }
+    return {
+        name: "Native hooks",
+        status: "pass",
+        message: `plugin-scoped hooks are enabled; ${setupHooksPathDescription}, and plugin cache native hook coverage smoke passed via ${expectedHooksPath}`,
+    };
+}
+async function checkNativeHooks(hooksPath, configPath, context) {
+    if (existsSync(configPath) && context.installMode === "plugin") {
+        try {
+            const configContent = await readFile(configPath, "utf-8");
+            if (configEnablesPluginScopedHooks(configContent)) {
+                return checkPluginScopedNativeHooks(context.codexHomeDir, hooksPath);
+            }
+        }
+        catch {
+            // Fall through to the hooks.json checks; the dedicated config check will
+            // report read failures separately.
+        }
+    }
+    if (!existsSync(hooksPath)) {
+        if (existsSync(configPath)) {
+            try {
+                const configContent = await readFile(configPath, "utf-8");
+                if (context.installMode === "plugin") {
+                    if (configHasOmxEntries(configContent)) {
+                        return {
+                            name: "Native hooks",
+                            status: "warn",
+                            message: `plugin mode is using legacy native hook fallback, but expected setup-owned hooks.json is missing at ${hooksPath}; run "omx setup --plugin --force" to restore the fallback hook file, or upgrade Codex to plugin_hooks support so setup can use plugin-scoped hooks`,
+                        };
+                    }
+                }
+                if (configHasOmxEntries(configContent)) {
+                    return {
+                        name: "Native hooks",
+                        status: "warn",
+                        message: `expected setup-owned hooks.json is missing at ${hooksPath} even though config.toml has OMX entries; run "omx setup --force" to restore native hook coverage`,
+                    };
+                }
+            }
+            catch {
+                // fall through to the neutral first-setup path when config cannot be read here;
+                // the dedicated config check will report read failures separately.
+            }
+        }
+        return {
+            name: "Native hooks",
+            status: "pass",
+            message: "hooks.json not found yet (expected before first setup)",
+        };
+    }
+    try {
+        const content = await readFile(hooksPath, "utf-8");
+        const missingEvents = getMissingManagedCodexHookEvents(content);
+        if (missingEvents === null) {
+            return {
+                name: "Native hooks",
+                status: "fail",
+                message: 'invalid hooks.json; Codex may skip OMX hook coverage until "omx setup --force" repairs it',
+            };
+        }
+        if (missingEvents.length > 0) {
+            return {
+                name: "Native hooks",
+                status: "warn",
+                message: `hooks.json is missing OMX-managed coverage for ${missingEvents.join(", ")}; run "omx setup --force" to restore native hooks`,
+            };
+        }
+        return {
+            name: "Native hooks",
+            status: "pass",
+            message: "hooks.json includes OMX-managed coverage for all native hook events",
+        };
+    }
+    catch {
+        return {
+            name: "Native hooks",
+            status: "fail",
+            message: "cannot read hooks.json",
+        };
+    }
+}
+export async function checkNativeHookDistSmoke(options = {}) {
+    const packageRoot = options.packageRoot ?? getPackageRoot();
+    const nodePath = options.nodePath ?? process.execPath;
+    const runner = options.runner ?? spawnSync;
+    const scriptPath = join(packageRoot, "dist", "scripts", "codex-native-hook.js");
+    const packageJsonPath = join(packageRoot, "package.json");
+    let packageVersion = "current";
+    try {
+        const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+        if (typeof packageJson.version === "string" && packageJson.version.trim()) {
+            packageVersion = packageJson.version.trim();
+        }
+    }
+    catch {
+        // Keep the generic recovery copy when package metadata is not readable.
+    }
+    if (!existsSync(scriptPath)) {
+        return {
+            name: "Native hook dist smoke",
+            status: "fail",
+            message: `installed native hook script is missing at ${scriptPath}; reinstall oh-my-codex and run "omx setup --force"`,
+        };
+    }
+    const smokeCwd = await mkdtemp(join(tmpdir(), "omx-doctor-native-hook-dist-"));
+    try {
+        const payload = JSON.stringify({
+            hook_event_name: "UserPromptSubmit",
+            session_id: "omx-doctor-native-hook-dist-smoke",
+            transcript_path: join(smokeCwd, "nonexistent-transcript.jsonl"),
+            cwd: smokeCwd,
+            prompt: "doctor smoke test",
+        });
+        const result = runner(nodePath, [scriptPath], {
+            cwd: smokeCwd,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                OMX_NATIVE_HOOK_DOCTOR_SMOKE: "1",
+                OMX_ROOT: join(smokeCwd, ".omx-doctor-root"),
+                OMX_SESSION_ID: "omx-doctor-native-hook-dist-smoke",
+                OMX_SOURCE_CWD: smokeCwd,
+                OMX_STARTUP_CWD: smokeCwd,
+            },
+            input: payload,
+            timeout: 5_000,
+        });
+        if (result.error) {
+            return {
+                name: "Native hook dist smoke",
+                status: "fail",
+                message: `installed native hook dist smoke failed to run (${result.error.message}); reinstall oh-my-codex and run "omx setup --force"`,
+            };
+        }
+        if (result.status !== 0) {
+            const stderr = (result.stderr || "").trim();
+            const stdout = (result.stdout || "").trim();
+            const detail = stderr || stdout || `exit ${result.status}`;
+            return {
+                name: "Native hook dist smoke",
+                status: "fail",
+                message: `installed native hook dist failed a minimal UserPromptSubmit smoke (${detail}); reinstall with "npm install -g oh-my-codex@${packageVersion} --force --min-release-age=0 --before=" and then run "omx setup --force"`,
+            };
+        }
+        return {
+            name: "Native hook dist smoke",
+            status: "pass",
+            message: "installed dist/scripts/codex-native-hook.js parsed and accepted a minimal UserPromptSubmit payload",
+        };
+    }
+    finally {
+        await rm(smokeCwd, { recursive: true, force: true });
+    }
+}
+export function classifyPostCompactHookStdout(stdout) {
+    const trimmed = stdout.trim();
+    if (trimmed === "")
+        return null;
+    try {
+        JSON.parse(trimmed);
+        return {
+            name: "Native PostCompact hook",
+            status: "fail",
+            message: "PostCompact hook emitted JSON stdout, but OMX PostCompact must emit no stdout until Codex defines a supported PostCompact output contract; run \"omx setup --force\" after upgrading",
+        };
+    }
+    catch (error) {
+        return {
+            name: "Native PostCompact hook",
+            status: "fail",
+            message: `PostCompact hook emitted invalid JSON stdout (${error instanceof Error ? error.message : String(error)}); run "omx setup --force" after upgrading`,
+        };
+    }
+}
+async function checkNativePostCompactHookRuntime(hooksPath, cwd, codexHomeDir) {
+    if (!existsSync(hooksPath))
+        return null;
+    let content;
+    try {
+        content = await readFile(hooksPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const postCompactCommands = getManagedCodexHookCommandsForEvent(content, "PostCompact");
+    if (postCompactCommands === null || postCompactCommands.length === 0) {
+        return null;
+    }
+    const expectedCommand = buildManagedCodexNativeHookCommand(getPackageRoot(), {
+        codexHomeDir,
+    });
+    const uniqueCommands = [...new Set(postCompactCommands)];
+    if (uniqueCommands.length !== 1 || uniqueCommands[0] !== expectedCommand) {
+        return {
+            name: "Native PostCompact hook",
+            status: "warn",
+            message: "effective PostCompact OMX command does not match this installation's managed hook command; doctor skipped execution for safety, and \"omx setup --force\" should refresh stale hooks.json entries",
+        };
+    }
+    const smokeCwd = await mkdtemp(join(tmpdir(), "omx-doctor-postcompact-"));
+    try {
+        const payload = JSON.stringify({
+            hook_event_name: "PostCompact",
+            cwd: smokeCwd,
+            session_id: "omx-doctor-postcompact-smoke",
+        });
+        const result = spawnSync(expectedCommand, {
+            cwd,
+            encoding: "utf-8",
+            env: {
+                ...process.env,
+                OMX_NATIVE_HOOK_DOCTOR_SMOKE: "1",
+            },
+            input: payload,
+            shell: true,
+            timeout: 5_000,
+        });
+        if (result.error) {
+            return {
+                name: "Native PostCompact hook",
+                status: "fail",
+                message: `PostCompact hook smoke validation failed to run (${result.error.message})`,
+            };
+        }
+        if (result.status !== 0) {
+            const stderr = (result.stderr || "").trim();
+            return {
+                name: "Native PostCompact hook",
+                status: "fail",
+                message: `PostCompact hook smoke validation exited ${result.status}${stderr ? `: ${stderr}` : ""}`,
+            };
+        }
+        const stdoutCheck = classifyPostCompactHookStdout(result.stdout || "");
+        if (stdoutCheck)
+            return stdoutCheck;
+        return {
+            name: "Native PostCompact hook",
+            status: "pass",
+            message: "verbose smoke validation confirmed the effective PostCompact hook exits successfully with no stdout",
+        };
+    }
+    finally {
+        await rm(smokeCwd, { recursive: true, force: true });
+    }
+}
+async function checkNativeHookRuntimeMirrors(cwd, hooksPath) {
+    if (!existsSync(hooksPath))
+        return null;
+    const discovery = await discoverCodexHookConfigPaths(cwd);
+    const runtimeMirrorCount = discovery.skipped.filter((entry) => entry.reason === "runtime_codex_home_mirror").length;
+    if (runtimeMirrorCount === 0)
+        return null;
+    return {
+        name: "Native hook runtime mirrors",
+        status: "warn",
+        message: `.omx/runtime/codex-home contains ${runtimeMirrorCount} hooks.json runtime mirror${runtimeMirrorCount === 1 ? "" : "s"} skipped by hook discovery; cleanup or relaunch so external hook review tools do not see duplicate native hook surfaces`,
+    };
+}
+async function checkPrompts(dir, installMode) {
+    if (installMode === "plugin") {
+        return {
+            name: "Prompts",
+            status: "pass",
+            message: "plugin mode intentionally omits setup-owned prompts; Codex plugin discovery supplies workflow surfaces",
+        };
+    }
+    const expectations = getCatalogExpectations();
+    if (!existsSync(dir)) {
+        return {
+            name: "Prompts",
+            status: "warn",
+            message: "prompts directory not found",
+        };
+    }
+    try {
+        const files = await readdir(dir);
+        const mdFiles = files.filter((f) => f.endsWith(".md"));
+        if (mdFiles.length >= expectations.promptMin) {
+            return {
+                name: "Prompts",
+                status: "pass",
+                message: `${mdFiles.length} agent prompts installed`,
+            };
+        }
+        return {
+            name: "Prompts",
+            status: "warn",
+            message: `${mdFiles.length} prompts (expected >= ${expectations.promptMin})`,
+        };
+    }
+    catch {
+        return {
+            name: "Prompts",
+            status: "fail",
+            message: "cannot read prompts directory",
+        };
+    }
+}
+async function checkLegacySkillRootOverlap() {
+    const overlap = await detectLegacySkillRootOverlap();
+    if (!overlap.legacyExists) {
+        return {
+            name: "Legacy skill roots",
+            status: "pass",
+            message: "no ~/.agents/skills overlap detected",
+        };
+    }
+    if (overlap.sameResolvedTarget) {
+        return {
+            name: "Legacy skill roots",
+            status: "pass",
+            message: `~/.agents/skills links to canonical ${overlap.canonicalDir}; treating both paths as one shared skill root`,
+        };
+    }
+    if (overlap.overlappingSkillNames.length === 0) {
+        return {
+            name: "Legacy skill roots",
+            status: "pass",
+            message: `shared ~/.agents/skills exists (${overlap.legacySkillCount} skills) alongside canonical ${overlap.canonicalDir}; no duplicate skill names detected`,
+        };
+    }
+    const mismatchMessage = overlap.mismatchedSkillNames.length > 0
+        ? `; ${overlap.mismatchedSkillNames.length} differ in SKILL.md content`
+        : "";
+    return {
+        name: "Legacy skill roots",
+        status: "warn",
+        message: `${overlap.overlappingSkillNames.length} overlapping skill names between ${overlap.canonicalDir} and ${overlap.legacyDir}${mismatchMessage}; Codex Enable/Disable Skills may show duplicates until ~/.agents/skills is cleaned up`,
+    };
+}
+function getParsedPluginMarketplaceConfig(content) {
+    const parsed = parseToml(content);
+    return {
+        marketplace: parsed.marketplaces?.[OMX_LOCAL_MARKETPLACE_NAME] ?? null,
+        plugin: parsed.plugins?.[OMX_LOCAL_PLUGIN_CONFIG_KEY] ?? null,
+    };
+}
+async function checkPluginMarketplaceRegistration(configPath, codexHomeDir) {
+    const packagedMarketplace = await resolvePackagedOmxMarketplace(getPackageRoot());
+    if (!packagedMarketplace) {
+        return {
+            name: "Skills",
+            status: "warn",
+            message: `plugin mode selected, but packaged ${OMX_LOCAL_MARKETPLACE_NAME} metadata was not found; reinstall oh-my-codex or run from a package that includes plugins/`,
+        };
+    }
+    if (!existsSync(configPath)) {
+        return {
+            name: "Skills",
+            status: "warn",
+            message: `plugin mode selected, but ${OMX_LOCAL_MARKETPLACE_NAME} is not registered because config.toml is missing; run "omx setup --plugin --force"`,
+        };
+    }
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const { marketplace: registration, plugin } = getParsedPluginMarketplaceConfig(content);
+        if (!registration) {
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `plugin mode selected, but Codex marketplace ${OMX_LOCAL_MARKETPLACE_NAME} is not registered; run "omx setup --plugin --force"`,
+            };
+        }
+        if (registration.source_type !== "local") {
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `Codex marketplace ${OMX_LOCAL_MARKETPLACE_NAME} has source_type=${String(registration.source_type)} (expected local); run "omx setup --plugin --force"`,
+            };
+        }
+        if (registration.source !== getPackageRoot()) {
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `Codex marketplace ${OMX_LOCAL_MARKETPLACE_NAME} points to ${String(registration.source)} (expected ${getPackageRoot()}); run "omx setup --plugin --force"`,
+            };
+        }
+        if (plugin?.enabled !== true) {
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `Codex plugin ${OMX_LOCAL_PLUGIN_CONFIG_KEY} is not enabled; run "omx setup --plugin --force"`,
+            };
+        }
+        const [packagedManifestVersion, expectedSkillNames, cacheDirs] = await Promise.all([
+            packagedOmxPluginVersion(packagedMarketplace),
+            expectedPackagedOmxSkillNames(packagedMarketplace),
+            discoverOmxPluginCacheDirs(codexHomeDir),
+        ]);
+        if (!packagedManifestVersion) {
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `packaged ${OMX_LOCAL_MARKETPLACE_NAME} plugin has no manifest version; reinstall oh-my-codex`,
+            };
+        }
+        if (!expectedSkillNames || expectedSkillNames.length === 0) {
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `packaged ${OMX_LOCAL_MARKETPLACE_NAME} plugin has no skills mirror; reinstall oh-my-codex`,
+            };
+        }
+        const cacheStates = (await Promise.all(cacheDirs.map((dir) => readOmxPluginCacheState(dir)))).filter((state) => state !== null);
+        const packagedManifestSummary = {
+            manifestVersion: packagedManifestVersion,
+            skillNames: expectedSkillNames,
+        };
+        const readyCache = cacheStates.find((state) => state.manifestVersion === packagedManifestSummary.manifestVersion &&
+            state.skillsPointer === "./skills/" &&
+            JSON.stringify(state.skillNames) ===
+                JSON.stringify(packagedManifestSummary.skillNames));
+        if (!readyCache) {
+            const staleManifestCache = cacheStates.find((state) => state.skillsPointer === "./skills/" &&
+                JSON.stringify(state.skillNames) ===
+                    JSON.stringify(packagedManifestSummary.skillNames) &&
+                state.manifestVersion !== packagedManifestSummary.manifestVersion);
+            const detail = staleManifestCache
+                ? `installed Codex plugin cache manifest version ${String(staleManifestCache.manifestVersion)} does not match packaged version ${packagedManifestSummary.manifestVersion}`
+                : cacheStates.length === 0
+                    ? "no installed Codex plugin cache was found"
+                    : "installed Codex plugin cache is missing the packaged skills mirror";
+            return {
+                name: "Skills",
+                status: "warn",
+                message: `plugin marketplace ${OMX_LOCAL_MARKETPLACE_NAME} is registered, but ${detail}; run "omx setup --plugin --force" so /skills can discover OMX plugin skills`,
+            };
+        }
+        return {
+            name: "Skills",
+            status: "pass",
+            message: `plugin marketplace ${OMX_LOCAL_MARKETPLACE_NAME} registered; OMX skills are supplied by ${readyCache.cacheDir}`,
+        };
+    }
+    catch {
+        return {
+            name: "Skills",
+            status: "fail",
+            message: "cannot read or parse config.toml for plugin marketplace registration",
+        };
+    }
+}
+const REQUIRED_NATIVE_REVIEWER_ROLES = ["architect", "critic"];
+const ADVISORY_NATIVE_REVIEWER_ROLES = ["scholastic"];
+function getParsedAgentTables(configPath) {
+    if (!existsSync(configPath))
+        return null;
+    try {
+        const parsed = parseToml(readFileSync(configPath, "utf-8"));
+        return parsed.agents &&
+            typeof parsed.agents === "object" &&
+            !Array.isArray(parsed.agents)
+            ? parsed.agents
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function configHasNativeReviewerRole(configPath, role) {
+    const agents = getParsedAgentTables(configPath);
+    if (!agents)
+        return false;
+    const value = agents[role];
+    return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function agentTomlDefinesRole(path, role) {
+    if (!existsSync(path))
+        return false;
+    try {
+        const parsed = parseToml(readFileSync(path, "utf-8"));
+        if (typeof parsed.name === "string" && parsed.name.trim() !== "") {
+            return parsed.name.trim() === role;
+        }
+        return basename(path, ".toml") === role;
+    }
+    catch {
+        return false;
+    }
+}
+function nativeReviewerRoleAvailable(paths, role) {
+    return agentTomlDefinesRole(join(paths.agentsDir, `${role}.toml`), role)
+        || configHasNativeReviewerRole(paths.configPath, role);
+}
+function formatNativeRoleFileList(roles) {
+    const files = roles.map((role) => `${role}.toml`);
+    if (files.length <= 1)
+        return files[0] ?? "";
+    return `${files.slice(0, -1).join(", ")} and ${files.at(-1)}`;
+}
+function checkNativeReviewerRoles(paths, installMode) {
+    if (installMode !== "plugin")
+        return null;
+    const missingRequired = REQUIRED_NATIVE_REVIEWER_ROLES.filter((role) => !nativeReviewerRoleAvailable(paths, role));
+    const missingAdvisory = ADVISORY_NATIVE_REVIEWER_ROLES.filter((role) => !nativeReviewerRoleAvailable(paths, role));
+    if (missingRequired.length > 0) {
+        const advisorySuffix = missingAdvisory.length > 0
+            ? `; advisory role missing: ${missingAdvisory.join(", ")}`
+            : "";
+        return {
+            name: "Native reviewer roles",
+            status: "fail",
+            message: `plugin mode supplies skills/hooks, but required RALPLAN/Autopilot native reviewer role(s) are unavailable: ${missingRequired.join(", ")}. ` +
+                `Install ${formatNativeRoleFileList(missingRequired)} under ${paths.agentsDir} or define equivalent [agents.<role>] entries in ${paths.configPath}; ` +
+                `otherwise role-specific subagent calls may degrade to prompt-only/default subagents${advisorySuffix}`,
+        };
+    }
+    if (missingAdvisory.length > 0) {
+        return {
+            name: "Native reviewer roles",
+            status: "warn",
+            message: `required RALPLAN/Autopilot native reviewer roles are available (${REQUIRED_NATIVE_REVIEWER_ROLES.join(", ")}); ` +
+                `advisory ontology reviewer role(s) missing: ${missingAdvisory.join(", ")} (optional unless explicitly used)`,
+        };
+    }
+    return {
+        name: "Native reviewer roles",
+        status: "pass",
+        message: `required RALPLAN/Autopilot native reviewer roles are available (${REQUIRED_NATIVE_REVIEWER_ROLES.join(", ")}); advisory ${ADVISORY_NATIVE_REVIEWER_ROLES.join(", ")} role is also available`,
+    };
+}
+function readInstalledAgentModelInfo(tomlPath) {
+    if (!existsSync(tomlPath))
+        return { exists: false };
+    try {
+        const parsed = parseToml(readFileSync(tomlPath, "utf-8"));
+        return {
+            exists: true,
+            model: typeof parsed.model === "string" && parsed.model.trim() !== ""
+                ? parsed.model.trim()
+                : undefined,
+            modelProvider: typeof parsed.model_provider === "string" &&
+                parsed.model_provider.trim() !== ""
+                ? parsed.model_provider.trim()
+                : undefined,
+        };
+    }
+    catch {
+        return { exists: true };
+    }
+}
+function resolveSparkModelSource(codexHomeOverride) {
+    const envDefault = process.env[OMX_DEFAULT_SPARK_MODEL_ENV];
+    if (typeof envDefault === "string" && envDefault.trim() !== "") {
+        return `${OMX_DEFAULT_SPARK_MODEL_ENV} env`;
+    }
+    const envLegacy = process.env[OMX_SPARK_MODEL_ENV];
+    if (typeof envLegacy === "string" && envLegacy.trim() !== "") {
+        return `${OMX_SPARK_MODEL_ENV} env`;
+    }
+    if (getEnvConfiguredSparkDefaultModel(process.env, codexHomeOverride)) {
+        return "config.toml env";
+    }
+    return "built-in default";
+}
+function getInstallableSparkLaneAgentNames() {
+    try {
+        const installable = getInstallableNativeAgentNames(readCatalogManifest(getPackageRoot()));
+        return Object.values(AGENT_DEFINITIONS)
+            .filter((agent) => agent.modelClass === "fast" && installable.has(agent.name))
+            .map((agent) => agent.name)
+            .sort();
+    }
+    catch {
+        return Object.values(AGENT_DEFINITIONS)
+            .filter((agent) => agent.modelClass === "fast")
+            .map((agent) => agent.name)
+            .sort();
+    }
+}
+/**
+ * Surface effective Spark/model lane routing and flag the common reasons the
+ * `gpt-5.3-codex-spark` quota stays unused even though resolution is wired
+ * (issue #2757): a missing/stale installed Spark-lane agent toml, a model that
+ * diverges from the resolved Spark default, or a non-default provider that does
+ * not draw from native Spark quota.
+ */
+export function checkSparkRouting(paths) {
+    const name = "Spark routing";
+    const codexHomeOverride = paths.codexHomeDir;
+    const sparkModel = getSparkDefaultModel(codexHomeOverride);
+    const frontierModel = getMainDefaultModel(codexHomeOverride);
+    const standardModel = getStandardDefaultModel(codexHomeOverride);
+    const sparkSource = resolveSparkModelSource(codexHomeOverride);
+    const rootProvider = getCodexConfigRootModelProvider(codexHomeOverride);
+    const laneSummary = `lanes: frontier=\`${frontierModel}\`, standard=\`${standardModel}\`, ` +
+        `spark=\`${sparkModel}\` (source: ${sparkSource})`;
+    const sparkAgents = getInstallableSparkLaneAgentNames();
+    if (sparkAgents.length === 0) {
+        return {
+            name,
+            status: "warn",
+            message: `${laneSummary}; no installable Spark-eligible (fast) native agent is defined, ` +
+                `so native subagents will not consume Spark quota`,
+        };
+    }
+    const problems = [];
+    const wired = [];
+    for (const agentName of sparkAgents) {
+        const info = readInstalledAgentModelInfo(join(paths.agentsDir, `${agentName}.toml`));
+        if (!info.exists) {
+            problems.push(`${agentName}.toml is missing under ${paths.agentsDir} (run \`omx setup --force\`)`);
+            continue;
+        }
+        if (!info.model) {
+            problems.push(`${agentName}.toml has no model field (stale install; run \`omx setup --force\`)`);
+            continue;
+        }
+        if (info.model !== sparkModel) {
+            problems.push(`${agentName}.toml model is \`${info.model}\` but the resolved Spark model is \`${sparkModel}\` (stale install; run \`omx setup --force\`)`);
+            continue;
+        }
+        if (info.modelProvider && rootProvider && info.modelProvider !== rootProvider) {
+            problems.push(`${agentName}.toml model_provider \`${info.modelProvider}\` differs from the config root provider \`${rootProvider}\` (stale install; run \`omx setup --force\`)`);
+            continue;
+        }
+        if (info.modelProvider && info.modelProvider !== "openai") {
+            problems.push(`${agentName}.toml routes Spark via non-default model_provider \`${info.modelProvider}\`; native Codex Spark quota only moves when Spark is served by the default provider`);
+            continue;
+        }
+        wired.push(`${agentName} -> \`${info.model}\`${info.modelProvider ? ` (provider: ${info.modelProvider})` : ""}`);
+    }
+    if (problems.length > 0) {
+        return {
+            name,
+            status: "warn",
+            message: `${laneSummary}; Spark lane issue(s): ${problems.join("; ")}`,
+        };
+    }
+    return {
+        name,
+        status: "pass",
+        message: `${laneSummary}; Spark-lane native agent(s) wired: ${wired.join(", ")}. ` +
+            `If Spark quota is still unused, the leader may not be delegating read-only lookups to the Spark lane, or the Codex usage view may lag.`,
+    };
+}
+async function checkSkills(paths, installMode) {
+    if (installMode === "plugin") {
+        return checkPluginMarketplaceRegistration(paths.configPath, paths.codexHomeDir);
+    }
+    const expectations = getCatalogExpectations();
+    if (!existsSync(paths.skillsDir)) {
+        return {
+            name: "Skills",
+            status: "warn",
+            message: "skills directory not found",
+        };
+    }
+    try {
+        const entries = await readdir(paths.skillsDir, { withFileTypes: true });
+        const skillDirs = entries.filter((e) => e.isDirectory());
+        if (skillDirs.length >= expectations.skillMin) {
+            return {
+                name: "Skills",
+                status: "pass",
+                message: `${skillDirs.length} skills installed`,
+            };
+        }
+        return {
+            name: "Skills",
+            status: "warn",
+            message: `${skillDirs.length} skills (expected >= ${expectations.skillMin})`,
+        };
+    }
+    catch {
+        return {
+            name: "Skills",
+            status: "fail",
+            message: "cannot read skills directory",
+        };
+    }
+}
+function checkAgentsMd(scope, codexHomeDir, installMode) {
+    const scopeFlag = scope === "project" ? "--scope project" : "--scope user";
+    const repairMessage = `OMX AGENTS contract markers missing; file may have been overwritten by another tool. ` +
+        `Run "omx setup ${scopeFlag} --merge-agents" to preserve local guidance while restoring OMX-managed sections, ` +
+        `or "omx setup ${scopeFlag} --force" to replace it after backup.`;
+    const pluginMissingAgentsRepairMessage = `persistent AGENTS.md is missing in plugin mode; session-scoped AGENTS.md can carry runtime overlay only, ` +
+        `so durable orchestration guidance is degraded. Run "omx setup ${scopeFlag} --force" and accept AGENTS.md defaults`;
+    if (scope === "user") {
+        const userAgentsMd = join(codexHomeDir, "AGENTS.md");
+        if (existsSync(userAgentsMd)) {
+            const content = readFileSync(userAgentsMd, "utf-8");
+            if (installMode === "plugin") {
+                if (!hasOmxAgentsContract(content)) {
+                    return {
+                        name: "AGENTS.md",
+                        status: "warn",
+                        message: `${repairMessage} Path: ${userAgentsMd}`,
+                    };
+                }
+                return {
+                    name: "AGENTS.md",
+                    status: "pass",
+                    message: `persistent plugin-mode AGENTS.md found in ${userAgentsMd}`,
+                };
+            }
+            if (!hasOmxAgentsContract(content)) {
+                return {
+                    name: "AGENTS.md",
+                    status: "warn",
+                    message: `${repairMessage} Path: ${userAgentsMd}`,
+                };
+            }
+            return {
+                name: "AGENTS.md",
+                status: "pass",
+                message: `found OMX contract in ${userAgentsMd}`,
+            };
+        }
+        if (installMode === "plugin") {
+            return {
+                name: "AGENTS.md",
+                status: "fail",
+                message: `${pluginMissingAgentsRepairMessage}. Path: ${userAgentsMd}`,
+            };
+        }
+        return {
+            name: "AGENTS.md",
+            status: "warn",
+            message: `not found in ${userAgentsMd} (run omx setup --scope user)`,
+        };
+    }
+    const projectAgentsMd = join(process.cwd(), "AGENTS.md");
+    if (existsSync(projectAgentsMd)) {
+        const content = readFileSync(projectAgentsMd, "utf-8");
+        if (installMode === "plugin") {
+            if (!hasOmxAgentsContract(content)) {
+                return {
+                    name: "AGENTS.md",
+                    status: "warn",
+                    message: `${repairMessage} Path: ${projectAgentsMd}`,
+                };
+            }
+            return {
+                name: "AGENTS.md",
+                status: "pass",
+                message: "persistent plugin-mode AGENTS.md found in project root",
+            };
+        }
+        if (!hasOmxAgentsContract(content)) {
+            return {
+                name: "AGENTS.md",
+                status: "warn",
+                message: `${repairMessage} Path: ${projectAgentsMd}`,
+            };
+        }
+        return {
+            name: "AGENTS.md",
+            status: "pass",
+            message: "found OMX contract in project root",
+        };
+    }
+    if (installMode === "plugin") {
+        return {
+            name: "AGENTS.md",
+            status: "fail",
+            message: `${pluginMissingAgentsRepairMessage}. Path: ${projectAgentsMd}`,
+        };
+    }
+    return {
+        name: "AGENTS.md",
+        status: "warn",
+        message: "not found in project root (run omx agents-init . or omx setup --scope project)",
+    };
+}
+function checkPromptTriage() {
+    try {
+        const config = readTriageConfig();
+        if (config.status === "disabled") {
+            return {
+                name: "Prompt triage",
+                status: "warn",
+                message: `disabled via ${config.path}`,
+            };
+        }
+        if (config.status === "invalid") {
+            return {
+                name: "Prompt triage",
+                status: "warn",
+                message: `config file malformed at ${config.path} — fails closed to disabled`,
+            };
+        }
+        // Smoke test: verify the classifier is callable and returns the expected shape.
+        const decision = triagePrompt("hello");
+        const validLanes = new Set(["HEAVY", "LIGHT", "PASS"]);
+        if (!decision ||
+            typeof decision !== "object" ||
+            !validLanes.has(decision.lane)) {
+            return {
+                name: "Prompt triage",
+                status: "fail",
+                message: `classifier returned unexpected shape (lane: ${String(decision?.lane)})`,
+            };
+        }
+        const sourceLabel = config.status === "defaulted" ? "enabled (default)" : "enabled";
+        return {
+            name: "Prompt triage",
+            status: "pass",
+            message: `config: ${sourceLabel}`,
+        };
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+            name: "Prompt triage",
+            status: "fail",
+            message: `module load error — ${msg}`,
+        };
+    }
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function pluginMcpServerEnabled(content, serverName) {
+    const headerPattern = new RegExp(`^\\s*\\[plugins\\.${escapeRegExp(JSON.stringify(OMX_LOCAL_PLUGIN_CONFIG_KEY))}\\.mcp_servers\\.${escapeRegExp(serverName)}\\]\\s*$`);
+    const lines = content.split(/\r?\n/);
+    const start = lines.findIndex((line) => headerPattern.test(line));
+    if (start < 0)
+        return null;
+    for (let index = start + 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (/^\s*\[/.test(line))
+            break;
+        const enabledMatch = line.match(/^\s*enabled\s*=\s*(true|false)\s*$/);
+        if (enabledMatch)
+            return enabledMatch[1] === "true";
+    }
+    return null;
+}
+function describePluginMcpState(content, mcpMode) {
+    const states = OMX_FIRST_PARTY_MCP_SERVER_NAMES.map((serverName) => pluginMcpServerEnabled(content, serverName));
+    const enabledCount = states.filter((state) => state === true).length;
+    const disabledCount = states.filter((state) => state === false).length;
+    const missingCount = states.filter((state) => state === null).length;
+    const expectedEnabled = mcpMode === "compat";
+    if (expectedEnabled && missingCount === 0 && enabledCount === states.length) {
+        return {
+            name: "MCP Servers",
+            status: "pass",
+            message: `plugin MCP compatibility enabled by setup MCP mode compat (${enabledCount}/${states.length} first-party servers enabled)`,
+        };
+    }
+    if (!expectedEnabled && enabledCount === 0) {
+        return {
+            name: "MCP Servers",
+            status: "pass",
+            message: `CLI-first plugin mode: first-party MCP compatibility explicitly disabled (${enabledCount}/${states.length} first-party servers enabled; ${disabledCount} disabled, ${missingCount} omitted)`,
+        };
+    }
+    return {
+        name: "MCP Servers",
+        status: "warn",
+        message: `plugin MCP compatibility overrides are incomplete or mixed (enabled=${enabledCount}, disabled=${disabledCount}, missing=${missingCount}); run "omx setup --plugin --force --mcp ${mcpMode ?? "none"}" to repair`,
+    };
+}
+async function checkMcpServers(configPath, installMode, mcpMode) {
+    if (!existsSync(configPath)) {
+        if (installMode === "plugin") {
+            return {
+                name: "MCP Servers",
+                status: "warn",
+                message: 'plugin mode selected, but config.toml is missing; run "omx setup --plugin --force" to register plugin discovery',
+            };
+        }
+        return {
+            name: "MCP Servers",
+            status: "warn",
+            message: "config.toml not found",
+        };
+    }
+    try {
+        const content = await readFile(configPath, "utf-8");
+        const mcpCount = (content.match(/\[mcp_servers\./g) || []).length;
+        if (hasLegacyOmxTeamRunTable(content)) {
+            return {
+                name: "MCP Servers",
+                status: "warn",
+                message: `${mcpCount} servers configured, but retired [mcp_servers.omx_team_run] is not supported; run "omx setup --force" to repair the config`,
+            };
+        }
+        if (installMode === "plugin") {
+            return describePluginMcpState(content, mcpMode);
+        }
+        if (mcpCount > 0) {
+            const hasOmx = OMX_FIRST_PARTY_MCP_SERVER_NAMES.some((name) => content.includes(`[mcp_servers.${name}]`));
+            if (hasOmx) {
+                return {
+                    name: "MCP Servers",
+                    status: "pass",
+                    message: `${mcpCount} servers configured; first-party OMX MCP compatibility is explicitly present`,
+                };
+            }
+            return {
+                name: "MCP Servers",
+                status: "pass",
+                message: `${mcpCount} user-managed MCP server(s) preserved; first-party OMX MCP omitted by default`,
+            };
+        }
+        return {
+            name: "MCP Servers",
+            status: "pass",
+            message: "CLI-first default: no first-party OMX MCP servers configured",
+        };
+    }
+    catch {
+        return {
+            name: "MCP Servers",
+            status: "fail",
+            message: "cannot read config.toml",
+        };
+    }
+}
+//# sourceMappingURL=doctor.js.map