@euqns/nudge-mcp 0.15.0 → 1.0.0

package/dist/codex-companion.js

@@ -1,5 +1,5 @@
 import { Codex, } from "@openai/codex-sdk";
-import { spawn, spawnSync } from "node:child_process";
+import { spawn, spawnSync, } from "node:child_process";
 import crypto from "node:crypto";
 import http from "node:http";
 import { createRequire } from "node:module";
@@ -10,6 +10,79 @@ import { NUDGE_MCP_VERSION } from "./version.js";
 const DEFAULT_APP_URL = "https://funjitsu-nudge.vercel.app";
 const DEFAULT_PORT = 47653;
 const MAX_BODY_BYTES = 64 * 1024;
+const PROVIDERS = {
+    codex: {
+        displayName: "Codex",
+        binary: process.platform === "win32" ? "codex.cmd" : "codex",
+        loginCommand: "codex login",
+    },
+    claude: {
+        displayName: "Claude Code",
+        binary: process.platform === "win32" ? "claude.cmd" : "claude",
+        loginCommand: "claude auth login",
+    },
+    cursor: {
+        displayName: "Cursor",
+        binary: process.platform === "win32" ? "cursor-agent.cmd" : "cursor-agent",
+        loginCommand: "cursor-agent login",
+    },
+};
+const CLAUDE_EFFORTS = [
+    {
+        reasoningEffort: "low",
+        description: "Faster responses with lighter reasoning.",
+    },
+    {
+        reasoningEffort: "medium",
+        description: "Balanced reasoning for everyday work.",
+    },
+    {
+        reasoningEffort: "high",
+        description: "More reasoning for difficult tasks.",
+    },
+    {
+        reasoningEffort: "xhigh",
+        description: "Extended reasoning for complex tasks.",
+    },
+    {
+        reasoningEffort: "max",
+        description: "Claude Code's maximum reasoning effort.",
+    },
+];
+const CLAUDE_MODELS = [
+    {
+        model: "default",
+        displayName: "Claude Code default",
+        description: "Use the default model from your Claude Code account.",
+        isDefault: true,
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: CLAUDE_EFFORTS,
+    },
+    {
+        model: "sonnet",
+        displayName: "Sonnet",
+        description: "Claude Code's balanced model alias.",
+        isDefault: false,
+        defaultReasoningEffort: "medium",
+        supportedReasoningEfforts: CLAUDE_EFFORTS,
+    },
+    {
+        model: "opus",
+        displayName: "Opus",
+        description: "Claude Code's most capable model alias.",
+        isDefault: false,
+        defaultReasoningEffort: "high",
+        supportedReasoningEfforts: CLAUDE_EFFORTS,
+    },
+    {
+        model: "haiku",
+        displayName: "Haiku",
+        description: "Claude Code's fastest model alias.",
+        isDefault: false,
+        defaultReasoningEffort: "low",
+        supportedReasoningEfforts: CLAUDE_EFFORTS,
+    },
+];
 const require = createRequire(import.meta.url);
 const REASONING_EFFORTS = new Set([
     "none",
@@ -22,7 +95,8 @@ const REASONING_EFFORTS = new Set([
     "ultra",
 ]);
 function reasoningEffort(value) {
-    return typeof value === "string" && REASONING_EFFORTS.has(value)
+    return typeof value === "string" &&
+        REASONING_EFFORTS.has(value)
         ? value
         : null;
 }
@@ -60,7 +134,10 @@ class CodexMetadataClient {
         });
         this.child = child;
         this.stderr = "";
-        const lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+        const lines = readline.createInterface({
+            input: child.stdout,
+            crlfDelay: Infinity,
+        });
         lines.on("line", (line) => this.handleLine(line));
         child.stderr.on("data", (chunk) => {
             this.stderr = `${this.stderr}${chunk.toString("utf8")}`.slice(-4_000);
@@ -73,7 +150,7 @@ class CodexMetadataClient {
         await this.rawRequest("initialize", {
             clientInfo: {
                 name: "nudge-companion",
-                title: "Nudge Local Codex",
+                title: "Nudge Agent",
                 version: NUDGE_MCP_VERSION,
             },
             capabilities: {
@@ -147,7 +224,9 @@ class CodexMetadataClient {
             .filter((model) => typeof model.model === "string" && model.model.length > 0)
             .map((model) => ({
             model: model.model,
-            displayName: typeof model.displayName === "string" ? model.displayName : model.model,
+            displayName: typeof model.displayName === "string"
+                ? model.displayName
+                : model.model,
             description: typeof model.description === "string" ? model.description : "",
             isDefault: model.isDefault === true,
             defaultReasoningEffort: reasoningEffort(model.defaultReasoningEffort) ?? "medium",
@@ -159,10 +238,14 @@ class CodexMetadataClient {
                     const effort = reasoningEffort(entry.reasoningEffort);
                     if (!effort)
                         return [];
-                    return [{
+                    return [
+                        {
                             reasoningEffort: effort,
-                            description: typeof entry.description === "string" ? entry.description : "",
-                        }];
+                            description: typeof entry.description === "string"
+                                ? entry.description
+                                : "",
+                        },
+                    ];
                 })
                 : [],
         }));
@@ -204,7 +287,7 @@ class CodexMetadataClient {
             currentReasoningEffort: selectedEffort,
             models,
             planType: account.account?.type === "chatgpt"
-                ? account.account.planType ?? null
+                ? (account.account.planType ?? null)
                 : null,
             rateLimits,
             updatedAt: Date.now(),
@@ -227,6 +310,7 @@ function parseArgs(argv) {
     let openBrowserOnStart = true;
     let port = DEFAULT_PORT;
     let portWasExplicit = false;
+    let preferredProvider;
     for (let index = 0; index < argv.length; index++) {
         const arg = argv[index];
         const next = argv[index + 1];
@@ -256,8 +340,22 @@ function parseArgs(argv) {
         else if (arg === "--no-open") {
             openBrowserOnStart = false;
         }
+        else if (arg === "--provider" && next) {
+            if (!(next in PROVIDERS)) {
+                throw new Error("--provider must be codex, claude, or cursor");
+            }
+            preferredProvider = next;
+            index++;
+        }
+        else if (arg.startsWith("--provider=")) {
+            const value = arg.slice("--provider=".length);
+            if (!(value in PROVIDERS)) {
+                throw new Error("--provider must be codex, claude, or cursor");
+            }
+            preferredProvider = value;
+        }
         else {
-            throw new Error(`Unknown codex companion option: ${arg}`);
+            throw new Error(`Unknown agent companion option: ${arg}`);
         }
     }
     if (!Number.isInteger(port) || port < 1024 || port > 65535) {
@@ -269,6 +367,7 @@ function parseArgs(argv) {
         openBrowser: openBrowserOnStart,
         port,
         portWasExplicit,
+        preferredProvider,
     };
 }
 async function listenOnLoopback(server, preferredPort, allowFallback) {
@@ -332,8 +431,10 @@ function writeJson(res, status, value, headers) {
     res.writeHead(status, { ...headers, "Content-Type": "application/json" });
     res.end(JSON.stringify(value));
 }
-function buildPrompt(prompt, context) {
-    const pathname = typeof context?.pathname === "string" ? context.pathname.slice(0, 500) : undefined;
+export function buildCompanionPrompt(prompt, context) {
+    const pathname = typeof context?.pathname === "string"
+        ? context.pathname.slice(0, 500)
+        : undefined;
     const routeContext = pathname
         ? `The user opened this chat from the Nudge route ${JSON.stringify(pathname)}.`
         : "The user opened this chat from Nudge.";
@@ -347,21 +448,62 @@ function buildPrompt(prompt, context) {
                 source: context.boardSource === "cloud" || context.boardSource === "local"
                     ? context.boardSource
                     : undefined,
-                view: typeof context.view === "string" ? context.view.slice(0, 50) : undefined,
+                role: context.boardRole === "owner" ||
+                    context.boardRole === "editor" ||
+                    context.boardRole === "viewer"
+                    ? context.boardRole
+                    : undefined,
+                view: typeof context.view === "string"
+                    ? context.view.slice(0, 50)
+                    : undefined,
                 canvasId: typeof context.canvasId === "string"
                     ? context.canvasId.slice(0, 200)
                     : undefined,
-                cardId: typeof context.cardId === "string" ? context.cardId.slice(0, 200) : undefined,
-                listCount: typeof context.listCount === "number" ? context.listCount : undefined,
-                cardCount: typeof context.cardCount === "number" ? context.cardCount : undefined,
+                cardId: typeof context.cardId === "string"
+                    ? context.cardId.slice(0, 200)
+                    : undefined,
+                cardTitle: typeof context.cardTitle === "string"
+                    ? context.cardTitle.slice(0, 500)
+                    : undefined,
+                cardDescription: typeof context.cardDescription === "string"
+                    ? context.cardDescription.slice(0, 4_000)
+                    : undefined,
+                cardHref: typeof context.cardHref === "string"
+                    ? context.cardHref.slice(0, 1_000)
+                    : undefined,
+                listId: typeof context.listId === "string"
+                    ? context.listId.slice(0, 200)
+                    : undefined,
+                listTitle: typeof context.listTitle === "string"
+                    ? context.listTitle.slice(0, 500)
+                    : undefined,
+                selectionSource: typeof context.selectionSource === "string"
+                    ? context.selectionSource.slice(0, 50)
+                    : undefined,
+                repository: context.repository && typeof context.repository === "object"
+                    ? context.repository
+                    : undefined,
+                listCount: typeof context.listCount === "number"
+                    ? context.listCount
+                    : undefined,
+                cardCount: typeof context.cardCount === "number"
+                    ? context.cardCount
+                    : undefined,
             }),
             "Use this exact board id for Nudge MCP calls unless the user names another board.",
+            context.cardId
+                ? "Treat the selected card as the subject when the user says this task, this card, or it."
+                : "No card is selected; do not guess which card the user means.",
         ]
         : [];
     return [
         routeContext,
         ...boardContext,
         "Use the configured Nudge MCP tools when the request needs board or card data.",
+        "Board mutations use a two-step confirmation workflow. First inspect enough data to show a concise preview naming every item and field that will change. Do not call a write tool until a later user message explicitly confirms that preview. A request such as 'create this' starts the preview; it is not confirmation. After execution, report success and include the returned Nudge link so the result opens in chat.",
+        "Call out deletes, replacement descriptions, membership changes, and terminal status moves as irreversible or potentially disruptive before confirmation. If permissions reject an operation, explain the required board role and offer a retry after access changes.",
+        "Local boards cannot be changed through Nudge MCP, and viewer-role cloud boards are read-only. Explain that permission state before proposing a write and do not attempt the mutation.",
+        "For a coding-agent handoff, use the nudge.agent-handoff/v1 sections: task brief, acceptance criteria, relevant links, repository context, and return path. The format must work for Claude Code, Codex, and Cursor. Runner output should be summarized back to the originating card with add_comment, after the same write preview and confirmation.",
         "Be concise about progress and return a clear final answer for the Nudge chat UI.",
         "The local filesystem is read-only. Nudge MCP tools may update boards when requested; do not claim that local files were changed.",
         "",
@@ -386,13 +528,198 @@ export function assertChatGptLogin() {
         ].join("\n"));
     }
 }
-export function subscriptionEnvironment() {
+export function assertCompanionProvider(provider) {
+    if (provider === "codex") {
+        assertChatGptLogin();
+        return;
+    }
+    const definition = PROVIDERS[provider];
+    const args = provider === "claude" ? ["auth", "status"] : ["status"];
+    const result = spawnSync(definition.binary, args, {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    if (result.error) {
+        throw new Error(`${definition.displayName} CLI was not found. Install it, then run \`${definition.loginCommand}\`.`);
+    }
+    if (result.status !== 0) {
+        const detail = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
+        throw new Error(`${definition.displayName} is not authenticated. Run \`${definition.loginCommand}\`.${detail ? `\nCurrent status: ${detail}` : ""}`);
+    }
+}
+export function validatedCompanionProviders(validate = assertCompanionProvider) {
+    const available = [];
+    const failures = new Map();
+    for (const provider of Object.keys(PROVIDERS)) {
+        try {
+            validate(provider);
+            available.push(provider);
+        }
+        catch (error) {
+            failures.set(provider, error instanceof Error ? error.message : String(error));
+        }
+    }
+    return { available, failures };
+}
+export function subscriptionEnvironment(environment = process.env) {
     const blocked = new Set([
+        "ANTHROPIC_API_KEY",
+        "CURSOR_API_KEY",
         "CODEX_ACCESS_TOKEN",
         "CODEX_API_KEY",
         "OPENAI_API_KEY",
     ]);
-    return Object.fromEntries(Object.entries(process.env).filter((entry) => entry[1] !== undefined && !blocked.has(entry[0])));
+    return Object.fromEntries(Object.entries(environment).filter((entry) => entry[1] !== undefined && !blocked.has(entry[0])));
+}
+function modelDisplayName(model) {
+    if (model === "auto")
+        return "Auto";
+    return model
+        .replace(/[-_]+/g, " ")
+        .replace(/\b\w/g, (letter) => letter.toUpperCase());
+}
+function cursorModel(candidate) {
+    const record = candidate && typeof candidate === "object"
+        ? candidate
+        : null;
+    const rawModel = typeof candidate === "string"
+        ? candidate
+        : typeof record?.model === "string"
+            ? record.model
+            : typeof record?.id === "string"
+                ? record.id
+                : typeof record?.value === "string"
+                    ? record.value
+                    : "";
+    const model = rawModel.trim();
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9._:/\[\]=,-]*$/.test(model))
+        return null;
+    const displayName = typeof record?.displayName === "string"
+        ? record.displayName
+        : typeof record?.name === "string"
+            ? record.name
+            : modelDisplayName(model);
+    return {
+        model,
+        displayName,
+        description: "Available to your Cursor account.",
+        isDefault: record?.isDefault === true || model === "auto",
+        defaultReasoningEffort: "none",
+        supportedReasoningEfforts: [],
+    };
+}
+/** Parse both current line output and future JSON output from Cursor's model command. */
+export function parseCursorModels(output) {
+    const trimmed = output.trim();
+    let candidates = [];
+    if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (Array.isArray(parsed))
+                candidates = parsed;
+            else if (parsed && typeof parsed === "object") {
+                const record = parsed;
+                if (Array.isArray(record.models))
+                    candidates = record.models;
+            }
+        }
+        catch {
+            // Older Cursor releases print one model id per line.
+        }
+    }
+    if (candidates.length === 0) {
+        candidates = output
+            .replace(/\u001b\[[0-9;]*m/g, "")
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter((line) => line.length > 0)
+            .filter((line) => !/^(available\s+)?models?:?$/i.test(line))
+            .map((line) => line
+            .replace(/^[*✓●>•-]\s*/, "")
+            .replace(/\s+\((?:default|current)\)$/i, ""))
+            .map((line) => line.split(/\t|\s{2,}/, 1)[0]);
+    }
+    const models = candidates
+        .map((candidate) => cursorModel(candidate))
+        .filter((model) => model !== null);
+    const deduplicated = Array.from(new Map(models.map((model) => [model.model, model])).values());
+    if (deduplicated.length > 0 &&
+        !deduplicated.some((model) => model.isDefault)) {
+        deduplicated[0] = { ...deduplicated[0], isDefault: true };
+    }
+    return deduplicated;
+}
+function captureCliOutput(command, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            env: subscriptionEnvironment(),
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        const timer = setTimeout(() => child.kill("SIGTERM"), 8_000);
+        child.stdout.on("data", (chunk) => {
+            stdout = `${stdout}${chunk.toString("utf8")}`.slice(-256_000);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = `${stderr}${chunk.toString("utf8")}`.slice(-8_000);
+        });
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                resolve(stdout);
+            else
+                reject(new Error(stderr.trim() || `Model discovery exited ${code}`));
+        });
+    });
+}
+async function subscriptionMetadata(provider, currentModel, currentEffort) {
+    let models;
+    if (provider === "claude") {
+        models = CLAUDE_MODELS;
+    }
+    else {
+        try {
+            models = parseCursorModels(await captureCliOutput(PROVIDERS.cursor.binary, ["--list-models"]));
+        }
+        catch {
+            models = [];
+        }
+        if (models.length === 0) {
+            models = [
+                {
+                    model: "auto",
+                    displayName: "Auto",
+                    description: "Let Cursor choose the best available model.",
+                    isDefault: true,
+                    defaultReasoningEffort: "none",
+                    supportedReasoningEfforts: [],
+                },
+            ];
+        }
+    }
+    const fallback = models.find((model) => model.isDefault) ?? models[0];
+    const selected = models.find((model) => model.model === currentModel) ?? fallback;
+    const effort = selected.supportedReasoningEfforts.some((candidate) => candidate.reasoningEffort === currentEffort)
+        ? currentEffort
+        : selected.defaultReasoningEffort;
+    return {
+        currentModel: selected.model,
+        currentReasoningEffort: effort,
+        models,
+        planType: "subscription",
+        rateLimits: [],
+        updatedAt: Date.now(),
+        provider: { id: provider, displayName: PROVIDERS[provider].displayName },
+        capabilities: {
+            modelSelection: true,
+            effortSelection: provider === "claude",
+        },
+    };
 }
 export function companionMcpTransport() {
     const companionFile = fileURLToPath(import.meta.url);
@@ -432,6 +759,194 @@ export function companionCodexConfig(env) {
         },
     };
 }
+function companionClaudeConfig() {
+    const transport = companionMcpTransport();
+    return JSON.stringify({
+        mcpServers: {
+            nudge: {
+                command: transport.command,
+                args: transport.args,
+            },
+        },
+    });
+}
+export function companionCliInvocation(provider, prompt, threadId, model = null, effort = null) {
+    const definition = PROVIDERS[provider];
+    if (provider === "claude") {
+        return {
+            command: definition.binary,
+            args: [
+                "-p",
+                "--output-format",
+                "stream-json",
+                "--verbose",
+                "--permission-mode",
+                "bypassPermissions",
+                "--disallowedTools",
+                "Edit",
+                "Write",
+                "NotebookEdit",
+                "Bash",
+                "--mcp-config",
+                companionClaudeConfig(),
+                "--strict-mcp-config",
+                ...(model && model !== "default" ? ["--model", model] : []),
+                ...(effort && effort !== "none" ? ["--effort", effort] : []),
+                ...(threadId ? ["--resume", threadId] : []),
+            ],
+            stdin: prompt,
+        };
+    }
+    return {
+        command: definition.binary,
+        args: [
+            "-p",
+            "--mode=ask",
+            "--output-format",
+            "stream-json",
+            ...(model ? ["--model", model] : []),
+            ...(threadId ? ["--resume", threadId] : []),
+            prompt,
+        ],
+        stdin: null,
+    };
+}
+export function companionPairingUrl(appUrl, pairing) {
+    return `${appUrl}/#nudge-agent=${pairing}`;
+}
+function syntheticUsage(usage) {
+    return {
+        input_tokens: typeof usage?.input_tokens === "number" ? usage.input_tokens : 0,
+        cached_input_tokens: typeof usage?.cache_read_input_tokens === "number"
+            ? usage.cache_read_input_tokens
+            : 0,
+        cache_write_input_tokens: typeof usage?.cache_creation_input_tokens === "number"
+            ? usage.cache_creation_input_tokens
+            : 0,
+        output_tokens: typeof usage?.output_tokens === "number" ? usage.output_tokens : 0,
+        reasoning_output_tokens: 0,
+    };
+}
+function cliActivity(provider, event) {
+    if (provider === "cursor" && event.type === "tool_call") {
+        const call = event.tool_call;
+        if (!call || typeof call !== "object")
+            return "Used a Cursor tool";
+        const name = Object.keys(call)[0];
+        return name
+            ? `Used ${name.replace(/ToolCall$/, "")}`
+            : "Used a Cursor tool";
+    }
+    if (provider === "claude" && event.type === "assistant") {
+        const message = event.message;
+        const blocks = Array.isArray(message?.content) ? message.content : [];
+        const tool = blocks.find((block) => !!block &&
+            typeof block === "object" &&
+            block.type === "tool_use");
+        return tool?.name ? `Used ${String(tool.name)}` : null;
+    }
+    return null;
+}
+async function runSubscriptionCliTurn({ provider, prompt, cwd, threadId, model, effort, signal, send, }) {
+    const definition = PROVIDERS[provider];
+    const invocation = companionCliInvocation(provider, prompt, threadId, model, effort);
+    send({ type: "agent", event: { type: "turn.started" } });
+    return await new Promise((resolve, reject) => {
+        const child = spawn(invocation.command, invocation.args, {
+            cwd,
+            stdio: ["pipe", "pipe", "pipe"],
+            env: subscriptionEnvironment(),
+        });
+        let stderr = "";
+        let activeThreadId = threadId;
+        let finalText = "";
+        let usage;
+        const lines = readline.createInterface({
+            input: child.stdout,
+            crlfDelay: Infinity,
+        });
+        lines.on("line", (line) => {
+            if (!line.trim())
+                return;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (typeof event.session_id === "string") {
+                activeThreadId = event.session_id;
+                if (event.type === "system") {
+                    send({
+                        type: "agent",
+                        event: { type: "thread.started", thread_id: activeThreadId },
+                    });
+                }
+            }
+            const activity = cliActivity(provider, event);
+            if (activity) {
+                const id = typeof event.call_id === "string"
+                    ? event.call_id
+                    : `tool-${Date.now().toString(36)}`;
+                send({
+                    type: "agent",
+                    event: {
+                        type: event.subtype === "completed" ? "item.completed" : "item.started",
+                        item: { id, type: "reasoning", text: activity },
+                    },
+                });
+            }
+            if (event.type === "result") {
+                if (typeof event.result === "string")
+                    finalText = event.result;
+                if (event.usage && typeof event.usage === "object") {
+                    usage = event.usage;
+                }
+            }
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr = `${stderr}${chunk.toString("utf8")}`.slice(-8_000);
+        });
+        const onAbort = () => child.kill("SIGTERM");
+        signal.addEventListener("abort", onAbort, { once: true });
+        child.once("error", (error) => {
+            signal.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            signal.removeEventListener("abort", onAbort);
+            if (signal.aborted) {
+                resolve(activeThreadId);
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`${definition.displayName} exited ${code}: ${stderr.trim().slice(-800) || "no error detail"}`));
+                return;
+            }
+            send({
+                type: "agent",
+                event: {
+                    type: "item.completed",
+                    item: {
+                        id: `message-${Date.now().toString(36)}`,
+                        type: "agent_message",
+                        text: finalText,
+                    },
+                },
+            });
+            send({
+                type: "agent",
+                event: { type: "turn.completed", usage: syntheticUsage(usage) },
+            });
+            resolve(activeThreadId);
+        });
+        if (invocation.stdin !== null) {
+            child.stdin.write(invocation.stdin);
+        }
+        child.stdin.end();
+    });
+}
 function companionThreadOptions(cwd, model, effort) {
     return {
         approvalPolicy: "never",
@@ -444,20 +959,59 @@ function companionThreadOptions(cwd, model, effort) {
         modelReasoningEffort: effort,
     };
 }
-export async function runCodexCompanion(argv) {
+const PROVIDER_IDS = Object.keys(PROVIDERS);
+export async function runAgentCompanion(argv) {
     const options = parseArgs(argv);
     const allowedOrigin = new URL(options.appUrl).origin;
     const token = crypto.randomBytes(32).toString("base64url");
-    assertChatGptLogin();
-    const codex = new Codex({
-        config: companionCodexConfig(),
-        env: subscriptionEnvironment(),
-    });
-    const metadataClient = new CodexMetadataClient();
-    let thread = null;
-    let selectedModel = null;
-    let selectedEffort = null;
+    const validation = validatedCompanionProviders();
+    const failures = validation.failures;
+    const runtimes = new Map();
+    for (const id of validation.available) {
+        runtimes.set(id, {
+            id,
+            codex: id === "codex"
+                ? new Codex({
+                    config: companionCodexConfig(),
+                    env: subscriptionEnvironment(),
+                })
+                : null,
+            metadataClient: id === "codex" ? new CodexMetadataClient() : null,
+            thread: null,
+            cliThreadId: null,
+            selectedModel: null,
+            selectedEffort: null,
+        });
+    }
+    if (runtimes.size === 0) {
+        throw new Error([
+            "Nudge Agent could not find an authenticated coding-agent subscription.",
+            ...PROVIDER_IDS.map((id) => `${PROVIDERS[id].displayName}: ${failures.get(id) ?? "unavailable"}`),
+        ].join("\n"));
+    }
+    const defaultProviderId = options.preferredProvider && runtimes.has(options.preferredProvider)
+        ? options.preferredProvider
+        : PROVIDER_IDS.find((id) => runtimes.has(id));
     let activeAbort = null;
+    const providerInfo = (id) => ({
+        id,
+        displayName: PROVIDERS[id].displayName,
+    });
+    const resolveRuntime = (value) => {
+        const id = (value ?? defaultProviderId);
+        return PROVIDER_IDS.includes(id) ? (runtimes.get(id) ?? null) : null;
+    };
+    const readMetadata = async (runtime) => {
+        if (runtime.metadataClient) {
+            const metadata = await runtime.metadataClient.metadata(runtime.selectedModel, runtime.selectedEffort);
+            return {
+                ...metadata,
+                provider: providerInfo(runtime.id),
+                capabilities: { modelSelection: true, effortSelection: true },
+            };
+        }
+        return subscriptionMetadata(runtime.id, runtime.selectedModel, runtime.selectedEffort);
+    };
     const corsHeaders = (origin) => ({
         ...(origin === allowedOrigin
             ? { "Access-Control-Allow-Origin": allowedOrigin }
@@ -473,6 +1027,9 @@ export async function runCodexCompanion(argv) {
         void (async () => {
             const origin = req.headers.origin;
             const headers = corsHeaders(origin);
+            const requestUrl = new URL(req.url ?? "/", "http://127.0.0.1");
+            const runtime = resolveRuntime(requestUrl.searchParams.get("provider"));
+            const provider = runtime ? PROVIDERS[runtime.id] : null;
             if (origin && origin !== allowedOrigin) {
                 writeJson(res, 403, { error: "Origin not allowed" }, headers);
                 return;
@@ -486,36 +1043,44 @@ export async function runCodexCompanion(argv) {
                 writeJson(res, 401, { error: "Invalid companion token" }, headers);
                 return;
             }
-            if (req.method === "GET" && req.url === "/v1/health") {
+            if (!runtime || !provider) {
+                writeJson(res, 400, { error: "That coding-agent subscription is unavailable" }, headers);
+                return;
+            }
+            if (req.method === "GET" && requestUrl.pathname === "/v1/health") {
                 writeJson(res, 200, {
                     ok: true,
                     cwd: options.cwd,
                     running: activeAbort !== null,
-                    threadId: thread?.id ?? null,
-                    model: selectedModel,
-                    effort: selectedEffort,
+                    threadId: runtime.codex
+                        ? (runtime.thread?.id ?? null)
+                        : runtime.cliThreadId,
+                    model: runtime.selectedModel,
+                    effort: runtime.selectedEffort,
+                    provider: providerInfo(runtime.id),
+                    providers: Array.from(runtimes.keys(), providerInfo),
                 }, headers);
                 return;
             }
-            if (req.method === "GET" && req.url === "/v1/metadata") {
+            if (req.method === "GET" && requestUrl.pathname === "/v1/metadata") {
                 try {
-                    const metadata = await metadataClient.metadata(selectedModel, selectedEffort);
-                    selectedModel = metadata.currentModel;
-                    selectedEffort = metadata.currentReasoningEffort;
+                    const metadata = await readMetadata(runtime);
+                    runtime.selectedModel = metadata.currentModel;
+                    runtime.selectedEffort = metadata.currentReasoningEffort;
                     writeJson(res, 200, metadata, headers);
                 }
                 catch (error) {
                     writeJson(res, 503, {
                         error: error instanceof Error
                             ? error.message
-                            : "Codex metadata is unavailable",
+                            : `${provider.displayName} metadata is unavailable`,
                     }, headers);
                 }
                 return;
             }
-            if (req.method === "POST" && req.url === "/v1/model") {
+            if (req.method === "POST" && requestUrl.pathname === "/v1/model") {
                 if (activeAbort) {
-                    writeJson(res, 409, { error: "A Codex turn is still running" }, headers);
+                    writeJson(res, 409, { error: `A ${provider.displayName} turn is still running` }, headers);
                     return;
                 }
                 let parsed;
@@ -527,21 +1092,29 @@ export async function runCodexCompanion(argv) {
                     return;
                 }
                 const model = typeof parsed.model === "string" ? parsed.model.trim() : "";
-                const metadata = await metadataClient.metadata(selectedModel, selectedEffort);
+                const metadata = await readMetadata(runtime);
                 const modelInfo = metadata.models.find((candidate) => candidate.model === model);
                 if (!modelInfo) {
-                    writeJson(res, 400, { error: "That Codex model is unavailable" }, headers);
+                    writeJson(res, 400, { error: `That ${provider.displayName} model is unavailable` }, headers);
                     return;
                 }
-                selectedModel = model;
-                selectedEffort = modelInfo.defaultReasoningEffort;
-                thread = null;
-                writeJson(res, 200, { ok: true, model, effort: selectedEffort }, headers);
+                runtime.selectedModel = model;
+                runtime.selectedEffort = modelInfo.defaultReasoningEffort;
+                runtime.thread = null;
+                runtime.cliThreadId = null;
+                writeJson(res, 200, { ok: true, model, effort: runtime.selectedEffort }, headers);
                 return;
             }
-            if (req.method === "POST" && req.url === "/v1/effort") {
+            if (req.method === "POST" && requestUrl.pathname === "/v1/effort") {
                 if (activeAbort) {
-                    writeJson(res, 409, { error: "A Codex turn is still running" }, headers);
+                    writeJson(res, 409, { error: `A ${provider.displayName} turn is still running` }, headers);
+                    return;
+                }
+                const metadata = await readMetadata(runtime);
+                if (metadata.capabilities?.effortSelection === false) {
+                    writeJson(res, 400, {
+                        error: `${provider.displayName} controls reasoning settings in its own CLI.`,
+                    }, headers);
                     return;
                 }
                 let parsed;
@@ -553,31 +1126,32 @@ export async function runCodexCompanion(argv) {
                     return;
                 }
                 const effort = reasoningEffort(parsed.effort);
-                const metadata = await metadataClient.metadata(selectedModel, selectedEffort);
                 const modelInfo = metadata.models.find((candidate) => candidate.model === metadata.currentModel);
                 if (!effort ||
                     !modelInfo?.supportedReasoningEfforts.some((candidate) => candidate.reasoningEffort === effort)) {
                     writeJson(res, 400, { error: "That reasoning effort is unavailable" }, headers);
                     return;
                 }
-                selectedModel = metadata.currentModel;
-                selectedEffort = effort;
-                thread = null;
-                writeJson(res, 200, { ok: true, model: selectedModel, effort }, headers);
+                runtime.selectedModel = metadata.currentModel;
+                runtime.selectedEffort = effort;
+                runtime.thread = null;
+                runtime.cliThreadId = null;
+                writeJson(res, 200, { ok: true, model: runtime.selectedModel, effort }, headers);
                 return;
             }
-            if (req.method === "POST" && req.url === "/v1/new") {
+            if (req.method === "POST" && requestUrl.pathname === "/v1/new") {
                 if (activeAbort) {
-                    writeJson(res, 409, { error: "A Codex turn is still running" }, headers);
+                    writeJson(res, 409, { error: `A ${provider.displayName} turn is still running` }, headers);
                     return;
                 }
-                thread = null;
+                runtime.thread = null;
+                runtime.cliThreadId = null;
                 writeJson(res, 200, { ok: true }, headers);
                 return;
             }
-            if (req.method === "POST" && req.url === "/v1/resume") {
+            if (req.method === "POST" && requestUrl.pathname === "/v1/resume") {
                 if (activeAbort) {
-                    writeJson(res, 409, { error: "A Codex turn is still running" }, headers);
+                    writeJson(res, 409, { error: `A ${provider.displayName} turn is still running` }, headers);
                     return;
                 }
                 let parsed;
@@ -590,20 +1164,53 @@ export async function runCodexCompanion(argv) {
                 }
                 const threadId = typeof parsed.threadId === "string" ? parsed.threadId.trim() : "";
                 if (!/^[a-zA-Z0-9-]{10,100}$/.test(threadId)) {
-                    writeJson(res, 400, { error: "Invalid Codex thread id" }, headers);
+                    writeJson(res, 400, { error: "Invalid coding-agent session id" }, headers);
+                    return;
+                }
+                if (!runtime.metadataClient || !runtime.codex) {
+                    const metadata = await readMetadata(runtime);
+                    const requestedModel = typeof parsed.model === "string" ? parsed.model.trim() : "";
+                    const requestedEffort = reasoningEffort(parsed.effort);
+                    if (requestedModel &&
+                        !metadata.models.some((candidate) => candidate.model === requestedModel)) {
+                        writeJson(res, 400, { error: `That ${provider.displayName} model is unavailable` }, headers);
+                        return;
+                    }
+                    const nextModel = requestedModel || metadata.currentModel;
+                    const modelInfo = metadata.models.find((candidate) => candidate.model === nextModel);
+                    const cursorDefaultEffort = metadata.capabilities?.effortSelection === false &&
+                        requestedEffort === "none";
+                    if (parsed.effort !== undefined &&
+                        (!requestedEffort ||
+                            (!cursorDefaultEffort &&
+                                !modelInfo?.supportedReasoningEfforts.some((candidate) => candidate.reasoningEffort === requestedEffort)))) {
+                        writeJson(res, 400, { error: "That reasoning effort is unavailable" }, headers);
+                        return;
+                    }
+                    runtime.selectedModel = nextModel;
+                    runtime.selectedEffort =
+                        requestedEffort ?? modelInfo?.defaultReasoningEffort ?? "none";
+                    runtime.cliThreadId = threadId;
+                    writeJson(res, 200, {
+                        ok: true,
+                        threadId,
+                        model: runtime.selectedModel,
+                        effort: runtime.selectedEffort,
+                    }, headers);
                     return;
                 }
                 const requestedModel = typeof parsed.model === "string" ? parsed.model.trim() : "";
                 const requestedEffort = reasoningEffort(parsed.effort);
-                const metadata = await metadataClient.metadata(selectedModel, selectedEffort);
+                const metadata = await runtime.metadataClient.metadata(runtime.selectedModel, runtime.selectedEffort);
                 if (requestedModel) {
                     if (!metadata.models.some((candidate) => candidate.model === requestedModel)) {
                         writeJson(res, 400, { error: "That Codex model is unavailable" }, headers);
                         return;
                     }
-                    selectedModel = requestedModel;
+                    runtime.selectedModel = requestedModel;
                 }
-                const modelInfo = metadata.models.find((candidate) => candidate.model === (selectedModel ?? metadata.currentModel));
+                const modelInfo = metadata.models.find((candidate) => candidate.model ===
+                    (runtime.selectedModel ?? metadata.currentModel));
                 if (parsed.effort !== undefined && !requestedEffort) {
                     writeJson(res, 400, { error: "Invalid reasoning effort" }, headers);
                     return;
@@ -613,22 +1220,28 @@ export async function runCodexCompanion(argv) {
                     writeJson(res, 400, { error: "That reasoning effort is unavailable" }, headers);
                     return;
                 }
-                selectedEffort = requestedEffort ?? modelInfo?.defaultReasoningEffort ?? null;
-                thread = codex.resumeThread(threadId, companionThreadOptions(options.cwd, selectedModel, selectedEffort));
-                writeJson(res, 200, { ok: true, threadId, model: selectedModel, effort: selectedEffort }, headers);
+                runtime.selectedEffort =
+                    requestedEffort ?? modelInfo?.defaultReasoningEffort ?? null;
+                runtime.thread = runtime.codex.resumeThread(threadId, companionThreadOptions(options.cwd, runtime.selectedModel, runtime.selectedEffort));
+                writeJson(res, 200, {
+                    ok: true,
+                    threadId,
+                    model: runtime.selectedModel,
+                    effort: runtime.selectedEffort,
+                }, headers);
                 return;
             }
-            if (req.method === "POST" && req.url === "/v1/cancel") {
+            if (req.method === "POST" && requestUrl.pathname === "/v1/cancel") {
                 activeAbort?.abort();
                 writeJson(res, 200, { ok: true }, headers);
                 return;
             }
-            if (req.method !== "POST" || req.url !== "/v1/chat") {
+            if (req.method !== "POST" || requestUrl.pathname !== "/v1/chat") {
                 writeJson(res, 404, { error: "Not found" }, headers);
                 return;
             }
             if (activeAbort) {
-                writeJson(res, 409, { error: "A Codex turn is already running" }, headers);
+                writeJson(res, 409, { error: `A ${provider.displayName} turn is already running` }, headers);
                 return;
             }
             let parsed;
@@ -644,7 +1257,9 @@ export async function runCodexCompanion(argv) {
                 writeJson(res, 400, { error: "prompt is required" }, headers);
                 return;
             }
-            thread ??= codex.startThread(companionThreadOptions(options.cwd, selectedModel, selectedEffort));
+            if (runtime.codex) {
+                runtime.thread ??= runtime.codex.startThread(companionThreadOptions(options.cwd, runtime.selectedModel, runtime.selectedEffort));
+            }
             const abort = new AbortController();
             activeAbort = abort;
             let responseFinished = false;
@@ -662,14 +1277,41 @@ export async function runCodexCompanion(argv) {
                     res.write(`${JSON.stringify(value)}\n`);
             };
             try {
-                send({ type: "connected", cwd: options.cwd, threadId: thread.id });
-                const streamed = await thread.runStreamed(buildPrompt(prompt, parsed.context), {
-                    signal: abort.signal,
+                const currentThreadId = runtime.codex
+                    ? (runtime.thread?.id ?? null)
+                    : runtime.cliThreadId;
+                send({
+                    type: "connected",
+                    cwd: options.cwd,
+                    threadId: currentThreadId,
                 });
-                for await (const event of streamed.events) {
-                    send({ type: "codex", event: event });
+                const contextualPrompt = buildCompanionPrompt(prompt, parsed.context);
+                if (runtime.codex && runtime.thread) {
+                    const streamed = await runtime.thread.runStreamed(contextualPrompt, {
+                        signal: abort.signal,
+                    });
+                    for await (const event of streamed.events) {
+                        send({ type: "agent", event: event });
+                    }
                 }
-                send({ type: "done", threadId: thread.id });
+                else {
+                    runtime.cliThreadId = await runSubscriptionCliTurn({
+                        provider: runtime.id,
+                        prompt: contextualPrompt,
+                        cwd: options.cwd,
+                        threadId: runtime.cliThreadId,
+                        model: runtime.selectedModel,
+                        effort: runtime.selectedEffort,
+                        signal: abort.signal,
+                        send,
+                    });
+                }
+                send({
+                    type: "done",
+                    threadId: runtime.codex
+                        ? (runtime.thread?.id ?? null)
+                        : runtime.cliThreadId,
+                });
             }
             catch (error) {
                 send({
@@ -692,10 +1334,16 @@ export async function runCodexCompanion(argv) {
         });
     });
     const port = await listenOnLoopback(server, options.port, !options.portWasExplicit);
-    const pairing = Buffer.from(JSON.stringify({ port, token }), "utf8").toString("base64url");
-    const url = `${options.appUrl}/#nudge-codex=${pairing}`;
+    const pairing = Buffer.from(JSON.stringify({
+        port,
+        token,
+        provider: providerInfo(defaultProviderId),
+        providers: Array.from(runtimes.keys(), providerInfo),
+    }), "utf8").toString("base64url");
+    const url = companionPairingUrl(options.appUrl, pairing);
     console.log("");
-    console.log("Nudge Codex companion is running");
+    console.log("Nudge Agent companion is running");
+    console.log(`  Agents:    ${Array.from(runtimes.keys(), (id) => PROVIDERS[id].displayName).join(", ")}`);
     console.log(`  App:       ${options.appUrl}`);
     console.log(`  Workspace: ${options.cwd}`);
     console.log(`  Listener:  http://127.0.0.1:${port}`);
@@ -704,7 +1352,15 @@ export async function runCodexCompanion(argv) {
     }
     console.log("  Files:     read-only");
     console.log("");
-    console.log("Codex will reuse the account from `codex login`.");
+    for (const id of PROVIDER_IDS) {
+        const definition = PROVIDERS[id];
+        if (runtimes.has(id)) {
+            console.log(`  ready       ${definition.displayName} — reusing \`${definition.loginCommand}\``);
+        }
+        else {
+            console.log(`  unavailable ${definition.displayName} — ${failures.get(id) ?? "not found"}`);
+        }
+    }
     console.log("Keep this terminal open while using Nudge chat.");
     console.log("");
     if (options.openBrowser)
@@ -714,11 +1370,16 @@ export async function runCodexCompanion(argv) {
     await new Promise((resolve) => {
         const shutdown = () => {
             activeAbort?.abort();
-            metadataClient.stop();
+            for (const runtime of runtimes.values())
+                runtime.metadataClient?.stop();
             server.close(() => resolve());
         };
         process.once("SIGINT", shutdown);
         process.once("SIGTERM", shutdown);
     });
 }
+/** Backward-compatible alias for the original Codex-only command. */
+export async function runCodexCompanion(argv) {
+    await runAgentCompanion(["--provider", "codex", ...argv]);
+}
 //# sourceMappingURL=codex-companion.js.map