openmausbot 0.1.96 → 0.1.97

package/dist-server/server/index.js

@@ -53,6 +53,8 @@ import { avatarGenerationRequestSchema, avatarGenerationStateMatches, generateAv
 import { fitsOnOneLine, parseBotProfilePatch } from "./bot-profile.js";
 import { groupTurnCwd } from "./room-cwd.js";
 import { RoomTurnDeadline, RoomTurnStallRegistry, roomTurnTimeoutMessage } from "./room-turn-timeout.js";
+import { roomTurnEnd } from "./room-turn-end.js";
+import { pickComputer } from "./computer-selection.js";
 import * as boat from "./boat.js";
 import { cloudComputerRpc } from "./cloud-computer-tools.js";
 import { TeamComputers, teamComputerAssignment, teamComputerCreate, teamComputerOwner } from "./team-computers.js";
@@ -97,7 +99,7 @@ import { McpOAuthError, McpSignInError, McpOAuthManager, mcpOAuthRedirectUri, wi
 import { probeMcpServer } from "./mcp-probe.js";
 import { GROUP_GOAL_MAX_TURNS, groupGoalAssignmentKey, groupGoalCompletionTurnId, groupGoalCoordinatorInstructions, groupGoalWorkerInstructions, parseGroupGoalDecision, resolveGroupGoalMember, selectGroupGoalCoordinator, } from "./group-goal-run.js";
 import { BUILT_IN_DRIVERS } from "./drivers/builtIn.js";
-import { openCodeProviderKeysAllowed, setOpenCodeOwnProviderKeys, setOpenCodeProviderKeyPolicy } from "./drivers/acp/opencode-go.js";
+import { openCodeProviderKeysAllowed, setOpenCodeProviderKeyPolicy } from "./drivers/acp/opencode-go.js";
 import { getOrCreateChannel, mirrorActivity, mirrorExchange, mirrorReply } from "./comms-visibility.js";
 import { readMessageText, recallMessages, recentMessages, searchMessagesAsync, closeMessageSearch, closeMessageDb, chatFollowups, cancelledChatFollowup, settleChatFollowups, threadsReferencing } from "./message-db.js";
 import { briefCrossingLabel, claimRecallCrossings, recallCrossingLabel } from "./recall-disclosure.js";
@@ -118,12 +120,13 @@ import { ProviderRegistry } from "./harness/registry.js";
 import { ManagedDesktopProviders } from "./managed-desktop.js";
 import { computerKindForResource, ManagedDesktopPolicy } from "./managed-policy.js";
 import { hostedModelPolicy, HOSTED_MODEL_POLICY_HEADER, HOSTED_PROVIDER_SETTINGS_ERROR } from "./hosted-models.js";
-import { boatNotConfiguredMessage, CLOUD_HOME_SECRET_KEYS, CLOUD_IGNORED_KEYS, CLOUD_PAIRING_PATH, cloudHomeConfiguration, cloudHomeOffersPlace, cloudHomePlaceRefusal, createCloudPairing, firstCloudTurnPatch, readSignedBody, } from "./cloud-home.js";
+import { CLOUD_HOME_SECRET_KEYS, CLOUD_IGNORED_KEYS, CLOUD_PAIRING_PATH, cloudHomeConfiguration, cloudHomeOffersPlace, cloudHomePlaceRefusal, createCloudPairing, firstCloudTurnPatch, readSignedBody, } from "./cloud-home.js";
 import { CLOUD_PERSONAL_REFUSAL, settleCloudOwnership } from "./cloud-owner.js";
 import { createCloudMoveRoutes, workspaceShared } from "./cloud-move-http.js";
 import { RESTART_EXIT_CODE } from "./restart.js";
 import { holdIncludedServices } from "./included-services.js";
 import { selectDefaultModelSelection, withNewBotEffort } from "./default-model-selection.js";
+import { computerEngineMoveText, removedComputerInstanceIds, writeComputerEngineMoveLines } from "./computer-engine-removal.js";
 import { cancelPeerApprovalsFor, cancelPeerApprovalsForThread, dismissStalePeerCards, peerApprovalFailure, requestPeerApproval, resolvePeerComms } from "./peer-approval.js";
 import { peerDeliveryReceipt } from "./peer-delivery.js";
 import { peerProvenanceNote, withPeerProvenance } from "./peer-provenance.js";
@@ -136,6 +139,7 @@ import { createLiveSession, liveAttachUrl, LiveSessionError } from "./live-call.
 import { LiveCallController, LiveCallSignedOutError } from "./live-call-controller.js";
 import { narrateTool, toUtterances } from "./tts/speech-text.js";
 import { turnStartLogLine } from "./turn-log.js";
+import { makeCapContinuationSubscriber } from "./turn-continuation.js";
 import { buildRecoveryText, buildTurnContext, engineIsFresh, NATIVELY_REPLAYING_DRIVER_KINDS, peerMessageText } from "./turn-context.js";
 import { Handoffs, handedStateUsable, recordHanded, renderUnseen, sessionStart, unseenMessages, withUnseenMessages } from "./delta-context.js";
 import { extractTurnImages } from "./turn-images.js";
@@ -168,7 +172,7 @@ import { CalendarCallManager } from "./calendar-calls.js";
 import { BUILT_IN_BROWSER_SYSTEM_PROMPT } from "./browser-engine.js";
 import { BrowserRuntime, browserRuntimeEnv } from "./browser-runtime.js";
 import { BrowserLive } from "./browser-live.js";
-import { agentBrowserFrame, agentBrowserIntegration, browserEngineEncryptionKey, prepareBrowserSessionState, clearBrowserSessionState, closeBrowserSession, ensureChrome, installAgentBrowserBinary, resolveAgentBrowserBinary, browserEngineStatus, browserSessionId, describeBrowserEngine, } from "./browser-engine.js";
+import { agentBrowserFrame, agentBrowserIntegration, browserEngineEncryptionKey, prepareBrowserSessionState, clearBrowserSessionState, closeBrowserSession, ensureChrome, installAgentBrowserBinary, resolveAgentBrowserBinary, browserEngineStatus, browserSessionId, describeBrowserEngine, setBrowserViewport, } from "./browser-engine.js";
 import { createScreenFrameSource } from "./screen-frame-source.js";
 import { screenFrameHash, screenSurfaceForTool, screenTouchingTool, settledFrameIsNews } from "./screen-frame-gate.js";
 import { asSchedule, RoutineRequestService } from "./routine-requests.js";
@@ -208,10 +212,11 @@ import { createTeamBackup, importTeamBackup } from "./team-backup.js";
 import { MAX_TEAM_BACKUP_BYTES } from "../shared/team-backup.js";
 import { shouldMountLocalComputer } from "./local-routing.js";
 import { autoLocalVmAttachable } from "./container-computer.js";
-import { startAutoVmClaim } from "./auto-vm-claims.js";
+import { lazyClaimWaitMs, startAutoVmClaim } from "./auto-vm-claims.js";
 import { computerFreeAfterText, computerParkedText, computerStoppedWaitingText, computerWaitingText } from "./computer-wait.js";
 import { modelContextWindow } from "./model-context-window.js";
-import { cloudPlaceDriverError, parseSurface, PlaceUnavailableError, placeUnavailable, resolveSurface, surfaceLabel, surfaceOfComputerKind, surfacePrompt } from "./surface.js";
+import { cloudPlaceRefusal, computerToolsRefusal, parseSurface, PlaceUnavailableError, placeUnavailable, resolveSurface, surfaceLabel, surfaceOfComputerKind, surfacePrompt } from "./surface.js";
+import { cloudRefusal } from "../shared/place-view.js";
 import { PendingTurnCancellations, ProviderTurnGenerationRegistry, RetiredTurnRegistry, guardTurnDispatch, isTurnAdmissionBlocked, isTurnEventQuarantined, } from "./turn-dispatch-guard.js";
 import { createGracefulShutdown } from "./graceful-shutdown.js";
 import { acquireDataDirLeaseForProcess } from "./data-dir-lease.js";
@@ -244,6 +249,7 @@ import { localDesktopTarget, localVmViewerStatus, viewerTargetId } from "./deskt
 import { createAntigravityLeftoverRoutes } from "./routes/antigravity-leftovers.js";
 import { findAntigravityLeftovers, removeAntigravityLeftovers } from "./drivers/antigravity-temp.js";
 import { createLiveRoutes } from "./routes/live.js";
+import { withScopeHint } from "./connector-scope-hint.js";
 const PORT = Number(process.env.OMB_PORT || process.env.OGB_PORT || 8799);
 const WEBHOOK_PORT = Number(process.env.OMB_WEBHOOK_PORT || PORT + 1);
 // Behind a proxy or tunnel, the base URL senders should use (docs/self-hosting.md).
@@ -558,7 +564,7 @@ function cloudLendingTurn(capability) {
         generation: capability.generation,
         thread: store.messagesFor(capability.threadId),
         starters: cloudThreadStarters(capability.threadId),
-        reportsFromOthers: store.messagesFor(capability.threadId).some(cloudOthersRoutineReport),
+        reportsFromOthers: store.messagesFor(capability.threadId).some(cloudReportFromOthers),
         ownerPerson: cloudProvenOwnerPerson,
         cardAnswerer: cloudCardAnswerer,
         routineRun: () => {
@@ -601,11 +607,13 @@ function cloudThreadStarters(threadId) {
 function cloudLendingView(capability) {
     return CLOUD_HOME !== null && cloudHomeLendingRefusal(cloudLendingTurn(capability)) === null;
 }
-/** On a Cloud home: a routine's report (its lifecycle card, carrying what
- * the run said) of a routine the owner did not write, as it stands now. It
- * brings someone else's instructions' results into the conversation it
- * reports to. */
-function cloudOthersRoutineReport(line) {
+/** On a Cloud home: a line that brings someone else's words into the
+ * conversation it lands in: a "post" webhook's payload, or a routine's
+ * report (its lifecycle card, carrying what the run said) of a routine the
+ * owner did not write, as it stands now. */
+function cloudReportFromOthers(line) {
+    if (line.webhookPost)
+        return true;
     if (line.kind !== "routine.run" || !line.routineRun)
         return false;
     const routine = routines?.listRoutines().find((candidate) => candidate.id === line.routineRun.routineId);
@@ -627,7 +635,7 @@ function cloudOwnerOnlyThread(threadId) {
     const lastKey = last ? `${last.id}:${last.card?.answeredBy ? JSON.stringify(last.card.answeredBy) : ""}` : undefined;
     if (cached && cached.length === thread.length && cached.last === lastKey)
         return cached.owner;
-    const owner = ownerOnlyConversation(thread, cloudProvenOwnerPerson, cloudCardAnswerer) && !thread.some(cloudOthersRoutineReport);
+    const owner = ownerOnlyConversation(thread, cloudProvenOwnerPerson, cloudCardAnswerer) && !thread.some(cloudReportFromOthers);
     if (ownerOnlyCache.size > 5_000)
         ownerOnlyCache.clear();
     ownerOnlyCache.set(threadId, { length: thread.length, last: lastKey, owner });
@@ -776,16 +784,11 @@ function approvalShape(shape) {
 /** Who opens a routine's results conversation on a Cloud home: the writer
  * of this request, else the owner for a routine that is theirs (they wrote
  * it as it stands, or they are its writer: cloud-owner.ts), else its last
- * writer, else nobody. A webhook's run is the owner's: only their own
- * devices can create, edit or rotate one (admin scope), so it runs at the
- * bot's own level, in its folder, as on the desktop. Its payload still never
- * reaches the lent Mac: cloud-lending.ts refuses every webhook run. */
+ * writer, else nobody. */
 function routineOpener(routineId) {
     if (routineWriterInFlight)
         return routineWriterInFlight;
     const routine = routines?.listRoutines().find((candidate) => candidate.id === routineId);
-    if (!routine && CLOUD_OWNER_KEY && webhooks.list().some((hook) => hook.id === routineId))
-        return CLOUD_OWNER_KEY;
     if (routine && CLOUD_OWNER_KEY && cloudRoutineAuthors?.authored(routineId, routine))
         return CLOUD_OWNER_KEY;
     const writer = cloudRoutineAuthors?.writer(routineId);
@@ -868,7 +871,7 @@ function guestWorkThread(from, target, fromThreadId, brief) {
  * to have written, or a conversation or room a revoked session opened. What
  * the owner is told about one, and when its engine cannot be confined. */
 const ROUTINE_FROM_BEFORE = "This routine was made before this update. Open it and save it once to run it with full access.";
-const CONVERSATION_FROM_BEFORE = "This conversation is from before your Cloud was only yours, so this bot works in it without a shell. Start a new conversation to use it fully.";
+const CONVERSATION_FROM_BEFORE = "This conversation is from before My Cloud was only yours, so this bot works in it without a shell. Start a new conversation to use it fully.";
 function confinedWhy(threadId) {
     const run = activeRoutineRunForThread(threadId);
     const writer = run ? cloudRoutineAuthors?.writer(run.routineId) : undefined;
@@ -877,7 +880,7 @@ function confinedWhy(threadId) {
 function guestEngineRefusal(threadId) {
     const why = confinedWhy(threadId);
     return why === ROUTINE_FROM_BEFORE ? `This bot's engine can't run it that way. ${why}`
-        : "This conversation is from before your Cloud was only yours, and this bot's engine can't work in it. Start a new conversation.";
+        : "This conversation is from before My Cloud was only yours, and this bot's engine can't work in it. Start a new conversation.";
 }
 /** On a Cloud home: a turn a guest drives, which runs in Ask whatever the
  * bot's own level (no Full access, no Auto reviewer, no saved commands), with
@@ -1528,8 +1531,6 @@ const openCodeKeysAllowed = () => openCodeProviderKeysAllowed({
     sharedSignIn: sharedSignIn(signInAllowList()),
 });
 setOpenCodeProviderKeyPolicy(openCodeKeysAllowed);
-// Keys the owner saved for OpenCode in Settings reach it on every server.
-setOpenCodeOwnProviderKeys(() => openCodeProviderKeys(cfg));
 let openCodeKeysLastAllowed = openCodeKeysAllowed();
 /** OpenCode lists a provider's models only while it may read that
  * provider's key. When enrollment or the sign-in list changes the answer,
@@ -1677,8 +1678,6 @@ function computerPlaceRefusal(kind) {
     const managed = managedPolicy.computerRefusal(kind);
     return managed ? { message: managed, code: "managed_policy" } : undefined;
 }
-/** Cloud chosen with no Boat account: a Cloud home suggests the browser, not a Local VM. */
-const BOAT_NOT_CONFIGURED = boatNotConfiguredMessage(Boolean(CLOUD_HOME));
 /** Why the organisation refuses this instance for bots, or undefined. */
 function policyModelRefusal(instance) {
     const engine = BUILT_IN_DRIVERS.find(driver => driver.driverKind === instance.driverKind)?.metadata.displayName;
@@ -1794,6 +1793,11 @@ function externalRuntimeMayCall(method, path) {
         return path === "/api/internal/agents" || /^\/api\/internal\/delegations\/[\w-]+$/.test(path);
     return method === "POST" && (path === "/api/internal/ask-bot" || path === "/api/internal/delegate-bot");
 }
+/** An external runtime polls check/wait_delegation for what it hands off, so
+ * the result must not also wake the bot's own engine on the pinned thread. */
+function externalCompletion(capability) {
+    return capability.generation === EXTERNAL_RUNTIME_GENERATION ? { completionOwner: "external" } : {};
+}
 function externalRuntimeCapability(header) {
     const grant = authorizeExternalRuntime(EXTERNAL_RUNTIMES_FILE, header, id => store.bot(id));
     if (!grant)
@@ -2087,14 +2091,63 @@ class ComputerWaitParked extends Error {
         this.generation = generation;
     }
 }
-/** A place the turn was told to use failed to attach: its cause plus the one
- * control that changes it (placeUnavailable). A cancelled setup, a parked
- * computer wait and an already-worded place failure pass through as they
- * are. The one wrapper for a bot thread and a room turn. */
-function asPlaceFailure(error, place, source, limit) {
+/** A failed place never sticks: an Auto-recorded pin to it (a
+ * select_computer switch, or where an earlier Auto turn landed) is the
+ * machine's memory, not a choice, so the next message runs on Auto. A
+ * person's pin stays. */
+function clearFailedAutoPin(botId, threadId, place) {
+    const pinned = store.taskByThread(botId, threadId);
+    if (pinned?.surface === place && pinned.surfaceSource === "auto") {
+        store.patchTask(botId, threadId, { surface: undefined, surfaceSource: undefined });
+    }
+}
+/** A place the turn was told to use failed to attach, read as one state of
+ * shared/place-view.ts: a cloud computer's refusal by its code or words, any
+ * other place by its own words. Its source decides the one way on. A
+ * cancelled setup, a parked computer wait and an already-read place failure
+ * pass through as they are. The one wrapper for a bot thread and a room
+ * turn, at dispatch and at a cloud computer's start on its first call. */
+async function asPlaceFailure(error, place, source, bot, backend = "box") {
     if (error instanceof DirectTurnSetupCancelled || error instanceof ComputerWaitParked || error instanceof PlaceUnavailableError)
         return error;
-    return placeUnavailable(place, source, error instanceof Error ? error.message : String(error), limit);
+    const failure = error instanceof Error ? error : new Error(String(error));
+    const cause = failure.message.trim().replace(/[\s.]+$/, "");
+    if (place !== "cloud" || backend === "vps") {
+        return placeUnavailable(place, {
+            state: "place-failed", params: { bot: bot.name, cause: `${cause.charAt(0).toUpperCase()}${cause.slice(1)}.` }, source,
+        }, Boolean(CLOUD_HOME));
+    }
+    // A Boat refusal keeps the provider's own status and code (boat.ts
+    // boatRefusal); a failed read of the account keeps its status.
+    const { boatCode, boatStatus, status } = failure;
+    const providerStatus = typeof boatStatus === "number" ? boatStatus : typeof status === "number" ? status : undefined;
+    const read = cloudRefusal({
+        message: failure.message,
+        ...(typeof boatCode === "string" ? { code: boatCode } : {}),
+        ...(providerStatus !== undefined ? { status: providerStatus } : {}),
+    }, boat.boatAccount(cfg)?.included === true);
+    const row = { state: read.state, params: { bot: bot.name, ...read.params }, source };
+    if (row.state === "cc-at-once")
+        row.params.holders = await cloudComputerHolders(bot.id);
+    return placeUnavailable(place, row, Boolean(CLOUD_HOME));
+}
+/** The bots that hold this account's cloud computers, other than `botId`,
+ * from this installation's own Boat list. Empty when it can't be read. */
+async function cloudComputerHolders(botId) {
+    try {
+        const listed = await boat.listManagedBoats(cfg, managedBoatOwners(), { adoptLegacy: false });
+        return [...new Set(listed.instances
+                .filter((instance) => instance.ownerBotId && instance.ownerBotId !== botId && instance.ownerName)
+                .map((instance) => instance.ownerName))];
+    }
+    catch {
+        return [];
+    }
+}
+/** Cloud chosen with no cloud computers here: on a Cloud home they are the
+ * plan's, so they are only unavailable; anywhere else they need a Boat key. */
+function boatNotConfigured(bot, source) {
+    return placeUnavailable("cloud", { state: CLOUD_HOME ? "cc-unavailable" : "cc-needs-key", params: { bot: bot.name }, source }, Boolean(CLOUD_HOME));
 }
 const directTurnDispatchClaims = new Map();
 const directTurnGenerationByThread = new Map();
@@ -2520,6 +2573,7 @@ const browserRuntime = new BrowserRuntime({
             browserLive.closeForSession(session);
         return closed;
     },
+    applyViewport: (spec) => setBrowserViewport(spec.command, spec.env),
 });
 const browserLive = new BrowserLive({ runtime: browserRuntime });
 // Temporary profiles last for this server run, but are never saved to disk.
@@ -2704,7 +2758,7 @@ function controlIntegration(botId, threadId, generation, machine = {}) {
             depth: 0,
             kind: "computer",
             ...(localVmTarget ? { localVmTarget } : {}),
-            ...(boxId ? { boxId } : {}),
+            ...(boxId !== undefined ? { boxId } : {}),
             ...(teamComputerTurns.get(threadId) ? { teamComputerId: teamComputerTurns.get(threadId).computerId } : {}),
             skillAuthoring: false,
             createdBots: 0,
@@ -2767,17 +2821,89 @@ function askBotAndWait(targetBotId, message, depth, fromBotId, fromThreadId, tar
         }).catch((err) => finish({ status: "error", text: `(couldn't start that bot: ${err instanceof Error ? err.message : String(err)})` }));
     });
 }
-// New bots honor setup's saved choice; unconfigured workspaces prefer Claude.
-// While enrolled, a Company model that can run beats a signed-out personal
-// engine, and the organisation's policy is respected; otherwise inert.
-async function defaultSelection() {
+// New bots honor setup's saved choice; without one, an engine that can run a
+// turn now (Claude first). While enrolled, a Company model that can run beats
+// a signed-out personal engine, and the organisation's policy is respected;
+// otherwise inert. `null` leaves the saved choice out (moveOffComputerEngine).
+async function defaultSelection(saved = cfg.defaultModelSelection ?? null) {
     if (hostedModels)
-        return hostedModels.select(cfg.defaultModelSelection);
-    return selectDefaultModelSelection(await registry.describe(), cfg.defaultModelSelection, {
+        return hostedModels.select(saved ?? undefined);
+    return selectDefaultModelSelection(await registry.describe(), saved ?? undefined, {
         company: (instanceId) => managedDesktop.owns(instanceId),
         refusal: (instance) => policyModelRefusal(instance),
     });
 }
+/** The Computer engine was removed: it ran a whole turn on Boat's own agent.
+ * Everything still set to it moves, once, to the engine a new bot gets
+ * (defaultSelection, the one picker), or the one a new bot would get without
+ * the saved choice when that cannot run: the saved default and new-bot
+ * defaults, each bot and conversation (Store.retireInstances keeps each one
+ * where it worked), and an automatic-recovery backup, which could never run
+ * and is cleared. Each moved conversation says so in one plain line. When no
+ * engine is available yet it runs again the next time the engines are read
+ * (describeInstances): an install, a sign-in, a key or a Company engine. At
+ * start it sees what a new bot made then would see; a policy that arrives
+ * later refuses an engine for a moved bot the way it does for any bot. A
+ * hosted workspace's reconcile has already moved every bot onto its own
+ * models. */
+async function moveOffComputerEngine() {
+    if (hostedModels)
+        return;
+    const removed = removedComputerInstanceIds(cfg.instances);
+    const named = (selection) => Boolean(selection && removed.has(selection.instanceId));
+    if (named(cfg.automaticRecovery?.backup)) {
+        saveConfig({ automaticRecovery: { enabled: false } });
+        cfg.automaticRecovery = { enabled: false };
+    }
+    const defaults = named(cfg.defaultModelSelection) || named(cfg.newBotDefaults?.profile.modelSelection);
+    if (!defaults && !store.bots.some(bot => named(bot.modelSelection) || bot.fallback?.some(named) ||
+        store.tasks(bot.id).some(task => named(task.modelSelection))))
+        return;
+    let replacement = named(cfg.defaultModelSelection) ? { instanceId: "", model: "" } : await defaultSelection();
+    if (!replacement.instanceId)
+        replacement = await defaultSelection(null);
+    if (!replacement.instanceId) {
+        console.warn("[engines] the Computer engine was removed and no other engine is available yet; its bots move when one is");
+        return;
+    }
+    if (defaults) {
+        // One write keeps both saved defaults on the replacement (saveConfig
+        // syncs them), and the copies in memory follow at once, so a bot made
+        // before the next start never lands on the removed engine.
+        const newBotDefaults = cfg.newBotDefaults && newBotDefaultsSchema.parse({
+            ...cfg.newBotDefaults, profile: { ...cfg.newBotDefaults.profile, modelSelection: replacement },
+        });
+        saveConfig(newBotDefaults ? { newBotDefaults } : { defaultModelSelection: replacement });
+        cfg.defaultModelSelection = replacement;
+        if (newBotDefaults)
+            cfg.newBotDefaults = newBotDefaults;
+    }
+    const instance = registry.get(replacement.instanceId);
+    const engine = instance?.displayName ?? instance?.driverKind ?? replacement.instanceId;
+    const moves = store.retireInstances(removed, replacement, {
+        driverKind: instance?.driverKind,
+        canWorkOnCloud: canWorkOnCloud(cloudEngine(instance)),
+        keepCloud: (bot) => boat.boatConfigured(cfg) && bot.cloudBackend !== "vps" && !inheritedTeamComputer(bot),
+    });
+    writeComputerEngineMoveLines(moves, (move) => {
+        const bot = store.bot(move.botId);
+        if (bot)
+            store.appendMessage(move.threadId, { role: "bot", kind: "activity", tool: { name: computerEngineMoveText(move, bot.name, engine), ok: true } });
+    });
+}
+let computerEngineMoveRunning = null;
+/** The move, once at a time; it returns at once when nothing names the
+ * removed engine any more. A failure is logged and never rejects, so it never
+ * stops this server from listening. Bots whose save failed are unchanged and
+ * move the next time the engines are read (describeInstances) or a turn
+ * reaches one of them (startTurn), so a server no app reads the engines from
+ * still moves them. */
+function retryComputerEngineMove() {
+    computerEngineMoveRunning ??= moveOffComputerEngine()
+        .catch((error) => console.warn(`[engines] moving bots off the removed Computer engine failed: ${error instanceof Error ? error.message : String(error)}`))
+        .finally(() => { computerEngineMoveRunning = null; });
+    return computerEngineMoveRunning;
+}
 function checkedModelSelection(raw, current, requireAvailableModel = false) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return { ok: false, status: 400, error: "modelSelection must be an object" };
@@ -3081,6 +3207,8 @@ const store = new Store(() => bootSelection, (selection) => withNewBotEffort(sel
 const teamComputers = new TeamComputers(join(DATA_DIR, "team-computers.json"), ENVIRONMENT_ID);
 let followupsReady = false;
 const sendSequencer = new SendSequencer();
+// Before the new-bot default is read: a saved default may name the engine.
+await retryComputerEngineMove();
 bootSelection = await defaultSelection();
 store.seedIfEmpty();
 hostedModels?.reconcile(store);
@@ -3190,7 +3318,6 @@ function previewSystemPrompt(bot) {
     const computerPromptKind = resolveComputerPromptKind({
         kind: previewComputer === "vm" ? "vm" : previewComputer === "cloud"
             ? bot.cloudBackend === "vps" ? "vps" : "box" : previewComputer === "local" ? "local" : null,
-        driverKind: instance?.driverKind,
         vmPrivate: localVmMode(cfg) === "per-bot",
     });
     const peers = reachablePeers(store.bots, bot);
@@ -3230,7 +3357,7 @@ function previewSystemPrompt(bot) {
                 computer: previewPlan.computer && previewPlan.computer !== "off" && computerPromptKind ? previewPlan.computer : null,
                 browser: previewPlan.computer === undefined ? false : previewPlan.browser,
             }, { note: previewPlan.note, cloudHome: Boolean(CLOUD_HOME) }) },
-        { id: "cloud-home", label: "OMB Cloud", text: CLOUD_HOME ? cloudHomePrompt(agentsMounted && lendingEnabled()) : "" },
+        { id: "cloud-home", label: "My Cloud", text: CLOUD_HOME ? cloudHomePrompt(agentsMounted && lendingEnabled()) : "" },
         { id: "composio", label: "Connected apps", text: caps?.composioMcp && bot.composio !== false && composio.configured(cfg) ? composioSystemPrompt(bot.connectorTools) + describeConnectorScopes(bot.connectorScopes) : "" },
         { id: "mcp", label: "MCP servers", text: caps?.customMcp ? customMcpPrompt(Object.keys(engineMcpServers(bot))) : "" },
         { id: "browser", label: "Browser", text: previewPlan.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
@@ -5449,6 +5576,10 @@ bus.subscribe((event) => {
     else if (event.type !== "session.exited")
         watchdog.touch(event.threadId);
 });
+// Automatic continuity: a turn that died on its budget or on tool errors gets
+// a `Continue:` task on the same bot, seeded with the persisted handoff — the
+// work moves forward without a person noticing and re-dispatching.
+bus.subscribe(makeCapContinuationSubscriber({ store, startTurn }));
 // Memory journal turn boundary (server/memory-journal.ts). A bot's own
 // file-tool writes to MEMORY.md and memory/ have no hook to tap, so the
 // diff against the baseline taken at dispatch is made when the turn
@@ -5945,7 +6076,7 @@ function inheritedTeamComputer(bot) {
     return teamComputers.forBot(bot);
 }
 function teamComputerPrompt(computer) {
-    return computer ? `Your team shares the Boat computer ${JSON.stringify(computer.name)}. Its desktop files and desktop browser logins are shared with other Auto bots in your team; only one turn may drive it at a time. The separate built-in Browser is not this desktop and does not automatically share its logins.` : "";
+    return computer ? `Your team shares the cloud computer ${JSON.stringify(computer.name)}. Its desktop files and desktop browser logins are shared with other Auto bots in your team; only one turn may drive it at a time. The separate built-in Browser is not this desktop and does not automatically share its logins.` : "";
 }
 function botComputerControlKey(bot) {
     const computer = inheritedTeamComputer(bot);
@@ -5956,21 +6087,26 @@ async function computerCallGate(internalCapability) {
     const snapshot = botComputerControlSnapshot(botId, internalCapability.teamComputerId);
     const slot = autoVmClaims.get(internalCapability.threadId);
     const lazyClaim = slot && slot.owner.generation === internalCapability.generation ? slot : undefined;
-    if (!snapshot.held && lazyClaim?.lazy && !lazyClaim.begin) {
-        // First screen tools/call on a lazily-attached Auto VM (issue
+    const waitMs = snapshot.held ? null : lazyClaimWaitMs(lazyClaim, LAZY_VM_CLAIM_GRACE_MS);
+    if (lazyClaim && waitMs !== null) {
+        // First screen tools/call on a lazily-attached computer (issue
         // #1361): fire the exclusive claim — once — and give it a moment
         // to land. A free, ready VM claims in the time of one container
         // inspect, so this call then proceeds with an honest answer;
         // only a claim still queued behind another holder answers held
-        // below, and then the contention text is true. Keyed on the
-        // slot, never on the thread's turn-computer entry: a bind this
+        // below, and then the contention text is true. A cloud computer's
+        // claim creates or wakes it, so every call waits on that start
+        // (graceMs) instead of being told someone else holds it. Keyed on
+        // the slot, never on the thread's turn-computer entry: a bind this
         // turn abandoned earlier (a VPS that turned out to be asleep)
         // must not hide the unclaimed VM and let the call through.
         startAutoVmClaim(autoVmClaims, internalCapability.threadId, internalCapability.generation);
+        let timer;
         await Promise.race([
             lazyClaim.begin ?? Promise.resolve(),
-            new Promise((resolve) => setTimeout(resolve, LAZY_VM_CLAIM_GRACE_MS)),
+            new Promise((resolve) => { timer = setTimeout(resolve, waitMs); }),
         ]);
+        clearTimeout(timer);
     }
     if (!snapshot.held && lazyClaim?.failed === true) {
         // A rejected lazy claim (gate finding F1, issue #1361): the
@@ -5990,10 +6126,11 @@ async function computerCallGate(internalCapability) {
     }
     if (!snapshot.held && lazyClaim?.lazy && lazyClaim.begin && !lazyClaim.claimed) {
         // The claim fired and is still waiting on the exclusive bind:
-        // another turn genuinely holds this desktop right now.
+        // another turn genuinely holds this desktop right now. A slow claim
+        // says what it is still doing instead.
         return {
             held: true, helpOpen: false,
-            blockedReason: "Another thread is using this computer. This call was not performed. Pause computer work until that thread finishes, then take a fresh screenshot before acting.",
+            blockedReason: lazyClaim.pendingReason ?? "Another thread is using this computer. This call was not performed. Pause computer work until that thread finishes, then take a fresh screenshot before acting.",
         };
     }
     const computer = turnComputerResources.get(internalCapability.threadId);
@@ -6019,11 +6156,6 @@ function teamComputerInUse(computer) {
         [...teamComputerTurns.values()].some(turn => turn.computerId === computer.id) ||
         store.bots.some(bot => computer.section !== null && sectionKey(bot.section) === computer.section && (botHasActiveTurn(bot.id) || Boolean(routines?.activeRunForBot(bot.id)) || computerControl.snapshot(bot.id).held));
 }
-function assertTeamControlCanBeTaken(computerId) {
-    if ([...teamComputerTurns.values()].some(turn => turn.computerId === computerId && turn.remoteAgent)) {
-        throw Object.assign(new Error("Stop the Computer engine's active turn before taking control of this shared desktop"), { status: 409 });
-    }
-}
 function claimTeamComputerLifecycle(computer) {
     if (computerProviderConfigTransitions.has("box"))
         throw Object.assign(new Error(providerTransitionMessage("box")), { status: 409 });
@@ -6060,9 +6192,9 @@ async function teamComputersPayload() {
 }
 /** The same named Boat identity and whole-turn lease in chats and rooms.
  * Assignment authorizes waking, never replacing a missing paid machine. */
-async function attachTeamBoat(computer, botId, owner, canMount, remoteAgent) {
+async function attachTeamBoat(computer, botId, owner, canMount) {
     if (!canMount)
-        throw new Error("This model cannot use the team's Boat computer; choose a model provider with computer tools or an explicit bot destination");
+        throw new Error("This model cannot use the team's cloud computer; choose a model provider with computer tools or an explicit bot destination");
     if (!boat.boatConfigured(cfg))
         throw new Error("The team's Boat account is not configured; reconnect it in Settings");
     const ownerId = teamComputerOwner(computer.id);
@@ -6071,46 +6203,51 @@ async function attachTeamBoat(computer, botId, owner, canMount, remoteAgent) {
     if (computerControl.snapshot(ownerId).held)
         throw new Error("Release human control of the team computer before starting another turn");
     await bindTurnComputer(owner, `computer:box-bot:${ownerId}`, true);
-    teamComputerTurns.set(owner.threadId, { owner, computerId: computer.id, botId, remoteAgent });
+    teamComputerTurns.set(owner.threadId, { owner, computerId: computer.id, botId });
     let machine = await boat.findBoat(cfg, ownerId);
     if (!machine)
-        throw new Error("The team's Boat computer is missing; explicitly create or retry it from the Team map");
+        throw new Error("The team's cloud computer is missing; explicitly create or retry it from the Team map");
     await bindTurnComputer(owner, `computer:box:${machine.id}`, true);
-    const action = boat.boatTurnLifecycleAction({ explicitCloud: true, state: typeof machine.state === "string" ? machine.state : null });
+    const action = boat.boatTurnLifecycleAction(typeof machine.state === "string" ? machine.state : null);
     if (action === "wake")
         machine = await boat.readyBoat(cfg, ownerId);
-    if (!machine || boat.boatTurnLifecycleAction({ explicitCloud: true, state: typeof machine.state === "string" ? machine.state : null }) !== "attach") {
+    if (!machine || boat.boatTurnLifecycleAction(typeof machine.state === "string" ? machine.state : null) !== "attach") {
         throw new Error("The team computer is not ready; check it in the Team map");
     }
     if (turnResourceOwners.get(owner.threadId)?.generation !== owner.generation ||
         !turnResources.owns(`computer:box:${machine.id}`, owner))
         throw new Error("This computer turn ended while its machine was starting");
     return {
-        mount: cloudComputerMount(botId, owner, machine.id, remoteAgent),
+        mount: cloudComputerMount(botId, owner, machine.id),
         capture: () => boat.screenshotBoat(cfg, ownerId, machine.id),
     };
 }
-/** The two engine facts the cloud-computer rule reads (shared/cloud-computer.ts). */
-function cloudEngine(instance) {
-    return { driverKind: instance?.driverKind, computerMcp: instance?.adapter.capabilities.computerMcp };
-}
-/** How a turn's engine reaches a cloud computer. The Computer engine runs its
- * whole turn on the Boat. Every other engine keeps its own model and sign-in
- * and gets the Boat as one more stdio computer server (harness-mcp-proxy
- * computer), in the same slot a Local VM or VPS uses: one mechanism on a
- * desktop, a headless server and an OMB Cloud. The agent process holds only a
- * turn-scoped capability naming this Boat, never a Boat credential. */
-function cloudComputerMount(botId, owner, boxId, remoteAgent) {
-    if (remoteAgent)
-        return { computer: { kind: "box", boxId } };
+/** The engine fact the cloud-computer rule reads (shared/cloud-computer.ts),
+ * and the model's name for a refusal to say. */
+function cloudEngine(instance, model) {
+    return {
+        computerMcp: instance?.adapter.capabilities.computerMcp,
+        name: model?.trim() || instance?.displayName || instance?.driverKind || "This model",
+    };
+}
+/** How a turn's engine reaches a cloud computer. Every engine keeps its own
+ * model and sign-in and gets the Boat as one more stdio computer server
+ * (harness-mcp-proxy computer), in the same slot a Local VM or VPS uses: one
+ * mechanism on a desktop, a headless server and an OMB Cloud. The agent
+ * process holds only a turn-scoped capability naming this Boat, never a Boat
+ * credential. */
+function cloudComputerMount(botId, owner, boxId) {
+    return { localComputer: cloudComputerTools(botId, owner, boxId) };
+}
+/** The cloud computer's stdio tools for this turn. `boxId` null: the Boat is
+ * the one the first computer call's claim creates or wakes (mountBotBoat). */
+function cloudComputerTools(botId, owner, boxId) {
     const control = controlIntegration(botId, owner.threadId, owner.generation, { boxId });
     return {
-        localComputer: {
-            command: process.execPath,
-            args: [SPAWNED_PROXIES.harnessMcp, "computer"],
-            env: { ...AGENTS_NODE_FLAG, OMB_HARNESS_URL: `http://127.0.0.1:${PORT}`, OMB_MCP_TOKEN: control.token },
-            platform: "linux",
-        },
+        command: process.execPath,
+        args: [SPAWNED_PROXIES.harnessMcp, "computer"],
+        env: { ...AGENTS_NODE_FLAG, OMB_HARNESS_URL: `http://127.0.0.1:${PORT}`, OMB_MCP_TOKEN: control.token },
+        platform: "linux",
     };
 }
 /** "Works on: This computer", strict. One mount for a bot thread and a group
@@ -6137,8 +6274,12 @@ async function mountHostComputer(owner, botId, providerSupportsLocal) {
  * is claimed on the first computer call, through the computer-control gate
  * (the Local VM's seam, #1361), never at mount: turns that never touch the
  * computer tools run side by side. `start` may provision or start the
- * container; without it the VPS is only inspected. The caller has already
- * recorded the thread with vpsThreadStarted and ends it on a problem. */
+ * container; without it the VPS is only inspected. Unlike the bot's cloud
+ * computer (mountBotBoat), the start stays here, at dispatch: the VPS tools
+ * are a bridge that execs into the running container as soon as the engine
+ * launches it (runMcpBridge), and a self-hosted container uses no plan
+ * hours. The caller has already recorded the thread with vpsThreadStarted
+ * and ends it on a problem. */
 async function mountBotVps(bot, owner, opts) {
     const vpsResource = `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`;
     const remote = opts.start
@@ -6169,54 +6310,113 @@ async function mountBotVps(bot, owner, opts) {
         },
     };
 }
-/** The bot's own Boat. Explicit Cloud is the consent boundary: it may create a
- * missing machine and wake an archived one (~8s, and it un-pauses billing);
- * Auto (only ever the Computer engine, see startTurn) only attaches a machine
- * that is already running. Callers have already checked that the engine can
- * work on it (cloudPlaceDriverError). */
-async function attachBotBoat(bot, owner, opts) {
-    // Explicit cloud turns can provision/wake the same bot's Boat. Claim before
-    // any network await so setup itself cannot race another turn.
-    if (opts.explicitCloud)
-        await bindTurnComputer(owner, `computer:box-bot:${bot.id}`, true);
-    let b;
-    try {
-        b = await boat.findBoat(cfg, bot.id);
-    }
-    catch (error) {
-        // Auto may fall through when an optional provider is offline, but a
-        // durable deletion fence must never be mistaken for "no computer".
-        if (opts.explicitCloud || error?.status === 409)
-            throw error;
-        b = null;
-    }
-    const lifecycleOf = (explicitCloud) => boat.boatTurnLifecycleAction({
-        explicitCloud,
-        state: typeof b?.state === "string" ? b.state : null,
-    });
-    let lifecycle = lifecycleOf(opts.explicitCloud);
+/** How long one computer call waits on a cloud computer that is being
+ * created or woken before it is told to look again. Under the 60 seconds an
+ * engine may give one tool call (Codex's default); a call that runs out finds
+ * the start still going and waits again, inside the start's own budget.
+ * OMB_CLOUD_COMPUTER_START_WAIT_MS shortens it for tests. */
+const CLOUD_COMPUTER_START_WAIT_MS = Math.max(1_000, Number(process.env.OMB_CLOUD_COMPUTER_START_WAIT_MS) || 45_000);
+/** How long the start itself may take once this turn has the computer to
+ * itself: above a slow first start (about a minute; Boat's own ready wait is
+ * 90 seconds). Past it the start has failed, and the turn says so and ends,
+ * instead of every call answering "still starting" until the watchdog.
+ * OMB_CLOUD_COMPUTER_START_BUDGET_MS shortens it for tests. */
+const CLOUD_COMPUTER_START_BUDGET_MS = Math.max(1_000, Number(process.env.OMB_CLOUD_COMPUTER_START_BUDGET_MS) || 150_000);
+const CLOUD_COMPUTER_STARTING = "The cloud computer is still starting. This call was not performed. Take a fresh screenshot in a moment.";
+const CLOUD_COMPUTER_DID_NOT_START = "the cloud computer didn't start in time";
+/** The bot's own Boat as a computer its engine uses, mounted like the VPS
+ * (mountBotVps): the tools mount now, and the Boat is created or woken by
+ * the turn's first computer call, through the computer-control gate (the
+ * Local VM's seam, #1361), never at mount. A turn that never touches the
+ * screen ("hi") makes no Boat call at all, so it costs no plan hours. The
+ * claim is attachBotBoat itself, with its explicit-Cloud consent: the person
+ * chose this place, and the bot is now using it. */
+function mountBotBoat(bot, owner, opts) {
+    const slot = {
+        owner,
+        lazy: true,
+        startsComputer: true,
+        label: "the cloud computer",
+        graceMs: CLOUD_COMPUTER_START_WAIT_MS,
+        // Until this turn has the computer to itself another conversation does,
+        // and a call is told so (the gate's contention text); from then on the
+        // claim is starting it.
+        onRejected: opts.onRejected,
+        claim: async () => {
+            let attached;
+            try {
+                attached = await attachBotBoat(bot, owner, {
+                    budgetMs: CLOUD_COMPUTER_START_BUDGET_MS,
+                    onSeated: () => { slot.pendingReason = CLOUD_COMPUTER_STARTING; },
+                });
+                if (!attached)
+                    throw new Error("the cloud computer could not be created or reached");
+            }
+            catch (error) {
+                throw opts.source ? await asPlaceFailure(error, "cloud", opts.source, bot, "box") : error;
+            }
+            slot.boxId = attached.boxId;
+            opts.onClaimed(attached.capture);
+        },
+    };
+    autoVmClaims.set(owner.threadId, slot);
+    return cloudComputerTools(bot.id, owner, null);
+}
+/** The Boat a lazily mounted cloud computer's claim landed on, for this
+ * exact turn; none while the claim is still running or after it failed. */
+function claimedBoatId(capability) {
+    const slot = autoVmClaims.get(capability.threadId);
+    return slot?.owner.generation === capability.generation && slot.claimed ? slot.boxId : undefined;
+}
+/** The bot's own Boat, for a turn whose place is Cloud. That choice is the
+ * consent boundary: it may create a missing machine and wake an archived one
+ * (~8s, and it un-pauses billing). Auto never reaches here. Callers have
+ * already checked that the engine can work on it (cloudPlaceRefusal).
+ * Every engine reaches it through mountBotBoat, on its first computer call:
+ * told once this turn has the Boat to itself, it has `budgetMs` to find,
+ * create or wake it. */
+async function attachBotBoat(bot, owner, start) {
+    // Claim before any network await so setup itself cannot race another turn.
+    await bindTurnComputer(owner, `computer:box-bot:${bot.id}`, true);
+    start.onSeated();
+    const machine = await withinBudget(startBotBoat(bot), start.budgetMs, CLOUD_COMPUTER_DID_NOT_START);
+    if (!machine)
+        return null;
+    await bindTurnComputer(owner, `computer:box:${machine.id}`);
+    return {
+        boxId: machine.id,
+        capture: () => boat.screenshotBoat(cfg, bot.id, machine.id),
+    };
+}
+/** `work`, or a rejection with `message` once `ms` pass first. The work is
+ * not cancelled: it ends on its own requests' deadlines, and the race has
+ * already handled a rejection it brings later. */
+function withinBudget(work, ms, message) {
+    let timer;
+    const expired = new Promise((_, reject) => { timer = setTimeout(() => reject(new Error(message)), ms); });
+    return Promise.race([work, expired]).finally(() => clearTimeout(timer));
+}
+/** Find the bot's Boat, creating or waking it: the Boat once it can be
+ * attached, or null. */
+async function startBotBoat(bot) {
+    let b = await boat.findBoat(cfg, bot.id);
+    const lifecycleOf = () => boat.boatTurnLifecycleAction(typeof b?.state === "string" ? b.state : null);
+    let lifecycle = lifecycleOf();
     if (lifecycle === "provision") {
-        broadcast({ kind: "computer", botId: bot.id, state: "provisioning" });
+        broadcast({ kind: "computer", botId: bot.id, state: "provisioning", place: "cloud" });
         await boat.provisionBoat(cfg, bot.id, bot.name);
         b = await boat.findBoat(cfg, bot.id);
-        lifecycle = lifecycleOf(true);
+        lifecycle = lifecycleOf();
     }
     // an archived boat answers every action with an error until it resumes —
     // wake it here, once, instead of letting the agent discover it one failed
     // tool call at a time.
     if (lifecycle === "wake") {
-        broadcast({ kind: "computer", botId: bot.id, state: "waking" });
+        broadcast({ kind: "computer", botId: bot.id, state: "waking", place: "cloud" });
         b = (await boat.readyBoat(cfg, bot.id)) ?? b;
-        lifecycle = lifecycleOf(true);
+        lifecycle = lifecycleOf();
     }
-    if (!b || lifecycle !== "attach")
-        return null;
-    const machine = b;
-    await bindTurnComputer(owner, `computer:box:${machine.id}`, opts.remoteAgent);
-    return {
-        capture: () => boat.screenshotBoat(cfg, bot.id, machine.id),
-        mount: cloudComputerMount(bot.id, owner, machine.id, opts.remoteAgent),
-    };
+    return b && lifecycle === "attach" ? b : null;
 }
 function managedBoatOwners() {
     return [...store.bots.map((bot) => ({
@@ -6288,8 +6488,6 @@ function turnProvider(bot, runOn, threadId) {
     const wants = turnSurfacePlan(bot, runOn, threadId).computer;
     if (wants !== undefined && wants !== "cloud")
         return null;
-    if (registry.get(bot.modelSelection.instanceId)?.adapter.capabilities.remoteAgent === true)
-        return "box";
     return bot.cloudBackend === "vps" ? "vps" : wants === "cloud" ? "box" : null;
 }
 /** Preview requests carry the selected conversation, not whichever thread
@@ -6308,8 +6506,6 @@ async function computerPreviewSurface(bot, threadId) {
     if (plan.computer !== undefined)
         return plan.computer === "off" && plan.browser ? "browser" : plan.computer;
     const instance = registry.get(bot.modelSelection.instanceId);
-    if (instance?.adapter.capabilities.remoteAgent === true)
-        return "cloud";
     if (bot.cloudBackend === "vps") {
         const remote = await vps.vpsComputerStatus(cfg, bot.id);
         if (remote.ready)
@@ -6337,7 +6533,8 @@ async function selectableComputers(bot) {
     const instance = registry.get(bot.modelSelection.instanceId);
     const caps = instance?.adapter.capabilities;
     const off = bot.computer === "off";
-    const localEngine = caps?.remoteAgent !== true;
+    // A desktop the bot's tools cannot reach is not offered, and not probed.
+    const toolsLeaveOut = computerToolsRefusal(bot.toolScope, "works-on", bot.name)?.message;
     const surfaces = ["cloud", "vm", "local", "browser"].filter(surface => !CLOUD_HOME || cloudHomeOffersPlace(surface));
     return Promise.all(surfaces.map(async (surface) => {
         let ready = false;
@@ -6351,24 +6548,31 @@ async function selectableComputers(bot) {
         try {
             if (off)
                 reason = "Computer access is Off in this bot's settings.";
+            else if (toolsLeaveOut && surface !== "browser")
+                reason = toolsLeaveOut;
             else if (surface === "cloud") {
                 if (bot.cloudBackend === "vps") {
-                    const status = canWorkOnCloud(cloudEngine(instance), "vps") ? await vps.vpsComputerStatus(cfg, bot.id) : null;
+                    const status = canWorkOnCloud(cloudEngine(instance)) ? await vps.vpsComputerStatus(cfg, bot.id) : null;
                     ready = status?.ready === true;
                     canStart = Boolean(status?.daemonUp && status.managed && status.container === "stopped" &&
                         status.image && status.imageMatches && status.network === "private" && status.mounts === "none" && status.security === "hardened");
                     canCreate = Boolean(status?.configured && status.daemonUp && status.container === "missing");
                     reason = status?.problem ?? reason;
                 }
-                else if (boat.boatConfigured(cfg) && canWorkOnCloud(cloudEngine(instance), "box")) {
+                else if (boat.boatConfigured(cfg) && canWorkOnCloud(cloudEngine(instance))) {
                     const status = await boat.boatStatus(cfg, bot.id);
-                    const lifecycle = boat.boatTurnLifecycleAction({ explicitCloud: true, state: status.box?.state ?? null });
+                    const lifecycle = boat.boatTurnLifecycleAction(status.box?.state ?? null);
                     ready = lifecycle === "attach";
                     canStart = lifecycle === "wake";
                     canCreate = lifecycle === "provision";
                 }
+                else {
+                    // The words the person reads for the same place (shared/place-view.ts).
+                    reason = (cloudPlaceRefusal(cloudEngine(instance, bot.modelSelection.model), "works-on", bot.name)
+                        ?? boatNotConfigured(bot, "works-on")).message;
+                }
             }
-            else if (surface === "vm" && localEngine && caps?.computerMcp) {
+            else if (surface === "vm" && caps?.computerMcp) {
                 const target = localVmTargetForStatus(bot.id);
                 const status = await containerComputerStatus(undefined, undefined, target);
                 ready = status.ready;
@@ -7881,12 +8085,15 @@ function finalizeDelegationWatch(threadId, ok, reply = "", failureName = "Delega
             // with the reply only visible in the thread (the "delegated and went
             // silent" gap). Failures wake it too — the user must hear the task did
             // not finish. Idle-checked and burst-capped so a busy source or a
-            // re-delegating loop cannot spin up runs.
-            if (ok) {
-                wakeDelegationSource(source, watched.sourceThreadId, targetName, undefined, watched.routineRunId);
-            }
-            else if (!ok) {
-                wakeDelegationSource(source, watched.sourceThreadId, targetName, failureName || "the delegated turn did not finish", watched.routineRunId);
+            // re-delegating loop cannot spin up runs. An external runtime polls
+            // for the receipt instead; waking would answer it a second time.
+            if (watched.completionOwner !== "external") {
+                if (ok) {
+                    wakeDelegationSource(source, watched.sourceThreadId, targetName, undefined, watched.routineRunId);
+                }
+                else {
+                    wakeDelegationSource(source, watched.sourceThreadId, targetName, failureName || "the delegated turn did not finish", watched.routineRunId);
+                }
             }
         }
     }
@@ -7941,7 +8148,7 @@ bus.subscribe((event) => {
 /** How a drained delegation becomes a real turn on the target. Shared by
  * the settle-time drain and the boot-time drain of what a previous process
  * left queued. */
-const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel, taskId, sourceBotId, openedThreadId, oneWay) => {
+const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel, taskId, sourceBotId, openedThreadId, oneWay, completionOwner) => {
     // startTurn REJECTS on an ordinary condition — busy target, deleted bot,
     // unavailable provider. Unhandled, that rejection is fatal to the
     // harness (Node's default), which in the packaged app kills the server
@@ -7975,6 +8182,7 @@ const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel,
             routineRunId: activeRoutineRunForThread(sourceThreadId)?.id,
             startedAtMs: Date.now(),
             ...(oneWay ? { oneWay: true } : {}),
+            ...(completionOwner ? { completionOwner } : {}),
         });
     }
     let failureReported = false;
@@ -8469,10 +8677,9 @@ const screenPollers = new Map();
 const SCREEN_POLL_MS = 6000;
 const SCREEN_MIN_GAP_MS = 3000;
 const SCREEN_SETTLE_TIMEOUT_MS = 10_000;
-/** `screenIsTheWork` starts the turn already counting as screen usage: a
- * boxAgent's whole session runs ON the boat, so every tool it calls acts on
- * that screen even though none of them is named like a computer tool. Its
- * shell-only turns are kept honest by the settle-time hash gate instead. */
+/** `screenIsTheWork` starts the poller already counting as screen usage: a
+ * poller restarted mid-turn (a lazy claim swapping in its capture) carries
+ * over whether the turn had touched its screen. */
 function startScreenPoller(botId, threadId, captures, { screenIsTheWork = false } = {}) {
     if (!captures.computer && !captures.browser)
         return;
@@ -8564,10 +8771,9 @@ function shownScreenHash(threadId) {
  * end state, not the previous action's. A turn that never touched the
  * screen settles nothing — and skips the capture, which is one less
  * command on the boat's single endpoint. A frame the reader can already see
- * settles nothing either: the boxAgent pre-touch counts every turn as
- * screen work, so without this its shell-only replies would all end in the
- * same idle desktop. Either way the poller is torn down here, so no
- * per-turn state survives the turn. */
+ * settles nothing either, so a turn never ends on the same idle desktop it
+ * already showed. Either way the poller is torn down here, so no per-turn
+ * state survives the turn. */
 async function finalScreenFrame(_botId, threadId) {
     const entry = screenPollers.get(threadId);
     const owner = turnResourceOwners.get(threadId);
@@ -8695,6 +8901,10 @@ async function startTurn(botId, text, opts) {
     const plan = turnSurfacePlan(bot, opts?.runOn, threadId);
     const instance = registry.get(bot.modelSelection.instanceId);
     if (!instance) {
+        // Still on the removed Computer engine: its move failed or found no
+        // engine. Try it again now, so the next message runs on the new engine.
+        if (removedComputerInstanceIds(cfg.instances).has(bot.modelSelection.instanceId))
+            void retryComputerEngineMove();
         throw Object.assign(new Error(`provider instance "${bot.modelSelection.instanceId}" is unavailable — pick another model in settings`), { status: 409 });
     }
     const policyRefusal = policyModelRefusal(instance);
@@ -8988,7 +9198,11 @@ async function startTurn(botId, text, opts) {
             const userTurnText = promptWithReply(skillAuthoring ? expandLearnTurnText(setupText) : setupText, opts?.replyTo, cfg.profile?.name?.trim() || "User");
             // Decided again at dispatch when setup outlasted a soul edit (config).
             const decideContext = (config) => {
-                const handedStale = Boolean(handed && (!unseen || (externalUpdate && handed.config !== config)));
+                // A Codex thread keeps the last effort it was sent and no turn can clear
+                // one: back on the default, a thread that holds a level is rebuilt from
+                // the transcript rather than resumed on that level.
+                const effortHeld = !effort && typeof handed?.effort === "string";
+                const handedStale = Boolean(handed && (!unseen || effortHeld || (externalUpdate && handed.config !== config)));
                 const { block: unseenBlock, placed } = unseen && !handedStale ? renderUnseen(unseen) : { block: "", placed: [] };
                 const { turnText: contextTurnText, resume } = buildTurnContext({
                     text: userTurnText,
@@ -9021,6 +9235,7 @@ async function startTurn(botId, text, opts) {
                     resumeCursor, sessionReset: !resume, recoveryText, recoveryIsReplay,
                     handoff: strictResume ? {
                         botId: bot.id, instanceId, config, resumeCursor: typeof resumeCursor === "string" ? resumeCursor : undefined,
+                        ...(instance.driverKind === "codex" ? { effort: effort ?? null } : {}),
                         started: sessionStart(contextOrder, contextTurnText !== userTurnText ? windowIds : [], carried),
                         recovery: sessionStart(contextOrder, recoveryText !== undefined ? windowIds : [], carried),
                         resumed: sessionStart(contextOrder, [], [...placed, ...carried]),
@@ -9093,8 +9308,7 @@ async function startTurn(botId, text, opts) {
             // because moving a live session would break resume.
             // A cloud run keeps the bot's own engine on this host, with the cloud
             // computer as one more tool, so it works in the same folder as any
-            // other turn (only the Computer engine runs on the Boat, and it has no
-            // workspace files).
+            // other turn.
             // On a Cloud home a conversation a guest opened is pinned to its own
             // folder when it first runs, not the bot's project folder the owner's
             // conversations share (what it leaves there reaches none of them). One
@@ -9135,9 +9349,6 @@ async function startTurn(botId, text, opts) {
             // landed. A team computer or a cloud routine is not this conversation's
             // choice, so those ignore the pin.
             const dispatchTask = store.taskByThread(bot.id, threadId);
-            if (plan.computer !== undefined && plan.computer !== "cloud" && instance.adapter.capabilities.remoteAgent === true) {
-                throw new Error("the Computer engine works on the cloud computer — set Works on to Cloud, or choose another engine");
-            }
             const wants = plan.computer;
             // A place the organisation disallows, or a Cloud home never offers, is
             // refused before anything is prepared; Auto below simply skips them.
@@ -9154,12 +9365,14 @@ async function startTurn(botId, text, opts) {
                 : opts?.runOn === "cloud" ? "routine"
                     : plan.pinned ? (dispatchTask?.surfaceSource === "auto" ? "auto-pin" : "pin")
                         : "works-on";
-            // An engine that cannot use the cloud computer is refused here, before
-            // anything is created or woken — never handed to another engine.
+            // An engine that cannot use the cloud computer, or a Tool selection
+            // that leaves its tools out, is refused here, before anything is
+            // created or woken — never handed to another engine.
             if (wants === "cloud" && placeSource) {
-                const unsupported = cloudPlaceDriverError(cloudEngine(instance), cloudBackend, placeSource);
+                const unsupported = cloudPlaceRefusal(cloudEngine(instance, bot.modelSelection.model), placeSource, bot.name)
+                    ?? computerToolsRefusal(toolScope, placeSource, bot.name);
                 if (unsupported)
-                    throw new PlaceUnavailableError("cloud", unsupported);
+                    throw unsupported;
             }
             let previewCapture = null;
             let browserCapture = null;
@@ -9285,7 +9498,7 @@ async function startTurn(botId, text, opts) {
             // the newer turn. The gate's refusals stay fail-closed for any screen
             // call racing this teardown; the turn-failed buzz and incident follow
             // the dispatch-failure rules (person-started turns only).
-            const surfaceLazyClaimRejection = (label) => (failure) => {
+            const surfaceLazyClaimRejection = (label) => (failure, error) => {
                 if (activeInternalGenerationByThread.get(threadId) !== resourceOwner.generation || !threadBusy(bot.id, threadId))
                     return;
                 // The wait ceiling parked this turn (#1651): register the resume and
@@ -9304,11 +9517,16 @@ async function startTurn(botId, text, opts) {
                     void interruptDirectThread(bot.id, threadId, { preserveComputerResume: true }).catch(() => { });
                     return;
                 }
-                const message = `computer unavailable — ${label} could not be claimed for this turn (${failure})`;
+                // A place that failed (mountBotBoat) is already read as its one line
+                // and one way on, and never sticks as an Auto-recorded pin.
+                const placeFailure = error instanceof PlaceUnavailableError ? error : undefined;
+                if (placeFailure)
+                    clearFailedAutoPin(bot.id, threadId, placeFailure.place);
+                const message = placeFailure?.message ?? `computer unavailable — ${label} could not be claimed for this turn (${failure})`;
                 store.appendMessage(threadId, {
                     role: "bot",
                     kind: "activity",
-                    tool: failedTurnTool(message),
+                    tool: failedTurnTool(message, placeFailure ? { place: placeFailure.row } : {}),
                 });
                 if (opts?.automationSource === undefined && !opts?.commsDepth && !opts?.cardContinuation) {
                     notify(buildNotification("turn-failed", bot, threadId, redactSecretsInText(message), { avatarUrl: bot.avatarUrl }));
@@ -9317,8 +9535,26 @@ async function startTurn(botId, text, opts) {
                     // completion fold must not report this failure a second time.
                     resourceOwner.lazyClaimFailureReported = true;
                 }
+                // A routine, a delegation or a resume reports this exactly as it
+                // reports a place that failed at dispatch: with this cause, before
+                // the interrupt settles the turn as merely "interrupted".
+                opts?.onDispatchError?.(message);
                 void interruptDirectThread(bot.id, threadId).catch(() => { });
             };
+            /** A lazily claimed remote desktop (the VPS, the bot's Boat) streams
+             * from the moment its claim lands. The dispatch-site poller start saw
+             * no capture (the claim runs after dispatch), so restart the poller
+             * with this one, keeping any browser capture and whether this turn
+             * already touched its screen. Same still-running guard as dispatch: a
+             * poller started after its own turn.completed would never stop. */
+            const adoptClaimedCapture = (capture) => {
+                previewCapture = capture;
+                if (!threadBusy(bot.id, threadId))
+                    return;
+                const touched = screenPollers.get(threadId)?.touched ?? false;
+                stopScreenPoller(bot.id, threadId);
+                startScreenPoller(bot.id, threadId, { computer: capture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
+            };
             // Explicit destinations are strict. In particular, Local VM must never
             // fall through to host CUA and accidentally click on the user's Mac.
             // The Local VM attach, shared by explicit "Local VM" and by Auto. Explicit
@@ -9327,7 +9563,7 @@ async function startTurn(botId, text, opts) {
             // be recreated on demand after idling away — and never creates a first
             // VM on its own; every failure there is a quiet "not this place".
             const attachLocalVm = async (strict) => {
-                if (!mountsComputerMcp || instance.adapter.capabilities.remoteAgent === true) {
+                if (!mountsComputerMcp) {
                     if (!strict)
                         return false;
                     throw new Error("this model cannot use the Local VM — choose Claude or an ACP model provider, or select another computer destination");
@@ -9383,7 +9619,7 @@ async function startTurn(botId, text, opts) {
                                 // guard as dispatch: a poller started after its own
                                 // turn.completed would never be torn down.
                                 if (previewCapture && threadBusy(bot.id, threadId)) {
-                                    const touched = screenPollers.get(threadId)?.touched ?? instance.adapter.capabilities.remoteAgent === true;
+                                    const touched = screenPollers.get(threadId)?.touched ?? false;
                                     stopScreenPoller(bot.id, threadId);
                                     startScreenPoller(bot.id, threadId, { computer: previewCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
                                 }
@@ -9430,7 +9666,7 @@ async function startTurn(botId, text, opts) {
                 // the person explicitly opted this bot into remote lifecycle actions.
                 // On Auto an engine that cannot use a computer simply skips it.
                 if ((wants === "cloud" || (wants === undefined && managedPolicy.computerAllowed("vps"))) && cloudBackend === "vps" &&
-                    canWorkOnCloud(cloudEngine(instance), "vps")) {
+                    canWorkOnCloud(cloudEngine(instance))) {
                     // The VPS "computer" is the desktop inside this bot's managed
                     // container, and only screen work needs that desktop to itself.
                     // So the lease is claimed on the first computer call, through the
@@ -9447,12 +9683,7 @@ async function startTurn(botId, text, opts) {
                         // Local VM's lazy claim does.
                         onClaimed: (vpsCapture) => {
                             pinAutoSurface("cloud");
-                            previewCapture = vpsCapture;
-                            if (threadBusy(bot.id, threadId)) {
-                                const touched = screenPollers.get(threadId)?.touched ?? false;
-                                stopScreenPoller(bot.id, threadId);
-                                startScreenPoller(bot.id, threadId, { computer: vpsCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
-                            }
+                            adoptClaimedCapture(vpsCapture);
                         },
                         onRejected: surfaceLazyClaimRejection("the VPS computer"),
                     });
@@ -9469,30 +9700,31 @@ async function startTurn(botId, text, opts) {
                     }
                 }
                 if (teamComputer) {
-                    const attached = await attachTeamBoat(teamComputer, bot.id, resourceOwner, canWorkOnCloud(cloudEngine(instance), "box"), instance.adapter.capabilities.remoteAgent === true);
+                    const attached = await attachTeamBoat(teamComputer, bot.id, resourceOwner, canWorkOnCloud(cloudEngine(instance)));
                     Object.assign(integrations, attached.mount);
                     previewCapture = attached.capture;
                     computerKind = "box";
                 }
-                // Cloud is strict when selected. On Auto only the Computer engine,
-                // whose whole turn runs on its Boat, attaches one, and only one that
-                // is already running. Every other engine reaches the Boat only when
+                // Cloud is strict when selected. A turn reaches the Boat only when
                 // this conversation is on it (Works on, a pin, a cloud routine, or
                 // select_computer): an Auto turn never reads the Boat account, so it
                 // adds no Boat call, cannot be stopped by a Boat being deleted, and
-                // never records a place nobody chose.
-                const remoteAgent = instance.adapter.capabilities.remoteAgent === true;
-                if (!teamComputer && cloudBackend === "box" && boat.boatConfigured(cfg) &&
-                    (wants === "cloud" || (wants === undefined && remoteAgent && !computerPlaceRefusal("box")))) {
-                    const attached = await attachBotBoat(bot, resourceOwner, { explicitCloud: wants === "cloud", remoteAgent });
-                    if (attached) {
-                        previewCapture = attached.capture;
-                        Object.assign(integrations, attached.mount);
-                        computerKind = "box";
-                    }
+                // never records a place nobody chose. Even then the Boat is created
+                // or woken only by the bot's first computer call (mountBotBoat): a
+                // chat that never touches the screen uses no plan hours.
+                if (!teamComputer && cloudBackend === "box" && boat.boatConfigured(cfg) && wants === "cloud") {
+                    integrations.localComputer = mountBotBoat(bot, resourceOwner, {
+                        // The row a failed attach always wrote: the place's one line and
+                        // its one way on, read where the place came from (an
+                        // Auto-recorded pin is cleared, as dispatch clears it).
+                        source: placeSource,
+                        onClaimed: adoptClaimedCapture,
+                        onRejected: surfaceLazyClaimRejection("the cloud computer"),
+                    });
+                    computerKind = "box";
                 }
                 if (wants === "cloud" && cloudBackend === "box" && !boat.boatConfigured(cfg)) {
-                    throw new Error(BOAT_NOT_CONFIGURED);
+                    throw boatNotConfigured(bot, placeSource ?? "works-on");
                 }
                 if (wants === "cloud" && cloudBackend === "box" && computerKind !== "box") {
                     throw new Error("the cloud computer could not be created or reached");
@@ -9503,21 +9735,20 @@ async function startTurn(botId, text, opts) {
                 // they are.
                 if (!namedPlace || !placeSource)
                     throw error;
-                throw asPlaceFailure(error, namedPlace, placeSource);
+                throw await asPlaceFailure(error, namedPlace, placeSource, bot, cloudBackend);
             }
             // Auto-only host fallback. Electron owns cua-driver/TCC attribution;
             // the harness only reads its already-running connection descriptor.
             // Auto reaches a Local VM this bot already has before it ever touches the
             // host's own desktop: on a headless server that VM is the only desktop
             // there is, and a person who prepared one meant it to be used.
-            if (wants === undefined && !integrations.computer && !integrations.localComputer && !computerPlaceRefusal("localVm") && await attachLocalVm(false))
+            if (wants === undefined && !integrations.localComputer && !computerPlaceRefusal("localVm") && await attachLocalVm(false))
                 computerKind = "vm";
             // An unattended run on a bot with a VPS configured never lands on the
             // host's own desktop instead: a scheduled job clicking on someone's
             // laptop is worse than a scheduled job that fails and says why.
             const unattendedVps = cloudBackend === "vps" && Boolean(opts?.automationSource);
-            if (!integrations.computer &&
-                !integrations.localComputer &&
+            if (!integrations.localComputer &&
                 wants === undefined &&
                 !unattendedVps &&
                 !computerPlaceRefusal("thisComputer") &&
@@ -9552,7 +9783,6 @@ async function startTurn(botId, text, opts) {
             }
             if (wants === undefined &&
                 cloudBackend === "vps" &&
-                !integrations.computer &&
                 !integrations.localComputer &&
                 autoVpsProblem &&
                 !computerSelectionTurns.has(threadId)) {
@@ -9560,7 +9790,7 @@ async function startTurn(botId, text, opts) {
                     ? "This scheduled run tried to start the VPS computer and could not reach it. Check the VPS connection in Settings → API keys."
                     : bot.autoStartVps
                         ? "Check the VPS connection in Settings → API keys."
-                        : "Open Computer and enable Start VPS automatically, or choose Cloud to start it manually.";
+                        : "Open Computer and enable Start VPS automatically, or choose Cloud computer to start it manually.";
                 throw new Error(`${autoVpsProblem}. ${hint}`);
             }
             // Agent control tools include peer comms and the secure credential
@@ -9683,9 +9913,8 @@ async function startTurn(botId, text, opts) {
             // Pin on use (issue #1650): every computer that registers a claim
             // slot — a ready Local VM, the VPS, the host fallback, a VM created
             // for this turn — records its pin inside the claim itself, so a turn
-            // that only mounted tools records nothing. The Computer engine's Boat
-            // (its whole turn runs there) and the built-in browser (no seat to
-            // claim) pin here.
+            // that only mounted tools records nothing. The built-in browser (no
+            // seat to claim) pins here.
             if (autoPinAllowed()) {
                 const claimSlot = autoVmClaims.get(threadId);
                 const pinsAtClaim = claimSlot?.owner.generation === resourceOwner.generation;
@@ -9706,7 +9935,6 @@ async function startTurn(botId, text, opts) {
             }
             const computerPromptKind = resolveComputerPromptKind({
                 kind: computerKind,
-                driverKind: instance.driverKind,
                 vmPrivate: localVmMode(cfg) === "per-bot",
             });
             const coordinationNode = opts?.coordination ? roomHandoffs.nodes.get(opts.coordination.id) : undefined;
@@ -9723,7 +9951,7 @@ async function startTurn(botId, text, opts) {
                 { id: "computer", label: "Computer", text: computerPrompt(computerPromptKind) },
                 { id: "team-computer", label: "Team computer", text: teamComputerPrompt(teamComputer) },
                 { id: "plan", label: "Surface", text: surfacePrompt({ computer: mountedComputer, browser: Boolean(integrations.browser) }, { pinned: plan.pinned, note: plan.note, canSelect: computerSelectionTurns.has(threadId), cloudHome: Boolean(CLOUD_HOME) }) },
-                { id: "cloud-home", label: "OMB Cloud", text: CLOUD_HOME ? cloudHomePrompt(Boolean(integrations.agents) && lendingEnabled()) : "" },
+                { id: "cloud-home", label: "My Cloud", text: CLOUD_HOME ? cloudHomePrompt(Boolean(integrations.agents) && lendingEnabled()) : "" },
                 // gated on the integration, not the key: the hint only goes to a
                 // bot whose driver actually mounted the tools
                 { id: "composio", label: "Connected apps", text: integrations.composio ? composioSystemPrompt(liveBot?.connectorTools ?? bot.connectorTools) + describeConnectorScopes((liveBot ?? bot).connectorScopes) : "" },
@@ -9856,7 +10084,7 @@ async function startTurn(botId, text, opts) {
             // keep polling the boat forever, carrying dead per-turn state. busy
             // is flipped false in the fold, so it is the honest "still running".
             if ((previewCapture || browserCapture) && threadBusy(bot.id, threadId)) {
-                startScreenPoller(bot.id, threadId, { ...(previewCapture ? { computer: previewCapture } : {}), ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: instance.adapter.capabilities.remoteAgent === true });
+                startScreenPoller(bot.id, threadId, { ...(previewCapture ? { computer: previewCapture } : {}), ...(browserCapture ? { browser: browserCapture } : {}) });
             }
             // An adapter may publish completion synchronously just before its
             // dispatch promise resolves. The event could not use the turn-id map
@@ -9950,16 +10178,10 @@ async function startTurn(botId, text, opts) {
                 drainDelegationWakes();
                 return;
             }
-            // A failed place never sticks. An Auto-recorded pin to it (a
-            // select_computer switch, or where an earlier Auto turn landed) is the
-            // machine's memory, not a choice: clear it so the next message runs on
-            // Auto. A person's pin stays, and the message names the composer.
-            if (e instanceof PlaceUnavailableError) {
-                const pinned = store.taskByThread(bot.id, threadId);
-                if (pinned?.surface === e.place && pinned.surfaceSource === "auto") {
-                    store.patchTask(bot.id, threadId, { surface: undefined, surfaceSource: undefined });
-                }
-            }
+            // A failed place never sticks; a person's pin stays, and the message
+            // names the composer.
+            if (e instanceof PlaceUnavailableError)
+                clearFailedAutoPin(bot.id, threadId, e.place);
             let message = e instanceof Error ? e.message : String(e);
             const current = store.projectBotForTask(bot.id, threadId);
             const backups = cfg.automaticRecovery?.enabled
@@ -10014,7 +10236,7 @@ async function startTurn(botId, text, opts) {
                 role: "bot",
                 kind: "activity",
                 turnSucceeded: false,
-                tool: failedTurnTool(message),
+                tool: failedTurnTool(message, e instanceof PlaceUnavailableError ? { place: e.row } : {}),
             });
             // Worth a buzz for the same reason a routine failure is, and the rule
             // notify.ts encodes: the bot is not working, and the cause is usually
@@ -10275,13 +10497,18 @@ routines = new RoutineManager({
         }
         return groupIsWorking(group) || coordinator.busy ? "busy" : "ready";
     },
-    createTask: (botId, title, activate = false, routineId) => {
+    createTask: (botId, title, activate = false, run) => {
         const task = store.createTask(botId, title, activate);
         // On a Cloud home a run's conversation is opened, like its results
         // conversation, by whoever wrote the routine: a run of one that is
         // nobody's is confined to a folder of its own, never the bot's project.
-        if (task && CLOUD_HOME && routineId)
-            threadStarters.set(task.threadId, routineOpener(routineId));
+        // A webhook's run is the owner's: only their own devices can create,
+        // edit or rotate a webhook, so it works at the bot's own level, in its
+        // folder, as on the desktop. Its payload still never reaches the lent
+        // Mac: cloud-lending.ts refuses every webhook run by its trigger.
+        if (task && CLOUD_HOME && run) {
+            threadStarters.set(task.threadId, run.triggerSource === "webhook" ? CLOUD_OWNER_KEY : routineOpener(run.routineId));
+        }
         // The store's frame announces it. A run's task that stays in the
         // background leaves the open thread alone, so that frame carries no
         // transcript: a whole thread on every scheduled run once passed the phone
@@ -10497,25 +10724,25 @@ async function cloudRoutineReadiness(botId, threadId) {
     if (!boat.boatConfigured(cfg)) {
         return {
             ready: false,
-            reason: 'The Boat cloud computer needs a working Boat API key. For the bot’s configured computer, including a self-hosted VPS, set run_on="maus" instead.',
+            reason: `${boatNotConfigured(bot, "routine").message} For the bot's configured computer, including a self-hosted VPS, set run_on="maus" instead.`,
         };
     }
     const instance = registry.get(bot.modelSelection.instanceId);
     if (!instance)
         return { ready: false, reason: "The target bot's model is unavailable. Choose another model in the bot's settings." };
     // The same rule a cloud turn applies, before anything is provisioned.
-    const unsupported = cloudPlaceDriverError(cloudEngine(instance), "box", "routine");
+    const unsupported = cloudPlaceRefusal(cloudEngine(instance, bot.modelSelection.model), "routine", bot.name);
     if (unsupported)
-        return { ready: false, reason: unsupported };
+        return { ready: false, reason: unsupported.message };
     try {
         if ((await instance.snapshot()).state !== "available") {
-            return { ready: false, reason: "The target bot's model is not ready to use the Boat cloud computer." };
+            return { ready: false, reason: "The target bot's model is not ready to use the cloud computer." };
         }
         const teamComputer = inheritedTeamComputer(bot);
         const ownerId = teamComputer ? teamComputerOwner(teamComputer.id) : bot.id;
         const machine = await boat.findBoat(cfg, ownerId);
         if (teamComputer && !machine) {
-            return { ready: false, reason: "The team's Boat computer is missing; explicitly create or retry it from the Team map." };
+            return { ready: false, reason: "The team's cloud computer is missing; explicitly create or retry it from the Team map." };
         }
         // Explicit Cloud may provision or wake the bot's own Boat at dispatch.
         // This probe only checks its identity/account, without starting billing.
@@ -11208,7 +11435,7 @@ const webhooks = new WebhookManager({
     post: (botId, threadId, text) => {
         if (!store.bot(botId))
             return;
-        store.appendMessage(threadId, { role: "bot", kind: "text", text });
+        store.appendMessage(threadId, { role: "bot", kind: "text", text, webhookPost: true });
     },
     // Mirrors resolveResultsThread's routines wiring a few hundred lines up
     // in this same file: create-on-first-use, never activated (so it never
@@ -11446,6 +11673,10 @@ setupRetry = 0) {
         noteForeignTurn(bot.id, threadId, internalGeneration);
     const resourceOwner = { threadId, generation: internalGeneration };
     turnResourceOwners.set(threadId, resourceOwner);
+    // Set when this member's cloud computer, claimed by its first computer
+    // call, could not start (or parked waiting for its seat): the turn ends on
+    // it, with this cause, instead of as merely interrupted.
+    let roomClaimFailure;
     let roomVmTarget = null;
     let retainRoomVmLease = false;
     let roomSpeaker;
@@ -11692,17 +11923,13 @@ setupRetry = 0) {
         const roomPlaceRefusal = roomKind && computerPlaceRefusal(roomKind);
         if (roomPlaceRefusal)
             throw Object.assign(new Error(roomPlaceRefusal.message), { code: roomPlaceRefusal.code });
-        // The Computer engine runs on the Boat; this computer has no tools it can
-        // reach, exactly as a bot thread refuses it.
-        if (roomPlan.computer === "local" && instance.adapter.capabilities.remoteAgent === true) {
-            throw new Error("the Computer engine works on the cloud computer — set Works on to Cloud, or choose another engine");
-        }
         // The same one rule as a bot thread, before anything is provisioned: an
         // engine that cannot use the cloud computer is refused, never swapped.
         if (!roomTeamComputer && roomPlan.computer === "cloud") {
-            const unsupported = cloudPlaceDriverError(cloudEngine(instance), turnProvider(readyBot) === "vps" ? "vps" : "box");
+            const unsupported = cloudPlaceRefusal(cloudEngine(instance, readyBot.modelSelection.model), "room", readyBot.name)
+                ?? computerToolsRefusal(readyBot.toolScope, "room", readyBot.name);
             if (unsupported)
-                throw new PlaceUnavailableError("cloud", unsupported);
+                throw unsupported;
         }
         // One place per room turn as well: a team computer reached on Auto means
         // no separate built-in browser.
@@ -11722,12 +11949,12 @@ setupRetry = 0) {
             return false;
         }
         if (roomTeamComputer) {
-            const attached = await attachTeamBoat(roomTeamComputer, readyBot.id, resourceOwner, canWorkOnCloud(cloudEngine(instance), "box"), instance.adapter.capabilities.remoteAgent === true);
+            const attached = await attachTeamBoat(roomTeamComputer, readyBot.id, resourceOwner, canWorkOnCloud(cloudEngine(instance)));
             if (isCancelled?.() || groupSpeakers.get(threadId) !== roomSpeaker ||
                 activeInternalGenerationByThread.get(threadId) !== internalGeneration)
                 return false;
             Object.assign(integrations, attached.mount);
-            startScreenPoller(readyBot.id, threadId, { computer: attached.capture }, { screenIsTheWork: instance.adapter.capabilities.remoteAgent === true });
+            startScreenPoller(readyBot.id, threadId, { computer: attached.capture });
         }
         // The speaker's own explicit place, mounted exactly as its bot thread
         // mounts it. A channel has no conversation pin and no Auto fallback here:
@@ -11735,6 +11962,51 @@ setupRetry = 0) {
         const roomSetupIsCurrent = () => !isCancelled?.() &&
             groupSpeakers.get(threadId) === roomSpeaker &&
             activeInternalGenerationByThread.get(threadId) === internalGeneration;
+        // A lazily claimed desktop (the VPS, the member's Boat) shows in the room
+        // from the moment its first computer call claims it.
+        const showClaimedScreen = (capture) => {
+            if (roomSetupIsCurrent() && store.group(readyGroup.id)?.busyBotId === readyBot.id) {
+                roomScreenBotId = readyBot.id;
+                startScreenPoller(readyBot.id, threadId, { computer: capture });
+            }
+        };
+        // The member's cloud computer could not start on its first computer call:
+        // the same row, report and parking a failure at setup gets (the catch at
+        // the end of this function), then the member's turn ends. Fenced to this
+        // member's still-running turn.
+        const failRoomClaim = (failure, error) => {
+            if (activeInternalGenerationByThread.get(threadId) !== internalGeneration || groupSpeakers.get(threadId) !== roomSpeaker)
+                return;
+            if (resourceOwner.computerParkedOn) {
+                registerComputerResume({
+                    botId: bot.id,
+                    threadId,
+                    resource: resourceOwner.computerParkedOn,
+                    generation: internalGeneration,
+                    afterMessageId: store.activePath(threadId).findLast((entry) => entry.role === "user")?.id,
+                });
+                roomClaimFailure = { parked: true };
+                if (orchestration)
+                    orchestration.result.stopReason = `${bot.name} parked waiting for the computer`;
+            }
+            else {
+                // Read as a room member's place (mountBotBoat): its one line, with no
+                // retry of its own.
+                const placeFailure = error instanceof PlaceUnavailableError ? error : undefined;
+                const message = placeFailure?.message ?? failure;
+                roomClaimFailure = { parked: false, message };
+                store.appendMessage(threadId, {
+                    role: "bot", kind: "activity",
+                    from: { botId: bot.id, name: bot.name, color: bot.color },
+                    tool: failedTurnTool(message, placeFailure ? { place: placeFailure.row } : {}),
+                });
+                onDispatchError?.(message);
+                // Claude settles the interrupt as exit_before_result: not a second
+                // incident for the same failure.
+                resourceOwner.lazyClaimFailureReported = true;
+            }
+            void instance.adapter.interruptTurn(threadId).catch(() => { });
+        };
         // An explicit place that cannot be attached fails the member's turn with
         // its cause and the one setting that changes it.
         try {
@@ -11748,15 +12020,7 @@ setupRetry = 0) {
                 if (turnProvider(readyBot) === "vps") {
                     vpsThreadStarted(readyBot.id, threadId);
                     roomVpsBotId = readyBot.id;
-                    const mounted = await mountBotVps(readyBot, resourceOwner, {
-                        start: true,
-                        onClaimed: (capture) => {
-                            if (roomSetupIsCurrent() && store.group(readyGroup.id)?.busyBotId === readyBot.id) {
-                                roomScreenBotId = readyBot.id;
-                                startScreenPoller(readyBot.id, threadId, { computer: capture });
-                            }
-                        },
-                    });
+                    const mounted = await mountBotVps(readyBot, resourceOwner, { start: true, onClaimed: showClaimedScreen });
                     if (!roomSetupIsCurrent())
                         return false;
                     if (!("integration" in mounted))
@@ -11766,24 +12030,18 @@ setupRetry = 0) {
                 }
                 else {
                     if (!boat.boatConfigured(cfg))
-                        throw new Error(BOAT_NOT_CONFIGURED);
-                    const remoteAgent = instance.adapter.capabilities.remoteAgent === true;
-                    const attached = await attachBotBoat(readyBot, resourceOwner, { explicitCloud: true, remoteAgent });
-                    if (!roomSetupIsCurrent())
-                        return false;
-                    if (!attached)
-                        throw new Error("the cloud computer could not be created or reached");
-                    Object.assign(integrations, attached.mount);
-                    roomScreenBotId = readyBot.id;
-                    startScreenPoller(readyBot.id, threadId, { computer: attached.capture }, { screenIsTheWork: remoteAgent });
+                        throw boatNotConfigured(readyBot, "room");
+                    // As in a bot thread: created or woken by the member's first
+                    // computer call, never by the room message itself.
+                    integrations.localComputer = mountBotBoat(readyBot, resourceOwner, { source: "room", onClaimed: showClaimedScreen, onRejected: failRoomClaim });
                     roomComputerKind = "box";
                 }
             }
             // Room and Goal turns use the speaker's desktop, never the coordinator's.
             // Claim the same lease as direct turns before asynchronous VM setup.
             if (readyBot.computer === "vm") {
-                if (instance.adapter.capabilities.computerMcp !== true || instance.adapter.capabilities.remoteAgent === true) {
-                    throw new Error("this model cannot use the Local VM");
+                if (instance.adapter.capabilities.computerMcp !== true) {
+                    throw placeUnavailable("vm", { state: "vm-cannot", params: { bot: readyBot.name, model: cloudEngine(instance, readyBot.modelSelection.model).name }, source: "room" }, Boolean(CLOUD_HOME));
                 }
                 // A distinct identity fences cleanup even in shared mode on the same room thread.
                 const target = { ...localVmTargetForThread(readyBot.id, threadId) };
@@ -11823,8 +12081,7 @@ setupRetry = 0) {
             const place = roomPlan.computer;
             if (place !== "cloud" && place !== "vm" && place !== "local")
                 throw error;
-            // A room row is not cut, so the cause keeps all its words.
-            throw asPlaceFailure(error, place, "works-on", Infinity);
+            throw await asPlaceFailure(error, place, "room", readyBot, turnProvider(readyBot) === "vps" ? "vps" : "box");
         }
         const roster = readyGroup.memberIds
             .map((id) => store.bot(id))
@@ -11911,7 +12168,6 @@ setupRetry = 0) {
         const recentLines = recentWork(recentWorkSources(bot), bot, { userName, currentThreadId: threadId, ...recentWorkFilter() });
         const roomComputerPromptKind = resolveComputerPromptKind({
             kind: roomTeamComputer || roomComputerKind === "box" ? "box" : roomVmTarget ? "vm" : roomComputerKind,
-            driverKind: instance.driverKind,
             vmPrivate: localVmMode(cfg) === "per-bot",
         });
         {
@@ -11932,7 +12188,7 @@ setupRetry = 0) {
             { id: "computer", label: "Computer", text: computerPrompt(roomComputerPromptKind) },
             { id: "team-computer", label: "Team computer", text: teamComputerPrompt(roomTeamComputer) },
             { id: "plan", label: "Surface", text: surfacePrompt({ computer: roomTeamComputer ? "cloud" : roomVmTarget ? "vm" : surfaceOfComputerKind(roomComputerKind), browser: Boolean(integrations.browser) }, { note: roomPlan.note, cloudHome: Boolean(CLOUD_HOME) }) },
-            { id: "cloud-home", label: "OMB Cloud", text: CLOUD_HOME ? cloudHomePrompt(Boolean(integrations.agents) && lendingEnabled()) : "" },
+            { id: "cloud-home", label: "My Cloud", text: CLOUD_HOME ? cloudHomePrompt(Boolean(integrations.agents) && lendingEnabled()) : "" },
             { id: "browser", label: "Browser", text: integrations.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
             { id: "recall", label: "Recall", text: integrations.agents && bot.memoryEnabled !== false ? SESSION_SEARCH_SYSTEM_PROMPT : "" },
             teamAvailabilityPart(outsideRoom),
@@ -12025,13 +12281,10 @@ setupRetry = 0) {
                 if (e.type === "item.completed" && e.itemType === "assistant_text")
                     replyText += `\n${e.text}`;
                 else if (e.type === "turn.completed") {
-                    if (orchestration && !e.ok) {
-                        orchestration.result.stopReason = e.stopReason ?? null;
-                        finish("provider_failed");
-                    }
-                    else {
-                        finish("settled");
-                    }
+                    const end = roomTurnEnd(e, Boolean(orchestration), roomClaimFailure);
+                    if (orchestration && end.stopReason !== undefined)
+                        orchestration.result.stopReason = end.stopReason;
+                    finish(end.outcome);
                 }
                 // Waiting on a person is not turn work: hold the ceiling while an
                 // approval or question card is open, so deciding slowly does not
@@ -12220,7 +12473,7 @@ setupRetry = 0) {
             drainSecretResumes();
             drainTeamSetupResumes();
         }
-        if (outcome === "provider_failed") {
+        if (outcome === "provider_failed" || outcome === "parked") {
             if (skillAuthoring)
                 skillAuthoringClaim.claimed = false;
             return false;
@@ -12309,7 +12562,7 @@ setupRetry = 0) {
         store.appendMessage(threadId, {
             role: "bot", kind: "activity",
             from: { botId: bot.id, name: bot.name, color: bot.color },
-            tool: failedTurnTool(message),
+            tool: failedTurnTool(message, error instanceof PlaceUnavailableError ? { place: error.row } : {}),
         });
         onDispatchError?.(message);
         if (orchestration) {
@@ -14124,6 +14377,10 @@ function persistMcpServers(next) {
 }
 async function describeInstances() {
     const configs = providerConfigs();
+    // Reading the engines is where this server learns one became available
+    // (an install, a sign-in, a key or a Company engine), so a bot still on the
+    // removed Computer engine moves now rather than at the next start.
+    void retryComputerEngineMove();
     return (await registry.describe()).map((instance) => {
         const entry = configs[instance.instanceId];
         const described = {
@@ -14552,7 +14809,7 @@ const liveCalls = new LiveCallController({
     },
     broadcast: (frame) => broadcast(frame, { adminOnly: true }),
     settings: () => ({ key: cfg.live?.key ?? "", ...liveSettingsFor(cfg) }),
-    createSession: ({ key, sdp, botId, threadId, voice }) => createLiveSession({ key, sdp, voice, bot: liveBotFor(botId), history: liveHistoryFor(threadId) }),
+    createSession: ({ key, sdp, botId, threadId, voice }) => createLiveSession({ key, sdp, voice, bot: liveBotFor(botId), history: liveHistoryFor(threadId), cloudHome: Boolean(CLOUD_HOME) }),
     // Node's WebSocket (undici) accepts headers in its second argument.
     openSocket: (url, key) => new WebSocket(url, { headers: { authorization: `Bearer ${key}` } }),
     attachUrl: (sessionId) => liveAttachUrl(sessionId),
@@ -15047,7 +15304,7 @@ const handleRequest = async (req, res) => {
                 // A Cloud home is one person's: only their own devices, which the
                 // Admin's pairing signs in with admin scope, may lend to it.
                 if (CLOUD_HOME && !auth.scopes.includes("admin"))
-                    return json(res, 403, { error: "Only your own computers can lend to your Cloud. Connect this computer to your Cloud from its OMB Cloud settings." });
+                    return json(res, 403, { error: "Only your own computers can lend to My Cloud. On this computer, open My Cloud from Settings → OpenMausBot Cloud first." });
                 sharedComputers.register(registration, { session: auth.session.id, person: CLOUD_HOME ? CLOUD_HOME_LENDER : personKey(auth.session) }, secret);
                 return json(res, 200, { ok: true });
             }
@@ -15230,9 +15487,13 @@ const handleRequest = async (req, res) => {
                     return json(res, 409, { error: "The user request ended before its computer was selected." });
                 if (unoffered)
                     return json(res, 409, { error: unoffered, options });
-                const option = requested === "auto"
-                    ? options.find(option => option.ready && option.surface === current) ?? options.find(option => option.ready && option.surface === "vm") ?? options.find(option => option.ready) ?? options.find(option => option.canStart) ?? options.find(option => option.canCreate && option.surface === "vm") ?? options.find(option => option.canCreate)
-                    : options.find(option => option.surface === requested);
+                // The computer this turn mounted is already selected, even before it
+                // is up when its first call starts it (the bot's cloud computer):
+                // switching to it would only restart the request.
+                const claim = autoVmClaims.get(internalCapability.threadId);
+                const startsOnFirstCall = claim?.owner.generation === internalCapability.generation && claim.startsComputer === true && !claim.failed;
+                const picked = pickComputer(options, requested, current, startsOnFirstCall);
+                const option = picked.option;
                 if (!option?.available)
                     return json(res, 409, { error: option?.reason ?? "No configured computer or browser is available. Open the Computer panel to set one up.", options });
                 if (source.selected) {
@@ -15240,8 +15501,11 @@ const handleRequest = async (req, res) => {
                         return json(res, 409, { error: "A computer switch is already pending. End this turn to continue there." });
                 }
                 else {
-                    if (option.surface === current && option.ready)
-                        return json(res, 200, { status: "ready", surface: current, message: "This computer is already selected. Use its mounted tools." });
+                    if (picked.current) {
+                        return json(res, 200, { status: "ready", surface: current, message: option.ready
+                                ? "This computer is already selected. Use its mounted tools."
+                                : "This computer is already selected. It starts on its first call; use its mounted tools." });
+                    }
                     source.selected = option.surface;
                     source.previousSurface = store.taskByThread(bot.id, bot.threadId)?.surface;
                 }
@@ -15343,17 +15607,19 @@ const handleRequest = async (req, res) => {
                 return json(res, 200, { result });
             }
             // The cloud computer's tools (harness-mcp-proxy computer): the turn's
-            // capability names its Boat, and the Boat credential stays here.
+            // capability names its Boat, and the Boat credential stays here. A
+            // capability minted before the Boat existed (boxId null) acts on the
+            // one its first call's claim created or woke (mountBotBoat).
             if (method === "POST" && path === "/api/internal/computer/mcp") {
                 const body = await readInternalBody();
-                const boxId = internalCapability.boxId;
-                if (!boxId)
+                if (internalCapability.boxId === undefined)
                     return json(res, 403, { error: "this turn has no cloud computer" });
                 const abort = new AbortController();
                 res.once("close", () => { if (!res.writableEnded)
                     abort.abort(); });
                 return json(res, 200, { result: await cloudComputerRpc(body, {
-                        cfg, boxId, signal: abort.signal,
+                        cfg, signal: abort.signal,
+                        boxId: () => internalCapability.boxId ?? claimedBoatId(internalCapability),
                         gate: () => computerCallGate(internalCapability),
                         assertActive: requireActiveInternalCapability,
                     }) });
@@ -16194,7 +16460,8 @@ const handleRequest = async (req, res) => {
                     const guestThread = guestWorkThread(from, target, fromThreadId, message);
                     if (guestThread === null)
                         return json(res, 500, { error: "couldn't open a conversation for that work" });
-                    const queued = queueDelegation(commsBus, from, { toBotId, message, reason: "asked while busy", depth, approvalAlreadyGranted, ...(guestThread ? { targetThreadId: guestThread } : {}) }, MAX_COMMS_DEPTH, fromThreadId);
+                    const queued = queueDelegation(commsBus, from, { toBotId, message, reason: "asked while busy", depth, approvalAlreadyGranted, ...(guestThread ? { targetThreadId: guestThread } : {}),
+                        ...externalCompletion(internalCapability) }, MAX_COMMS_DEPTH, fromThreadId);
                     if ((queued.result !== "ok" || !queued.id) && guestThread)
                         store.deleteTask(toBotId, guestThread);
                     if (queued.result !== "ok" || !queued.id)
@@ -16362,6 +16629,7 @@ const handleRequest = async (req, res) => {
                         sourceThreadId: fromThreadId,
                         sourceBotId: currentFrom.id,
                         routineRunId: activeRoutineRunForThread(fromThreadId)?.id,
+                        ...externalCompletion(internalCapability),
                     });
                     store.appendMessage(fromThreadId, {
                         role: "bot",
@@ -16566,7 +16834,7 @@ const handleRequest = async (req, res) => {
                 const guestThread = guestWorkThread(from, target, fromThreadId, reason ?? message);
                 if (guestThread === null)
                     return json(res, 500, { error: "couldn't open a conversation for that work" });
-                const queued = queueDelegation(commsBus, from, { toBotId, message, reason, depth, ...(guestThread ? { targetThreadId: guestThread } : {}) }, MAX_COMMS_DEPTH, fromThreadId);
+                const queued = queueDelegation(commsBus, from, { toBotId, message, reason, depth, ...(guestThread ? { targetThreadId: guestThread } : {}), ...externalCompletion(internalCapability) }, MAX_COMMS_DEPTH, fromThreadId);
                 if ((queued.result !== "ok" || !queued.id) && guestThread)
                     store.deleteTask(toBotId, guestThread);
                 if (queued.result !== "ok" || !queued.id) {
@@ -17546,8 +17814,15 @@ const handleRequest = async (req, res) => {
                     const policy = currentSender.outbound ?? DEFAULT_OUTBOUND_POLICY;
                     const threadId = internalCapability.threadId;
                     const { app } = describeTool(outboundTool);
-                    const summary = outboundCalls.map((call) => {
+                    // One entry per call, in the summary's order, so a phone can say
+                    // "Send to Linear? Create linear comment ×2" without parsing the
+                    // raw arguments out of the subtitle.
+                    const calls = outboundCalls.map((call) => {
                         const described = describeTool(call.slug);
+                        return { app: described.app, label: described.label };
+                    });
+                    const summary = outboundCalls.map((call, index) => {
+                        const described = calls[index];
                         const argsText = call.arguments === undefined ? "" : JSON.stringify(call.arguments);
                         return `${described.app ? `${described.app} · ` : ""}${described.label}${argsText ? `\n${argsText.slice(0, 400)}${argsText.length > 400 ? "… [arguments truncated]" : ""}` : ""}`;
                     }).join("\n\n");
@@ -17577,7 +17852,7 @@ const handleRequest = async (req, res) => {
                                 tool: outboundTool,
                                 held: HELD_NOTE["approval.held.outbound"],
                                 heldCode: "approval.held.outbound",
-                                outboundRequest: { tool: outboundTool, app },
+                                outboundRequest: { tool: outboundTool, app, calls },
                             },
                         });
                         appendDecision(DATA_DIR, {
@@ -17672,7 +17947,8 @@ const handleRequest = async (req, res) => {
                 if (upstream.transportSessionId)
                     headers["mcp-session-id"] = upstream.transportSessionId;
                 res.writeHead(upstream.status, headers);
-                return res.end(Buffer.from(upstream.bytes));
+                // A missing OAuth permission gets a note on what fixes it (MOCA-273).
+                return res.end(Buffer.from(withScopeHint(upstream.bytes, upstream.contentType, connectorCalls.map((call) => call.slug))));
             }
             // ── computer control: proxies read the hold, bots plead for help ──
             if (path === "/api/internal/computer-control") {
@@ -22252,8 +22528,6 @@ const handleRequest = async (req, res) => {
                 const key = teamComputerOwner(found.id);
                 if (parsed.data.action === "take" && boatLifecycleBusyBots.has(key))
                     return json(res, 409, { error: "Wait for this computer's action to finish before taking control" });
-                if (parsed.data.action === "take")
-                    assertTeamControlCanBeTaken(found.id);
                 if (parsed.data.controlLeaseId) {
                     const result = parsed.data.action === "take"
                         ? computerControl.acquireLease(key, parsed.data.controlLeaseId)
@@ -22292,7 +22566,7 @@ const handleRequest = async (req, res) => {
             if (method === "POST" && !computerId) {
                 const parsed = teamComputerCreate.safeParse(body);
                 if (!parsed.success)
-                    return json(res, 400, { error: "Provide requestId (UUID), a name, and acknowledgeCost: true to create a paid Boat" });
+                    return json(res, 400, { error: "Provide requestId (UUID), a name, and acknowledgeCost: true to create a paid cloud computer" });
                 if (!boat.boatConfigured(cfg))
                     return json(res, 409, { error: "Configure Boat in Settings before creating a cloud computer" });
                 const computer = teamComputers.create(parsed.data.name, parsed.data.requestId);
@@ -22312,7 +22586,7 @@ const handleRequest = async (req, res) => {
             }
             if (method === "POST" && found && action && action !== "control") {
                 if (action === "provision" && body?.acknowledgeCost !== true)
-                    return json(res, 400, { error: "Confirm Boat creation or wake costs with acknowledgeCost: true" });
+                    return json(res, 400, { error: "Confirm cloud computer creation or wake costs with acknowledgeCost: true" });
                 // A ready-only join never wakes, provisions or steals an agent's turn.
                 // The caller takes a separate explicit human-control lease first.
                 if (action === "join") {
@@ -22634,7 +22908,12 @@ const handleRequest = async (req, res) => {
         // The bots' browser engine: install it on this machine (agent-browser +
         // a Chrome for Testing, a one-time download), or ask how that is going.
         // One install at a time; the config frame's browserEngine tells the rest.
+        // JSON only, so a form posted from another local page cannot start it.
         if (method === "POST" && path === "/api/browser-engine/install") {
+            const mediaType = String(req.headers["content-type"] ?? "").split(";", 1)[0].trim().toLowerCase();
+            if (mediaType !== "application/json") {
+                return json(res, 415, { error: "content-type must be application/json" });
+            }
             if (!browserEngineInstall) {
                 const status = browserEngineStatus();
                 if (status.kind === "unavailable" && !status.installable)
@@ -24285,9 +24564,6 @@ const handleRequest = async (req, res) => {
                 if (!currentBot)
                     return json(res, 404, { error: "no such bot" });
                 const controlKey = botComputerControlKey(currentBot);
-                const teamComputer = inheritedTeamComputer(currentBot);
-                if (action === "take" && teamComputer)
-                    assertTeamControlCanBeTaken(teamComputer.id);
                 const leaseResult = body.controlLeaseId === undefined
                     ? null
                     : controlLeaseIdSchema.safeParse(body.controlLeaseId);
@@ -24464,12 +24740,12 @@ const handleRequest = async (req, res) => {
             }
             if (bot.computer !== "cloud" && !threadPreview) {
                 return json(res, 409, {
-                    error: "Choose Cloud before changing or opening this Boat. Auto only checks existing computer state.",
+                    error: "Choose Cloud computer before changing or opening this cloud computer. Auto only checks existing computer state.",
                 });
             }
             if (m[2] === "remove") {
                 // Boats sleep and wake; only the VPS backend has a container to remove.
-                return json(res, 409, { error: "the cloud Boat backend has no container to remove — use sleep instead" });
+                return json(res, 409, { error: "a cloud computer has no container to remove — put it to sleep instead" });
             }
             const releaseComputerLifecycle = claimBotComputerLifecycle(botId);
             try {