@euqns/nudge-mcp 0.16.0 → 1.1.0

package/dist/codex-companion.js

@@ -1,8 +1,10 @@
 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 { readdir, realpath, stat } from "node:fs/promises";
 import http from "node:http";
 import { createRequire } from "node:module";
+import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
 import { fileURLToPath } from "node:url";
@@ -27,6 +29,62 @@ const PROVIDERS = {
         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",
@@ -39,7 +97,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;
 }
@@ -77,7 +136,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);
@@ -164,7 +226,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",
@@ -176,10 +240,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
+                                : "",
+                        },
+                    ];
                 })
                 : [],
         }));
@@ -221,7 +289,7 @@ class CodexMetadataClient {
             currentReasoningEffort: selectedEffort,
             models,
             planType: account.account?.type === "chatgpt"
-                ? account.account.planType ?? null
+                ? (account.account.planType ?? null)
                 : null,
             rateLimits,
             updatedAt: Date.now(),
@@ -244,7 +312,7 @@ function parseArgs(argv) {
     let openBrowserOnStart = true;
     let port = DEFAULT_PORT;
     let portWasExplicit = false;
-    let provider = "codex";
+    let preferredProvider;
     for (let index = 0; index < argv.length; index++) {
         const arg = argv[index];
         const next = argv[index + 1];
@@ -278,7 +346,7 @@ function parseArgs(argv) {
             if (!(next in PROVIDERS)) {
                 throw new Error("--provider must be codex, claude, or cursor");
             }
-            provider = next;
+            preferredProvider = next;
             index++;
         }
         else if (arg.startsWith("--provider=")) {
@@ -286,7 +354,7 @@ function parseArgs(argv) {
             if (!(value in PROVIDERS)) {
                 throw new Error("--provider must be codex, claude, or cursor");
             }
-            provider = value;
+            preferredProvider = value;
         }
         else {
             throw new Error(`Unknown agent companion option: ${arg}`);
@@ -301,7 +369,7 @@ function parseArgs(argv) {
         openBrowser: openBrowserOnStart,
         port,
         portWasExplicit,
-        provider,
+        preferredProvider,
     };
 }
 async function listenOnLoopback(server, preferredPort, allowFallback) {
@@ -365,8 +433,44 @@ function writeJson(res, status, value, headers) {
     res.writeHead(status, { ...headers, "Content-Type": "application/json" });
     res.end(JSON.stringify(value));
 }
+export function resolveCompanionWorkspacePath(value, currentCwd, homeDirectory = os.homedir()) {
+    const input = value.trim();
+    if (!input || input.includes("\0") || input.length > 4_096) {
+        throw new Error("Enter a valid folder path");
+    }
+    if (input === "~")
+        return path.resolve(homeDirectory);
+    if (input.startsWith("~/") || input.startsWith("~\\")) {
+        return path.resolve(homeDirectory, input.slice(2));
+    }
+    return path.resolve(currentCwd, input);
+}
+export async function browseCompanionWorkspace(value, currentCwd) {
+    const requested = resolveCompanionWorkspacePath(value, currentCwd);
+    const info = await stat(requested);
+    if (!info.isDirectory())
+        throw new Error("That path is not a folder");
+    const cwd = await realpath(requested);
+    const entries = await readdir(cwd, { withFileTypes: true });
+    const directories = entries
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => ({ name: entry.name, path: path.join(cwd, entry.name) }))
+        .sort((left, right) => left.name.localeCompare(right.name, undefined, {
+        numeric: true,
+        sensitivity: "base",
+    }));
+    const root = path.parse(cwd).root;
+    return {
+        cwd,
+        parent: cwd === root ? null : path.dirname(cwd),
+        directories: directories.slice(0, 500),
+        truncated: directories.length > 500,
+    };
+}
 export function buildCompanionPrompt(prompt, context) {
-    const pathname = typeof context?.pathname === "string" ? context.pathname.slice(0, 500) : undefined;
+    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.";
@@ -385,11 +489,15 @@ export function buildCompanionPrompt(prompt, context) {
                     context.boardRole === "viewer"
                     ? context.boardRole
                     : undefined,
-                view: typeof context.view === "string" ? context.view.slice(0, 50) : 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,
+                cardId: typeof context.cardId === "string"
+                    ? context.cardId.slice(0, 200)
+                    : undefined,
                 cardTitle: typeof context.cardTitle === "string"
                     ? context.cardTitle.slice(0, 500)
                     : undefined,
@@ -399,7 +507,9 @@ export function buildCompanionPrompt(prompt, context) {
                 cardHref: typeof context.cardHref === "string"
                     ? context.cardHref.slice(0, 1_000)
                     : undefined,
-                listId: typeof context.listId === "string" ? context.listId.slice(0, 200) : undefined,
+                listId: typeof context.listId === "string"
+                    ? context.listId.slice(0, 200)
+                    : undefined,
                 listTitle: typeof context.listTitle === "string"
                     ? context.listTitle.slice(0, 500)
                     : undefined,
@@ -409,8 +519,12 @@ export function buildCompanionPrompt(prompt, context) {
                 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,
+                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
@@ -469,6 +583,20 @@ export function assertCompanionProvider(provider) {
         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",
@@ -479,6 +607,156 @@ export function subscriptionEnvironment(environment = process.env) {
     ]);
     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);
     const runningFromTypeScript = companionFile.endsWith(".ts");
@@ -528,7 +806,7 @@ function companionClaudeConfig() {
         },
     });
 }
-export function companionCliInvocation(provider, prompt, threadId) {
+export function companionCliInvocation(provider, prompt, threadId, model = null, effort = null) {
     const definition = PROVIDERS[provider];
     if (provider === "claude") {
         return {
@@ -548,6 +826,8 @@ export function companionCliInvocation(provider, prompt, threadId) {
                 "--mcp-config",
                 companionClaudeConfig(),
                 "--strict-mcp-config",
+                ...(model && model !== "default" ? ["--model", model] : []),
+                ...(effort && effort !== "none" ? ["--effort", effort] : []),
                 ...(threadId ? ["--resume", threadId] : []),
             ],
             stdin: prompt,
@@ -560,6 +840,7 @@ export function companionCliInvocation(provider, prompt, threadId) {
             "--mode=ask",
             "--output-format",
             "stream-json",
+            ...(model ? ["--model", model] : []),
             ...(threadId ? ["--resume", threadId] : []),
             prompt,
         ],
@@ -588,7 +869,9 @@ function cliActivity(provider, event) {
         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";
+        return name
+            ? `Used ${name.replace(/ToolCall$/, "")}`
+            : "Used a Cursor tool";
     }
     if (provider === "claude" && event.type === "assistant") {
         const message = event.message;
@@ -600,9 +883,9 @@ function cliActivity(provider, event) {
     }
     return null;
 }
-async function runSubscriptionCliTurn({ provider, prompt, cwd, threadId, signal, send, }) {
+async function runSubscriptionCliTurn({ provider, prompt, cwd, threadId, model, effort, signal, send, }) {
     const definition = PROVIDERS[provider];
-    const invocation = companionCliInvocation(provider, prompt, threadId);
+    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, {
@@ -614,7 +897,10 @@ async function runSubscriptionCliTurn({ provider, prompt, cwd, threadId, signal,
         let activeThreadId = threadId;
         let finalText = "";
         let usage;
-        const lines = readline.createInterface({ input: child.stdout, crlfDelay: Infinity });
+        const lines = readline.createInterface({
+            input: child.stdout,
+            crlfDelay: Infinity,
+        });
         lines.on("line", (line) => {
             if (!line.trim())
                 return;
@@ -709,26 +995,66 @@ function companionThreadOptions(cwd, model, effort) {
         modelReasoningEffort: effort,
     };
 }
+const PROVIDER_IDS = Object.keys(PROVIDERS);
 export async function runAgentCompanion(argv) {
     const options = parseArgs(argv);
-    const provider = PROVIDERS[options.provider];
+    let workspaceCwd = options.cwd;
     const allowedOrigin = new URL(options.appUrl).origin;
     const token = crypto.randomBytes(32).toString("base64url");
-    assertCompanionProvider(options.provider);
-    const codex = options.provider === "codex"
-        ? new Codex({
-            config: companionCodexConfig(),
-            env: subscriptionEnvironment(),
-        })
-        : null;
-    const metadataClient = options.provider === "codex"
-        ? new CodexMetadataClient()
-        : null;
-    let thread = null;
-    let cliThreadId = 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 resetThreads = () => {
+        for (const candidate of runtimes.values()) {
+            candidate.thread = null;
+            candidate.cliThreadId = 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 }
@@ -744,6 +1070,9 @@ export async function runAgentCompanion(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;
@@ -757,67 +1086,82 @@ export async function runAgentCompanion(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,
+                    cwd: workspaceCwd,
                     running: activeAbort !== null,
-                    threadId: options.provider === "codex" ? thread?.id ?? null : cliThreadId,
-                    model: selectedModel,
-                    effort: selectedEffort,
-                    provider: { id: options.provider, displayName: provider.displayName },
+                    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 (!metadataClient) {
-                    writeJson(res, 200, {
-                        currentModel: options.provider,
-                        currentReasoningEffort: "none",
-                        models: [
-                            {
-                                model: options.provider,
-                                displayName: `${provider.displayName} default`,
-                                description: `Uses the model selected by your ${provider.displayName} CLI account.`,
-                                isDefault: true,
-                                defaultReasoningEffort: "none",
-                                supportedReasoningEfforts: [],
-                            },
-                        ],
-                        planType: "subscription",
-                        rateLimits: [],
-                        updatedAt: Date.now(),
-                        provider: { id: options.provider, displayName: provider.displayName },
-                        capabilities: { modelSelection: false, effortSelection: false },
+            if (req.method === "GET" && requestUrl.pathname === "/v1/workspace") {
+                try {
+                    const requestedPath = requestUrl.searchParams.get("path") ?? workspaceCwd;
+                    const listing = await browseCompanionWorkspace(requestedPath, workspaceCwd);
+                    writeJson(res, 200, listing, headers);
+                }
+                catch (error) {
+                    writeJson(res, 400, {
+                        error: error instanceof Error
+                            ? error.message
+                            : "That folder is unavailable",
                     }, headers);
+                }
+                return;
+            }
+            if (req.method === "POST" && requestUrl.pathname === "/v1/workspace") {
+                if (activeAbort) {
+                    writeJson(res, 409, { error: `A ${provider.displayName} turn is still running` }, headers);
                     return;
                 }
+                let parsed;
                 try {
-                    const metadata = await metadataClient.metadata(selectedModel, selectedEffort);
-                    selectedModel = metadata.currentModel;
-                    selectedEffort = metadata.currentReasoningEffort;
-                    writeJson(res, 200, {
-                        ...metadata,
-                        provider: { id: options.provider, displayName: provider.displayName },
-                        capabilities: { modelSelection: true, effortSelection: true },
+                    parsed = JSON.parse(await readBody(req));
+                    const requestedPath = typeof parsed.cwd === "string" ? parsed.cwd : "";
+                    const listing = await browseCompanionWorkspace(requestedPath, workspaceCwd);
+                    workspaceCwd = listing.cwd;
+                    resetThreads();
+                    writeJson(res, 200, { ok: true, cwd: workspaceCwd }, headers);
+                }
+                catch (error) {
+                    writeJson(res, 400, {
+                        error: error instanceof Error
+                            ? error.message
+                            : "That folder is unavailable",
                     }, headers);
                 }
+                return;
+            }
+            if (req.method === "GET" && requestUrl.pathname === "/v1/metadata") {
+                try {
+                    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 (!metadataClient) {
-                    writeJson(res, 400, { error: `${provider.displayName} controls model selection in its own CLI.` }, headers);
-                    return;
-                }
+            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;
@@ -829,25 +1173,29 @@ export async function runAgentCompanion(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 (!metadataClient) {
-                    writeJson(res, 400, { error: `${provider.displayName} controls reasoning settings in its own CLI.` }, headers);
+            if (req.method === "POST" && requestUrl.pathname === "/v1/effort") {
+                if (activeAbort) {
+                    writeJson(res, 409, { error: `A ${provider.displayName} turn is still running` }, headers);
                     return;
                 }
-                if (activeAbort) {
-                    writeJson(res, 409, { error: "A Codex turn is still running" }, headers);
+                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;
@@ -859,33 +1207,32 @@ export async function runAgentCompanion(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;
-                cliThreadId = 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;
-                cliThreadId = 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;
@@ -901,22 +1248,50 @@ export async function runAgentCompanion(argv) {
                     writeJson(res, 400, { error: "Invalid coding-agent session id" }, headers);
                     return;
                 }
-                if (!metadataClient || !codex) {
-                    cliThreadId = threadId;
-                    writeJson(res, 200, { ok: true, threadId }, headers);
+                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;
@@ -926,17 +1301,23 @@ export async function runAgentCompanion(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(workspaceCwd, 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;
             }
@@ -957,8 +1338,8 @@ export async function runAgentCompanion(argv) {
                 writeJson(res, 400, { error: "prompt is required" }, headers);
                 return;
             }
-            if (codex) {
-                thread ??= codex.startThread(companionThreadOptions(options.cwd, selectedModel, selectedEffort));
+            if (runtime.codex) {
+                runtime.thread ??= runtime.codex.startThread(companionThreadOptions(workspaceCwd, runtime.selectedModel, runtime.selectedEffort));
             }
             const abort = new AbortController();
             activeAbort = abort;
@@ -977,11 +1358,17 @@ export async function runAgentCompanion(argv) {
                     res.write(`${JSON.stringify(value)}\n`);
             };
             try {
-                const currentThreadId = codex ? thread?.id ?? null : cliThreadId;
-                send({ type: "connected", cwd: options.cwd, threadId: currentThreadId });
+                const currentThreadId = runtime.codex
+                    ? (runtime.thread?.id ?? null)
+                    : runtime.cliThreadId;
+                send({
+                    type: "connected",
+                    cwd: workspaceCwd,
+                    threadId: currentThreadId,
+                });
                 const contextualPrompt = buildCompanionPrompt(prompt, parsed.context);
-                if (codex && thread) {
-                    const streamed = await thread.runStreamed(contextualPrompt, {
+                if (runtime.codex && runtime.thread) {
+                    const streamed = await runtime.thread.runStreamed(contextualPrompt, {
                         signal: abort.signal,
                     });
                     for await (const event of streamed.events) {
@@ -989,16 +1376,23 @@ export async function runAgentCompanion(argv) {
                     }
                 }
                 else {
-                    cliThreadId = await runSubscriptionCliTurn({
-                        provider: options.provider,
+                    runtime.cliThreadId = await runSubscriptionCliTurn({
+                        provider: runtime.id,
                         prompt: contextualPrompt,
-                        cwd: options.cwd,
-                        threadId: cliThreadId,
+                        cwd: workspaceCwd,
+                        threadId: runtime.cliThreadId,
+                        model: runtime.selectedModel,
+                        effort: runtime.selectedEffort,
                         signal: abort.signal,
                         send,
                     });
                 }
-                send({ type: "done", threadId: codex ? thread?.id ?? null : cliThreadId });
+                send({
+                    type: "done",
+                    threadId: runtime.codex
+                        ? (runtime.thread?.id ?? null)
+                        : runtime.cliThreadId,
+                });
             }
             catch (error) {
                 send({
@@ -1024,12 +1418,13 @@ export async function runAgentCompanion(argv) {
     const pairing = Buffer.from(JSON.stringify({
         port,
         token,
-        provider: { id: options.provider, displayName: provider.displayName },
+        provider: providerInfo(defaultProviderId),
+        providers: Array.from(runtimes.keys(), providerInfo),
     }), "utf8").toString("base64url");
     const url = companionPairingUrl(options.appUrl, pairing);
     console.log("");
     console.log("Nudge Agent companion is running");
-    console.log(`  Agent:     ${provider.displayName}`);
+    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}`);
@@ -1038,7 +1433,15 @@ export async function runAgentCompanion(argv) {
     }
     console.log("  Files:     read-only");
     console.log("");
-    console.log(`${provider.displayName} will reuse the account from \`${provider.loginCommand}\`.`);
+    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)
@@ -1048,7 +1451,8 @@ export async function runAgentCompanion(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);