openmausbot 0.1.94 → 0.1.96

package/dist-server/server/drivers/agents-proxy.js

@@ -1,34 +1,12 @@
-// Agent-to-agent comms MCP proxy — spawned as an MCP server inside a bot's
-// agent process (via the "agents" integration). Exposes peer, routine, and
-// skill tools routed back through the harness so the harness stays the
-// single owner of turns, permissions, and recursion limits. The coordination
-// tools are:
-//
-//   list_bots()                          → the other bots in this section + their status
-//   list_rooms()                         → the shared rooms this bot may post into
-//   post_to_room(group_id, message)      → put ONE message in a room; nobody's
-//                                          turn starts, so nobody replies
-//   ask_bot(bot_id, msg)                 → send msg to that bot, wait, return its reply
-//   delegate_bot(bot_id, msg, reason?)   → hand the task to a peer ASYNC: returns
-//                                          immediately, the peer runs after your
-//                                          current turn finishes, the result is
-//                                          delivered to the source conversation
-//   start_thread(title, msg, bot_id?)    → open a real thread — on yourself for
-//                                          separate work, or on a teammate as a
-//                                          handoff that runs on its own
-//   create_bot(name, role, instructions) → Chiefs can add a specialist to
-//                                          their own section
-//   create_room / manage_room            → Chiefs manage own-section rooms,
-//                                          never move bots or sections
-//   request_credential(id, reason?)       → show a secure, allowlisted key card
-//   list_routines()                       → inspect this bot's scheduled work
-//   propose_routine(...)                  → apply or request confirmation for a new routine
-//   propose_routine_action(...)           → apply or request confirmation for a routine change
-//   propose_profile(...)                  → apply or request confirmation for a profile change
+// The "agents" MCP server — spawned inside a bot's agent process (via the
+// "agents" integration). Exposes the teammate, room, routine, memory and
+// skill tools, each routed back through the harness so the harness stays the
+// single owner of turns, permissions, and recursion limits.
 //
 // Speaks raw JSON-RPC 2.0 over stdio (no MCP SDK — house style, matches
-// computer-proxy / permission-proxy). All state comes from env, injected by
-// the harness when it builds the integration:
+// permission-proxy). All state comes from env, injected by the harness when
+// it builds the integration (catalogProfileFromEnv and
+// toolCallContextFromEnv read it). The main ones:
 //   OMB_HARNESS_URL  base URL of the harness (http://127.0.0.1:8799)
 //   OMB_BOT_ID       the calling bot's id (excluded from list_bots; sender)
 //   OMB_COMMS_TOKEN  shared secret for the localhost-only internal endpoints
@@ -44,7 +22,8 @@ import readline from "node:readline";
 import { availableTools, catalogProfileFromEnv } from "./agents-catalog.js";
 import { callTool, capResult, toolCallContextFromEnv } from "./agents-call.js";
 const AVAILABLE_TOOLS = availableTools(catalogProfileFromEnv(process.env));
-// One proxy process serves one turn, so its per-turn guards start here.
+// A warm engine keeps this process across its turns; the harness keeps
+// every per-turn limit, so nothing here counts.
 const CONTEXT = toolCallContextFromEnv(process.env);
 const send = (msg) => process.stdout.write(JSON.stringify(msg) + "\n");
 const ok = (id, result) => send({ jsonrpc: "2.0", id, result });
@@ -61,7 +40,7 @@ async function handle(msg) {
             ok(id, {
                 protocolVersion: params.protocolVersion ?? "2024-11-05",
                 capabilities: { tools: {} },
-                serverInfo: { name: "opengrokbot-agents", version: "0.1.0" },
+                serverInfo: { name: "openmausbot-agents", version: "0.1.0" },
             });
             return;
         case "notifications/initialized":

package/dist-server/server/drivers/antigravity.js

@@ -1,5 +1,5 @@
 import { createAcpDriver } from "./acp/core.js";
-import { AntigravityAuthController, antigravityProfileAuthenticated, catalogFromAntigravityConfigOptions, prepareAntigravityProfile, probeAntigravityModels, validateAntigravityRuntime, } from "./antigravity-acp.js";
+import { AntigravityAuthController, antigravityProfileAuthenticated, prepareAntigravityProfile, probeAntigravityModels, validateAntigravityRuntime, } from "./antigravity-acp.js";
 import { antigravityManagedInstallAvailable, installAntigravityRuntime, resolveAntigravityRuntime, } from "./antigravity-runtime.js";
 import { resolveAntigravityReleaseAsset } from "./antigravity-release.js";
 import { VERIFICATION_TEMP_KEY, scheduleAntigravityTempSweep } from "./antigravity-temp.js";
@@ -20,9 +20,6 @@ export function antigravityPermissionMode(fullAuto, approvalMode) {
         return "yolo";
     return approvalMode === "edits" ? "auto_edit" : "default";
 }
-export function antigravityModelsFromSession(value) {
-    return catalogFromAntigravityConfigOptions(value, STATIC_ANTIGRAVITY_MODELS.default);
-}
 const managedAsset = resolveAntigravityReleaseAsset();
 const support = {
     driverKind: "antigravityAgent",

package/dist-server/server/drivers/boatagent.js

@@ -43,6 +43,22 @@ const providerFor = (model) => {
     }
     return { provider: model.startsWith("gpt") ? "codex" : "claude-code", model };
 };
+/** Boat answers a prompt it cannot run with 409 provider_not_configured: the
+ * Boat has no AI sign-in for the harness the model needs. Say that, and the
+ * one thing the person can do about it here. */
+export const PROVIDER_NOT_CONFIGURED_MESSAGE = "The Computer engine has no AI sign-in on its cloud computer. Choose another engine in this bot's settings.";
+/** An OMB Cloud's included Boat account has no agent sign-ins and never
+ * will: the operator's account must not run (or pay for) customers' models. */
+export const COMPUTER_ENGINE_CLOUD_UNAVAILABLE = "The Computer engine isn't available on OpenMaus Cloud — choose another engine.";
+/** The words of a Boat error envelope ({code, message, error:{code,
+ * message}}), never a bare code when Boat sent a sentence. */
+export function boatErrorMessage(body, status) {
+    const code = body?.code ?? body?.error?.code;
+    if (code === "provider_not_configured")
+        return PROVIDER_NOT_CONFIGURED_MESSAGE;
+    const message = body?.message ?? body?.error?.message ?? (typeof body?.error === "string" ? body.error : undefined) ?? code;
+    return typeof message === "string" && message.trim() ? message : `box HTTP ${status}`;
+}
 function decodeConfig(raw) {
     const o = (raw ?? {});
     return {
@@ -91,9 +107,8 @@ export const BoatAgentDriver = {
                 signal: opts.signal ?? AbortSignal.timeout(30_000),
             });
             const body = await res.json().catch(() => null);
-            if (!res.ok || body?.ok === false) {
-                throw new Error(body?.code ?? body?.error ?? `box HTTP ${res.status}`);
-            }
+            if (!res.ok || body?.ok === false)
+                throw new Error(boatErrorMessage(body, res.status));
             return body;
         };
         const sendTurn = async (turn) => {
@@ -103,6 +118,8 @@ export const BoatAgentDriver = {
             const boxId = computer && (!computer.kind || computer.kind === "box") ? computer.boxId : undefined;
             if (!account())
                 throw new Error('box not configured — add {"box":{"token":"…"}} to ~/.openmausbot/config.json');
+            if (account()?.included)
+                throw new Error(COMPUTER_ENGINE_CLOUD_UNAVAILABLE);
             if (!boxId) {
                 throw new Error("this bot has no computer yet — open the Computer panel and provision one");
             }
@@ -368,6 +385,8 @@ export const BoatAgentDriver = {
             if (!account()) {
                 return { state: "unavailable", reason: 'no Boat token — add {"box":{"token":"…"}} to ~/.openmausbot/config.json' };
             }
+            if (account()?.included)
+                return { state: "unavailable", reason: COMPUTER_ENGINE_CLOUD_UNAVAILABLE };
             try {
                 await api("/me");
                 return { state: "available", authenticated: true, version: null };
@@ -385,7 +404,7 @@ export const BoatAgentDriver = {
             snapshot,
             adapter: {
                 provider: DRIVER_KIND,
-                capabilities: { sessionModelSwitch: "in-session", remoteAgent: true, usesCloudComputer: true },
+                capabilities: { sessionModelSwitch: "in-session", remoteAgent: true },
                 sendTurn,
                 interruptTurn: async (threadId) => active.get(threadId)?.cancel(),
                 respondToRequest: async (threadId, requestId, decision) => {

package/dist-server/server/drivers/cerebras.js

@@ -37,7 +37,7 @@ export const CerebrasDriver = {
     install: {
         docsUrl: "https://cloud.cerebras.ai/",
         settings: "connections",
-        signInCommand: "Save a Cerebras API key in Settings → Connections, or set CEREBRAS_API_KEY on the server.",
+        signInCommand: "Save a Cerebras API key in Settings → API keys, or set CEREBRAS_API_KEY on the server.",
     },
     decodeConfig,
     defaultConfig: () => decodeConfig({}),
@@ -95,8 +95,8 @@ export const CerebrasDriver = {
                 ...(stream ? { stream_options: { include_usage: true } } : {}),
             }),
             httpErrorLabel: "Cerebras",
-            missingKeyError: "Save a Cerebras API key in Settings → Connections, or set CEREBRAS_API_KEY.",
-            unavailableReason: "No Cerebras API key — open Settings → Connections.",
+            missingKeyError: "Save a Cerebras API key in Settings → API keys, or set CEREBRAS_API_KEY.",
+            unavailableReason: "No Cerebras API key — open Settings → API keys.",
             timeoutMs: 180_000, billing: "metered", includeUsageInCompleted: true,
             nativeLog: {
                 source: "cerebras.chat.completions",

package/dist-server/server/drivers/chat-mcp-tools.js

@@ -7,7 +7,6 @@ import { stripControlPlaneEnv } from "../config.js";
 import { augmentedPath } from "../env-path.js";
 import { killCliTree, spawnCli } from "../procs.js";
 import { chatImage } from "./chat-images.js";
-import { ChatBoatClient } from "./chat-boat-tools.js";
 import { mcpStdioServer } from "../mcp-gate-config.js";
 import { allowsTool, canUseMcpServer, parseToolScope } from "../../shared/tool-scope.js";
 /** The transport cannot safely continue this turn. A dispatched operation may
@@ -238,7 +237,7 @@ const validatorOptions = {
     // or describe an open tuple. Ajv still enforces every constraint.
     strictRequired: false, strictTypes: false, strictTuples: false,
 };
-function compileSchema(schema) {
+export function compileToolSchema(schema) {
     const dialect = schema.$schema;
     if (dialect !== undefined && dialect !== "http://json-schema.org/draft-07/schema#" && dialect !== "https://json-schema.org/draft/2020-12/schema") {
         throw new Error("MCP tool schema uses an unsupported dialect; use JSON Schema draft-07 or 2020-12");
@@ -291,8 +290,6 @@ export async function mountChatTools(integrations, signal, computerUse = false,
     const scope = parsed.scope;
     const servers = [];
     const eligible = (server) => scope === undefined || canUseMcpServer(scope, server);
-    if (computerUse && integrations?.computer && eligible("computer"))
-        servers.push(["computer", integrations.computer]);
     if (computerUse && integrations?.localComputer && eligible("computer"))
         servers.push(["computer", integrations.localComputer]);
     if (computerUse && integrations?.browser && eligible("browser"))
@@ -339,10 +336,10 @@ export async function mountChatTools(integrations, signal, computerUse = false,
                 throw aborted();
             // Every mounted MCP server can return images when the caller enables
             // image delivery, including custom servers. Text stays bounded below.
-            const client = "boxId" in descriptor ? new ChatBoatClient(descriptor) : new ChatMcpClient(descriptor, computerUse);
+            const client = new ChatMcpClient(descriptor, computerUse);
             clients.push(client);
             const include = (tool) => scope === undefined || (object(tool) && typeof tool.name === "string" && allowsTool(scope, { kind: "mcp", server: name, name: tool.name }));
-            const tools = client instanceof ChatMcpClient ? await client.tools(signal, include) : (await client.tools()).filter(include);
+            const tools = await client.tools(signal, include);
             return { name, client, builtInBrowser: descriptor === integrations?.browser, tools };
         }));
         for (const mount of mounts) {
@@ -360,7 +357,7 @@ export async function mountChatTools(integrations, signal, computerUse = false,
                     throw new Error("MCP tools require an object input schema");
                 if (Buffer.byteLength(JSON.stringify(tool.inputSchema)) > SCHEMA_BYTES)
                     throw new Error("MCP tool schema exceeds the 64KB limit");
-                const schema = compileSchema(tool.inputSchema);
+                const schema = compileToolSchema(tool.inputSchema);
                 const parameters = { ...tool.inputSchema };
                 const constraints = {};
                 if (computerUse) {

package/dist-server/server/drivers/claude-login-auth.js

@@ -1,23 +1,14 @@
 import { randomUUID } from "node:crypto";
-import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, resolve } from "node:path";
+import { isAbsolute, join, resolve } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { killCliTree, spawnCli } from "../procs.js";
+import { canonicalPath } from "./codex-device-auth.js";
 const MAX_OUTPUT = 32_768;
 /** Where Anthropic's sign-in lives. Anything else in the CLI's output is not a link we show. */
 const SIGN_IN_HOSTS = ["claude.com", "claude.ai", "console.anthropic.com", "platform.claude.com"];
 // One login per credential home at a time; turns are never blocked by this.
 const authenticatingHomes = new Set();
-function canonicalPath(path) {
-    try {
-        return realpathSync(path);
-    }
-    catch {
-        const parent = dirname(path);
-        return parent === path ? path : join(canonicalPath(parent), basename(path));
-    }
-}
 /** The sign-in link, or null for anything that is not Anthropic's own page over https. */
 export function claudeSignInLink(value) {
     if (!value)

package/dist-server/server/drivers/claude.js

@@ -6,8 +6,9 @@
 //
 // Integrations become MCP servers on the CLI:
 //   - Composio Sessions (connected apps → tools) over streamable HTTP
-//   - the bot's cloud computer (boat.dev) via server/computer-proxy.ts
-//     — screenshot/exec/open_url, the CUA-on-the-boat bridge
+//   - every computer (this Mac, a Local VM, a VPS, or a Boat cloud
+//     computer through server/harness-mcp-proxy.ts computer) as the one
+//     stdio `computer` server in turn.integrations.localComputer
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
 import { createServer as createNetServer } from "node:net";
@@ -339,7 +340,7 @@ export function claudeCliUpdate(version, cli) {
     const effects = [
         ...(missing.includes("--autocompact") ? ["no compaction window picked by OpenMausBot"] : []),
         ...(missing.includes("--setting-sources") ? ["bots still see this machine's own Claude Code setup"] : []),
-        ...(missing.includes("--system-prompt-snapshot") ? ["coordinated resumed turns cannot refresh stale system prompts"] : []),
+        ...(missing.includes("--system-prompt-snapshot") ? ["resumed turns cannot refresh stale system prompts"] : []),
     ];
     return {
         title: "Update Claude Code for context controls",
@@ -1034,10 +1035,11 @@ export const ClaudeDriver = {
         // harness snapshots every instance whenever it describes them — app
         // load, the Engines page, and right after `claude update`, which is
         // exactly when the answer changes — so a turn normally finds it filled.
-        // Most flags before any snapshot assume a current CLI; autocompact
-        // requires confirmed help support. A coordinated turn checks first
-        // because the snapshot-refresh flag is newer than the
-        // other context controls and an unknown flag would reject that request.
+        // A turn that finds it empty reads the version itself first: the
+        // snapshot-refresh flag every turn passes is newer than the other context
+        // controls, and an unknown flag would reject the turn. If that read
+        // fails, most flags assume a current CLI; the snapshot flag needs a
+        // confirmed version and autocompact a confirmed help listing.
         let cliVersion = null;
         let cliVersionChecked = false;
         // Whether `claude --help` lists --autocompact, read once per CLI version
@@ -1203,7 +1205,7 @@ export const ClaudeDriver = {
                 args.push("--disallowedTools", config.disallowedTools.join(","));
             }
             const turnEnvironment = environment();
-            if ((turn.refreshSystemPrompt || turn.guestConfined || turn.toolScope !== undefined) && !cliVersionChecked) {
+            if (!cliVersionChecked) {
                 const version = await readCliVersion(turnEnvironment);
                 if (version) {
                     cliVersion = parseClaudeCliVersion(version);
@@ -1246,12 +1248,12 @@ export const ClaudeDriver = {
             if (compactWindow && cliHasAutocompact === true) {
                 args.push("--autocompact", compactWindow);
             }
-            // An old pair conversation can still carry its first assignment in
-            // Claude's recorded system prompt. The current brief rides in the user
-            // turn, so refresh the recorded prompt on --resume too. Gated by the
-            // version floor like every other flag the CLI may predate: an unknown
-            // flag is a hard argument error, not a graceful degrade.
-            if (turn.refreshSystemPrompt && cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
+            // A resumed conversation can still carry an earlier assignment, place
+            // or teammate list in Claude's recorded system prompt, so every turn
+            // refreshes the recorded prompt, on --resume too. Gated by the version
+            // floor like every other flag the CLI may predate: an unknown flag is a
+            // hard argument error, not a graceful degrade.
+            if (cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
                 args.push("--system-prompt-snapshot", "off");
             }
             const turnModel = config.managed ? turn.model : await resolveClaudeTurnModel(turn.model, turnEnvironment);

package/dist-server/server/drivers/codex-device-auth.js

@@ -9,7 +9,9 @@ const MAX_OUTPUT = 16_384;
 // Two configured instances can use the same on-disk login. Only the auth
 // operation is exclusive: normal turns are not blocked by this lock.
 const authenticatingHomes = new Set();
-function canonicalPath(path) {
+/** The real path of a credential home, so two spellings of one home share
+ * one sign-in lock. A missing tail keeps its name under its real parent. */
+export function canonicalPath(path) {
     try {
         return realpathSync(path);
     }

package/dist-server/server/drivers/codex.js

@@ -1567,10 +1567,11 @@ export const CodexDriver = {
                     // Only the stable half of the prompt belongs in the developer slot:
                     // it is the part that must survive compaction unchanged, and any
                     // change to it invalidates the provider's cached prefix. The volatile
-                    // half (memory, mentions, outstanding teammate work) is delivered
-                    // inside the turn that changed it, after the cached prefix, the same
-                    // contract SendTurnInput.systemStable documents. Without the split
-                    // the driver keeps the previous single-block behaviour.
+                    // half (the sections in VOLATILE_SECTIONS, system-prompt.ts) is
+                    // delivered inside the turn that changed it, after the cached
+                    // prefix, the same contract SendTurnInput.systemStable documents.
+                    // Without the split the driver keeps the previous single-block
+                    // behaviour.
                     const stableInstructions = typeof turn.systemStable === "string" && typeof turn.systemVolatile === "string"
                         ? turn.systemStable
                         : null;

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

@@ -45,7 +45,7 @@ export const GrokDriver = {
             generateModel: () => "grok-3-mini",
             nativeLog: {
                 source: "xai.chat.completions",
-                outgoing: (_turn, messages, model) => ({ model, messages }),
+                outgoing: (_turn, messages, model) => ({ model, messageCount: messages.length }),
                 incoming: ({ text, usage }) => ({ text, usage }),
             },
         });

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

@@ -1,4 +1,6 @@
-export const MAX_CHAT_TOOL_CALLS = 32;
+/** Calls one model reply may carry (its index bound). The turn's own total is
+ * MAX_TURN_TOOL_CALLS in openai-chat.ts. */
+const MAX_REPLY_TOOL_CALLS = 32;
 const MAX_ARGUMENT_CHARS = 256_000;
 export class ChatProtocolError extends Error {
 }
@@ -36,7 +38,7 @@ export class ChatToolCalls {
         for (const [position, raw] of value.entries()) {
             const delta = object(raw);
             const index = streaming ? delta?.index : position;
-            if (!delta || !Number.isInteger(index) || Number(index) < 0 || Number(index) >= MAX_CHAT_TOOL_CALLS) {
+            if (!delta || !Number.isInteger(index) || Number(index) < 0 || Number(index) >= MAX_REPLY_TOOL_CALLS) {
                 throw new ChatProtocolError("provider returned an invalid tool-call index");
             }
             const call = this.calls.get(Number(index)) ?? { id: "", type: "function", function: { name: "", arguments: "" } };

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

@@ -7,7 +7,7 @@ import { ChatToolSessionError, mountChatTools } from "./chat-mcp-tools.js";
 import { assertImageTransport, chatImageBudget, chatToolImages, chatUserContent } from "./chat-images.js";
 import { promptHalves, volatileContextNote, withContextNote } from "./prompt-split.js";
 import { createChatToolApproval } from "./chat-tool-approval.js";
-import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, MAX_CHAT_TOOL_CALLS, object } from "./openai-chat-protocol.js";
+import { ChatProtocolError, ChatReasoningDetails, ChatToolCalls, object } from "./openai-chat-protocol.js";
 import { appendNative } from "./native.js";
 import { classifyError, computeBackoff, interruptibleDelay, RETRY_MAX_ATTEMPTS } from "./retry.js";
 /** The message of a JSON error body a provider returned with HTTP 200.
@@ -31,6 +31,15 @@ const usageFrom = (usage) => usage
 const asError = (value) => value instanceof Error ? value : new Error(String(value));
 class UnsupportedChatToolsError extends Error {
 }
+/** One turn's safety stops: model steps, and tool calls across all of them.
+ * Tool-heavy models (a memory server, a browser) take dozens of steps, and
+ * a stopped turn cannot simply be continued — the next turn is rebuilt from
+ * the text transcript, which holds none of these tool results. The calls
+ * that ran have taken effect, so the stop asks only for what is left: a
+ * retry of the whole task would repeat them. */
+const MAX_CHAT_ROUNDS = 64;
+const MAX_TURN_TOOL_CALLS = 200;
+const stoppedAfter = (count) => `Stopped after ${count} without a final answer. The steps so far already ran, so ask only for what's left.`;
 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) {
@@ -325,7 +334,7 @@ export function createOpenAIChatRuntime(options) {
             throw new Error(options.missingKeyError);
         if (active.has(turn.threadId))
             throw new Error("a turn is already running on this thread");
-        if (options.computerUse && (turn.images?.length || turn.integrations?.computer || turn.integrations?.localComputer || turn.integrations?.browser))
+        if (options.computerUse && (turn.images?.length || turn.integrations?.localComputer || turn.integrations?.browser))
             assertImageTransport(options.apiUrl);
         const turnId = newId();
         const abort = new AbortController();
@@ -334,7 +343,7 @@ export function createOpenAIChatRuntime(options) {
         for (const message of messages)
             retainImages(message.content);
         const model = turn.model || options.models().default;
-        const secrets = [options.apiKey, turn.integrations?.computer?.token, turn.integrations?.computer?.control?.token].filter((value) => Boolean(value));
+        const secrets = [options.apiKey].filter((value) => Boolean(value));
         for (const integration of Object.values(turn.integrations ?? {})) {
             const entries = object(integration);
             const specs = entries && "command" in entries ? [entries] : Object.values(entries ?? {}).map(object);
@@ -413,7 +422,7 @@ export function createOpenAIChatRuntime(options) {
                 if (questionAllowed && !tools.definitions.some((definition) => definition.function.name === ASK_USER_TOOL)) {
                     tools.definitions.push(ASK_USER_TOOL_DEFINITION);
                 }
-                for (let round = 0; round < 16; round++) {
+                for (let round = 0; round < MAX_CHAT_ROUNDS; round++) {
                     abort.signal.throwIfAborted();
                     // Drain parked mid-turn input here, before the next completion
                     // request: the previous round's tool results are complete, so a
@@ -531,8 +540,9 @@ export function createOpenAIChatRuntime(options) {
                             throw new ChatProtocolError("provider reused a tool-call ID; refusing to repeat an operation");
                         seenCalls.add(call.id);
                     }
-                    if (seenCalls.size > MAX_CHAT_TOOL_CALLS)
-                        throw new ChatProtocolError("tool-call limit reached");
+                    // The whole batch is refused before any of it runs.
+                    if (seenCalls.size > MAX_TURN_TOOL_CALLS)
+                        throw new ChatProtocolError(stoppedAfter(`${MAX_TURN_TOOL_CALLS} tool calls`));
                     messages.push({ role: "assistant", content: completion.text || null, tool_calls: completion.toolCalls,
                         ...(completion.protocolReasoning && !reasoningReplayRejected.has(model) ? { [options.reasoningReplayField ?? "reasoning_content"]: completion.protocolReasoning } : {}),
                         ...(completion.protocolReasoningDetails.length ? { reasoning_details: completion.protocolReasoningDetails } : {}),
@@ -645,7 +655,7 @@ export function createOpenAIChatRuntime(options) {
                         messages.push({ role: "user", content: screenshotParts });
                 }
                 if (!ok)
-                    throw new ChatProtocolError("model-call limit reached before a final response");
+                    throw new ChatProtocolError(stoppedAfter(`${MAX_CHAT_ROUNDS} steps`));
             }
             catch (value) {
                 stopReason = abort.signal.aborted ? "interrupted" : stopReason ?? "error";
@@ -695,10 +705,7 @@ export function createOpenAIChatRuntime(options) {
         adapter: {
             provider: options.driverKind,
             capabilities: { ...(options.computerUse ? { computerMcp: options.tools !== false,
-                    // Same gate as cloudComputerMcp: with tools off the runtime cannot
-                    // mount the leased Boat descriptor either. The fleet invariant test
-                    // pins usesCloudComputer === (remoteAgent || cloudComputerMcp).
-                    usesCloudComputer: options.tools !== false, cloudComputerMcp: options.tools !== false, localComputerMcp: options.tools !== false,
+                    localComputerMcp: options.tools !== false,
                     browserMcp: options.tools !== false, nativeImageInput: true, images: true } : {}),
                 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

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

@@ -1,9 +1,9 @@
 // The stable/volatile prompt split, shared by the drivers that deliver it.
 // The stable half is everything that must stay byte-identical for a
 // provider's cached prefix (or a spawned CLI's session contract) to
-// survive; the volatile half (memory, mentions, outstanding teammate
-// work, recent work) legitimately changes mid-conversation and reaches
-// the model inside the turn that changed it, after the cacheable prefix.
+// survive; the volatile half (the sections in VOLATILE_SECTIONS,
+// system-prompt.ts) legitimately changes mid-conversation and reaches the
+// model inside the turn that changed it, after the cacheable prefix.
 import { createHash } from "node:crypto";
 import { mkdirSync, readFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
@@ -20,7 +20,7 @@ export function promptHalves(turn) {
     return { stable: systemStable, volatile: systemVolatile };
 }
 export const VOLATILE_CONTEXT_NOTE_PREFIX = "Context from OpenMausBot updated since this conversation started; it replaces any earlier copy:";
-export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation (memory, mentions, outstanding teammate work) have been cleared; the standing instructions still apply.";
+export const VOLATILE_CONTEXT_CLEARED_NOTE = "The OpenMausBot context notes from earlier in this conversation have been cleared; the standing instructions still apply.";
 /** The labelled block that carries a changed volatile half inside a user
  * turn. A half that is empty and always was needs no note; one that was
  * cleared announces the removal so the model stops relying on it. */

package/dist-server/server/drivers/retry.js

@@ -17,6 +17,10 @@ const TERMINAL_PATTERNS = [
         pattern: /\b(?:40[13]|unauthorized|forbidden|invalid api key|missing bearer|authentication required|not logged in|logged out)\b/i,
         reason: "auth",
     },
+    // A subscription's usage window is hours away, so its limit is terminal
+    // for this engine even when the provider phrases it as a rate limit;
+    // checked before the transient 429 pattern for that reason.
+    { pattern: /\busage limit\b|\bhit your (?:usage )?limit\b|\b(?:weekly|daily|monthly|subscription|usage) limit reached\b|\bout of credits\b/i, reason: "quota" },
     { pattern: /\b402\b|\bquota\b|\bbilling\b|\bsubscription\b/i, reason: "quota" },
     { pattern: /\bmodel not found\b|\bunknown model\b|\bdoes not exist for model\b|\bunsupported model\b/i, reason: "unknown_model" },
     { pattern: /\b400\b|\b422\b|\binvalid request\b|\bmalformed\b|\bunexpected status\b/i, reason: "invalid_request" },
@@ -50,14 +54,14 @@ export function classifyError(err) {
         const { exitCode: code } = err;
         if (code !== null && code < 0)
             return { transient: false, reason: "interrupted" };
-        for (const { pattern, reason } of TRANSIENT_PATTERNS) {
-            if (pattern.test(text))
-                return { transient: true, reason };
-        }
         for (const { pattern, reason } of TERMINAL_PATTERNS) {
             if (pattern.test(text))
                 return { transient: false, reason };
         }
+        for (const { pattern, reason } of TRANSIENT_PATTERNS) {
+            if (pattern.test(text))
+                return { transient: true, reason };
+        }
         return { transient: false, reason: "terminal_exit" };
     }
     for (const { pattern, reason } of TERMINAL_PATTERNS) {

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

@@ -4,7 +4,7 @@
 // driver's own install descriptor and never from a request, npm runs with
 // a fixed argument list, and the binary is found on the engines' PATH
 // afterwards because that directory is registered ahead of everything else.
-import { existsSync, mkdirSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { join } from "node:path";
 import { stripVTControlCharacters } from "node:util";
 import { DATA_DIR, stripWorkspaceCredentialEnv } from "./config.js";
@@ -169,7 +169,3 @@ function runNpm(args, env, cwd, timeoutMs) {
         });
     });
 }
-/** True once something has been installed here, for status pages. */
-export function enginesInstalled(baseDir = DATA_DIR) {
-    return existsSync(enginesBinDir(baseDir));
-}

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

@@ -4,6 +4,13 @@
 // a per-thread canonical NDJSON log (the debugging trick both upstream and
 // agentcal lean on), and delivered to subscribers (the SSE endpoint and
 // the server-side message folder).
+//
+// Streamed text is merged here, once, for every engine on every kind of
+// install: a provider sends a reply as hundreds of small text deltas, and
+// each would otherwise be its own log line, listener call and SSE frame. The
+// bus holds a thread's text for at most DELTA_MERGE_MS and publishes it as
+// one delta, sooner when anything else happens on that thread, so the order
+// of events never changes.
 import { appendFileSync } from "node:fs";
 import { join } from "node:path";
 import { EVENTS_DIR } from "../config.js";
@@ -11,10 +18,19 @@ import { redactSecrets } from "../redact.js";
 import { capThreadLog, currentThreadLogCap } from "../thread-log-rotation.js";
 import { newId } from "../contracts.js";
 const INCOMPLETE_LOG_MESSAGE = "Canonical event history is incomplete: OpenMausBot could not write one or more events to disk. Live updates will continue.";
+/** How long a thread's streamed text waits to be merged with what follows. */
+const DELTA_MERGE_MS = 50;
+/** Two deltas are one stream when only their text, id and time differ. */
+function sameStream(a, b) {
+    return a.provider === b.provider && a.providerInstanceId === b.providerInstanceId && a.turnId === b.turnId &&
+        a.itemId === b.itemId && a.streamKind === b.streamKind && a.synthetic === b.synthetic;
+}
 export class EventBus {
     listeners = new Set();
     unsubscribes = new Map();
     pendingLogWarnings = new Map();
+    /** Per thread: the streamed text not yet published, and when it goes. */
+    pendingText = new Map();
     appendLog;
     constructor(appendLog = appendFileSync) {
         this.appendLog = appendLog;
@@ -35,6 +51,38 @@ export class EventBus {
         }
     }
     publish(event) {
+        const pending = this.pendingText.get(event.threadId);
+        if (event.type === "content.delta") {
+            if (pending && sameStream(pending.event, event)) {
+                pending.event = { ...pending.event, delta: pending.event.delta + event.delta };
+                return;
+            }
+            if (pending)
+                this.flushThread(event.threadId);
+            const timer = setTimeout(() => this.flushThread(event.threadId), DELTA_MERGE_MS);
+            timer.unref?.();
+            this.pendingText.set(event.threadId, { event, timer });
+            return;
+        }
+        if (pending)
+            this.flushThread(event.threadId);
+        this.write(event);
+    }
+    /** Publish every thread's waiting text now: on detach, and as the server exits. */
+    flush() {
+        for (const threadId of Array.from(this.pendingText.keys()))
+            this.flushThread(threadId);
+    }
+    flushThread(threadId) {
+        const pending = this.pendingText.get(threadId);
+        if (!pending)
+            return;
+        // gone from the map before delivery: a listener may publish on this thread
+        this.pendingText.delete(threadId);
+        clearTimeout(pending.timer);
+        this.write(pending.event);
+    }
+    write(event) {
         const pendingWarning = this.pendingLogWarnings.get(event.threadId);
         const persistedEvents = pendingWarning ? [pendingWarning, redactSecrets(event)] : [redactSecrets(event)];
         try {
@@ -91,5 +139,6 @@ export class EventBus {
     detach(instanceId) {
         this.unsubscribes.get(instanceId)?.();
         this.unsubscribes.delete(instanceId);
+        this.flush();
     }
 }

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

@@ -228,7 +228,6 @@ export class ProviderRegistry {
                     modelVariants: inst.adapter.capabilities.modelVariants === true,
                     queueing: inst.adapter.capabilities.queueing === true,
                     localComputerMcp: inst.adapter.capabilities.localComputerMcp === true,
-                    cloudComputerMcp: inst.adapter.capabilities.cloudComputerMcp === true,
                     approvalReview: inst.reviewPermission !== undefined,
                 },
                 access: driver?.metadata.access ?? "subscription",