openmausbot 0.1.90 → 0.1.92

package/dist-server/server/boat.js

@@ -13,6 +13,7 @@
 import { createHash } from "node:crypto";
 import { DATA_DIR } from "./config.js";
 import { loadEnvironmentId } from "./environment.js";
+import { boatCredential, boatProviderApi } from "./included-services.js";
 import { adoptResolvedBoat, beginBoatCreate, boatCreateRecoverySnapshot, discardBoatCreate, rememberCreatedBoat, resolveBoatCreate, retireDeletedBoatCreate, } from "./boat-create-idempotency.js";
 import { boatDeletionSnapshot, getBoatDeletion, hasPendingBoatDeletionForBot, markBoatDeletionAccepted, markBoatDeletionBlocked, prepareBoatDeletion, retireBoatDeletion, } from "./boat-delete-journal.js";
 const shellQuote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
@@ -34,10 +35,8 @@ export function isolatedRemoteCommand(command) {
         shellQuote(command),
     ].join(" ");
 }
-// overridable so tests can point at a stub instead of the live provider.
 // Boat's provider surface keeps its historical Box-era names: env OMB_BOX_API,
 // base path /api/box/v1, REST paths /boxes/*, and the box_ token prefix.
-const BOAT_API = process.env.OMB_BOX_API || "https://ascii.dev/api/box/v1";
 const READY = new Set(["idle", "ready", "running"]);
 const SLEEPING = new Set(["archived", "archiving", "stopped", "stopping"]);
 const DEFAULT_BOAT_TTL_SECONDS = 8 * 60 * 60;
@@ -105,11 +104,15 @@ export function boatTurnLifecycleAction({ explicitCloud, canMount, state, }) {
 function snapshotBoatConfig(cfg) {
     return { box: cfg.box ? { token: cfg.box.token } : undefined };
 }
+/** The base URL follows the credential in use (included-services.ts): an own
+ * token goes to Boat (OMB_BOX_API points it at a stub in tests), Cloud Pro's
+ * included token only to its relay. */
 function boatFetch(cfg, path, opts = {}) {
-    return fetch(`${BOAT_API}${path}`, {
+    const account = boatAccount(cfg);
+    return fetch(`${account?.api ?? boatProviderApi()}${path}`, {
         ...opts,
         headers: {
-            authorization: `Bearer ${cfg.box?.token}`,
+            authorization: `Bearer ${account?.token}`,
             "content-type": "application/json",
             ...opts.headers,
         },
@@ -280,7 +283,7 @@ async function requestRecordedBoatDeletion(cfg, identity, pollDelaysMs = BOAT_DE
     }
     if (!removed.ok) {
         markBoatDeletionBlocked(identity.boxId);
-        throw Object.assign(new Error(boatErrorMessage(removed.status, "boat delete", removed.body)), { status: removed.status });
+        throw Object.assign(new Error(boatErrorMessage(removed.status, "boat delete", removed.body, usesIncludedBoat(cfg))), { status: removed.status });
     }
     const confirmation = await confirmAcceptedBoatDeletion(cfg, deletion, removed.body, pollDelaysMs);
     if (confirmation === "blocked")
@@ -346,6 +349,8 @@ async function mintDesktopUrl(cfg, boxId, { vncBudgetMs = 60_000 } = {}) {
 async function waitReady(cfg, boxId, budgetMs = 90_000) {
     assertBoatNotDeleting(boxId);
     const t0 = Date.now();
+    // Boat's words for the last failed resume, if the wait runs out on them.
+    let resumeFailure = null;
     while (Date.now() - t0 < budgetMs) {
         assertBoatNotDeleting(boxId);
         const { body } = await boatJson(cfg, `/boxes/${boxId}`);
@@ -354,11 +359,25 @@ async function waitReady(cfg, boxId, budgetMs = 90_000) {
             return body.box;
         if (state === "error")
             return null;
-        // an archiving boat can't resume until the snapshot lands — nudge after
-        if (state === "archived")
-            await boatJson(cfg, `/boxes/${boxId}/resume`, { method: "POST" });
+        // an archiving boat can't resume until the snapshot lands — nudge after.
+        // A refusal (a plan limit, say) is final: report it now. A server error
+        // is retried on the next poll, as Boat asks; 409 is a state race with a
+        // wake already under way.
+        if (state === "archived") {
+            const resumed = await boatJson(cfg, `/boxes/${boxId}/resume`, { method: "POST" });
+            if (resumed.ok)
+                resumeFailure = null;
+            else if (resumed.status !== 409) {
+                const message = boatErrorMessage(resumed.status, "waking the cloud computer", resumed.body, usesIncludedBoat(cfg));
+                if (resumed.status < 500)
+                    throw new Error(message);
+                resumeFailure = message;
+            }
+        }
         await new Promise((r) => setTimeout(r, 2500));
     }
+    if (resumeFailure)
+        throw new Error(resumeFailure);
     return null;
 }
 // Resolving a bot's boat means LISTing every boat in the account, so it is
@@ -367,9 +386,9 @@ async function waitReady(cfg, boxId, budgetMs = 90_000) {
 // whenever the direct read fails (deleted/renamed boat) and always carries
 // the live state so callers can still see "archived".
 const boatIdCache = new Map();
-function boatInventoryProblem(status, body) {
+function boatInventoryProblem(status, body, included = false) {
     if (status === 401 || status === 403) {
-        return "boat.dev rejected the Boat API key — update it in Settings → Connections";
+        return included ? INCLUDED_BOAT_UNAVAILABLE : "boat.dev rejected the Boat API key — update it in Settings → API keys";
     }
     if (status === 429)
         return "boat.dev is rate-limiting this account — wait a minute and refresh";
@@ -396,7 +415,11 @@ async function listBoatPages(cfg) {
             return { ok: false, problem: "Could not reach boat.dev to list cloud computers — check your connection and refresh" };
         }
         if (!listed.ok || !Array.isArray(listed.body?.boxes)) {
-            return { ok: false, problem: boatInventoryProblem(listed.status, listed.body), credentialRejected: listed.status === 401 || listed.status === 403 };
+            return {
+                ok: false,
+                problem: boatInventoryProblem(listed.status, listed.body, usesIncludedBoat(cfg)),
+                credentialRejected: listed.status === 401 || listed.status === 403,
+            };
         }
         boats.push(...listed.body.boxes);
         const next = listed.body?.pageInfo?.nextCursor;
@@ -672,7 +695,7 @@ export async function inspectBoatIdentity(cfg, boxId) {
         return { available: true, identity: null, problem: null };
     }
     if (!inspected.ok) {
-        return { available: false, identity: null, problem: boatInventoryProblem(inspected.status, inspected.body) };
+        return { available: false, identity: null, problem: boatInventoryProblem(inspected.status, inspected.body, usesIncludedBoat(cfg)) };
     }
     const candidate = inspected.body?.box;
     const returnedId = typeof candidate?.id === "string" ? candidate.id : "";
@@ -685,7 +708,7 @@ export async function inspectBoatIdentity(cfg, boxId) {
 function inventoryFailure(inventory) {
     const error = new Error(inventory.configured
         ? (inventory.problem ?? "Cloud computer inventory is unavailable")
-        : "Boat is not configured — add its API key in Settings → Connections");
+        : "Boat is not configured — add its API key in Settings → API keys");
     error.status = inventory.configured ? 503 : 409;
     return error;
 }
@@ -722,8 +745,9 @@ async function stopBoat(cfg, boxId) {
     // must never say a computer is sleeping when boat.dev rejected the action.
     await runCommand(cfg, boxId, QUIESCE_BROWSER, { timeoutMs: 5_000 }).catch(() => null);
     const stopped = await boatJson(cfg, `/boxes/${boxId}/stop`, { method: "POST" });
-    if (!stopped.ok)
-        throw Object.assign(new Error(boatErrorMessage(stopped.status, "boat sleep", stopped.body)), { status: stopped.status });
+    if (!stopped.ok) {
+        throw Object.assign(new Error(boatErrorMessage(stopped.status, "boat sleep", stopped.body, usesIncludedBoat(cfg))), { status: stopped.status });
+    }
 }
 function forgetBoatId(boxId) {
     for (const [botId, cachedId] of boatIdCache) {
@@ -854,15 +878,30 @@ export async function readyBoat(cfg, botId, budgetMs = 60_000) {
         return boat;
     return waitReady(cfg, boat.id, budgetMs);
 }
+/** The Boat credential a request uses: the person's own token, else Cloud
+ * Pro's included one. Settings' own-key flows read cfg.box.token instead. */
+export function boatAccount(cfg) {
+    return boatCredential(cfg.box?.token);
+}
 export function boatConfigured(cfg) {
-    return Boolean(cfg.box?.token);
+    return Boolean(boatAccount(cfg));
+}
+function usesIncludedBoat(cfg) {
+    return boatAccount(cfg)?.included === true;
+}
+/** What Settings shows: configured-or-not, and whether that is Cloud Pro's
+ * included account rather than a saved key. Never the token. */
+export function describeBoatAccount(cfg) {
+    const account = boatAccount(cfg);
+    return { configured: Boolean(account), ...(account?.included ? { included: true } : {}) };
 }
 /** Ask the provider whether a token is real, before we let someone save
  * it. Without this the paste "succeeds", and the first sign of trouble is
- * a 401 in a different panel minutes later, with nothing to act on. */
+ * a 401 in a different panel minutes later, with nothing to act on. Only
+ * ever an own token, so only ever Boat itself. */
 export async function verifyToken(token) {
     try {
-        const res = await fetch(`${BOAT_API}/boxes`, {
+        const res = await fetch(`${boatProviderApi()}/boxes`, {
             headers: { authorization: `Bearer ${token}` },
             signal: AbortSignal.timeout(20_000),
         });
@@ -884,11 +923,15 @@ export async function verifyToken(token) {
         return { ok: false, message: "Couldn't reach boat.dev to check that token — check your connection and retry." };
     }
 }
+/** A rejected Cloud Pro relay token: nothing the person pasted, so nothing
+ * for them to fix in Settings. */
+const INCLUDED_BOAT_UNAVAILABLE = "Cloud Pro's included cloud computers aren't available right now. Try again later.";
 /** Turn a provider refusal into something a person can act on. The
  * provider's own message is better than anything we can invent — it knows
  * the plan, the limit and the link — so prefer it and only fall back to
- * our own wording when it says nothing useful. */
-export function boatErrorMessage(status, what, body) {
+ * our own wording when it says nothing useful. `included`: the request used
+ * Cloud Pro's included token, not the person's own. */
+export function boatErrorMessage(status, what, body, included = false) {
     const theirs = typeof body?.message === "string" ? body.message.trim() : "";
     const link = typeof body?.error?.details?.billingUrl === "string" ? body.error.details.billingUrl : "";
     if (status === 402) {
@@ -896,6 +939,8 @@ export function boatErrorMessage(status, what, body) {
         return [theirs || "boat.dev needs a paid Boat plan before it will create a computer.", link].filter(Boolean).join(" ");
     }
     if (status === 401 || status === 403) {
+        if (included)
+            return INCLUDED_BOAT_UNAVAILABLE;
         return "your box token was rejected by boat.dev — open App Settings and paste a current token (it starts with box_)";
     }
     if (status === 429) {
@@ -1089,7 +1134,7 @@ export async function provisionBoat(cfg, botId, _botName) {
             // retry when boat.dev reports their shorter TTL ceiling.
             const createRes = await createBoat(cfg, botId, credentialEnv);
             if (!createRes.ok || !createRes.body?.box?.id) {
-                throw new Error(boatErrorMessage(createRes.status, "boat create", createRes.body));
+                throw new Error(boatErrorMessage(createRes.status, "boat create", createRes.body, usesIncludedBoat(cfg)));
             }
             boat = createRes.body.box;
             createRequest = createRes.request;
@@ -1099,7 +1144,7 @@ export async function provisionBoat(cfg, botId, _botName) {
                 body: JSON.stringify({ name: vmName }),
             });
             if (!rename.ok)
-                throw new Error(boatErrorMessage(rename.status, "box naming", rename.body));
+                throw new Error(boatErrorMessage(rename.status, "box naming", rename.body, usesIncludedBoat(cfg)));
             if (createRequest)
                 createRequest = resolveBoatCreate(createRequest);
         }

package/dist-server/server/bot-overview.js

@@ -144,14 +144,17 @@ export function grantsSummary(connectorTools) {
     })
         .sort((a, b) => (a.slug < b.slug ? -1 : 1));
 }
-function computerReach(computer) {
+function computerReach(computer, cloudHome = false) {
+    // A Cloud home never offers either; say so rather than list a preference
+    // that every task there refuses.
+    const unavailable = cloudHome ? ", which isn't available on OMB Cloud" : "";
     switch (computer) {
         case "cloud":
             return "Computer preference: cloud computer.";
         case "vm":
-            return "Computer preference: Local VM.";
+            return `Computer preference: Local VM${unavailable}.`;
         case "local":
-            return "Computer preference: this computer.";
+            return `Computer preference: this computer${unavailable}.`;
         case "browser":
             return "Computer preference: browser only.";
         case "off":
@@ -162,7 +165,7 @@ function computerReach(computer) {
 }
 function reachesLines(facts) {
     const lines = [];
-    const computer = computerReach(facts.bot.computer);
+    const computer = computerReach(facts.bot.computer, facts.cloudHome);
     if (computer)
         lines.push(computer);
     lines.push(facts.bot.cwd ? `Works in ${facts.bot.cwd}.` : "Works in its private workspace.");

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

@@ -442,8 +442,17 @@ export function agentBrowserIntegration(input) {
             ...(sourceEnv.USERPROFILE ? { USERPROFILE: sourceEnv.USERPROFILE } : {}),
         })),
     };
-    if (input.headless !== false)
+    // A Linux host with no display cannot run headed Chrome, and OMB's managed
+    // browser is headless automation (docs/browser-packaging.md). Pin headless
+    // there even for a headed-capable caller. The engine's own flag is
+    // AGENT_BROWSER_HEADED; an explicit "0" pins the default so a daemon that
+    // kept a headed launch config still comes back headless instead of failing
+    // every launch until it is killed by hand (#1383).
+    const displayless = (input.platform ?? process.platform) === "linux" && !sourceEnv.DISPLAY && !sourceEnv.WAYLAND_DISPLAY;
+    if (input.headless !== false || displayless) {
         env.AGENT_BROWSER_HEADLESS = "1";
+        env.AGENT_BROWSER_HEADED = "0";
+    }
     if (input.attachCdpUrl)
         env.AGENT_BROWSER_CDP = input.attachCdpUrl;
     // MCP clients may filter the parent environment. Carry the configured

package/dist-server/server/browser-live.js

@@ -39,6 +39,19 @@ function displayUrl(value) {
         return "";
     }
 }
+/** Chrome's own launch-failure wording: the engine is installed and its
+ * daemon answers, but no browser can start (no display, an early exit).
+ * Distinct from a missing engine — the fix is a fresh session, not an
+ * install, so the generic "check the engine is installed" guidance would
+ * send the operator the wrong way (#1383). */
+function browserLaunchFailure(error) {
+    const detail = [
+        error?.stderr,
+        error?.stdout,
+        error instanceof Error ? error.message : String(error),
+    ].filter((part) => typeof part === "string").join("\n");
+    return /missing x server|\$DISPLAY|devtoolsactiveport|chrome exited|could not launch|failed to launch|browser launch failed/iu.test(detail);
+}
 /** Project only the viewer protocol. Never relay engine commands, results or console output. */
 export function normalizeBrowserLiveMessage(value) {
     const message = object(value);
@@ -150,6 +163,7 @@ export function parseBrowserLiveAction(value) {
 export class BrowserLive {
     runtime;
     viewers = new Map();
+    sessionResets = new Map();
     constructor({ runtime }) { this.runtime = runtime; }
     current(viewer) {
         try {
@@ -298,12 +312,37 @@ export class BrowserLive {
                 throw new Error("stale viewer");
             const result = object(JSON.parse(stdout));
             const data = object(result?.data);
-            if (result?.success !== true || !data)
-                throw new Error("browser command failed");
+            if (result?.success !== true || !data) {
+                // Keep the engine's own error internal (logged, never sent) so a
+                // launch failure is recognized for what it is below.
+                const detail = [result?.error, result?.message].filter((part) => typeof part === "string").join(" ");
+                throw new Error(detail ? `browser command failed: ${detail}` : "browser command failed");
+            }
             return data;
         }
         catch (error) {
             console.warn("browser-live:", error);
+            if (browserLaunchFailure(error)) {
+                // The daemon is alive but holding a launch configuration Chrome
+                // cannot satisfy on this host (a headed launch with no display). It
+                // fails every command the same way until the daemon is killed —
+                // discard the session so the next connect starts a fresh one. One
+                // tracked reset per session: a reconnect or repeated command joins
+                // the in-flight teardown instead of spawning another (#1383).
+                if (!this.sessionResets.has(viewer.session)) {
+                    const reset = closeBrowserSession(viewer.spec.command, env).then((closed) => {
+                        if (closed)
+                            console.warn(`browser-live: reset ${viewer.session} after a failed browser launch; reconnecting starts a fresh session`);
+                        else
+                            console.warn(`browser-live: reset of ${viewer.session} after a failed browser launch did not finish; the next command retries it`);
+                        return closed;
+                    }, () => false);
+                    this.sessionResets.set(viewer.session, reset);
+                    void reset.finally(() => { if (this.sessionResets.get(viewer.session) === reset)
+                        this.sessionResets.delete(viewer.session); });
+                }
+                throw new BrowserLiveError("The browser could not start on this server. Reconnect to retry with a fresh browser session.", 503);
+            }
             throw new BrowserLiveError("The browser could not complete this action. Check that the browser engine is installed, then reconnect.", 503);
         }
     }
@@ -380,6 +419,11 @@ export class BrowserLive {
         options.res.once("close", () => this.close(viewer));
         options.res.once("error", () => this.close(viewer));
         try {
+            // A failed launch already started this session's daemon teardown; wait
+            // for it so the status probe meets a fresh daemon, not the stuck one.
+            const resetting = this.sessionResets.get(viewer.session);
+            if (resetting)
+                await resetting;
             let status = await this.command(viewer, ["stream", "status"]);
             if (status.enabled !== true) {
                 try {

package/dist-server/server/browser-runtime.js

@@ -1,6 +1,16 @@
 import { killCliTree, spawnCli } from "./procs.js";
 import { DEFAULT_BROWSER_RESULT_BUDGET, shapeBrowserToolResult, slimBrowserToolList, stripHarnessOwnedArguments } from "./browser-tool-shape.js";
 export const BROWSER_CONTROL_REFUSAL = "Browser tools are paused while a person controls this browser. Wait for them to hand control back; do not try another browser or execution tool.";
+/** Harness-owned recovery tool, advertised beside the engine's own tools. A
+ * phone or chat-only user has no Browser panel Restart button; without this
+ * an interrupted action refuses the bot's browser until the app restarts. */
+export const BROWSER_RESTART_TOOL = "restart_browser";
+const BROWSER_RESTART_TOOL_SPEC = {
+    name: BROWSER_RESTART_TOOL,
+    description: "Close and restart your browser. Use this only when a browser tool says a browser action was interrupted and the browser must be restarted. Open pages are closed; afterwards open the page you need again and check whether the interrupted action already happened before repeating it.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+};
+const BROWSER_INTERRUPTED = `A browser action was interrupted. Restart this browser with the ${BROWSER_RESTART_TOOL} tool before continuing.`;
 const MAX_REQUEST_BYTES = 1_048_576;
 const MAX_RESPONSE_BYTES = 16_777_216;
 /** Startup, not per-request work: a cold engine spawn can exceed a tight
@@ -200,10 +210,15 @@ class BrowserClient {
 export class BrowserRuntime {
     gates = new Map();
     clients = new Map();
+    /** Last advertised tools per session, so a turn that starts while the
+     * browser is uncertain still sees the tools it can use after recovering. */
+    toolLists = new Map();
     options;
-    constructor(options = {}) {
+    closeBrowser;
+    constructor({ closeBrowser, ...options } = {}) {
         const budget = Number(process.env.OMB_BROWSER_RESULT_BUDGET);
         this.options = { requestTimeoutMs: 120_000, takeoverTimeoutMs: 15_000, idleMs: 60_000, maxPending: 16, resultBudget: Number.isFinite(budget) && budget > 0 ? budget : DEFAULT_BROWSER_RESULT_BUDGET, ...options };
+        this.closeBrowser = closeBrowser ?? (async () => false);
     }
     gate(session) {
         let gate = this.gates.get(session);
@@ -227,7 +242,7 @@ export class BrowserRuntime {
         if (gate.owner !== null)
             throw new Error(BROWSER_CONTROL_REFUSAL);
         if (gate.uncertain)
-            throw new Error("A browser action was interrupted. Restart this browser before continuing.");
+            throw new Error(BROWSER_INTERRUPTED);
         if (gate.closing)
             throw new Error("The browser is closing. Try again shortly.");
         gate.agents++;
@@ -250,10 +265,21 @@ export class BrowserRuntime {
         // must refuse the closing window itself or its client outlives restart().
         if (method !== "tools/call" && this.gate(session).closing)
             throw new Error("The browser is closing. Try again shortly.");
+        if (method === "tools/call" && params && typeof params === "object" && params.name === BROWSER_RESTART_TOOL) {
+            beforeDispatch?.();
+            await this.agentRestart(session, () => this.closeBrowser(session, spec));
+            beforeDispatch?.(); // A turn revoked while the browser closed receives no result.
+            return { content: [{ type: "text", text: "Browser restarted. Open pages were closed; open the page you need again and check whether the interrupted action already happened before repeating it." }] };
+        }
         // Uncertainty survives client replacement and never self-resolves: refuse
-        // every new browser request until an explicit restart clears it.
-        if (this.gate(session).uncertain)
-            throw new Error("A browser action was interrupted. Restart this browser before continuing.");
+        // every new browser request until an explicit restart clears it. Listing
+        // never reaches the engine; it answers from the last list so the restart
+        // tool is reachable and the engine's tools are there once it succeeds.
+        if (this.gate(session).uncertain) {
+            if (method === "tools/list")
+                return withRestartTool(this.toolLists.get(session) ?? { tools: [] });
+            throw new Error(BROWSER_INTERRUPTED);
+        }
         const invoke = async () => {
             const key = JSON.stringify([spec.command, spec.args, Object.entries(spec.env).sort(([a], [b]) => a.localeCompare(b))]);
             let entry = this.clients.get(session);
@@ -281,8 +307,11 @@ export class BrowserRuntime {
                 const request = method === "tools/call" ? stripHarnessOwnedArguments(params) : params;
                 let result = await entry.client.rpc(method, request);
                 beforeDispatch?.(); // A turn revoked while the tool ran receives no result.
-                if (method === "tools/list")
-                    return slimBrowserToolList(result);
+                if (method === "tools/list") {
+                    const tools = withRestartTool(slimBrowserToolList(result));
+                    this.toolLists.set(session, tools);
+                    return tools;
+                }
                 const toolName = request && typeof request === "object" && typeof request.name === "string" ? request.name : undefined;
                 if (toolName === "agent_browser_open" && result && typeof result === "object" &&
                     result.isError !== true) {
@@ -448,6 +477,35 @@ export class BrowserRuntime {
             this.changed(gate);
         }
     }
+    /** The agent's own recovery, for a turn with no Browser panel to press
+     * Restart in. The same barrier as restart() — the native browser must
+     * close — but it never takes a person's hold, and a failed close leaves no
+     * owner behind that would lock a person out of the panel. */
+    async agentRestart(session, closeBrowser) {
+        const gate = this.gate(session);
+        if (gate.owner !== null)
+            throw new Error(BROWSER_CONTROL_REFUSAL);
+        if (gate.closing || gate.releasing || gate.agents || gate.humans)
+            throw new Error("The browser is busy. Wait for current work to finish before restarting.");
+        gate.ready = false;
+        gate.closing = true;
+        this.changed(gate);
+        try {
+            if (!await closeBrowser())
+                throw new Error("The browser could not be closed. Ask the person to press Restart in the Browser panel of OpenMausBot on their computer, or to restart OpenMausBot.");
+            await this.clients.get(session)?.client.stop();
+            await this.clients.get(session)?.client.stop(); // see restart()
+            gate.uncertain = false;
+        }
+        catch (error) {
+            gate.uncertain = true;
+            throw error;
+        }
+        finally {
+            gate.closing = false;
+            this.changed(gate);
+        }
+    }
     /** Call after the underlying browser is closed when recovering an uncertain
      * action. This closes the MCP transport, not saved logins or profile files. */
     async close(session) {
@@ -460,10 +518,18 @@ export class BrowserRuntime {
         await this.clients.get(session)?.client.stop();
         gate.closing = false;
         this.changed(gate);
-        if (!gate.owner && !gate.agents && !gate.humans)
+        if (!gate.owner && !gate.agents && !gate.humans) {
             this.gates.delete(session);
+            this.toolLists.delete(session);
+        }
     }
     async closeAll() {
         await Promise.all([...new Set([...this.clients.keys(), ...this.gates.keys()])].map((session) => this.close(session)));
     }
 }
+function withRestartTool(result) {
+    if (!result || typeof result !== "object" || !Array.isArray(result.tools))
+        return result;
+    const tools = (result.tools).filter((tool) => tool?.name !== BROWSER_RESTART_TOOL);
+    return { ...result, tools: [...tools, BROWSER_RESTART_TOOL_SPEC] };
+}

package/dist-server/server/browser-tool-shape.js

@@ -12,11 +12,13 @@
 import { trimResultText } from "./mcp-trim.js";
 /** Launch, session and network settings OpenMausBot owns through the
  * environment (see browser-engine.ts). A model has no business setting them
- * per call — `session` would reach another bot's browser, `extraArgs` and
- * `caCert` change the launch — and each one cost more schema than the tool's
- * own description. */
+ * per call — `session` would reach another bot's browser, `extraArgs`,
+ * `caCert` and `headed` change the launch — and each one cost more schema
+ * than the tool's own description. `headed` in particular overrides
+ * AGENT_BROWSER_HEADED and the managed config, so a single call can pin a
+ * daemon to a launch mode this host cannot satisfy (#1383). */
 export const HARNESS_OWNED_BROWSER_PARAMS = new Set([
-    "allowedDomains", "caCert", "clearCaCert", "extraArgs", "idleTimeout", "namespace",
+    "allowedDomains", "caCert", "clearCaCert", "extraArgs", "headed", "idleTimeout", "namespace",
     "restore", "restoreCheckFn", "restoreCheckText", "restoreCheckUrl", "restoreSave", "session", "timeoutMs",
 ]);
 /** Characters of one browser result that may enter the model's context.

package/dist-server/server/chief-of-staff.js

@@ -29,7 +29,7 @@ export function chiefOfStaffSystemPrompt(chiefId, bots, canDelegate, trustedOpen
     });
     const delegation = canDelegate
         ? boundedCoordination
-            ? "Use list_bots or list_room_targets for the live reachable roster. Use coordinate_bots to ask actual teammates for advice or assign concrete work. Outside a room, everything you send a teammate continues your one standing conversation with them, using their own model and permissions, so they still have the context of your earlier assignments. Busy teammates queue. Give self-contained briefs, then end your turn; you resume automatically after their results return. Leads can coordinate their own specialists. Do not poll, send acknowledgements as new work, or substitute native helpers for named bots. On return, verify the requested outcome, resolve decisions within the user's scope, request concrete corrections with rework=true when necessary, and return one consolidated answer. Consultations are advice, not proof that work or tests ran. A refusal from coordinate_bots means nothing was sent: fix what it names (usually the id — copy it from list_bots or your roster; a unique teammate name also works) and retry, and never describe a handoff the tool did not accept."
+            ? "Use list_bots or list_room_targets for the live reachable roster. Use coordinate_bots to ask actual teammates for advice or assign concrete work. Outside a room, each distinct assignment starts a fresh thread for that teammate, using their own model and permissions. Include the context they need in each brief. Busy teammates queue. Give self-contained briefs, then end your turn; you resume automatically after their results return. Leads can coordinate their own specialists. Do not poll, send acknowledgements as new work, or substitute native helpers for named bots. On return, verify the requested outcome, resolve decisions within the user's scope, request concrete corrections with rework=true when necessary, and return one consolidated answer. Consultations are advice, not proof that work or tests ran. A refusal from coordinate_bots means nothing was sent: fix what it names (usually the id — copy it from list_bots or your roster; a unique teammate name also works) and retry, and never describe a handoff the tool did not accept."
             : [
                 "Use list_bots to confirm the live roster and IDs. When assigning work to a teammate, use delegate_bot: it returns immediately, keeps you available to the user, and delivers the teammate's outcome back into this conversation automatically — success or failure. When the result arrives you are woken with it: report it to the user and act. If the teammate fails or stalls, tell the user plainly and decide the next step yourself.",
                 "After delegate_bot accepts the task, acknowledge the handoff and continue with any independent work or end your turn. Do not call wait_delegation or repeatedly poll check_delegation in the same turn.",