openmausbot 0.1.91 → 0.1.93

package/dist-server/server/drivers/openai-chat.js

@@ -30,6 +30,17 @@ const usageFrom = (usage) => usage
 const asError = (value) => value instanceof Error ? value : new Error(String(value));
 class UnsupportedChatToolsError extends Error {
 }
+const NUDGE_ANNOUNCED_ACTION = "You said what you would do next but called no tool. Do it now with your tools, or reply with your final answer if nothing is left to do.";
+/** A short reply that only announces a next step, with nothing to answer. */
+export function announcesAction(text) {
+    const reply = text.trim();
+    if (!reply || reply.length > 400 || reply.includes("?"))
+        return false;
+    return /(?:[:\u2014\u2013]|\.\.\.|\u2026)$/.test(reply) ||
+        /^(?:checking|let me|i'll|i will|i'm going to|i am going to|opening|pulling|looking|searching|navigating|reading|fetching|loading|now (?:i'll|let me|opening|checking|pulling|reading))\b/i.test(reply);
+}
+const TEXT_ONLY_ATTACHMENT_NOTE = "[The person attached image(s), but this model cannot see images. Say so if the request depends on them.]";
+const TEXT_ONLY_SCREENSHOT_NOTE = "[Screenshot not shown: this model cannot see images. Read the page with a snapshot or a text tool instead.]";
 function rejectsToolsParameter(status, body) {
     if (status !== 400 && status !== 422)
         return false;
@@ -48,11 +59,32 @@ function rejectsToolsParameter(status, body) {
         /\b(?:tools|tool calling|function calling) (?:is|are) not supported\b/i.test(message) ||
         /^(?:unsupported|unknown|unrecognized) (?:parameter|field):?\s*['"]?tools['"]?[.!]?$/i.test(message.trim()));
 }
+class UnsupportedReasoningReplayError extends Error {
+}
+/** DeepSeek-style providers need `reasoning_content` echoed on a tool-call
+ *  assistant message; strict endpoints such as Groq reject the property. */
+function rejectsReasoningReplay(status, body) {
+    if (status !== 400 && status !== 422)
+        return false;
+    let envelope;
+    try {
+        envelope = object(JSON.parse(body));
+    }
+    catch {
+        return false;
+    }
+    const message = object(envelope?.error)?.message ?? envelope?.error;
+    return typeof message === "string" && /\breasoning_content\b/.test(message) &&
+        /\b(?:unsupported|not supported|unknown|unrecognized|unexpected|not permitted|not allowed)\b/i.test(message);
+}
 /** Shared runtime for the three providers that speak OpenAI chat completions. */
 export function createOpenAIChatRuntime(options) {
     const { input } = options;
     const listeners = new Set();
     const active = new Map();
+    /** Models whose endpoint rejected an echoed `reasoning_content`. In memory
+     * only: later rounds and turns omit the field instead of failing again. */
+    const reasoningReplayRejected = new Set();
     const emit = (event) => {
         for (const listener of Array.from(listeners))
             listener(event);
@@ -95,6 +127,9 @@ export function createOpenAIChatRuntime(options) {
                 const message = `${options.httpErrorLabel} HTTP ${response.status}${body ? `: ${body.slice(0, 200)}` : ""}`;
                 if (rejectsToolsParameter(response.status, body))
                     throw new UnsupportedChatToolsError(message);
+                if (messages.some((entry) => entry.reasoning_content !== undefined) && rejectsReasoningReplay(response.status, body)) {
+                    throw new UnsupportedReasoningReplayError(message);
+                }
                 throw new Error(message);
             }
             if (!stream || response.headers.get("content-type")?.includes("application/json")) {
@@ -258,6 +293,7 @@ export function createOpenAIChatRuntime(options) {
                 clearTimeout(idleTimer);
         }
     };
+    const seesImages = (turn) => options.imageInput?.(turn.model || options.models().default) ?? true;
     const messagesFor = (turn) => {
         // The system message is the head of the resent prefix, so only the
         // stable half belongs there: a volatile edit must not re-price the
@@ -278,7 +314,9 @@ export function createOpenAIChatRuntime(options) {
                 role: message.role,
                 content: message.text,
             })),
-            { role: "user", content: options.computerUse ? chatUserContent(userTurn) : userTurn.text },
+            { role: "user", content: !options.computerUse ? userTurn.text
+                    : seesImages(turn) ? chatUserContent(userTurn)
+                        : userTurn.images?.length ? `${userTurn.text}\n\n${TEXT_ONLY_ATTACHMENT_NOTE}` : userTurn.text },
         ];
     };
     const sendTurn = async (turn) => {
@@ -357,6 +395,7 @@ export function createOpenAIChatRuntime(options) {
             let toolFailed = false;
             const denials = [];
             const seenCalls = new Set();
+            let nudged = false;
             try {
                 tools = await mountChatTools(options.tools === false ? undefined : turn.integrations, abort.signal, options.computerUse);
                 let optionalQuestionOnly = options.tools !== false && tools.definitions.length === 0;
@@ -377,7 +416,7 @@ export function createOpenAIChatRuntime(options) {
                     const parked = turnEntry.asides.splice(0);
                     if (parked.length)
                         messages.push({ role: "user", content: parked.join("\n\n") });
-                    native("out", options.nativeLog.outgoing(turn, messages, model));
+                    native("out", options.nativeLog.outgoing(turn, messages, model, tools.definitions));
                     let attempt = 0;
                     let completion;
                     for (;;) {
@@ -419,6 +458,16 @@ export function createOpenAIChatRuntime(options) {
                         catch (value) {
                             const error = asError(value);
                             const verdict = classifyError(error);
+                            // A schema rejection of the echoed reasoning executed nothing
+                            // upstream, so the same transcript without that one property
+                            // repeats no operation. The error needs the field in the
+                            // request, so the stripped resend cannot loop.
+                            if (error instanceof UnsupportedReasoningReplayError && !streamed && !abort.signal.aborted) {
+                                reasoningReplayRejected.add(model);
+                                for (const message of messages)
+                                    delete message.reasoning_content;
+                                continue;
+                            }
                             // Only our optional question changed a previously plain request.
                             // A structured parameter rejection has executed nothing; never
                             // downgrade mounted tools, streamed output or a handled call.
@@ -456,6 +505,11 @@ export function createOpenAIChatRuntime(options) {
                         if (completion.finishReason && completion.finishReason !== "stop") {
                             throw new ChatProtocolError(`provider did not finish the response (${completion.finishReason})`);
                         }
+                        if (options.nudgeAnnouncedAction && !nudged && tools.definitions.length && announcesAction(completion.text)) {
+                            nudged = true;
+                            messages.push({ role: "assistant", content: completion.text }, { role: "user", content: NUDGE_ANNOUNCED_ACTION });
+                            continue;
+                        }
                         if (toolFailed) {
                             stopReason = "tool_error";
                             throw new ChatProtocolError("One or more tool operations failed or were denied. See the tool results; the final response is not an execution receipt.");
@@ -474,7 +528,7 @@ export function createOpenAIChatRuntime(options) {
                     if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
                         throw new ChatProtocolError("tool-call limit reached");
                     messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
-                        ...(completion.protocolReasoning ? { reasoning_content: completion.protocolReasoning } : {}),
+                        ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { [options.reasoningReplayField ?? "reasoning_content"]: completion.protocolReasoning } : {}),
                         ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
                     });
                     const screenshotParts = [];
@@ -539,6 +593,10 @@ export function createOpenAIChatRuntime(options) {
                                 started = true;
                                 if (allowed) {
                                     result = await tools.execute(call.function.name, args, abort.signal);
+                                    if (result.images?.length && !seesImages(turn)) {
+                                        const { images: _dropped, ...rest } = result;
+                                        result = { ...rest, text: `${rest.text}\n${TEXT_ONLY_SCREENSHOT_NOTE}` };
+                                    }
                                     if (result.images?.length) {
                                         try {
                                             assertImageTransport(options.apiUrl);
@@ -637,7 +695,11 @@ export function createOpenAIChatRuntime(options) {
                 sessionModelSwitch: "in-session", customMcp: options.tools !== false, agentsMcp: options.tools !== false, composioMcp: options.tools !== false,
                 // The runtime owns the whole tool loop, so it can always take a
                 // user message mid-turn: park it, deliver before the next completion.
-                queueing: true },
+                queueing: true,
+                // No shell and no file tool on the host at all: only MCP tools, each
+                // call a card in Ask (the Boat's `exec` runs on the Boat). A guest's
+                // turn is as confined as it gets.
+                guestTurns: "confined" },
             sendTurn,
             interruptTurn: async (threadId, turnId) => {
                 const turn = active.get(threadId);

package/dist-server/server/drivers/openai-compat.js

@@ -15,6 +15,27 @@ const DEFAULT_MODELS = {
         { id: "llama-3.3-70b-versatile", label: "Llama 3.3 70B (Groq)", custom: true },
     ],
 };
+const DEFAULT_KEY_ENV = "OPENAI_COMPAT_API_KEY";
+/** A provider's own key (the built-in OpenAI and OpenRouter instances). An
+ * instance reading one of these never falls back to the workspace
+ * OpenAI-compatible key, URL, model or routing. */
+const OWN_KEY_ENVS = new Set(["OMB_OPENAI_API_KEY", "OMB_OPENROUTER_API_KEY"]);
+/** OpenAI's own API, seeded until its live catalog loads. */
+const OPENAI_MODELS = {
+    default: "gpt-5",
+    options: [
+        { id: "gpt-5", label: "gpt-5" },
+        { id: "gpt-5-mini", label: "gpt-5-mini" },
+    ],
+};
+/** OpenAI's /models lists every model the key can reach: embeddings, speech,
+ * images, moderation and Responses-only models too. Only chat models belong
+ * in a chat picker. */
+export function isOpenAIChatModel(id) {
+    if (!/^(gpt-|chatgpt-|o\d)/i.test(id))
+        return false;
+    return !/(audio|realtime|tts|transcribe|search|image|embedding|moderation|instruct|codex|computer-use|deep-research|-pro\b)/i.test(id);
+}
 function isOpenRouterUrl(url) {
     try {
         const host = new URL(url).hostname.toLowerCase();
@@ -30,7 +51,11 @@ function decodeConfig(raw) {
         throw new Error("tools must be a boolean");
     if (config.managedModels !== undefined && (!Array.isArray(config.managedModels) || !config.managedModels.length || config.managedModels.some(model => typeof model !== "string" || !model.trim())))
         throw new Error("Invalid managed models.");
-    const envUrl = process.env.OPENAI_COMPAT_URL;
+    const ownKey = typeof config.apiKeyEnv === "string" && OWN_KEY_ENVS.has(config.apiKeyEnv);
+    if (config.catalog !== undefined && config.catalog !== "openai")
+        throw new Error("catalog must be \"openai\"");
+    // Workspace defaults belong to the shared OpenAI-compatible connection only.
+    const envUrl = ownKey ? undefined : process.env.OPENAI_COMPAT_URL;
     return {
         ...(config.tools !== undefined ? { tools: config.tools } : {}),
         ...(config.managedModels ? { managedModels: config.managedModels } : {}),
@@ -38,55 +63,65 @@ function decodeConfig(raw) {
             .replace(/\/+$/, ""),
         apiKeyEnv: typeof config.apiKeyEnv === "string" && config.apiKeyEnv
             ? config.apiKeyEnv
-            : "OPENAI_COMPAT_API_KEY",
+            : DEFAULT_KEY_ENV,
+        ...(config.catalog === "openai" ? { catalog: "openai" } : {}),
         key: typeof config.key === "string" && config.key ? config.key : undefined,
         model: typeof config.model === "string" && config.model
             ? config.model
-            : process.env.OPENAI_COMPAT_MODEL || undefined,
+            : ownKey ? undefined : process.env.OPENAI_COMPAT_MODEL || undefined,
         // An explicit empty override disables inherited routing for an isolated
         // connection (CLI setup uses this). Absent still inherits the global pin.
         provider: typeof config.provider === "string"
             ? config.provider || undefined
-            : process.env.OPENAI_COMPAT_PROVIDER || undefined,
+            : ownKey ? undefined : process.env.OPENAI_COMPAT_PROVIDER || undefined,
     };
 }
 export const OpenAICompatDriver = {
     driverKind: DRIVER_KIND,
     metadata: {
-        displayName: "OpenAI-compatible (OpenRouter / Groq)",
+        displayName: "Other (OpenAI-compatible)",
         supportsMultipleInstances: true,
-        access: "custom",
+        access: "api",
     },
     models: DEFAULT_MODELS,
+    // Nothing to install: the key and base URL are saved in the app. The old
+    // descriptor offered a config.json sentence as an "Open install in
+    // Terminal" command.
     install: {
         docsUrl: "https://openrouter.ai/keys",
-        signInCommand: "add {\"openaiCompat\":{\"key\":\"sk-or-v1-…\"}} to ~/.openmausbot/config.json (or set OPENAI_COMPAT_API_KEY)",
-        command: {
-            darwin: "Get a free key at https://openrouter.ai/keys (or https://console.groq.com) then add it to ~/.openmausbot/config.json under openaiCompat.key",
-            linux: "Get a free key at https://openrouter.ai/keys (or https://console.groq.com) then add it to ~/.openmausbot/config.json under openaiCompat.key",
-            win32: "Get a free key at https://openrouter.ai/keys (or https://console.groq.com) then add it to %USERPROFILE%\\.openmausbot\\config.json under openaiCompat.key",
-        },
+        settings: "connections",
+        signInCommand: "Save an OpenAI-compatible API key in Settings → API keys, or set OPENAI_COMPAT_API_KEY on the server.",
     },
     decodeConfig,
     defaultConfig: () => decodeConfig({}),
     async create(input) {
         const { config } = input;
+        // An instance that names its own key variable reads only that one: the
+        // workspace key (OPENAI_COMPAT_API_KEY) belongs to the workspace's
+        // endpoint and must not reach this instance's host.
+        const ownKeyVariable = config.apiKeyEnv !== DEFAULT_KEY_ENV;
         const apiKey = config.key ??
             input.environment[config.apiKeyEnv] ??
-            input.environment.OPENAI_COMPAT_API_KEY ??
+            (ownKeyVariable ? undefined : input.environment[DEFAULT_KEY_ENV]) ??
             process.env[config.apiKeyEnv] ??
-            process.env.OPENAI_COMPAT_API_KEY ??
+            (ownKeyVariable ? undefined : process.env[DEFAULT_KEY_ENV]) ??
             "";
+        // The default key and the built-in providers' keys are saved in
+        // Settings → API keys; any other variable is configured where it was written.
+        const missingKey = !ownKeyVariable || OWN_KEY_ENVS.has(config.apiKeyEnv)
+            ? "No API key — open Settings → API keys."
+            : `no API key — set ${config.apiKeyEnv} or add it to the instance config`;
+        const seeded = config.catalog === "openai" ? OPENAI_MODELS : DEFAULT_MODELS;
         let catalog = config.managedModels
             ? { default: config.managedModels[0], options: config.managedModels.map(id => ({ id, label: id })) }
             : config.model
                 ? {
                     default: config.model,
-                    options: DEFAULT_MODELS.options.some((model) => model.id === config.model)
-                        ? DEFAULT_MODELS.options
-                        : [{ id: config.model, label: config.model, custom: true }, ...DEFAULT_MODELS.options],
+                    options: seeded.options.some((model) => model.id === config.model)
+                        ? seeded.options
+                        : [{ id: config.model, label: config.model, custom: true }, ...seeded.options],
                 }
-                : DEFAULT_MODELS;
+                : seeded;
         const fetchModels = async () => {
             if (config.managedModels)
                 return;
@@ -100,7 +135,14 @@ export const OpenAICompatDriver = {
                 if (!response.ok)
                     return;
                 const json = await response.json();
-                const rows = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : [];
+                let rows = Array.isArray(json) ? json : Array.isArray(json.data) ? json.data : [];
+                // OpenAI lists its catalog unordered and mixed with non-chat models:
+                // keep chat models, newest first.
+                if (config.catalog === "openai") {
+                    rows = rows
+                        .filter((row) => typeof row.id === "string" && isOpenAIChatModel(row.id))
+                        .sort((a, b) => (typeof b.created === "number" ? b.created : 0) - (typeof a.created === "number" ? a.created : 0));
+                }
                 const seen = new Set();
                 const options = [];
                 for (const row of rows) {
@@ -111,7 +153,8 @@ export const OpenAICompatDriver = {
                     options.push({
                         id,
                         label: typeof row.name === "string" && row.name.trim() ? row.name : id,
-                        custom: true,
+                        // A provider's own catalog is its official list, not a custom model.
+                        ...(config.catalog === "openai" ? {} : { custom: true }),
                     });
                 }
                 if (!options.length)
@@ -146,15 +189,22 @@ export const OpenAICompatDriver = {
                     : {}),
             }),
             httpErrorLabel: "upstream",
-            missingKeyError: `no API key — set ${config.apiKeyEnv} or add it to the instance config`,
-            unavailableReason: `no API key — set ${config.apiKeyEnv} or add it to the instance config`,
+            missingKeyError: missingKey,
+            unavailableReason: missingKey,
             timeoutMs: idleTimeoutMs(),
             reasoning: true,
             billing: "metered",
             includeUsageInCompleted: true,
             nativeLog: {
                 source: "openai-compat.chat.completions",
-                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
+                // Tool names are the answer to "did the harness send them?" — the
+                // LiteLLM/proxy hop after this point is what drops tools silently,
+                // and until now the tee held no record either side could compare.
+                outgoing: (_turn, messages, model, tools) => ({
+                    model,
+                    messageCount: messages.length,
+                    tools: tools.map(tool => tool.function.name),
+                }),
                 incoming: ({ text, reasoning, usage }) => ({
                     textLength: text.length,
                     reasoningLength: reasoning.length,

package/dist-server/server/drivers/prompt-split.js

@@ -57,6 +57,8 @@ export function readPromptSplitReceipt(scope, key) {
                     stable: record.stable,
                     volatile: record.volatile,
                     ...(typeof record.turnsSinceFull === "number" ? { turnsSinceFull: record.turnsSinceFull } : {}),
+                    ...(typeof record.lastUsed === "number" && record.lastUsed > 0 ? { lastUsed: record.lastUsed } : {}),
+                    ...(typeof record.peakUsed === "number" && record.peakUsed > 0 ? { peakUsed: record.peakUsed } : {}),
                 };
             }
         }

package/dist-server/server/engine-install.js

@@ -9,9 +9,10 @@ import { join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { DATA_DIR, stripWorkspaceCredentialEnv } from "./config.js";
 import { augmentedPath, findCliCandidates, registerPathDir, resetPathCache } from "./env-path.js";
-import { killCliTree, spawnCli } from "./procs.js";
+import { execCli, killCliTree, spawnCli } from "./procs.js";
 const MAX_OUTPUT = 64 * 1024;
 const DEFAULT_TIMEOUT_MS = 10 * 60_000;
+const PROBE_TIMEOUT_MS = 30_000;
 /** npm's global prefix for engines the app installs itself. */
 export function enginesPrefix(baseDir = DATA_DIR) {
     return join(baseDir, "tools", "npm");
@@ -68,21 +69,54 @@ async function installOnce(pkg, options) {
     stripWorkspaceCredentialEnv(env);
     // npm 11 skips a dependency's install script unless the package is named
     // here; the engines that need one (Claude Code) are exactly these.
-    const args = ["install", "-g", "--prefix", prefix, "--loglevel=error", `--allow-scripts=${pkg}`, `${pkg}@latest`];
-    const result = await runNpm(args, env, prefix, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
-    if (result.code !== 0) {
-        throw new Error(`npm could not install ${pkg} on this server.${tail(result.output)}`);
-    }
+    // Engines like Codex ship their native binary as a platform optional
+    // dependency, so a user-level `omit=optional` must not leave it out.
+    const args = ["install", "-g", "--prefix", prefix, "--loglevel=error", "--include=optional", `--allow-scripts=${pkg}`, `${pkg}@latest`];
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    await runInstall(pkg, args, env, prefix, timeoutMs);
     // Whatever the boot registration did, the directory we just filled must
     // be on the engines' PATH from here on.
-    registerPathDir(enginesBinDir(options.baseDir));
+    const binDir = enginesBinDir(options.baseDir);
+    registerPathDir(binDir);
     resetPathCache();
-    if (options.cli) {
-        const binDir = enginesBinDir(options.baseDir);
-        if (!findCliCandidates(options.cli).some((path) => path.startsWith(binDir))) {
-            throw new Error(`${pkg} installed, but it did not provide a \`${options.cli}\` command. Check the package name in this engine's install descriptor.`);
-        }
+    if (!options.cli)
+        return;
+    const installed = findCliCandidates(options.cli).find((path) => path.startsWith(binDir));
+    if (!installed) {
+        throw new Error(`${pkg} installed, but it did not provide a \`${options.cli}\` command. Check the package name in this engine's install descriptor.`);
     }
+    // npm exits 0 even when it drops an optional dependency it failed to
+    // download, which leaves a launcher without its platform binary (#2064).
+    // A copy here shadows every other one on PATH, so prove it starts; a
+    // second run fetches what the first one dropped.
+    let failure = await probeCli(installed, env);
+    if (failure === null)
+        return;
+    await runInstall(pkg, args, env, prefix, timeoutMs);
+    failure = await probeCli(installed, env);
+    if (failure === null)
+        return;
+    throw new Error(`npm installed ${pkg}, but \`${options.cli}\` does not start: ${failure}\nnpm can leave out a platform package when its download fails, even after a retry. Check this server's network connection, then install again from Settings.`);
+}
+async function runInstall(pkg, args, env, prefix, timeoutMs) {
+    const result = await runNpm(args, env, prefix, timeoutMs);
+    if (result.code !== 0) {
+        throw new Error(`npm could not install ${pkg} on this server.${tail(result.output)}`);
+    }
+}
+/** Null when `<cli> --version` succeeds, else why it did not. A Node
+ * launcher that throws prints its source line first, so its `Error:` line
+ * is the one worth showing. */
+function probeCli(cli, env) {
+    return new Promise((resolveProbe) => {
+        execCli(cli, ["--version"], { env: { ...env, PATH: augmentedPath() }, timeout: PROBE_TIMEOUT_MS, killSignal: "SIGKILL", maxBuffer: MAX_OUTPUT }, (error, stdout, stderr) => {
+            if (!error)
+                return resolveProbe(null);
+            const lines = stripVTControlCharacters(`${stderr ?? ""}\n${stdout}`).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+            const said = lines.find((line) => /^\w*Error: /.test(line)) ?? lines[0] ?? error.message;
+            resolveProbe(said.slice(0, 400));
+        });
+    });
 }
 function tail(output) {
     const clean = stripVTControlCharacters(output).trim();

package/dist-server/server/env-path.js

@@ -27,6 +27,15 @@ function nvmBinDirs() {
         return [];
     }
 }
+/** A sealed test fixture finds CLIs only where it was granted them: its own
+ * PATH, OMB_EXTRA_PATH, app-managed dirs, and install dirs under its own
+ * temporary home. The machine-wide install dirs and the login shell's PATH
+ * would hand it this computer's real CLIs — a Homebrew `codex` made the
+ * fixture's ChatGPT plan engine "available" on a developer Mac (#2035).
+ * Only the verification launcher (scripts/control-omb.ts) sets it. */
+function sealedFixture() {
+    return process.env.OMB_TEST_SEALED_PATH === "1";
+}
 function knownDirs() {
     const home = homedir();
     return [
@@ -36,8 +45,11 @@ function knownDirs() {
         join(home, ".grok", "bin"), // x.ai installer
         join(home, ".opencode", "bin"), // opencode installer
         join(home, ".claude", "local"), // claude "local install"
-        "/opt/homebrew/bin", // brew, Apple silicon
-        "/usr/local/bin", // brew Intel / classic installs
+        // Machine-wide rather than under the (possibly temporary) home.
+        ...(sealedFixture() ? [] : [
+            "/opt/homebrew/bin", // brew, Apple silicon
+            "/usr/local/bin", // brew Intel / classic installs
+        ]),
         join(home, ".volta", "bin"),
         join(home, ".bun", "bin"),
         join(home, ".asdf", "shims"),
@@ -52,8 +64,9 @@ function knownDirs() {
  * invisible until it restarts, because Windows never pushes PATH changes
  * into a live process. Scanning the standard install locations recovers
  * those without a restart — `~/.grok/bin` (the x.ai installer) and
- * `%APPDATA%\npm` (global npm shims), plus `%LOCALAPPDATA%\agy\bin`, cover
- * every engine we ship an install command for. */
+ * `%APPDATA%\npm` (global npm shims), plus `%LOCALAPPDATA%\agy\bin` and
+ * `%LOCALAPPDATA%\cursor-agent`, cover every engine we ship an install
+ * command for. */
 function windowsKnownDirs() {
     const home = homedir();
     const appData = process.env.APPDATA ?? join(home, "AppData", "Roaming");
@@ -62,12 +75,15 @@ function windowsKnownDirs() {
         join(appData, "npm"), // npm -g shims: claude, codex
         join(home, ".grok", "bin"), // x.ai installer
         join(localAppData, "agy", "bin"), // Antigravity installer
+        // Cursor installer: cursor-agent.* and its `agent` copies (MOCA-272)
+        join(localAppData, "cursor-agent"),
         join(home, ".local", "bin"), // claude native installer
         join(home, ".claude", "local"),
         join(home, "bin"), // Factory droid installer (%USERPROFILE%\bin)
         join(home, ".bun", "bin"),
         join(home, ".deno", "bin"),
         join(home, "go", "bin"),
+        join(process.env.ProgramFiles ?? "C:\\Program Files", "Docker", "Docker", "resources", "bin"), // Docker Desktop installer
     ];
 }
 let cached = null;
@@ -115,7 +131,7 @@ export function augmentedPath() {
     // belt-and-braces: fold in the login shell's PATH once, in the
     // background — catches anything the known-dirs list doesn't (custom
     // rc exports). Never blocks a spawn; the next one benefits.
-    if (!probed && !process.env.VITEST && process.platform !== "win32") {
+    if (!probed && !process.env.VITEST && !sealedFixture() && process.platform !== "win32") {
         probed = true;
         probeLoginShellPath();
     }

package/dist-server/server/harness/registry.js

@@ -235,11 +235,11 @@ export class ProviderRegistry {
                 install: withServerInstall(driver?.install, npmPresent),
                 authentication: inst.startAuthentication
                     ? {
-                        method: inst.getAuthentication && inst.completeAuthentication
+                        method: inst.authenticationMethod ?? (inst.getAuthentication && inst.completeAuthentication
                             ? "paste-code" // a link to open, then a code pasted back (Claude)
                             : inst.getAuthentication
                                 ? "device-code" // a code to enter at the provider's page (Codex)
-                                : "browser", // a link and a callback URL (managed engines)
+                                : "browser"), // a link and a callback URL (managed engines)
                         // the browser may remove the stored sign-in to switch accounts
                         signOut: inst.signOut !== undefined,
                     }