openmausbot 0.1.96 → 0.1.98

package/dist-server/server/computer-engine-removal.js

@@ -0,0 +1,70 @@
+/** The removed engine's driver kind ("boxAgent" was Boat's historical name). */
+export const REMOVED_COMPUTER_DRIVER = "boxAgent";
+/** The instance id every default fleet gave it. */
+const REMOVED_COMPUTER_INSTANCE = "computer";
+/** Instance ids that named the Computer engine. A saved fleet may hold the
+ * default id or one of its own; an id the person reused for another engine
+ * is theirs and stays. */
+export function removedComputerInstanceIds(saved) {
+    const ids = new Set();
+    const reused = saved && Object.hasOwn(saved, REMOVED_COMPUTER_INSTANCE) &&
+        saved[REMOVED_COMPUTER_INSTANCE].driver !== REMOVED_COMPUTER_DRIVER;
+    if (!reused)
+        ids.add(REMOVED_COMPUTER_INSTANCE);
+    for (const [id, entry] of Object.entries(saved ?? {})) {
+        if (entry.driver === REMOVED_COMPUTER_DRIVER)
+            ids.add(id);
+    }
+    return ids;
+}
+/** A fleet without the removed engine: a saved entry for it is dropped, so
+ * it is never offered and the next save leaves it off disk. */
+export function withoutComputerEngine(map) {
+    for (const [id, entry] of Object.entries(map)) {
+        if (entry.driver === REMOVED_COMPUTER_DRIVER)
+            delete map[id];
+    }
+    return map;
+}
+/** The line a moved conversation shows, in plain words. It names the removed
+ * choice as people saw it in the model list ("Computer", not the panel's
+ * Computer tab), claims a cloud computer only where one is still used, says
+ * so when the new engine can't use the one it had, and names the one setting
+ * to change when a turn there would be refused. */
+export function computerEngineMoveText(move, botName, engine) {
+    const removed = "The Computer choice in the model list was removed.";
+    const bot = move.scope !== "conversation";
+    const head = move.scope === "conversation" ? `This conversation now uses ${engine}.`
+        : move.scope === "bot-only" ? `${botName} now uses ${engine}; this conversation keeps its own model.`
+            : `${botName} now uses ${engine}.`;
+    const noComputer = ` ${engine} can't use a computer, so`;
+    const place = move.cloud
+        ? bot ? ` ${botName} still works on its cloud computer.` : ` It still works on ${botName}'s cloud computer.`
+        : move.noComputer === "auto"
+            ? `${noComputer} ${bot ? `${botName} no longer works on its` : `it no longer works on ${botName}'s`}` +
+                " cloud computer. To use it again, choose a model that can use a computer."
+            : move.noComputer === "works-on"
+                ? `${noComputer} ${botName} can't reply on ${engine} while its Works on is Cloud computer.` +
+                    " Choose a model that can use a computer, or set Works on to Auto."
+                : move.noComputer === "pin"
+                    ? `${noComputer} ${botName} can't reply here while this conversation is pinned to its cloud computer.` +
+                        " Choose a model that can use a computer, or clear this conversation's place in the composer."
+                    : "";
+    const ask = !move.askNow ? ""
+        : move.scope === "bot-only" ? ` ${botName}'s permissions are now Ask, but this conversation's stay as they were.`
+            : " Its permissions are now Ask.";
+    return `${head} ${removed}${place}${ask}`;
+}
+/** Writes each moved conversation's line. The move is saved by then, so a
+ * later try never finds these conversations again: a line that fails is
+ * logged, and every other line is still written. */
+export function writeComputerEngineMoveLines(moves, write) {
+    for (const move of moves) {
+        try {
+            write(move);
+        }
+        catch (error) {
+            console.warn(`[engines] the Computer engine move line for ${move.threadId} was not written: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+}

package/dist-server/server/computer-selection.js

@@ -0,0 +1,18 @@
+/** The option a request picks, and whether it is the computer this turn
+ * already has. `current` is the turn's mounted place. `startsOnFirstCall`
+ * says that place's computer is the one this turn's first computer call
+ * creates or wakes (the bot's own cloud computer): it is this turn's before
+ * it is up, so asking for it, or for Auto, keeps it instead of restarting
+ * the request somewhere else. */
+export function pickComputer(options, requested, current, startsOnFirstCall) {
+    const isCurrent = (option) => option.surface === current && (option.ready || (startsOnFirstCall && option.available));
+    const option = requested === "auto"
+        ? options.find(isCurrent)
+            ?? options.find((candidate) => candidate.ready && candidate.surface === "vm")
+            ?? options.find((candidate) => candidate.ready)
+            ?? options.find((candidate) => candidate.canStart)
+            ?? options.find((candidate) => candidate.canCreate && candidate.surface === "vm")
+            ?? options.find((candidate) => candidate.canCreate)
+        : options.find((candidate) => candidate.surface === requested);
+    return { option, current: option !== undefined && isCurrent(option) };
+}

package/dist-server/server/config.js

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
+import { withoutComputerEngine } from "./computer-engine-removal.js";
 import { newBotDefaultsSchema } from "./new-bot-defaults.js";
 import { EFFORT_LEVELS } from "../shared/wire.js";
 import { isModelVariant } from "./contracts.js";
@@ -23,6 +24,13 @@ export const FISH_TTS_MODELS = ["s2.1-pro", "s2.1-pro-free"];
 export const DEFAULT_ROOM_TURN_TIMEOUT_MINUTES = 5;
 export const MIN_ROOM_TURN_TIMEOUT_MINUTES = 1;
 export const MAX_ROOM_TURN_TIMEOUT_MINUTES = 1_440;
+/** Per-call ceiling for a bot's MCP tools (tools/call on the chat MCP
+ * transport). 10 minutes matches the historic constant in
+ * chat-mcp-tools.ts; a single tool call that runs longer is cut at this
+ * deadline because its execution outcome can no longer be trusted. */
+export const DEFAULT_MCP_CALL_TIMEOUT_MINUTES = 10;
+export const MIN_MCP_CALL_TIMEOUT_MINUTES = 1;
+export const MAX_MCP_CALL_TIMEOUT_MINUTES = 60;
 export const DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES = 30;
 export const DEFAULT_ROOM_HANDOFF_MIN_RUNWAY_MINUTES = 10;
 export const DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES = 240;
@@ -104,6 +112,16 @@ const roomConfigSchema = z.object({
     (rooms.handoffLifetimeMinutes ?? DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES) &&
     (rooms.handoffLifetimeMinutes ?? DEFAULT_ROOM_HANDOFF_LIFETIME_MINUTES) <=
         (rooms.handoffHardCapMinutes ?? DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES), { message: "rooms handoff bounds must satisfy handoffMinRunwayMinutes <= handoffLifetimeMinutes <= handoffHardCapMinutes" });
+const mcpConfigSchema = z.object({
+    /** Ceiling (minutes) for one bot MCP tool call. Missing values resolve to
+     * 10, preserving the historic chat-mcp-tools constant. */
+    callTimeoutMinutes: z
+        .number()
+        .int()
+        .min(MIN_MCP_CALL_TIMEOUT_MINUTES)
+        .max(MAX_MCP_CALL_TIMEOUT_MINUTES)
+        .optional(),
+}).strict();
 /** Isolation for bot desktops. Migration note (issue #1654): switching
  * modes changes lease keys and vm-home directories, so desktops cold-start
  * under the new mode — a pool seat lives in vm-homes/pool-N — while the old
@@ -502,6 +520,7 @@ const appConfigSchema = z.object({
      * system language. Unknown tags degrade to English in the renderer. */
     language: optionalText,
     rooms: roomConfigSchema.optional(),
+    mcp: mcpConfigSchema.optional(),
     context: z.object({
         rebuildBytes: z.number().int().min(1_024).max(1_000_000).optional(),
         compactAt: z.number().positive().max(10_000_000).optional(),
@@ -634,6 +653,9 @@ export function browserEngineAttachCdpUrl(cfg) {
 export function roomTurnTimeoutMinutes(cfg) {
     return cfg.rooms?.turnTimeoutMinutes ?? DEFAULT_ROOM_TURN_TIMEOUT_MINUTES;
 }
+export function mcpCallTimeoutMinutes(cfg) {
+    return cfg.mcp?.callTimeoutMinutes ?? DEFAULT_MCP_CALL_TIMEOUT_MINUTES;
+}
 export const LIVE_IDLE_MINUTES_DEFAULT = 5;
 /** Non-secret Live settings. The key only shows up as `configured`. */
 export function liveSettingsFor(cfg) {
@@ -1203,7 +1225,7 @@ export function saveConfig(patch, options = {}) {
     const storedProfiles = storedBrowserProfilesSchema.safeParse(disk.browserProfiles);
     if (storedProfiles.success)
         disk.browserProfiles = storedProfiles.data;
-    for (const key of ["xai", "anthropic", "mistral", "cerebras", "openai", "openrouter", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "live", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
+    for (const key of ["xai", "anthropic", "mistral", "cerebras", "openai", "openrouter", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "live", "profile", "rooms", "mcp", "threads", "context", "memory", "localVm", "features", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;
@@ -1443,10 +1465,10 @@ export function instanceOwnsRouting(cfg, entry, routingDefaults) {
 }
 /** The credential env instanceConfigs() injects for one driver at runtime.
  * Each secret goes only to the driver that actually reads it: the API-key
- * Grok driver reads XAI_API_KEY, the Computer driver reads BOX_TOKEN, and
- * OpenCode reads OPENCODE_API_KEY. Every other engine brings its own
- * login, so handing it a key it never uses would only put that key in the
- * environment of an unrelated child process. */
+ * Grok driver reads XAI_API_KEY and OpenCode reads OPENCODE_API_KEY. Every
+ * other engine brings its own login, so handing it a key it never uses would
+ * only put that key in the environment of an unrelated child process. The
+ * Boat token reaches no engine at all: the harness alone talks to Boat. */
 function injectedEnvironment(cfg, instanceId, driver) {
     const environment = new Map();
     if (driver === "mistral" && cfg.mistral?.key)
@@ -1485,11 +1507,6 @@ function injectedEnvironment(cfg, instanceId, driver) {
         if (driver === "openai-compat" && cfg.openaiCompat?.url)
             environment.set("OPENAI_COMPAT_URL", cfg.openaiCompat.url);
     }
-    // driverKind "boxAgent" and env BOX_TOKEN keep their historical names.
-    // Only the person's own token: without one the driver itself falls back
-    // to Cloud Pro's included token, which never enters an environment map.
-    if (driver === "boxAgent" && cfg.box?.token)
-        environment.set("BOX_TOKEN", cfg.box.token);
     if (driver === "opencodeGo") {
         // Keys for OpenCode's other providers, under the names OpenCode reads.
         for (const [name, key] of Object.entries(openCodeProviderKeys(cfg)))
@@ -1551,7 +1568,6 @@ export function instanceConfigs(cfg) {
         chatgpt: { driver: "codex", displayName: "ChatGPT plan", config: { authMode: "chatgpt-plan" } },
         antigravity: { driver: "antigravityAgent" },
         opencodeGo: { driver: "opencodeGo" },
-        computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
         cerebras: { driver: "cerebras" },
@@ -1578,7 +1594,8 @@ export function instanceConfigs(cfg) {
         ...CUSTOM_ONLY,
     };
     const configured = cfg.instances && Object.keys(cfg.instances).length ? cfg.instances : null;
-    const map = configured ? { ...configured } : { ...DEFAULT_FLEET };
+    // A fleet saved before the Computer engine was removed may still name it.
+    const map = withoutComputerEngine(configured ? { ...configured } : { ...DEFAULT_FLEET });
     // Product fleets pick up newly shipped engines. A one-off test/shadow map
     // (no claude/grok/codex) is left exactly as written.
     if (configured &&

package/dist-server/server/connector-card-text.js

@@ -0,0 +1,15 @@
+// The plain line a connection card carries beside its `connector` payload.
+//
+// Desktop and current phones draw `kind: "connector"` as a card and never
+// read this. It exists for clients that do not know the kind yet — phone
+// builds from before the in-chat card shipped decode it as "unknown" and draw
+// whatever `text` a message has, so without it they showed nothing at all
+// while the bot sat waiting for a connection. Exports and backups read it too.
+// It names the app and points at the card; it never carries a link, because
+// the authorization URL is only ever handed to the person's own client.
+/** "Connect GitHub to continue." — or, for a second account, the alias too. */
+export function connectorCardText(label, alias) {
+    const app = label.replace(/\s+/g, " ").trim() || "this app";
+    const account = alias?.replace(/\s+/g, " ").trim();
+    return account ? `Connect ${app} as “${account}” to continue.` : `Connect ${app} to continue.`;
+}

package/dist-server/server/connector-scope-hint.js

@@ -0,0 +1,83 @@
+// A connected-app call refused for a missing OAuth permission (MOCA-273).
+//
+// Google answers 403 ACCESS_TOKEN_SCOPE_INSUFFICIENT when the account's grant
+// lacks a scope the action needs, such as gmail.settings.basic for a filter.
+// Composio's default auth config for a toolkit never asks for that scope, so
+// reconnecting cannot fix it and a bot that only sees the 403 retries or
+// asks the person to reconnect. The fix is the person's own auth config in
+// their Composio project, which OpenMausBot already prefers
+// (listCustomAuthConfigs). This appends that explanation to the tool result,
+// leaving the provider's own error untouched.
+const SCOPE_ERROR = /ACCESS_TOKEN_SCOPE_INSUFFICIENT|insufficient authentication scopes|insufficientPermissions/i;
+/** The Google scope a known tool needs, when the tool name says which. */
+function requiredScope(slug) {
+    if (!slug.startsWith("GMAIL_"))
+        return null;
+    if (/FORWARD|SEND_AS|DELEGATE/.test(slug))
+        return "https://www.googleapis.com/auth/gmail.settings.sharing";
+    if (/FILTER|VACATION|AUTO_REPLY|IMAP|POP|LANGUAGE/.test(slug))
+        return "https://www.googleapis.com/auth/gmail.settings.basic";
+    return null;
+}
+function appName(slug) {
+    const toolkit = slug.split("_")[0] ?? "";
+    if (toolkit === "GMAIL")
+        return "Gmail";
+    if (toolkit.startsWith("GOOGLE"))
+        return "Google";
+    return toolkit.charAt(0) + toolkit.slice(1).toLowerCase();
+}
+/** The note a bot reads after its call was refused for a missing permission. */
+export function scopeHint(slugs) {
+    const slug = slugs.find((candidate) => requiredScope(candidate)) ?? slugs[0] ?? "";
+    const app = slug ? appName(slug) : "This app";
+    const scope = slug ? requiredScope(slug) : null;
+    const permission = scope ? `the ${scope} permission` : "the permission this action needs";
+    return `OpenMausBot note: ${app} refused this because the connected account has not granted ${permission}. ` +
+        `Reconnecting will not add it: the default Composio connection never asks for it. ` +
+        `To allow it, the person creates their own ${app} auth config in their Composio project that includes ${permission}, ` +
+        `then reconnects ${app} under Connected apps; OpenMausBot uses that config automatically. ` +
+        `Tell the person this. Do not retry this call.`;
+}
+/** Adds the note to one JSON-RPC frame whose tool result is a scope refusal. */
+function annotateFrame(frame, slugs) {
+    const result = frame?.result;
+    if (!result || !Array.isArray(result.content))
+        return false;
+    const refused = result.content.some((item) => item && typeof item === "object" && typeof item.text === "string" &&
+        SCOPE_ERROR.test(item.text));
+    if (!refused)
+        return false;
+    result.content.push({ type: "text", text: scopeHint(slugs) });
+    return true;
+}
+/**
+ * The relayed MCP response, with the note added when a tool call came back
+ * refused for a missing OAuth permission. Anything else, including a body it
+ * cannot read, is returned byte for byte.
+ */
+export function withScopeHint(bytes, contentType, slugs) {
+    const text = new TextDecoder().decode(bytes);
+    if (!SCOPE_ERROR.test(text))
+        return bytes;
+    try {
+        if (/text\/event-stream/i.test(contentType)) {
+            let changed = false;
+            const lines = text.split("\n").map((line) => {
+                if (!line.startsWith("data:"))
+                    return line;
+                const frame = JSON.parse(line.slice(5));
+                if (!annotateFrame(frame, slugs))
+                    return line;
+                changed = true;
+                return `data: ${JSON.stringify(frame)}`;
+            });
+            return changed ? new TextEncoder().encode(lines.join("\n")) : bytes;
+        }
+        const frame = JSON.parse(text);
+        return annotateFrame(frame, slugs) ? new TextEncoder().encode(JSON.stringify(frame)) : bytes;
+    }
+    catch {
+        return bytes;
+    }
+}

package/dist-server/server/default-model-selection.js

@@ -1,6 +1,22 @@
 const claudeFirst = (instances) => instances.find((instance) => instance.driverKind === "claudeAgent") ?? instances[0];
-/** A saved choice is intentional: an unavailable provider or removed model
- * sends new bots to setup instead of silently changing their provider. */
+/** Installed and waiting on a sign-in. A custom endpoint brings its own
+ * credential, so its sign-in state does not count. */
+export function signedOut(instance) {
+    return instance.snapshot.state === "available" && instance.access !== "custom" && instance.snapshot.authenticated === false;
+}
+/** The ready rule: an engine can run a turn now when it is available, the
+ * organisation allows it, and it is not signed out (signedOut). */
+export function readyToRun(instance, context = {}) {
+    return instance.snapshot.state === "available" && context.refusal?.(instance) === undefined && !signedOut(instance);
+}
+/** The engine a new bot gets, and the one a bot moved off a removed engine
+ * gets (computer-engine-removal.ts): one picker for both.
+ *
+ * A saved choice is intentional: an unavailable provider or removed model
+ * sends new bots to setup instead of silently changing their provider.
+ * Without one, an engine that can run a turn now wins (Claude first), then the
+ * first available one. On an enrolled desktop a working personal engine
+ * still beats a Company one, so billing stays the person's explicit choice. */
 export function selectDefaultModelSelection(instances, preferred, context = {}) {
     if (preferred) {
         const instance = instances.find((candidate) => candidate.instanceId === preferred.instanceId);
@@ -22,19 +38,12 @@ export function selectDefaultModelSelection(instances, preferred, context = {})
     }
     // The organisation's policy is inert (no refusal) unless this desktop is enrolled.
     const available = instances.filter((instance) => instance.snapshot.state === "available" && context.refusal?.(instance) === undefined);
+    const ready = available.filter((instance) => readyToRun(instance, context));
     const company = context.company;
-    let pick;
-    if (company && instances.some((instance) => company(instance.instanceId))) {
-        // Enrolled: an installed but signed-out personal Claude would send every
-        // new bot to setup although a Company model can run. Prefer instances that
-        // can run a turn now; a working personal engine still wins, so billing
-        // stays the person's explicit choice.
-        const ready = available.filter((instance) => instance.access === "custom" || instance.snapshot.authenticated !== false);
-        pick = claudeFirst(ready.filter((instance) => !company(instance.instanceId))) ?? claudeFirst(ready) ?? claudeFirst(available);
-    }
-    else {
-        pick = claudeFirst(available);
-    }
+    const personal = company && instances.some((instance) => company(instance.instanceId))
+        ? claudeFirst(ready.filter((instance) => !company(instance.instanceId)))
+        : undefined;
+    const pick = personal ?? claudeFirst(ready) ?? claudeFirst(available);
     return { instanceId: pick?.instanceId ?? "", model: pick?.models.default ?? "" };
 }
 /** Complete a new bot's selection with the workspace's new-bot effort. An

package/dist-server/server/delegations.js

@@ -195,6 +195,8 @@ export function _loadPending() {
                 }
                 if (item.oneWay === true)
                     loaded.oneWay = true;
+                if (item.completionOwner === "external")
+                    loaded.completionOwner = "external";
                 return [loaded];
             });
             if (items.length)
@@ -401,7 +403,7 @@ onSettled) {
                 if (outcome === "settled" && stillQueued) {
                     const receipt = findDelegationReceipt(item.id);
                     try {
-                        if (receipt && !item.oneWay)
+                        if (receipt && wakesSource(item))
                             onSettled?.(receipt);
                     }
                     catch (error) {
@@ -445,6 +447,10 @@ function appendDeliveryMessage(bus, sourceThreadId, item, message) {
         return;
     bus.store.appendMessage(threadId, message);
 }
+/** A settled handoff resumes the bot that queued it, unless its outcome
+ * belongs elsewhere: to a one-way send's recipient, or to an external
+ * runtime that polls for the receipt. */
+const wakesSource = (item) => !item.oneWay && item.completionOwner !== "external";
 const isExpired = (item, now) => now - item.queuedAt >= DELEGATION_TTL_MS;
 /** Past the busy-hold cap — the tighter bound that fires while its target is
  * still busy, long before the 24-hour window. */
@@ -528,15 +534,15 @@ export function expireStaleDelegations(bus, now, onSettled) {
             expireDelegation(bus, threadId, item, ownerId ?? item.sourceBotId);
             const receipt = findDelegationReceipt(item.id);
             if (receipt)
-                expired.push({ receipt, oneWay: item.oneWay === true });
+                expired.push({ receipt, wake: wakesSource(item) });
         }
     }
     if (!expired.length)
         return 0;
     savePending();
-    for (const { receipt, oneWay } of expired) {
+    for (const { receipt, wake } of expired) {
         try {
-            if (!oneWay)
+            if (wake)
                 onSettled?.(receipt);
         }
         catch (error) {
@@ -717,7 +723,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     const prefixed = item.targetThreadId
         ? item.message
         : `[Delegated by @${sender.name}, another bot in this OpenMausBot workspace. Do the work and reply directly.]\n\n${item.message}${reasonLine}`;
-    await runTarget(item.toBotId, prefixed, item.oneWay ? 0 : item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId, item.oneWay === true);
+    await runTarget(item.toBotId, prefixed, item.oneWay ? 0 : item.depth + 1, sourceThreadId, channel, item.id, sender.id, item.targetThreadId, item.oneWay === true, item.completionOwner);
     return "dispatched";
 }
 /** "Is the target free to take this handoff right now?" Both shapes ask for

package/dist-server/server/delta-context.js

@@ -109,6 +109,7 @@ export function recordHanded(state, order, received) {
     return {
         ...(state.session === undefined ? {} : { session: state.session }),
         ...(state.config === undefined ? {} : { config: state.config }),
+        ...(state.effort === undefined ? {} : { effort: state.effort }),
         ...(state.omitted === undefined ? {} : { omitted: state.omitted }),
         ...(through === undefined ? {} : { through }),
         ids: sorted,
@@ -241,10 +242,14 @@ export class Handoffs {
             ? pending.resumeCursor === undefined ? pending.started : pending.recovery
             : existing === undefined ? pending.resumed : undefined;
         if (!start) {
+            if (typeof pending.effort === "string" && existing?.session === session && existing.effort !== pending.effort) {
+                this.store.write(pending.botId, threadId, pending.instanceId, { ...existing, effort: pending.effort });
+            }
             this.add(threadId, pending, [...pending.placed, ...pending.carried]);
             return;
         }
-        this.store.write(pending.botId, threadId, pending.instanceId, recordHanded({ session, config: pending.config, ...(start.omitted === undefined ? {} : { omitted: start.omitted }), ids: [] }, this.store.order(threadId), start.sent));
+        this.store.write(pending.botId, threadId, pending.instanceId, recordHanded({ session, config: pending.config, ...(pending.effort === undefined ? {} : { effort: pending.effort }),
+            ...(start.omitted === undefined ? {} : { omitted: start.omitted }), ids: [] }, this.store.order(threadId), start.sent));
     }
     add(threadId, pending, received) {
         const session = pending.session ?? pending.resumeCursor;

package/dist-server/server/drivers/acp/core.js

@@ -31,6 +31,7 @@ import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { createHash } from "node:crypto";
 import { PROVIDER_CREDENTIAL_ENV, stripControlPlaneEnv, WORKSPACE_CREDENTIAL_ENV } from "../../config.js";
 import { decodeInjectId } from "../local-inject.js";
+import { DeviceAuthController } from "../device-auth.js";
 import { deletePromptSplitReceipt, promptHalves, readPromptSplitReceipt, splitSessionPrompt, writePromptSplitReceipt } from "../prompt-split.js";
 import { describeSpawnFailure, execCli, killCliTree, spawnCli } from "../../procs.js";
 import { classifyQuiet, describeQuiet, lastSeenPhrase, LogTail, quietKey, sampleProcessTree, } from "./quiet-status.js";
@@ -350,7 +351,7 @@ export function createAcpDriver(support) {
                 }
                 // The operator's own secrets are outside any driver's allowlist.
                 stripControlPlaneEnv(env);
-                support.transformEnv?.(env, activeConfig, instanceId);
+                support.transformEnv?.(env, activeConfig, instanceId, input.environment);
                 return env;
             };
             let models = support.models;
@@ -373,6 +374,9 @@ export function createAcpDriver(support) {
             };
             if (support.resolveModelsOnCreate !== false)
                 await refreshModels();
+            const deviceSignIn = support.deviceSignIn
+                ? new DeviceAuthController(support.deviceSignIn, { cli: config.cli, environment: () => childEnv(), onAuthenticated: refreshModels })
+                : null;
             const listeners = new Set();
             const active = new Map();
             // One live agent process per thread, kept across turns — the Claude
@@ -1904,6 +1908,11 @@ export function createAcpDriver(support) {
                     return models;
                 },
                 refreshModels: support.resolveModels ? refreshModels : undefined,
+                ...(deviceSignIn ? {
+                    startAuthentication: () => deviceSignIn.start(),
+                    getAuthentication: (flowId) => deviceSignIn.get(flowId),
+                    cancelAuthentication: () => deviceSignIn.cancel(),
+                } : {}),
                 snapshot,
                 adapter: {
                     provider: DRIVER_KIND,
@@ -1950,6 +1959,7 @@ export function createAcpDriver(support) {
                     },
                 },
                 dispose: async () => {
+                    await deviceSignIn?.dispose();
                     for (const { stop } of active.values())
                         stop();
                     for (const threadId of Array.from(sessions.keys()))

package/dist-server/server/drivers/acp/grok.js

@@ -20,6 +20,45 @@ export const STATIC_GROK_MODELS = {
     ],
 };
 const SLUG = /^[a-z0-9][a-z0-9._-]*$/i;
+/** Grok's own home: `$GROK_HOME`, else `~/.grok`. Its grok.com sign-in,
+ * config and catalog all live here. */
+export function grokHome(env = process.env) {
+    return env.GROK_HOME || harnessHome("grok", env);
+}
+/** The grok.com sign-in a turn runs on is stored. */
+export function grokSignedIn(env) {
+    return existsSync(join(grokHome(env), "auth.json"));
+}
+function grokLoginFailure(output) {
+    if (/(unexpected argument|unrecognized (argument|option)|unknown option).*device-(auth|code)/i.test(output)) {
+        return "This server's Grok is too old to sign in with a code. Update Grok on the server, then try again.";
+    }
+    if (/device-code login is not available/i.test(output)) {
+        return "This Grok account can't sign in with a code. Use an xAI API key instead.";
+    }
+    if (/expired/i.test(output))
+        return "The Grok sign-in code expired. Start sign-in again for a new code.";
+    if (/denied|rejected/i.test(output))
+        return "Grok sign-in was declined in the browser. Start sign-in again to try once more.";
+    return "Grok sign-in did not finish. Check the server's connection, then try again.";
+}
+/** Grok Build's half of the in-app sign-in (device-auth.ts): `grok login
+ * --device-auth` on the grok.com subscription. Grok has no status command,
+ * so nothing is checked first, and a stored login that a failed turn just
+ * refused is signed in again; the sign-in is confirmed the way a turn checks
+ * it. Checked against grok 1.0.25 and 1.0.41: `login --help` and the
+ * device-code text in their binaries. */
+export const GROK_DEVICE_SIGN_IN = {
+    provider: "grok",
+    product: "Grok",
+    account: "Grok",
+    homeEnv: "GROK_HOME",
+    homeDir: ".grok",
+    loginArgs: ["login", "--device-auth"],
+    install: "Install it with xAI's installer (https://x.ai/cli), then try again.",
+    failure: grokLoginFailure,
+    signedIn: grokSignedIn,
+};
 function unquote(raw) {
     const value = raw.trim();
     if (value.length >= 2 && value.startsWith('"') && value.endsWith('"')) {
@@ -30,7 +69,7 @@ function unquote(raw) {
 /** Local slugs from ~/.grok/config.toml, plus the cloud defaults.
  *  `grok -m <slug>` already accepts these; the picker just didn't list them. */
 export function readGrokModelCatalog(env = process.env) {
-    const path = join(env.GROK_HOME || harnessHome("grok", env), "config.toml");
+    const path = join(grokHome(env), "config.toml");
     let text = "";
     try {
         text = readFileSync(path, "utf8");
@@ -112,7 +151,7 @@ export function ensureGrokInjectSlug(modelId, env = process.env) {
     const host = localHost(inject.host);
     if (!host)
         return modelId;
-    const path = join(env.GROK_HOME || harnessHome("grok", env), "config.toml");
+    const path = join(grokHome(env), "config.toml");
     let text = "";
     try {
         text = readFileSync(path, "utf8");
@@ -215,7 +254,7 @@ export function grokInheritedProfile(cli, env, cwd) {
     let path = flag >= 0 ? (args[flag].includes("=") ? args[flag].slice(args[flag].indexOf("=") + 1) : args[flag + 1]) : undefined;
     if (flag >= 0 && (!path || path.startsWith("-")))
         return unsupported();
-    const files = [join(env.GROK_HOME || harnessHome("grok", env), "config.toml")];
+    const files = [join(grokHome(env), "config.toml")];
     for (let directory = resolve(cwd);;) {
         const file = join(directory, ".grok", "config.toml");
         if (!files.includes(file))
@@ -331,7 +370,7 @@ const support = {
     effortLevels: ["low", "medium", "high"],
     defaultCli: "grok",
     nativeSource: "grok.acp",
-    loginNote: "Grok CLI is not signed in — run `grok login` in a terminal",
+    loginNote: "Grok is not signed in to your grok.com account — choose Sign in to Grok in engine setup",
     // No Windows one-liner: the installer is a POSIX shell script, and offering
     // `curl … | bash` there would be advice that cannot run. Windows falls back
     // to docsUrl, which is honest rather than broken.
@@ -341,8 +380,11 @@ const support = {
             linux: "curl -fsSL https://x.ai/cli/install.sh | bash",
         },
         docsUrl: "https://x.ai/cli",
+        // The terminal route, for people who prefer it; the app's own sign-in
+        // is the device code below, which needs no terminal.
         signInCommand: "grok login",
     },
+    deviceSignIn: GROK_DEVICE_SIGN_IN,
     // Write the [model.slug] block with the instance HOME/GROK_HOME, then pass
     // the slug on argv. spawnArgs must not call ensureGrokInjectSlug itself —
     // that helper defaults to process.env and would miss the instance override.
@@ -458,7 +500,7 @@ const support = {
     // an unauthenticated CLI is a user action, not something to paper over.
     pickAuthMethod: (methods) => (methods.some((m) => m.id === "cached_token") ? "cached_token" : null),
     authFailure: "fail",
-    isAuthenticated: (env) => existsSync(join(harnessHome("grok", env), "auth.json")),
+    isAuthenticated: (env) => grokSignedIn(env),
     // `--append-system-prompt`/`--rules` are accepted by the CLI but do NOT
     // reach the agent-stdio system prompt (verified against 1.0.0), so the
     // persona is prepended codex-style.