@claudexor/cli 1.0.1

package/dist/plugins.js

@@ -0,0 +1,1383 @@
+import { spawn } from "node:child_process";
+import { copyFileSync, existsSync, lstatSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { hostFallbackExamples, recoveryVerbs } from "./command-registry.js";
+import { CLAUDEXOR_VERSION, ensureDir, sha256, userConfigDir, userHomeDir, writeJson, } from "@claudexor/util";
+export const PLUGIN_HOSTS = ["cursor", "claude", "codex", "opencode"];
+export const PLUGIN_TARGETS = [...PLUGIN_HOSTS, "all"];
+export const PLUGIN_VERBS = ["install", "status", "doctor", "repair", "uninstall"];
+const STATE_VERSION = 1;
+const MARKER = "claudexor:managed host-plugin-lifecycle";
+const MCP_NAME = "claudexor";
+function managedComment(kind = "md") {
+    return kind === "js"
+        ? `// ${MARKER}; version=${CLAUDEXOR_VERSION}\n`
+        : `<!-- ${MARKER}; version=${CLAUDEXOR_VERSION} -->\n`;
+}
+function jsonText(value) {
+    return JSON.stringify(value, null, 2) + "\n";
+}
+function generatedMcpEnv(runtime) {
+    return {
+        CLAUDEXOR_CONFIG_DIR: runtime.configDir,
+        // MANAGED is drift-detection CONTENT (versions the generated artifact
+        // text for status/doctor). PLUGIN_VERSION is ALSO read at runtime:
+        // `mcp serve` compares it with the CLI version and warns on stderr when
+        // the installed artifacts are stale (repair + host reload fixes it).
+        CLAUDEXOR_MANAGED: MARKER,
+        CLAUDEXOR_PLUGIN_VERSION: CLAUDEXOR_VERSION,
+    };
+}
+function mcpServers(runtime) {
+    return {
+        mcpServers: {
+            [MCP_NAME]: {
+                command: runtime.nodePath,
+                args: [runtime.cliPath, "mcp", "serve"],
+                env: generatedMcpEnv(runtime),
+            },
+        },
+    };
+}
+function opencodeMcpEntry(runtime) {
+    return {
+        type: "local",
+        command: [runtime.nodePath, runtime.cliPath, "mcp", "serve"],
+        environment: generatedMcpEnv(runtime),
+        enabled: true,
+        // Tool-DISCOVERY timeout only (OpenCode semantics). Tool EXECUTION time
+        // is governed by OpenCode's global MCP execution timeout — long verbs
+        // (agent/best-of) can exceed it; the generated README and INTEGRATIONS.md
+        // carry the guidance (raise experimental.mcp_timeout, or prefer the CLI
+        // for long runs). The runId trailer keeps abandoned calls recoverable.
+        timeout: 5000,
+    };
+}
+/** `claudexor inspect <runId>`, `follow <runId>`, ... — from the registry's recovery verbs. */
+function recoveryVerbLine() {
+    const verbs = recoveryVerbs();
+    const parts = verbs.map((verb, i) => (i === 0 ? `\`claudexor ${verb} <runId>\`` : `\`${verb} <runId>\``));
+    return parts.length > 1 ? `${parts.slice(0, -1).join(", ")}, or ${parts[parts.length - 1]}` : (parts[0] ?? "");
+}
+function skillText(host) {
+    const namespace = host === "claude" ? "claudexor@skills-dir" : "claudexor";
+    return [
+        "---",
+        "name: claudexor",
+        "description: Use Claudexor for harness-agnostic planning, runs, races, and review through its local CLI/MCP bridge.",
+        "---",
+        managedComment().trimEnd(),
+        "# Claudexor",
+        "",
+        "Use Claudexor when a task benefits from a harness-agnostic control plane, cross-harness review, best-of-N race, or evidence-backed planning.",
+        "",
+        "Claudexor owns orchestration. This host integration is a bridge to the local CLI and MCP server; it does not add host-local business logic.",
+        "",
+        "Prefer these routes:",
+        "",
+        "- MCP tool `claudexor_status` to check available harnesses.",
+        "- MCP tool `claudexor_capabilities` for the full machine-readable catalog (harness health, modes, mutability matrix).",
+        "- MCP tool `claudexor_ask` for read-only answers.",
+        "- MCP tool `claudexor_explore` for bounded read-only research synthesis.",
+        "- MCP tool `claudexor_plan` for read-only implementation plans.",
+        "- MCP tool `claudexor_run` for a single agent run.",
+        "- MCP tool `claudexor_best_of` for best-of-N attempts.",
+        "- MCP tool `claudexor_create` for create-from-scratch runs.",
+        "- MCP tool `claudexor_orchestrate` for a typed orchestration plan (SUGGEST autonomy over MCP: it plans, it does not execute).",
+        "- MCP tools `claudexor_runs` / `claudexor_inspect` / `claudexor_apply_check` to recover a lost run handle (read-only).",
+        "",
+        "When the host cannot call MCP tools, ask the user to run the local CLI explicitly:",
+        "",
+        ...hostFallbackExamples().map((example) => `\`${example}\``),
+        "",
+        "MCP support is one-shot and honest: tools return the final Claudexor output, not a live Claudexor thread. Use an explicit `repoPath` when the host cwd may not be the target project.",
+        "",
+        "Readiness semantics: a harness is usable only when `claudexor_status` reports it `ok` (doctor-backed). An installed binary, a stored key, or an auth file alone is NOT readiness — do not retry a degraded harness expecting different results; surface the doctor reasons instead.",
+        "",
+        "Host timeouts: mutating tools can run for many minutes and hosts often cap tool calls. The `runId:` trailer arrives in EVERY result — if the host times out, the run continues daemon-side; recover it with `claudexor_inspect` or the CLI.",
+        "",
+        `Mutating runs (agent/best-of/create) are daemon-tracked and end with a \`runId:\` trailer — use ${recoveryVerbLine()} for evidence, live progress, delivery, or unblocking a blocked run. Structured results carry \`applyEligibility\`: apply only when \`eligible\` is true; otherwise follow \`requiredAction\`.`,
+        "",
+        "Safety rules:",
+        "",
+        "- NEVER paste live credentials into prompts — every ingress hard-blocks secret-like values (typed `inline_secret_rejected`). Store keys with `claudexor secrets set` and reference them.",
+        "- NEVER auto-answer `claudexor decision` for a blocked run: risk acceptance (accept-risk/override) is the HUMAN operator's call. Report the blocked state and the decision options.",
+        "- Exit codes: 0 = success terminal; 1 = failed/blocked/cancelled run; 2 = usage error (unknown verb/flag/mode). `--json` errors come as `{ok:false, exitCode, error}` on stdout.",
+        "",
+        `Host namespace: ${namespace}`,
+        "",
+    ].join("\n");
+}
+function commandText(host) {
+    const frontmatter = (host === "claude" || host === "cursor" || host === "opencode"
+        ? ["---", "description: Use Claudexor CLI/MCP for harness-agnostic coding workflows", "---"]
+        : []);
+    return [
+        ...frontmatter,
+        managedComment().trimEnd(),
+        "Use Claudexor for this request when cross-harness planning, review, best-of-N race, or evidence-backed execution is useful.",
+        "",
+        "First prefer the available MCP tools named `claudexor_*`. If MCP tools are unavailable, tell the user the exact local CLI command to run, such as:",
+        "",
+        ...hostFallbackExamples().map((example) => `- \`${example.replace('"..."', '"$ARGUMENTS"')}\``),
+        "",
+        "Do not claim live thread parity through MCP. Ask for an explicit repo path if the target project is ambiguous.",
+        "",
+    ].filter((line, i, all) => line !== "" || all[i - 1] !== "").join("\n");
+}
+function readmeText(host) {
+    return [
+        managedComment().trimEnd(),
+        `# Claudexor ${host} integration`,
+        "",
+        `This directory is generated by \`claudexor plugin install ${host}\`.`,
+        "",
+        "It packages Claudexor instructions and MCP configuration for the host. All orchestration remains in the local Claudexor CLI and engine.",
+        "",
+        "Long-running MCP tools (claudexor_run, claudexor_best_of, claudexor_create) are daemon-tracked: every result carries a `runId:` trailer, so a call abandoned by a host timeout stays recoverable via `claudexor inspect <runId>` / `claudexor follow <runId>`.",
+        "",
+    ].join("\n");
+}
+function manifest(kind) {
+    const description = `Claudexor control plane host integration (${MARKER})`;
+    if (kind === "cursor") {
+        // Cursor requires literal path ARRAYS for `commands`/`skills`, never glob strings,
+        // and `skills` must name the skill DIRECTORY (not its SKILL.md). Glob strings register
+        // nothing, which left the plugin loading empty on install. `displayName`/`publisher`
+        // are non-schema and dropped; the root `mcp.json` is auto-detected (kept for the test
+        // and as the explicit MCP pointer).
+        return jsonText({
+            name: "claudexor",
+            description,
+            version: CLAUDEXOR_VERSION,
+            author: { name: "Claudexor" },
+            commands: ["commands/claudexor.md"],
+            skills: ["skills/claudexor"],
+            mcpServers: "./mcp.json",
+        });
+    }
+    if (kind === "codex") {
+        return jsonText({
+            name: "claudexor",
+            version: CLAUDEXOR_VERSION,
+            description,
+            author: { name: "Claudexor" },
+            skills: "./skills/",
+            mcpServers: "./.mcp.json",
+            interface: {
+                displayName: "Claudexor",
+                shortDescription: "Harness-agnostic coding through the local Claudexor CLI.",
+                longDescription: "Use Claudexor for local planning, runs, races, and review through generated skills and one-shot MCP tools.",
+                developerName: "Claudexor",
+                category: "Productivity",
+                capabilities: ["Productivity"],
+            },
+        });
+    }
+    const base = {
+        name: "claudexor",
+        version: CLAUDEXOR_VERSION,
+        description,
+        interface: {
+            displayName: "Claudexor",
+            description: "Harness-agnostic coding through the local Claudexor CLI and MCP server.",
+        },
+        claudexor: {
+            managed: true,
+            marker: MARKER,
+            version: CLAUDEXOR_VERSION,
+        },
+    };
+    if (kind === "claude") {
+        return jsonText({
+            ...base,
+            author: { name: "Claudexor" },
+        });
+    }
+    return jsonText(base);
+}
+function opencodePluginText(runtime) {
+    const hint = "Use Claudexor MCP tools or run `claudexor plan/agent/best-of` when cross-harness orchestration, review, or evidence-backed execution is useful.";
+    return `${managedComment("js")}export const ClaudexorPlugin = async () => {\n  const hint = ${JSON.stringify(hint)};\n  return {\n    \"experimental.chat.system.transform\": async (_input, output) => {\n      if (!output || typeof output !== \"object\") return;\n      const current = typeof output.system === \"string\" ? output.system : typeof output.prompt === \"string\" ? output.prompt : \"\";\n      if (current.includes(\"Claudexor\")) return;\n      if (typeof output.system === \"string\") output.system = output.system + \"\\n\\n\" + hint;\n      else if (typeof output.prompt === \"string\") output.prompt = output.prompt + \"\\n\\n\" + hint;\n    },\n  };\n};\n\nexport default ClaudexorPlugin;\n\n// OpenCode hook note: uses experimental.chat.system.transform because OpenCode does not expose tui.prompt.append as a plugin hook.\n// MCP command: ${runtime.nodePath} ${runtime.cliPath} mcp serve\n`;
+}
+const HOST_DEFINITIONS = {
+    claude: {
+        host: "claude",
+        displayName: "Claude Code",
+        installState: "installed",
+        root: (home) => join(home, ".claude"),
+        artifacts: (home, runtime) => {
+            const root = join(home, ".claude", "skills", "claudexor");
+            return [
+                { path: join(root, ".claude-plugin", "plugin.json"), content: manifest("claude"), description: "Claude plugin manifest" },
+                { path: join(root, "skills", "claudexor", "SKILL.md"), content: skillText("claude"), description: "Claude skill" },
+                { path: join(root, "commands", "claudexor.md"), content: commandText("claude"), description: "Claude command" },
+                { path: join(root, ".mcp.json"), content: jsonText(mcpServers(runtime)), description: "Claude MCP config" },
+                { path: join(root, "README.md"), content: readmeText("claude"), description: "Claude integration README" },
+            ];
+        },
+        legacy: (home) => [
+            {
+                path: join(home, ".claude", "plugins", "claudexor"),
+                root: join(home, ".claude"),
+                expectedFiles: [".claude-plugin/plugin.json", "commands/claudexor.md"],
+                verifier: legacyThinShimVerifier,
+            },
+        ],
+        reloadNote: "Start a new Claude Code session; skills-directory plugins auto-load from ~/.claude/skills.",
+    },
+    codex: {
+        host: "codex",
+        displayName: "Codex",
+        installState: "registered",
+        root: (home) => join(home, ".codex"),
+        artifacts: (home, runtime) => {
+            const root = join(home, ".codex", "plugins", "claudexor");
+            return [
+                { path: join(root, ".codex-plugin", "plugin.json"), content: manifest("codex"), description: "Codex plugin manifest" },
+                { path: join(root, "skills", "claudexor", "SKILL.md"), content: skillText("codex"), description: "Codex skill" },
+                { path: join(root, ".mcp.json"), content: jsonText(mcpServers(runtime)), description: "Codex MCP config" },
+                { path: join(root, "README.md"), content: readmeText("codex"), description: "Codex integration README" },
+            ];
+        },
+        config: "codex-marketplace",
+        legacy: (home) => [
+            {
+                path: join(home, ".agents", "skills", "claudexor"),
+                root: join(home, ".agents"),
+                expectedFiles: ["SKILL.md"],
+                verifier: legacyCodexSkillVerifier,
+            },
+        ],
+        reloadNote: "Restart Codex, open Plugins, choose the personal marketplace, then install/enable Claudexor.",
+    },
+    cursor: {
+        host: "cursor",
+        displayName: "Cursor",
+        installState: "installed",
+        root: (home) => join(home, ".cursor"),
+        artifacts: (home, runtime) => {
+            const root = join(home, ".cursor", "plugins", "local", "claudexor");
+            return [
+                { path: join(root, ".cursor-plugin", "plugin.json"), content: manifest("cursor"), description: "Cursor plugin manifest" },
+                { path: join(root, "skills", "claudexor", "SKILL.md"), content: skillText("cursor"), description: "Cursor skill" },
+                { path: join(root, "commands", "claudexor.md"), content: commandText("cursor"), description: "Cursor command" },
+                { path: join(root, "mcp.json"), content: jsonText(mcpServers(runtime)), description: "Cursor MCP config" },
+                { path: join(root, "README.md"), content: readmeText("cursor"), description: "Cursor integration README" },
+            ];
+        },
+        legacy: (home) => [
+            {
+                path: join(home, ".cursor", "plugins", "local", "claudexor"),
+                root: join(home, ".cursor"),
+                expectedFiles: [".cursor-plugin/plugin.json", "commands/claudexor.md"],
+                verifier: legacyThinShimVerifier,
+            },
+        ],
+        reloadNote: "Reload Cursor and enable the local plugin if it is not auto-enabled; Claudexor does not edit Cursor SQLite/binary state.",
+    },
+    opencode: {
+        host: "opencode",
+        displayName: "OpenCode",
+        installState: "installed",
+        root: (home) => join(home, ".config", "opencode"),
+        artifacts: (home, runtime) => {
+            const root = join(home, ".config", "opencode");
+            return [
+                { path: join(root, "skills", "claudexor", "SKILL.md"), content: skillText("opencode"), description: "OpenCode skill" },
+                { path: join(root, "commands", "claudexor.md"), content: commandText("opencode"), description: "OpenCode command" },
+                { path: join(root, "plugins", "claudexor.js"), content: opencodePluginText(runtime), description: "OpenCode JS plugin" },
+            ];
+        },
+        config: "opencode-mcp",
+        legacy: (home) => [
+            {
+                path: join(home, ".config", "opencode", "claudexor"),
+                root: join(home, ".config", "opencode"),
+                expectedFiles: ["AGENTS.md"],
+                verifier: legacyOpenCodeAgentVerifier,
+            },
+        ],
+        reloadNote: "Restart OpenCode; global plugins, commands, skills, and MCP config load from ~/.config/opencode. The JS plugin uses OpenCode's experimental.chat.system.transform hook.",
+    },
+};
+function runtimePaths() {
+    const home = userHomeDir();
+    const configDir = userConfigDir();
+    const warnings = [];
+    const allowTestOverrides = process.env.VITEST === "true" || process.env.NODE_ENV === "test";
+    const envNode = allowTestOverrides ? process.env.CLAUDEXOR_NODE_PATH?.trim() : undefined;
+    const bundledNode = join(home, ".claudexor", "node", "bin", "node");
+    const nodePath = envNode || (existsSync(bundledNode) ? bundledNode : process.execPath);
+    if (!isAbsolute(nodePath) || !existsSync(nodePath) || !statSync(nodePath).isFile()) {
+        throw new Error(`unable to resolve a safe Node executable for plugin MCP config: ${nodePath}`);
+    }
+    if (!envNode && nodePath !== bundledNode)
+        warnings.push(`using current node instead of ${bundledNode}`);
+    if (!allowTestOverrides && process.env.CLAUDEXOR_NODE_PATH?.trim())
+        warnings.push("ignored CLAUDEXOR_NODE_PATH outside tests");
+    const envCli = allowTestOverrides ? process.env.CLAUDEXOR_CLI_PATH?.trim() : undefined;
+    const distCli = join(dirname(fileURLToPath(import.meta.url)), "cli.js");
+    const argvCli = process.argv[1] && existsSync(resolve(process.argv[1])) ? resolve(process.argv[1]) : "";
+    const cliPath = envCli || (existsSync(distCli) ? distCli : argvCli);
+    if (!cliPath || !isAbsolute(cliPath) || !existsSync(cliPath) || !statSync(cliPath).isFile()) {
+        throw new Error("unable to resolve a safe absolute claudexor CLI entrypoint");
+    }
+    if (!allowTestOverrides && process.env.CLAUDEXOR_CLI_PATH?.trim())
+        warnings.push("ignored CLAUDEXOR_CLI_PATH outside tests");
+    return { home, configDir, nodePath, cliPath, backupStamp: safeTimestamp(), warnings };
+}
+function stateFilePath(configDir = userConfigDir()) {
+    return join(configDir, "plugins", "state.json");
+}
+function emptyState() {
+    return { version: STATE_VERSION, hosts: {} };
+}
+function loadState(configDir = userConfigDir()) {
+    const path = stateFilePath(configDir);
+    const text = readText(path);
+    if (text === null)
+        return emptyState();
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`plugin state is not valid JSON: ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (!parsed || typeof parsed !== "object" || parsed.version !== STATE_VERSION) {
+        throw new Error(`plugin state has unsupported shape: ${path}`);
+    }
+    const state = parsed;
+    state.hosts ??= {};
+    return state;
+}
+function saveState(state, configDir = userConfigDir()) {
+    writeJsonFile(stateFilePath(configDir), state);
+}
+function hostState(state, host) {
+    const existing = state.hosts[host];
+    if (existing) {
+        existing.artifacts ??= {};
+        existing.configEntries ??= {};
+        return existing;
+    }
+    const created = { artifacts: {}, configEntries: {}, updatedAt: new Date().toISOString() };
+    state.hosts[host] = created;
+    return created;
+}
+function hashText(text) {
+    return sha256(text);
+}
+function readText(path) {
+    assertReadableLeaf(path);
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT")
+            return null;
+        throw new Error(`unable to read ${path}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function readJsonFile(path) {
+    const text = readText(path);
+    if (text === null)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        throw new Error(`${path} is not strict JSON: ${err instanceof Error ? err.message : String(err)}`);
+    }
+}
+function writeFile(path, text) {
+    ensureSafeWriteParent(path);
+    assertSafeLeaf(path);
+    writeFileSync(path, text, { encoding: "utf8", mode: 0o600 });
+}
+function writeJsonFile(path, value) {
+    ensureSafeWriteParent(path);
+    assertSafeLeaf(path);
+    writeJson(path, value);
+}
+function nearestExistingAncestor(path) {
+    let current = path;
+    while (!existsSync(current)) {
+        const parent = dirname(current);
+        if (parent === current)
+            throw new Error(`unable to find an existing ancestor for ${path}`);
+        current = parent;
+    }
+    return current;
+}
+function ensureSafeWriteParent(path) {
+    const parent = dirname(path);
+    const existing = nearestExistingAncestor(parent);
+    const root = findManagingRoot(path);
+    if (root) {
+        const rootAnchor = existsSync(root) ? root : nearestExistingAncestor(root);
+        assertExistingDirectoryChain(rootAnchor, existing, path);
+        const realAnchor = realpathSync(rootAnchor);
+        const realExisting = realpathSync(existing);
+        if (!isPathInside(realAnchor, realExisting)) {
+            throw new Error(`${path} resolves outside managed host/config root`);
+        }
+    }
+    else {
+        assertExistingDirectoryChain(existing, existing, path);
+    }
+    ensureDir(parent);
+}
+function assertExistingDirectoryChain(anchor, existing, managedPath) {
+    if (!isPathInside(anchor, existing))
+        throw new Error(`${managedPath} resolves outside managed host/config root`);
+    let current = anchor;
+    const rel = relative(anchor, existing);
+    for (const part of ["", ...rel.split(/[\\/]/).filter(Boolean)]) {
+        if (part)
+            current = join(current, part);
+        const st = lstatSync(current);
+        if (st.isSymbolicLink()) {
+            throw new Error(`${current} is a symlink; refusing to create plugin directories through symlinks`);
+        }
+        if (!st.isDirectory())
+            throw new Error(`${current} is not a directory`);
+    }
+}
+function assertReadableLeaf(path) {
+    try {
+        lstatSync(path);
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT")
+            return;
+        throw err;
+    }
+    const parent = dirname(path);
+    const root = findManagingRoot(path);
+    if (root) {
+        const anchor = existsSync(root) ? root : nearestExistingAncestor(root);
+        assertExistingDirectoryChain(anchor, parent, path);
+        const realParent = realpathSync(parent);
+        const realRoot = realpathSync(root);
+        if (!isPathInside(realRoot, realParent))
+            throw new Error(`${path} resolves outside managed host/config root`);
+    }
+    rejectSymlinkPath(path);
+    if (!lstatSync(path).isFile())
+        throw new Error(`${path} is not a regular file`);
+}
+function rejectSymlinkPath(path) {
+    let st;
+    try {
+        st = lstatSync(path);
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT")
+            return;
+        throw err;
+    }
+    if (st.isSymbolicLink())
+        throw new Error(`${path} is a symlink; refusing to manage plugin files through symlinks`);
+}
+function assertSafeLeaf(path) {
+    const parent = dirname(path);
+    const realParent = realpathSync(parent);
+    const root = findManagingRoot(path);
+    if (root && !isPathInside(realpathSync(root), realParent)) {
+        throw new Error(`${path} resolves outside managed host/config root`);
+    }
+    rejectSymlinkPath(path);
+    try {
+        const st = lstatSync(path);
+        if (!st.isFile())
+            throw new Error(`${path} is not a regular file`);
+    }
+    catch (err) {
+        if (err && typeof err === "object" && "code" in err && err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
+function findManagingRoot(path) {
+    const home = userHomeDir();
+    const stateRoot = dirname(stateFilePath());
+    if (isPathInside(stateRoot, path))
+        return stateRoot;
+    for (const host of PLUGIN_HOSTS) {
+        const root = HOST_DEFINITIONS[host].root(home);
+        if (isPathInside(root, path))
+            return root;
+    }
+    return isPathInside(home, path) ? home : null;
+}
+function listTreeEntries(root) {
+    if (!existsSync(root))
+        return [];
+    if (lstatSync(root).isSymbolicLink())
+        throw new Error(`${root} is a symlink; refusing recursive plugin cleanup`);
+    const out = [];
+    const walk = (dir) => {
+        for (const name of readdirSync(dir)) {
+            const path = join(dir, name);
+            const rel = relative(root, path);
+            const st = lstatSync(path);
+            if (st.isSymbolicLink())
+                throw new Error(`${path} is a symlink; refusing recursive plugin cleanup`);
+            if (st.isDirectory()) {
+                out.push({ rel, kind: "dir" });
+                walk(path);
+            }
+            else if (st.isFile()) {
+                out.push({ rel, kind: "file" });
+            }
+            else {
+                out.push({ rel, kind: "other" });
+            }
+        }
+    };
+    walk(root);
+    return out.sort((a, b) => a.rel.localeCompare(b.rel));
+}
+function expectedLegacyDirs(files) {
+    const dirs = new Set();
+    for (const file of files) {
+        let dir = dirname(file);
+        while (dir && dir !== ".") {
+            dirs.add(dir);
+            dir = dirname(dir);
+        }
+    }
+    return dirs;
+}
+function assertLegacyTargetInRoot(target) {
+    assertExistingDirectoryChain(target.root, target.path, target.path);
+    const root = realpathSync(target.root);
+    const path = realpathSync(target.path);
+    if (!isPathInside(root, path))
+        throw new Error(`${target.path} resolves outside ${target.root}; refusing legacy cleanup`);
+}
+function isOldThinShimManifest(text) {
+    try {
+        const obj = JSON.parse(text);
+        const keys = Object.keys(obj).sort();
+        return (keys.join(",") === "description,name,version" &&
+            obj.name === "claudexor" &&
+            typeof obj.version === "string" &&
+            obj.description === "Claudexor control plane (thin shim)");
+    }
+    catch {
+        return false;
+    }
+}
+const OLD_LEGACY_THIN_SHIM = `Use the local \`claudexor\` CLI for harness-agnostic, evidence-driven coding.
+It orchestrates Codex/Claude/Cursor/OpenCode with best-of-n tournaments,
+cross-family review, and budget balancing. Prefer it for multi-harness work.
+
+- \`claudexor ask "<question>"\`        read-only answer/explanation
+- \`claudexor explore "<question>"\`    read-only exploration/synthesis
+- \`claudexor run "<task>"\`            Agent run (native parity + artifacts)
+- \`claudexor race "<task>" --n 4\`     Best-of-N tournament + cross-family review
+- \`claudexor plan "<task>"\`           read-only plan
+- \`claudexor create "<task>"\`         create a new project
+- \`claudexor inspect <run_id>\`        inspect artifacts under .claudexor/runs
+
+These plugins are thin shims: they call the local CLI; all orchestration lives in claudexor.`;
+const OLD_LEGACY_CLAUDE_COMMAND = `---
+description: Run Claudexor
+---
+${OLD_LEGACY_THIN_SHIM}
+`;
+const OLD_LEGACY_CURSOR_COMMAND = `---
+name: claudexor
+description: Run Claudexor
+---
+${OLD_LEGACY_THIN_SHIM}
+`;
+function exactLegacyText(text, expected) {
+    return text === expected || (expected.endsWith("\n") && text === expected.slice(0, -1));
+}
+function legacyThinShimVerifier(file, text) {
+    if (file.endsWith("plugin.json"))
+        return isOldThinShimManifest(text);
+    if (file === "commands/claudexor.md") {
+        return exactLegacyText(text, OLD_LEGACY_CLAUDE_COMMAND) || exactLegacyText(text, OLD_LEGACY_CURSOR_COMMAND);
+    }
+    return false;
+}
+function legacyCodexSkillVerifier(file, text) {
+    const expected = "---\nname: claudexor\ndescription: Harness-agnostic coding via the claudexor CLI\n---\n";
+    return file === "SKILL.md" && exactLegacyText(text, expected);
+}
+function legacyOpenCodeAgentVerifier(file, text) {
+    const expected = "These plugins are thin shims\nHarness-agnostic coding via the claudexor CLI\n";
+    return file === "AGENTS.md" && exactLegacyText(text, expected);
+}
+function isLegacyOwned(target) {
+    if (!existsSync(target.path))
+        return false;
+    assertLegacyTargetInRoot(target);
+    const entries = listTreeEntries(target.path);
+    const files = entries.filter((e) => e.kind === "file").map((e) => e.rel);
+    if (files.length === 0)
+        return false;
+    const expected = new Set(target.expectedFiles);
+    const expectedDirs = expectedLegacyDirs(target.expectedFiles);
+    if (entries.some((e) => e.kind === "other"))
+        return false;
+    if (entries.some((e) => e.kind === "dir" && !expectedDirs.has(e.rel)))
+        return false;
+    if (files.length !== expected.size || files.some((f) => !expected.has(f)))
+        return false;
+    return files.every((f) => {
+        const text = readText(join(target.path, f));
+        if (text === null)
+            return false;
+        return target.verifier(f, text);
+    });
+}
+function backupRoot(def, runtime) {
+    return join(def.root(runtime.home), ".claudexor-backups", runtime.backupStamp);
+}
+function safeTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-");
+}
+function backupFile(def, runtime, path) {
+    assertSafeLeaf(path);
+    const dest = join(backupRoot(def, runtime), relative(runtime.home, path));
+    ensureSafeWriteParent(dest);
+    assertSafeLeaf(dest);
+    copyFileSync(path, dest);
+    return dest;
+}
+function hasManagedMarker(text) {
+    return text.includes(MARKER) || text.includes('"marker": "claudexor:managed host-plugin-lifecycle"');
+}
+function artifactOwned(state, host, artifact, current, force) {
+    const entry = state.hosts[host]?.artifacts[artifact.path];
+    return entry?.hash === hashText(current) || (entry !== undefined && hasManagedMarker(current)) || current === artifact.content || (force && hasManagedMarker(current));
+}
+function isPathInside(root, path) {
+    const rel = relative(root, path);
+    return rel === "" || (!rel.startsWith("..") && !isAbsolute(rel));
+}
+function recordArtifact(state, host, artifact) {
+    const hs = hostState(state, host);
+    hs.artifacts[artifact.path] = {
+        host,
+        path: artifact.path,
+        hash: hashText(artifact.content),
+        description: artifact.description,
+        updatedAt: new Date().toISOString(),
+    };
+    hs.updatedAt = new Date().toISOString();
+}
+function recordConfig(state, host, path, key, value) {
+    const hs = hostState(state, host);
+    hs.configEntries[key] = {
+        host,
+        path,
+        key,
+        hash: hashText(jsonText(value)),
+        updatedAt: new Date().toISOString(),
+    };
+    hs.updatedAt = new Date().toISOString();
+}
+function desiredCodexMarketplaceEntry() {
+    return {
+        name: "claudexor",
+        source: { source: "local", path: "./.codex/plugins/claudexor" },
+        policy: { installation: "AVAILABLE", authentication: "ON_INSTALL" },
+        category: "Productivity",
+        interface: {
+            displayName: "Claudexor",
+            description: "Harness-agnostic coding through the local Claudexor CLI and MCP server.",
+        },
+        claudexor: { managed: true, marker: MARKER, version: CLAUDEXOR_VERSION },
+    };
+}
+function validateConfigEntry(stateEntry, host, path, key, res) {
+    if (!stateEntry)
+        return true;
+    if (stateEntry.host === host && stateEntry.path === path && stateEntry.key === key)
+        return true;
+    res.errors.push(`${stateFilePath()} contains out-of-scope ${host} config state for ${key}; remove that state entry or clean it manually`);
+    return false;
+}
+function configEntryOwned(stateEntry, current, desired, force, requireState = false) {
+    if (requireState && !stateEntry)
+        return false;
+    const currentText = JSON.stringify(current);
+    const hasMarker = currentText.includes(MARKER);
+    const exactMarkedDesired = !requireState && hasMarker && jsonText(current) === jsonText(desired);
+    return stateEntry?.hash === hashText(jsonText(current)) || exactMarkedDesired || (stateEntry !== undefined && hasMarker) || (force && hasMarker);
+}
+function codexMarketplaceEntries(plugins) {
+    return plugins
+        .map((value, index) => ({ index, value }))
+        .filter(({ value }) => value && typeof value === "object" && value.name === "claudexor");
+}
+function mergeCodexMarketplace(state, dryRun, force, def, runtime, res) {
+    const path = join(userHomeDir(), ".agents", "plugins", "marketplace.json");
+    const desired = desiredCodexMarketplaceEntry();
+    const parsed = readJsonFile(path);
+    const base = parsed === undefined ? { name: "personal", interface: { displayName: "Personal" }, plugins: [] } : parsed;
+    if (!base || typeof base !== "object" || !Array.isArray(base.plugins)) {
+        res.errors.push(`${path} is not a Codex marketplace JSON object with plugins[]`);
+        return false;
+    }
+    const obj = base;
+    const matches = codexMarketplaceEntries(obj.plugins);
+    if (matches.length > 0) {
+        const stateEntry = state.hosts.codex?.configEntries["codex-marketplace"];
+        if (!validateConfigEntry(stateEntry, "codex", path, "codex-marketplace", res))
+            return false;
+        if (matches.some(({ value }) => !configEntryOwned(stateEntry, value, desired, force))) {
+            res.errors.push(`${path} already has an unowned claudexor marketplace entry`);
+            return false;
+        }
+        if (matches.length === 1 && jsonText(matches[0]?.value) === jsonText(desired)) {
+            recordConfig(state, "codex", path, "codex-marketplace", desired);
+            return true;
+        }
+        const insertAt = matches[0]?.index ?? obj.plugins.length;
+        obj.plugins = obj.plugins.filter((p) => !(p && typeof p === "object" && p.name === "claudexor"));
+        obj.plugins.splice(insertAt, 0, desired);
+    }
+    else {
+        obj.plugins.push(desired);
+    }
+    if (!dryRun) {
+        if (existsSync(path)) {
+            const b = backupFile(def, runtime, path);
+            res.notes.push(`backed up marketplace to ${b}`);
+        }
+        writeJsonFile(path, obj);
+        recordConfig(state, "codex", path, "codex-marketplace", desired);
+    }
+    res.changed = true;
+    res.actions.push(`${dryRun ? "would update" : "updated"} Codex personal marketplace`);
+    return true;
+}
+function chooseOpenCodeConfigPath() {
+    const root = join(userHomeDir(), ".config", "opencode");
+    const json = join(root, "opencode.json");
+    const jsonc = join(root, "opencode.jsonc");
+    if (existsSync(json))
+        return json;
+    if (existsSync(jsonc))
+        return jsonc;
+    return json;
+}
+function openCodeConfigObject(path, parsed, res) {
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        res.errors.push(`${path} is not an OpenCode JSON config object`);
+        return null;
+    }
+    const obj = parsed;
+    if (obj.mcp === undefined)
+        obj.mcp = {};
+    if (!obj.mcp || typeof obj.mcp !== "object" || Array.isArray(obj.mcp)) {
+        res.errors.push(`${path} has a non-object mcp field`);
+        return null;
+    }
+    return { obj, mcp: obj.mcp };
+}
+function mergeOpenCodeMcp(state, dryRun, force, def, runtime, res) {
+    const path = chooseOpenCodeConfigPath();
+    const desired = opencodeMcpEntry(runtime);
+    const parsed = readJsonFile(path);
+    const base = parsed === undefined ? { $schema: "https://opencode.ai/config.json", mcp: {} } : parsed;
+    const validated = openCodeConfigObject(path, base, res);
+    if (!validated)
+        return false;
+    const { obj, mcp } = validated;
+    const current = mcp[MCP_NAME];
+    if (current !== undefined) {
+        const stateEntry = state.hosts.opencode?.configEntries["opencode-mcp"];
+        if (!validateConfigEntry(stateEntry, "opencode", path, "opencode-mcp", res))
+            return false;
+        const owned = configEntryOwned(stateEntry, current, desired, force);
+        if (!owned) {
+            res.errors.push(`${path} already has an unowned mcp.claudexor entry`);
+            return false;
+        }
+        if (jsonText(current) === jsonText(desired)) {
+            recordConfig(state, "opencode", path, "opencode-mcp", desired);
+            return true;
+        }
+    }
+    mcp[MCP_NAME] = desired;
+    if (!dryRun) {
+        if (existsSync(path)) {
+            const b = backupFile(def, runtime, path);
+            res.notes.push(`backed up OpenCode config to ${b}`);
+        }
+        writeJsonFile(path, obj);
+        recordConfig(state, "opencode", path, "opencode-mcp", desired);
+    }
+    res.changed = true;
+    res.actions.push(`${dryRun ? "would update" : "updated"} OpenCode MCP config`);
+    return true;
+}
+function checkConfig(host, state, res, runtime) {
+    if (host === "codex") {
+        const path = join(userHomeDir(), ".agents", "plugins", "marketplace.json");
+        const parsed = readJsonFile(path);
+        if (parsed === undefined) {
+            res.notes.push("Codex personal marketplace is missing");
+            return false;
+        }
+        const desired = desiredCodexMarketplaceEntry();
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.plugins)) {
+            res.errors.push(`${path} is not a Codex marketplace JSON object with plugins[]`);
+            return false;
+        }
+        const plugins = parsed.plugins;
+        const matches = codexMarketplaceEntries(plugins);
+        const stateEntry = state.hosts.codex?.configEntries["codex-marketplace"];
+        if (!validateConfigEntry(stateEntry, "codex", path, "codex-marketplace", res))
+            return false;
+        if (matches.length === 1 && jsonText(matches[0]?.value) === jsonText(desired)) {
+            recordConfig(state, "codex", path, "codex-marketplace", desired);
+            return true;
+        }
+        if (matches.some(({ value }) => !configEntryOwned(stateEntry, value, desired, false))) {
+            res.errors.push(`${path} has an unowned claudexor marketplace entry`);
+            return false;
+        }
+        res.notes.push(matches.length > 0 ? "Codex marketplace entry is drifted" : "Codex marketplace entry is missing");
+        return false;
+    }
+    if (host === "opencode") {
+        const path = chooseOpenCodeConfigPath();
+        const parsed = readJsonFile(path);
+        if (parsed === undefined) {
+            res.notes.push("OpenCode config is missing");
+            return false;
+        }
+        const validated = openCodeConfigObject(path, parsed, res);
+        if (!validated)
+            return false;
+        const current = validated.mcp[MCP_NAME];
+        const desired = opencodeMcpEntry(runtime);
+        const stateEntry = state.hosts.opencode?.configEntries["opencode-mcp"];
+        if (!validateConfigEntry(stateEntry, "opencode", path, "opencode-mcp", res))
+            return false;
+        if (current !== undefined && !configEntryOwned(stateEntry, current, desired, false)) {
+            res.errors.push(`${path} has an unowned mcp.claudexor entry`);
+            return false;
+        }
+        if (jsonText(current) === jsonText(desired)) {
+            recordConfig(state, "opencode", path, "opencode-mcp", desired);
+            return true;
+        }
+        res.notes.push(current !== undefined ? "OpenCode MCP entry is drifted" : "OpenCode MCP entry is missing");
+        return false;
+    }
+    if (host === "cursor") {
+        const ideState = join(userHomeDir(), ".cursor", "ide_state.json");
+        if (existsSync(ideState)) {
+            try {
+                readJsonFile(ideState);
+                res.notes.push("Cursor JSON state detected and parseable; no SQLite/binary enablement was touched");
+            }
+            catch (err) {
+                res.warnings.push(`Cursor JSON state was not parseable and was not changed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            res.notes.push("Cursor plugin files are managed directly; no stable JSON registration file was found");
+        }
+    }
+    return true;
+}
+function removeConfig(host, state, dryRun, force, def, runtime, res) {
+    if (host === "codex") {
+        const path = join(userHomeDir(), ".agents", "plugins", "marketplace.json");
+        const parsed = readJsonFile(path);
+        if (parsed === undefined)
+            return true;
+        if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed.plugins)) {
+            res.errors.push(`${path} is not a Codex marketplace JSON object with plugins[]`);
+            return false;
+        }
+        const obj = parsed;
+        const stateEntry = state.hosts.codex?.configEntries["codex-marketplace"];
+        if (!validateConfigEntry(stateEntry, "codex", path, "codex-marketplace", res))
+            return false;
+        const matches = codexMarketplaceEntries(obj.plugins);
+        if (matches.length === 0)
+            return true;
+        if (matches.some(({ value }) => !configEntryOwned(stateEntry, value, desiredCodexMarketplaceEntry(), force, true))) {
+            res.errors.push(`${path} has an unowned claudexor marketplace entry`);
+            return false;
+        }
+        obj.plugins = obj.plugins.filter((p) => !(p && typeof p === "object" && p.name === "claudexor"));
+        if (!dryRun) {
+            const b = backupFile(def, runtime, path);
+            res.notes.push(`backed up marketplace to ${b}`);
+            writeJsonFile(path, obj);
+            delete hostState(state, "codex").configEntries["codex-marketplace"];
+        }
+        res.changed = true;
+        res.actions.push(`${dryRun ? "would remove" : "removed"} Codex marketplace entry`);
+    }
+    if (host === "opencode") {
+        const path = chooseOpenCodeConfigPath();
+        const parsed = readJsonFile(path);
+        if (parsed === undefined)
+            return true;
+        const validated = openCodeConfigObject(path, parsed, res);
+        if (!validated)
+            return false;
+        const { obj, mcp } = validated;
+        const current = mcp[MCP_NAME];
+        if (current === undefined)
+            return true;
+        const stateEntry = state.hosts.opencode?.configEntries["opencode-mcp"];
+        if (!validateConfigEntry(stateEntry, "opencode", path, "opencode-mcp", res))
+            return false;
+        const owned = configEntryOwned(stateEntry, current, opencodeMcpEntry(runtime), force, true);
+        if (!owned) {
+            res.errors.push(`${path} has an unowned mcp.claudexor entry`);
+            return false;
+        }
+        if (!dryRun) {
+            const b = backupFile(def, runtime, path);
+            res.notes.push(`backed up OpenCode config to ${b}`);
+            delete mcp[MCP_NAME];
+            writeJsonFile(path, obj);
+            delete hostState(state, "opencode").configEntries["opencode-mcp"];
+        }
+        res.changed = true;
+        res.actions.push(`${dryRun ? "would remove" : "removed"} OpenCode MCP entry`);
+    }
+    return true;
+}
+function checkArtifacts(def, artifacts, state, res) {
+    let all = true;
+    let any = false;
+    let drift = false;
+    let blocked = false;
+    for (const artifact of artifacts) {
+        const current = readText(artifact.path);
+        if (current === null) {
+            all = false;
+            continue;
+        }
+        any = true;
+        if (current === artifact.content) {
+            recordArtifact(state, def.host, artifact);
+            continue;
+        }
+        all = false;
+        if (artifactOwned(state, def.host, artifact, current, false)) {
+            drift = true;
+            res.notes.push(`${artifact.description} is drifted`);
+        }
+        else {
+            blocked = true;
+            res.errors.push(`${artifact.path} exists and is not Claudexor-owned`);
+        }
+    }
+    return { all, any, drift, blocked };
+}
+function applyArtifacts(def, artifacts, state, dryRun, force, runtime, res) {
+    for (const artifact of artifacts) {
+        const current = readText(artifact.path);
+        if (current === artifact.content) {
+            recordArtifact(state, def.host, artifact);
+            continue;
+        }
+        if (current !== null && !artifactOwned(state, def.host, artifact, current, force)) {
+            res.errors.push(`${artifact.path} exists and is not Claudexor-owned`);
+            return false;
+        }
+        if (!dryRun) {
+            if (current !== null) {
+                const b = backupFile(def, runtime, artifact.path);
+                res.notes.push(`backed up ${artifact.description} to ${b}`);
+            }
+            writeFile(artifact.path, artifact.content);
+            recordArtifact(state, def.host, artifact);
+        }
+        res.changed = true;
+        res.actions.push(`${dryRun ? "would write" : "wrote"} ${artifact.description}`);
+    }
+    return true;
+}
+function obsoleteArtifactRoots(host, home) {
+    switch (host) {
+        case "claude":
+            return [join(home, ".claude", "skills", "claudexor"), join(home, ".claude", "plugins", "claudexor")];
+        case "codex":
+            return [join(home, ".codex", "plugins", "claudexor"), join(home, ".agents", "skills", "claudexor")];
+        case "cursor":
+            return [join(home, ".cursor", "plugins", "local", "claudexor")];
+        case "opencode":
+            return [join(home, ".config", "opencode", "skills", "claudexor"), join(home, ".config", "opencode", "claudexor")];
+    }
+}
+function artifactStatePathAllowed(def, artifacts, path) {
+    if (artifacts.some((a) => a.path === path))
+        return true;
+    return obsoleteArtifactRoots(def.host, userHomeDir()).some((root) => isPathInside(root, path));
+}
+function removeObsoleteStateArtifacts(def, artifacts, state, dryRun, _force, res) {
+    const hs = hostState(state, def.host);
+    const allowed = new Set(artifacts.map((a) => a.path));
+    for (const [path, entry] of Object.entries(hs.artifacts)) {
+        if (entry.host !== def.host || entry.path !== path || !artifactStatePathAllowed(def, artifacts, path)) {
+            res.errors.push(`${stateFilePath()} contains out-of-scope ${def.host} artifact state for ${path}; remove that state entry or clean it manually`);
+            return false;
+        }
+        if (allowed.has(path))
+            continue;
+        const current = readText(path);
+        if (current === null) {
+            delete hs.artifacts[path];
+            continue;
+        }
+        const owned = entry.hash === hashText(current);
+        if (!owned) {
+            res.errors.push(`${path} is obsolete Claudexor state but no longer matches ownership evidence`);
+            return false;
+        }
+        if (!dryRun) {
+            rmSync(path, { force: true });
+            delete hs.artifacts[path];
+        }
+        res.changed = true;
+        res.actions.push(`${dryRun ? "would remove" : "removed"} obsolete Claudexor artifact ${path}`);
+    }
+    return true;
+}
+function removeArtifacts(def, artifacts, state, dryRun, force, res) {
+    if (!removeObsoleteStateArtifacts(def, artifacts, state, dryRun, force, res))
+        return false;
+    const hs = hostState(state, def.host);
+    const paths = artifacts.map((a) => a.path).sort((a, b) => b.length - a.length);
+    for (const path of paths) {
+        const current = readText(path);
+        if (current === null) {
+            delete hs.artifacts[path];
+            continue;
+        }
+        const desired = artifacts.find((a) => a.path === path);
+        const owned = hs.artifacts[path]?.hash === hashText(current) || current === desired?.content || (force && hasManagedMarker(current));
+        if (!owned) {
+            res.errors.push(`${path} exists but no longer matches Claudexor ownership state`);
+            return false;
+        }
+        if (!dryRun) {
+            rmSync(path, { force: true });
+            delete hs.artifacts[path];
+        }
+        res.changed = true;
+        res.actions.push(`${dryRun ? "would remove" : "removed"} ${path}`);
+    }
+    pruneEmptyDirs(def.root(userHomeDir()));
+    return true;
+}
+function pruneEmptyDirs(_root) {
+    // Deliberately conservative: removing files is enough for uninstall; avoid
+    // recursive directory cleanup in user config roots.
+}
+function removeVerifiedLegacy(def, dryRun, res) {
+    for (const legacy of def.legacy(userHomeDir())) {
+        if (!existsSync(legacy.path))
+            continue;
+        if (isLegacyOwned(legacy)) {
+            if (!dryRun)
+                rmSync(legacy.path, { recursive: true, force: true });
+            res.changed = true;
+            res.actions.push(`${dryRun ? "would remove" : "removed"} verified legacy shim ${legacy.path}`);
+            continue;
+        }
+        const entries = listTreeEntries(legacy.path);
+        const files = entries.filter((e) => e.kind === "file").map((e) => e.rel);
+        const hasModernMarker = files.some((f) => readText(join(legacy.path, f))?.includes(MARKER));
+        if (hasModernMarker)
+            continue;
+        const hasLegacyShape = files.some((f) => legacy.expectedFiles.includes(f));
+        if (hasLegacyShape) {
+            res.errors.push(`${legacy.path} looks like a legacy Claudexor path but is not verified as old shim content`);
+            return false;
+        }
+    }
+    return true;
+}
+async function mcpSelfTest(runtime) {
+    return await new Promise((resolve) => {
+        const child = spawn(runtime.nodePath, [runtime.cliPath, "mcp", "serve"], {
+            cwd: process.cwd(),
+            env: mcpSelfTestEnv(runtime),
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let pending = "";
+        const lines = [];
+        let stderr = "";
+        let sentToolsList = false;
+        let settled = false;
+        const timer = setTimeout(() => {
+            settled = true;
+            child.kill("SIGKILL");
+            resolve("MCP self-test timed out");
+        }, 5000);
+        child.stdout.on("data", (d) => {
+            if (settled)
+                return;
+            const chunk = String(d);
+            stdout += chunk;
+            pending += chunk;
+            const frames = pending.split("\n");
+            pending = frames.pop() ?? "";
+            try {
+                for (const frame of frames.filter(Boolean))
+                    lines.push(JSON.parse(frame));
+                const init = lines.find((line) => line && typeof line === "object" && line.id === 1);
+                if (init?.result?.serverInfo?.name && !sentToolsList) {
+                    sentToolsList = true;
+                    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method: "notifications/initialized", params: {} }) + "\n");
+                    child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: 2, method: "tools/list", params: {} }) + "\n");
+                }
+                const tools = lines.find((line) => line && typeof line === "object" && line.id === 2);
+                if (tools && !settled) {
+                    settled = true;
+                    const listed = tools.result?.tools;
+                    clearTimeout(timer);
+                    child.kill("SIGTERM");
+                    if (Array.isArray(listed) && listed.some((t) => t.name === "claudexor_status")) {
+                        resolve(null);
+                    }
+                    else {
+                        resolve("MCP self-test returned an unexpected tools-list response");
+                    }
+                }
+            }
+            catch (err) {
+                if (!settled && stdout.includes("\n")) {
+                    settled = true;
+                    clearTimeout(timer);
+                    child.kill("SIGTERM");
+                    resolve(`MCP self-test response parse failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+        });
+        child.stderr.on("data", (d) => { stderr += String(d); });
+        child.on("error", (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(`MCP self-test failed to start: ${err.message}`);
+        });
+        child.on("exit", (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            if (!stdout)
+                resolve(`MCP self-test exited before response (${code ?? "signal"}): ${stderr.trim()}`);
+            else
+                resolve(`MCP self-test exited before tools-list completed (${code ?? "signal"}): ${stderr.trim()}`);
+        });
+        child.stdin.write(JSON.stringify({
+            jsonrpc: "2.0",
+            id: 1,
+            method: "initialize",
+            params: {
+                protocolVersion: "2025-06-18",
+                capabilities: {},
+                clientInfo: { name: "claudexor-plugin-doctor", version: CLAUDEXOR_VERSION },
+            },
+        }) + "\n");
+    });
+}
+function mcpSelfTestEnv(runtime) {
+    const env = {};
+    for (const key of ["HOME", "PATH", "CLAUDEXOR_CONFIG_DIR", "TMPDIR", "TMP", "TEMP", "LANG", "LC_ALL"]) {
+        const value = process.env[key];
+        if (value)
+            env[key] = value;
+    }
+    Object.assign(env, generatedMcpEnv(runtime));
+    return env;
+}
+function verbNote(def, verb) {
+    if (verb === "uninstall")
+        return `${def.displayName} integration removed from managed Claudexor files/config; restart the host to unload cached plugin state.`;
+    return def.reloadNote;
+}
+function initialResult(def, verb, runtime) {
+    return {
+        host: def.host,
+        state: "missing",
+        ok: false,
+        changed: false,
+        path: def.root(runtime.home),
+        actions: [],
+        notes: [verbNote(def, verb), ...runtime.warnings],
+        warnings: [],
+        errors: [],
+    };
+}
+async function runHost(def, verb, options, state, runtime) {
+    const dryRun = options.dryRun === true;
+    const force = options.force === true;
+    const res = initialResult(def, verb, runtime);
+    const artifacts = def.artifacts(runtime.home, runtime);
+    try {
+        if (verb === "status" || verb === "doctor") {
+            const art = checkArtifacts(def, artifacts, state, res);
+            const configOk = checkConfig(def.host, state, res, runtime);
+            const hasConfig = def.config !== undefined;
+            if (res.errors.length > 0 || art.blocked)
+                res.state = "blocked";
+            else if (art.all && configOk)
+                res.state = def.installState;
+            else if (art.drift)
+                res.state = "drifted";
+            else if (art.any || (hasConfig && configOk))
+                res.state = "partial";
+            else
+                res.state = "missing";
+            if (verb === "doctor" && dryRun && (res.state === "installed" || res.state === "registered")) {
+                res.actions.push("would run MCP initialize/initialized/tools-list self-test");
+            }
+            else if (verb === "doctor" && (res.state === "installed" || res.state === "registered")) {
+                const mcpError = await mcpSelfTest(runtime);
+                if (mcpError) {
+                    res.errors.push(mcpError);
+                    res.state = "blocked";
+                }
+                else {
+                    res.actions.push("MCP initialize/tools-list self-test passed");
+                }
+            }
+            res.ok = res.errors.length === 0 && (res.state === "installed" || res.state === "registered");
+            return res;
+        }
+        if (verb === "uninstall") {
+            if (!removeVerifiedLegacy(def, dryRun, res)) {
+                res.state = "blocked";
+                return res;
+            }
+            if (!removeConfig(def.host, state, dryRun, force, def, runtime, res)) {
+                res.state = "blocked";
+                return res;
+            }
+            if (!removeArtifacts(def, artifacts, state, dryRun, force, res)) {
+                res.state = "blocked";
+                return res;
+            }
+            res.state = "missing";
+            res.ok = res.errors.length === 0;
+            return res;
+        }
+        if (!removeVerifiedLegacy(def, dryRun, res)) {
+            res.state = "blocked";
+            return res;
+        }
+        if (!removeObsoleteStateArtifacts(def, artifacts, state, dryRun, force, res)) {
+            res.state = "blocked";
+            return res;
+        }
+        if (!applyArtifacts(def, artifacts, state, dryRun, force, runtime, res)) {
+            res.state = "blocked";
+            return res;
+        }
+        if (def.config === "codex-marketplace" && !mergeCodexMarketplace(state, dryRun, force, def, runtime, res)) {
+            res.state = "blocked";
+            return res;
+        }
+        if (def.config === "opencode-mcp" && !mergeOpenCodeMcp(state, dryRun, force, def, runtime, res)) {
+            res.state = "blocked";
+            return res;
+        }
+        if (def.host === "cursor")
+            checkConfig("cursor", state, res, runtime);
+        res.state = def.installState;
+        // a dry-run must be legible even when nothing needs doing — otherwise an
+        // already-current host prints only its status and reads as if --dry-run was
+        // ignored. Disclose that the lifecycle was evaluated and found no changes.
+        if (dryRun && res.actions.length === 0) {
+            res.actions.push("no changes needed — Claudexor-owned files and config are already current");
+        }
+        res.ok = res.errors.length === 0;
+        return res;
+    }
+    catch (err) {
+        res.state = "blocked";
+        res.errors.push(err instanceof Error ? err.message : String(err));
+        return res;
+    }
+}
+function targets(target) {
+    return target === "all" ? PLUGIN_HOSTS : [target];
+}
+function exitCodeFor(verb, result) {
+    // `status` reports, but drift/blocked are actionable problems that must be
+    // scriptable: exit 1 so CI/agents can gate on them. Absence states
+    // (missing/partial/installed/registered) stay 0 — not-installed is not an error.
+    if (verb === "status") {
+        return result.results.some((r) => r.state === "drifted" || r.state === "blocked") ? 1 : 0;
+    }
+    return result.results.every((r) => r.ok) ? 0 : 1;
+}
+export async function runPluginCommand(verb, target, options = {}) {
+    if (!PLUGIN_VERBS.includes(verb))
+        throw new Error(`unknown plugin command '${verb}'`);
+    if (!PLUGIN_TARGETS.includes(target))
+        throw new Error(`unknown plugin target '${target}' (expected ${PLUGIN_TARGETS.join("|")})`);
+    const runtime = runtimePaths();
+    const state = loadState(runtime.configDir);
+    const results = [];
+    for (const host of targets(target)) {
+        results.push(await runHost(HOST_DEFINITIONS[host], verb, options, state, runtime));
+    }
+    if (!options.dryRun && (verb === "install" || verb === "repair" || verb === "uninstall"))
+        saveState(state, runtime.configDir);
+    const result = {
+        verb,
+        target,
+        dryRun: options.dryRun === true,
+        results,
+        ok: results.every((r) => r.ok),
+        exitCode: 0,
+    };
+    result.exitCode = exitCodeFor(verb, result);
+    return result;
+}
+export function formatPluginResult(result) {
+    const lines = [];
+    for (const r of result.results) {
+        const marker = r.ok ? "ok" : result.verb === "status" ? "warn" : "blocked";
+        lines.push(`[${marker}] ${r.host}: ${r.state}${r.changed ? " (changed)" : ""}`);
+        for (const action of r.actions)
+            lines.push(`  - ${action}`);
+        for (const note of r.notes)
+            lines.push(`  note: ${note}`);
+        for (const warning of r.warnings)
+            lines.push(`  warning: ${warning}`);
+        for (const error of r.errors)
+            lines.push(`  error: ${error}`);
+    }
+    return lines.join("\n");
+}
+export function pluginCommandErrorResult(verb, target, dryRun, exitCode, error) {
+    return {
+        verb: verb ?? null,
+        target: target ?? null,
+        dryRun,
+        results: [],
+        ok: false,
+        exitCode,
+        error,
+    };
+}
+//# sourceMappingURL=plugins.js.map