openmausbot 0.1.96 → 0.1.98

package/dist-server/server/index.js

@@ -52,7 +52,9 @@ import { messageFileDisposition, messageFileDownloadName, messageAttachmentName,
 import { avatarGenerationRequestSchema, avatarGenerationStateMatches, generateAvatarImage, avatarImageStatus, snapshotAvatarGenerationState, } from "./avatar-image.js";
 import { fitsOnOneLine, parseBotProfilePatch } from "./bot-profile.js";
 import { groupTurnCwd } from "./room-cwd.js";
-import { RoomTurnDeadline, RoomTurnStallRegistry, roomTurnTimeoutMessage } from "./room-turn-timeout.js";
+import { RoomTurnDeadline, RoomTurnStallRegistry, effectiveRoomTurnTimeoutMinutes, parseConversationTurnTimeout, 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";
@@ -65,6 +67,7 @@ import { liveCardKind, liveDecisionRefusal } from "../shared/live-approval.js";
 import { boatAccountResourceChangeError, cloudBackendChangeError, vpsAliasResourceChangeError, } from "./cloud-backend.js";
 import * as composio from "./composio.js";
 import { connectorCallFromFrame, connectorRefusalText, connectorUnrecognizedText, evaluateConnectorTools } from "./connector-verdict.js";
+import { connectorCardText } from "./connector-card-text.js";
 import { chiefOfStaffSystemPrompt } from "./chief-of-staff.js";
 import { buildRecall } from "./recall.js";
 import { createMemoryUpkeep, upkeepEnabled } from "./memory-upkeep.js";
@@ -72,7 +75,7 @@ import { appendAboutMe, commitLearned, planLearned } from "./profile-learned.js"
 import { canAccessTeam, canReachPeer, coordinatorSupervises, livePeerRoster, livePeerRosterBlock, peerAllowed, peerName, peerRosterSystemPrompt, peerStatus, peerStatusWords, reachablePeers, resolveTeammate, roomPeerRosterSystemPrompt, roomRosterLine, PEER_ACCESS_HELP } from "./peer-roster.js";
 import { containerComputerAction, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, containerExec, containerRuntimeStatus, localVmWakeAction, localVmWorkspaceExists, perBotLocalVmTarget, poolLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, VM_WORKSPACE_GUEST, } from "./container-computer.js";
 import { attachForTurn, saveBotAttachment } from "./bot-attachment.js";
-import { cacheUntilConfigChanges, ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmIdleTimeoutMinutes, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, threadEventLogMaxBytes, maxConcurrentBotThreads, threadEventLogRetentionDays, saveConfig, showToolCallsEnabled, routinesInConversationEnabled, claudeUserMcpEnabled, skillAuthoringEnabled, autoRecallEnabled, captureQuietMs, tidyHour, sharedComputersEnabled, builtInBrowserEnabled, llmThreadTitlesEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, stripWorkspaceCredentialEnv, PROVIDER_CREDENTIAL_ENV, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, browserEngineAttachCdpUrl, DATA_DIR, skillsLibraryEnabled, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, onConfigSaved, CLAUDE_API_INSTANCE, liveSettingsFor, mergeOpenCodeProviderKeys, openCodeProviderKeys, } from "./config.js";
+import { cacheUntilConfigChanges, ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmIdleTimeoutMinutes, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, mcpCallTimeoutMinutes, threadEventLogMaxBytes, maxConcurrentBotThreads, threadEventLogRetentionDays, saveConfig, showToolCallsEnabled, routinesInConversationEnabled, claudeUserMcpEnabled, skillAuthoringEnabled, autoRecallEnabled, captureQuietMs, tidyHour, sharedComputersEnabled, builtInBrowserEnabled, llmThreadTitlesEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, stripWorkspaceCredentialEnv, PROVIDER_CREDENTIAL_ENV, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, browserEngineAttachCdpUrl, DATA_DIR, skillsLibraryEnabled, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, onConfigSaved, CLAUDE_API_INSTANCE, liveSettingsFor, mergeOpenCodeProviderKeys, openCodeProviderKeys, } from "./config.js";
 import { sweepThreadEventLogs } from "./thread-retention.js";
 import { ComputerControl } from "./computer-control.js";
 import { augmentedPath, findCliCandidates, resetPathCache } from "./env-path.js";
@@ -81,7 +84,8 @@ import { appendUsage, parseUsageRange, readUsage, summarizeUsage, usageCsv, USAG
 import { loadPlanUsage, planAccountsFromInstances } from "./plan-usage.js";
 import { GroupUsageReader } from "./group-thread-usage.js";
 import { ledgerCost } from "./model-prices.js";
-import { checkProviderKey, PROVIDER_KEY_KINDS } from "./provider-key-check.js";
+import { checkProviderKey, PROVIDER_KEY_KINDS, providerBaseUrl } from "./provider-key-check.js";
+import { forgetKey, noteKeyAccepted, noteKeyRejected, onKeyRejectionChange } from "./key-rejections.js";
 import { assertWithinBudget, noteSpend, spendAlertText, spendState, takeSpendAlert } from "./spend.js";
 import { fleetAvailable, fleetRequest, fleetSocketPath } from "./fleet-client.js";
 import { entitled } from "./enterprise.js";
@@ -97,7 +101,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,17 +122,19 @@ 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 { threadModelFallback } from "./thread-model.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";
 import { decideRoomPost, emptyRoomPostBudget } from "./room-post-budget.js";
-import { isProjectEmoji, mentionedBots, parseConnectorTools, roomResponders, sectionKey, Store, titleFromLlm, toWireTask, } from "./store.js";
+import { isProjectEmoji, mentionedBots, parseConnectorTools, roomResponders, sectionKey, Store, threadTitleFrom, titleFromLlm, toWireTask, } from "./store.js";
 import * as tts from "./tts/index.js";
 import { createDecider, deciderIncludedHere, deciderReady, deciderSavePatch, describeDecider } from "./decider/index.js";
 import { decideRoomResponder } from "./decider/room-routing.js";
@@ -136,6 +142,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 +175,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 +215,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";
@@ -239,11 +247,13 @@ import { createHostedSlackRoutes } from "./routes/hosted-slack.js";
 import { createBotPresetRoutes } from "./routes/bot-presets.js";
 import { createBotMemoryRoutes } from "./routes/bot-memory.js";
 import { createDeciderRoutes } from "./routes/decider.js";
+import { createThreadModelRoutes } from "./routes/thread-models.js";
 import { createDesktopViewer, desktopViewerUrl } from "./routes/desktop-viewer.js";
 import { localDesktopTarget, localVmViewerStatus, viewerTargetId } from "./desktop-viewer-targets.js";
 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 +568,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 +611,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 +639,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 +788,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);
@@ -832,12 +839,13 @@ function openerFrom(fromThreadId) {
         return person;
     return person && !cloudOwnerPerson(person) ? person : CLOUD_NOBODY_KEY;
 }
-/** The model a thread a bot opens from one of its own threads starts on:
- * that thread's, not the bot default the person may have moved away from
- * (#1950). Only the bot's own thread counts — a room or a teammate's thread
- * is not one of its tasks, and another bot's model belongs to another engine.
- * Approval stays the bot's, except that a level the inherited engine would
- * have to confirm on a model switch starts the new thread in Ask. */
+/** The model a thread a bot opens from one of its own threads starts on
+ * (#1950): the model a person picked in that thread, kept as the new thread's
+ * own. A thread that follows the bot opens one that follows it too. Only the
+ * bot's own thread counts — a room or a teammate's thread is not one of its
+ * tasks, and another bot's model belongs to another engine. Approval stays
+ * the bot's, except that a level the inherited engine would have to confirm
+ * on a model switch starts the new thread in Ask. */
 function parentThreadModel(botId, parentThreadId) {
     // The stored profile, never a per-thread projection: the comparison is
     // against the defaults the new thread would otherwise get.
@@ -868,7 +876,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 +885,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 +1536,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,
@@ -1667,6 +1673,9 @@ const managedPolicy = new ManagedDesktopPolicy({ onChange: () => {
         broadcast({ kind: "config", ...configStatus() });
         resyncOpenCodeProviderKeys();
     } });
+// A key the provider refused, or accepted again, changes what Model
+// providers and the picker show; the config event refreshes /api/instances.
+onKeyRejectionChange(() => broadcast({ kind: "config", ...configStatus() }));
 /** A computer kind this server will not use, refused before anything is
  * prepared: a Cloud home never offers this computer or a Local VM
  * (cloud-home.ts), and an enrolled organisation may disallow any kind. */
@@ -1677,8 +1686,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 +1801,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)
@@ -2051,6 +2063,9 @@ function agentsIntegration(botId, threadId, depth, skillAuthoring, generation, r
                 const speaking = botForThread(botId, threadId) ?? store.bot(botId);
                 return tts.voiceReady(cfg, speaking?.voice) && speaking?.voiceNotes !== false ? "1" : "0";
             })(),
+            // And for a role: team setup, bot creation and deletion, rooms and
+            // retries are shown only to a Chief of Staff, whom their routes require.
+            OMB_CHIEF_OF_STAFF: store.bot(botId)?.chiefOfStaff === true ? "1" : "0",
         },
     };
 }
@@ -2087,14 +2102,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 +2584,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 +2769,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 +2832,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" };
@@ -2879,6 +3016,62 @@ function checkedTaskModelSwitch(current, raw, updateBotDefault, resetApprovalToA
     }
     return checked;
 }
+/** An engine as a turn's start sees it, without waiting on its CLI: the live
+ * instance and what its last read said (registry.lastSnapshot). Before the
+ * first read it counts as available, so only what is known stops a pick. */
+function threadEngine(instanceId) {
+    const live = registry.get(instanceId);
+    if (!live)
+        return undefined;
+    return {
+        instanceId, driverKind: live.driverKind, enabled: live.enabled, models: live.models,
+        capabilities: { modelVariants: live.adapter.capabilities.modelVariants === true },
+        snapshot: registry.lastSnapshot(instanceId) ?? { state: "available" },
+        access: providerConfigs()[instanceId]?.access ?? registry.access(instanceId),
+    };
+}
+/** This thread's own model, when it gives way to its bot's now
+ * (threadModelFallback); null when the thread follows its bot or its own
+ * model runs as picked. */
+function threadModelGivingWay(botId, threadId) {
+    const bot = store.bot(botId);
+    const own = store.taskByThread(botId, threadId)?.modelSelection;
+    if (!bot || !own)
+        return null;
+    return threadModelFallback(own, bot.modelSelection, threadEngine, {
+        refusal: policyModelRefusal,
+        ...(hostedModels ? { allows: (selection) => hostedModels.allows(selection) } : {}),
+    }) ? own : null;
+}
+/** The model a turn in this thread would run on now (healThreadModel). */
+function turnSelection(botId, threadId) {
+    return threadModelGivingWay(botId, threadId) ? store.bot(botId)?.modelSelection : store.projectBotForTask(botId, threadId)?.modelSelection;
+}
+/** A model as a person reads it: its catalog label, after its engine's name
+ * while that engine is here. */
+function modelName(selection) {
+    const instance = registry.get(selection.instanceId);
+    const label = instance?.models.options.find((option) => option.id === selection.model)?.label ?? selection.model;
+    return instance ? `${instance.displayName || instance.driverKind} · ${label}` : label;
+}
+/** A thread's own model that can't run here gives way to its bot's: the turn
+ * about to start runs on the bot's model, the thread follows the bot from
+ * then on, and one plain line in it says so. Every turn starts through
+ * startTurn (a person's message, a routine, a delegation, a webhook, a
+ * queued follow-up), so this is the one place it happens; a room turn
+ * already runs on each member's own model. */
+function healThreadModel(botId, threadId) {
+    const bot = store.bot(botId);
+    const own = threadModelGivingWay(botId, threadId);
+    if (!bot || !own || bot.approvalGrant || threadBusy(botId, threadId))
+        return;
+    if (!store.followBotModel(botId, [threadId], (from, to) => hostedModels?.resetTask(from, to) ?? {}).length)
+        return;
+    store.appendMessage(threadId, { role: "bot", kind: "activity", tool: {
+            name: `notice: This thread's model (${modelName(own)}) isn't available, so it now uses ${bot.name}'s model (${modelName(bot.modelSelection)}).`,
+            ok: true,
+        } });
+}
 function checkedExportSkillNames(value, bots) {
     // Sharing instructions is explicit: ordinary package exports include none.
     if (value === undefined)
@@ -3075,13 +3268,27 @@ function checkedMemberIds(value) {
     return { ok: true, memberIds };
 }
 let bootSelection = { instanceId: "", model: "" };
+/** The engines read at start, while it runs (below). It is where the server
+ * learns what each engine supports (a Claude CLI's version and flags), so a
+ * turn waits for it, as every turn did when the server listened only after
+ * that read. */
+let enginesRead = null;
 /** Preset bots for New bot, from shared files and the organization (presets.ts). */
 const presetStore = createPresetStore();
-const store = new Store(() => bootSelection, (selection) => withNewBotEffort(selection, cfg.newBots?.effort, registry.get(selection.instanceId)?.adapter.capabilities.effortLevels));
+const store = new Store(() => bootSelection, (selection) => withNewBotEffort(selection, cfg.newBots?.effort, registry.get(selection.instanceId)?.adapter.capabilities.effortLevels), (instanceId) => registry.cliTarget(instanceId)?.driverKind);
 const teamComputers = new TeamComputers(join(DATA_DIR, "team-computers.json"), ENVIRONMENT_ID);
 let followupsReady = false;
 const sendSequencer = new SendSequencer();
-bootSelection = await defaultSelection();
+// Before the new-bot default is read: a saved default may name the engine.
+await retryComputerEngineMove();
+// Reading the new-bot default probes every engine CLI (each up to its
+// timeout), and at start only the first-run seed needs the answer. A later
+// start listens without waiting: the same read runs behind it, and turns
+// wait for it (enginesRead).
+if (store.needsSeed())
+    bootSelection = await defaultSelection();
+else
+    enginesRead = defaultSelection().then((selection) => { bootSelection = selection; }, (error) => console.warn(`[engines] reading the engines at start failed: ${error instanceof Error ? error.message : String(error)}`)).finally(() => { enginesRead = null; });
 store.seedIfEmpty();
 hostedModels?.reconcile(store);
 // Skills library boot sweep (features.skillsLibrary): migrate per-bot
@@ -3135,11 +3342,13 @@ if (browserCleanupReferencesReconciled)
  * than the desktop window did. Stripped here rather than at each call site
  * so a new broadcast cannot forget. */
 let activeCoordinationForThread = (_threadId) => false;
-const wireTask = (task) => {
+/** One thread as a client sees it. `botModel` is its bot's model: a thread
+ * without a model of its own runs on it (toWireTask). */
+const wireTask = (task, botModel) => {
     // Time-based snoozes heal on read against the server clock — no client
     // timer, no device skew. The 0 sentinel ("until new activity") is not a
     // time and survives reads; only a wake event in the store clears it.
-    const { snoozedUntil, ...base } = toWireTask(task);
+    const { snoozedUntil, ...base } = toWireTask(task, botModel);
     const coordinated = { ...base, waitingForTeammates: activeCoordinationForThread(task.threadId) && !task.busy };
     const asleep = snoozedUntil === 0 || (snoozedUntil !== undefined && snoozedUntil > Date.now());
     return asleep ? { ...coordinated, snoozedUntil } : coordinated;
@@ -3153,7 +3362,7 @@ const wireBot = (bot) => {
         ? { ...rest, approvalMode: "ask", autoApprove: false }
         : rest;
     return { ...visible, waitingForTeammates: activeCoordinationForThread(bot.threadId) && !threadBusy(bot.id, bot.threadId),
-        avatarUrl: visible.avatarUrl ?? null, ...(tasks ? { tasks: tasks.map(wireTask) } : {}) };
+        avatarUrl: visible.avatarUrl ?? null, ...(tasks ? { tasks: tasks.map((task) => wireTask(task, bot.modelSelection)) } : {}) };
 };
 function toolScopeForTurn(botId) {
     const bot = store.bot(botId);
@@ -3168,7 +3377,7 @@ function toolScopeForTurn(botId) {
  * can validate it before sending the confirmation that makes it effective. */
 const wireTrustedApprovalBot = (bot) => {
     const { resumeCursors: _resumeCursors, tasks, approvalGrant: _approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, packageBase: _packageBase, assignedSkills: _assignedSkills, ...rest } = bot;
-    return { ...rest, approvalMode: approvalModeFor(rest), avatarUrl: rest.avatarUrl ?? null, ...(tasks ? { tasks: tasks.map(wireTask) } : {}) };
+    return { ...rest, approvalMode: approvalModeFor(rest), avatarUrl: rest.avatarUrl ?? null, ...(tasks ? { tasks: tasks.map((task) => wireTask(task, bot.modelSelection)) } : {}) };
 };
 /** A settings-based preview, not a receipt of a dispatched turn. No
  * provisioning or credentials are needed to inspect it. The selected engine
@@ -3190,7 +3399,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 +3438,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 : "" },
@@ -3823,7 +4031,7 @@ const storedAvatarExists = (avatarUrl) => attachmentExists(avatarUrl.slice("/api
 const publicBot = (bot) => ({
     ...wireBot(bot),
     ...messagePage(bot.threadId, DEFAULT_PAGE),
-    tasks: store.tasks(bot.id).map(wireTask),
+    tasks: store.tasks(bot.id).map((task) => wireTask(task, bot.modelSelection)),
 });
 const publicBotQueuedMessages = () => queuedSteerSnapshot((botId, threadId) => Boolean(store.taskByThread(botId, threadId)));
 // busyBotId names only the speaker that currently owns the provider process.
@@ -4015,6 +4223,15 @@ function updateChannel(groupId, value) {
             throw Object.assign(new Error("invalid default responder"), { status: 400 });
         patch.defaultResponder = responder;
     }
+    if (Object.prototype.hasOwnProperty.call(body, "turnTimeoutMinutes")) {
+        if (!existing.dm) {
+            throw Object.assign(new Error("set the turn limit on that conversation"), { status: 400 });
+        }
+        const parsed = parseConversationTurnTimeout(body.turnTimeoutMinutes);
+        if (!parsed.ok)
+            throw Object.assign(new Error(parsed.error), { status: 400 });
+        patch.turnTimeoutMinutes = parsed.minutes;
+    }
     if (body.cwd !== undefined) {
         if (existing.dm)
             throw Object.assign(new Error("direct-message channels cannot have a working folder"), { status: 400 });
@@ -4335,7 +4552,14 @@ function publicGroupState(record) {
         usage = groupUsageReader.forThread(group.threadId);
     }
     catch { /* accounting must not block chat */ }
-    return { ...group, usage: usage ?? null, working: groupIsWorking(group) || [...roomHandoffs.nodes.values()].some(n => n.groupId === group.id && !["completed", "failed", "cancelled"].includes(n.status)) };
+    return {
+        ...group,
+        // Always present so a client can tell "back to the group default"
+        // apart from a partial patch that did not mention the field.
+        turnTimeoutMinutes: record.turnTimeoutMinutes ?? null,
+        usage: usage ?? null,
+        working: groupIsWorking(group) || [...roomHandoffs.nodes.values()].some(n => n.groupId === group.id && !["completed", "failed", "cancelled"].includes(n.status)),
+    };
 }
 function beginGroupTurnOperation(groupId, threadId, botIds = []) {
     const operation = {
@@ -5449,6 +5673,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 +6173,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 +6184,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 +6223,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 +6253,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 +6289,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 +6300,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 +6371,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 +6407,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 +6585,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 +6603,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 +6630,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 +6645,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 +8182,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 +8245,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 +8279,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 +8774,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 +8868,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);
@@ -8641,6 +8944,8 @@ async function startTurn(botId, text, opts) {
             },
         };
     }
+    // A thread whose own model can't run runs on its bot's from now on.
+    healThreadModel(botId, threadId);
     const bot = store.projectBotForTask(botId, threadId);
     if (!bot)
         throw Object.assign(new Error("no such task"), { status: 404 });
@@ -8695,6 +9000,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);
@@ -8878,6 +9187,11 @@ async function startTurn(botId, text, opts) {
     turnContext.delete(threadId);
     void (async () => {
         try {
+            if (enginesRead) {
+                await enginesRead;
+                if (!directTurnClaimIsCurrent(bot.id, dispatchClaimId, threadId))
+                    throw new DirectTurnSetupCancelled("turn stopped while the engines were read");
+            }
             // Readiness can wait on the network. Admit the task first so its busy
             // state, Stop action and watchdog own that wait just like VM setup.
             if (opts?.runOn === "cloud") {
@@ -8988,7 +9302,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 +9339,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 +9412,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 +9453,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 +9469,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 +9602,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 +9621,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 +9639,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 +9667,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 +9723,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 +9770,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 +9787,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 +9804,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 +9839,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 +9887,6 @@ async function startTurn(botId, text, opts) {
             }
             if (wants === undefined &&
                 cloudBackend === "vps" &&
-                !integrations.computer &&
                 !integrations.localComputer &&
                 autoVpsProblem &&
                 !computerSelectionTurns.has(threadId)) {
@@ -9560,7 +9894,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 +10017,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 +10039,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 +10055,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) : "" },
@@ -9814,6 +10146,7 @@ async function startTurn(botId, text, opts) {
                 mentionTurn: tagged.length > 0,
                 integrations,
                 mcpFromUserConfig: claudeUserMcpEnabled(cfg) && !managedPolicy.restrictsMcp(),
+                mcpCallTimeoutMs: mcpCallTimeoutMinutes(cfg) * 60_000,
                 cwd,
             }), () => !directTurnClaimExists(bot.id, dispatchClaimId, threadId), async () => {
                 await instance.adapter.interruptTurn(threadId).catch(() => { });
@@ -9856,7 +10189,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 +10283,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 +10341,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
@@ -10057,6 +10384,9 @@ function routineSourceOwner(run) {
             ? { bot, group: undefined, threadId: task.threadId }
             : null;
     }
+    // Without a results snapshot (a run from before every routine reported to
+    // its bot's main thread, or a bot with no visible thread) the chat that
+    // made the routine is the destination.
     const threadId = run.sourceThreadId?.trim();
     if (!threadId)
         return null;
@@ -10077,6 +10407,21 @@ function routineSourceOwner(run) {
     const group = store.groupByThread(threadId);
     return group?.memberIds.includes(bot.id) ? { bot, group, threadId } : null;
 }
+/** There is no durable "main thread" (bot.threadId is only the UI
+ * selection), so a routine reports into the bot's oldest open conversation:
+ * the one it was created with until that is deleted or archived. Deleting
+ * the last one already gives the bot a fresh conversation (Store.deleteTask). */
+function botMainThread(botId) {
+    const visible = store.tasks(botId).filter((task) => !task.routineRunId);
+    const open = visible.filter((task) => task.archivedAt === undefined);
+    return (open.length ? open : visible).reduce((oldest, task) => (!oldest || task.createdAt < oldest.createdAt ? task : oldest), undefined)?.threadId;
+}
+/** Routines without a chosen thread used to get an automatic "<name> ·
+ * Results" thread. One nobody renamed is that automatic default, not a
+ * choice: new runs move to the main thread, and the old thread stays. */
+function legacyResultsThread(routineName, task) {
+    return task.title.endsWith(" · Results") || task.title === threadTitleFrom(`${routineName} · Results`);
+}
 function routineSourceThread(run) {
     return routineSourceOwner(run)?.threadId ?? null;
 }
@@ -10275,13 +10620,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
@@ -10305,21 +10655,32 @@ routines = new RoutineManager({
         return Boolean(bot && !bot.hidden && task && !task.routineRunId);
     },
     resolveResultsThread: (routine, forceNew) => {
-        // A trusted chat source is already snapshotted as sourceThreadId on each
-        // run. Keep it distinct: it can belong to a teammate or room, whereas an
-        // explicit resultsThreadId must be a visible task owned by the running bot.
-        if (!forceNew && routineSourceOwner(routine))
-            return routine.resultsThreadId;
+        // Every run reports into the routine's bot's main thread, wherever the
+        // routine was made (chat, editor, API, or a teammate's request). A run
+        // still executes in its own hidden task, which Run logs and Open run use.
+        // A thread the person chose in "Post results to" keeps winning.
+        const bot = store.bot(routine.botId);
+        const chosen = !forceNew && routine.resultsThreadId && bot && !bot.hidden
+            ? store.taskByThread(bot.id, routine.resultsThreadId) : undefined;
+        // On a Cloud home a routine reports only where its writer may write: a
+        // guest's (or nobody's) keeps a results conversation opened as theirs.
+        const opener = CLOUD_HOME ? routineOpener(routine.id) : undefined;
+        const main = bot && !bot.hidden ? botMainThread(bot.id) : undefined;
+        const mainAllowed = main && (!CLOUD_HOME || (opener === CLOUD_OWNER_KEY && !cloudGuestOpened(main)));
+        const keepChosen = chosen && !chosen.routineRunId && !(mainAllowed && legacyResultsThread(routine.name, chosen));
+        if (keepChosen)
+            return chosen.threadId;
+        if (mainAllowed || !CLOUD_HOME)
+            return main;
         const threadId = store.createTask(routine.botId, `${routine.name} · Results`, false)?.threadId;
-        // On a Cloud home the results conversation is opened by whoever wrote the
-        // routine: it carries their name for it (cloudGuestOpened).
-        if (threadId && CLOUD_HOME)
-            threadStarters.set(threadId, routineOpener(routine.id));
+        if (threadId)
+            threadStarters.set(threadId, opener);
         return threadId;
     },
     discardResultsThread: (botId, threadId) => {
         const task = store.taskByThread(botId, threadId);
-        if (task && !task.busy && !task.routineRunId && store.messagesFor(threadId).length === 0) {
+        // The main thread is reused, never allocated, so a failed write keeps it.
+        if (task && threadId !== botMainThread(botId) && !task.busy && !task.routineRunId && store.messagesFor(threadId).length === 0) {
             store.deleteTask(botId, threadId);
             handoffs.forget(threadId);
         }
@@ -10491,31 +10852,35 @@ if (recoveryOwners.length > 0) {
 // after the user confirms a durable card. Keeping this beside the scheduler
 // makes the card resolvable after an app restart without involving the model.
 async function cloudRoutineReadiness(botId, threadId) {
-    const bot = threadId ? store.projectBotForTask(botId, threadId) : store.bot(botId);
+    const projected = threadId ? store.projectBotForTask(botId, threadId) : store.bot(botId);
+    // The model its turn will run on: a thread's own model that can't run
+    // gives way to the bot's when the turn starts (healThreadModel).
+    const selection = threadId ? turnSelection(botId, threadId) : projected?.modelSelection;
+    const bot = projected && selection ? { ...projected, modelSelection: selection } : projected;
     if (!bot || bot.hidden)
         return { ready: false, reason: "The routine's target bot no longer exists." };
     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,12 +11573,11 @@ 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
-    // steals the bot's live selection the way POST /api/bots/:id/tasks
-    // does), reused forever after via trigger.resultsThreadId.
+    // Create-on-first-use, never activated (so it never steals the bot's
+    // live selection the way POST /api/bots/:id/tasks does), reused forever
+    // after via trigger.resultsThreadId.
     resolvePostThread: (trigger, forceNew) => {
         if (!forceNew && trigger.resultsThreadId)
             return trigger.resultsThreadId;
@@ -11446,6 +11810,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 +12060,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 +12086,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 +12099,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 +12157,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 +12167,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 +12218,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 +12305,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 +12325,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),
@@ -11951,6 +12344,10 @@ setupRetry = 0) {
             { id: "skill-instructions", label: "Skill instructions", text: renderSkillInstructions(selectedSkills, { includeRoot: Boolean(workspace) }) },
             { id: "playbooks", label: "Playbooks", text: installedPlaybookInstructions(text, bot.playbooks) },
         ]);
+        // The engines read at start is part of setup (it learns what this engine
+        // supports): wait for it before the claim below.
+        if (enginesRead)
+            await enginesRead;
         // run the turn and wait for it to settle, folding the reply text so a
         // chained @mention can be routed afterwards
         // Claim only after setup succeeded. An unavailable, busy, unsupported, or
@@ -11990,7 +12387,10 @@ setupRetry = 0) {
             else
                 markCancelledProviderHandshake(threadId, retirementOwner);
         };
-        const timeoutMinutes = roomTurnTimeoutMinutes(cfg);
+        const liveGroup = store.group(groupId) ?? group;
+        const timeoutMinutes = effectiveRoomTurnTimeoutMinutes(roomTurnTimeoutMinutes(cfg), liveGroup.dm
+            ? liveGroup.turnTimeoutMinutes
+            : store.groupTaskByThread(liveGroup.id, threadId)?.turnTimeoutMinutes);
         const outcome = await new Promise((resolve) => {
             let done = false;
             let unsub = () => { };
@@ -12025,13 +12425,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
@@ -12081,6 +12478,7 @@ setupRetry = 0) {
                 cwd,
                 integrations,
                 mcpFromUserConfig: claudeUserMcpEnabled(cfg) && !managedPolicy.restrictsMcp(),
+                mcpCallTimeoutMs: mcpCallTimeoutMinutes(cfg) * 60_000,
                 ...(instance.instanceId === readyBot.modelSelection.instanceId
                     ? memberTurnSelection(readyBot.modelSelection)
                     : { model: instance.models.default }),
@@ -12220,7 +12618,7 @@ setupRetry = 0) {
             drainSecretResumes();
             drainTeamSetupResumes();
         }
-        if (outcome === "provider_failed") {
+        if (outcome === "provider_failed" || outcome === "parked") {
             if (skillAuthoring)
                 skillAuthoringClaim.claimed = false;
             return false;
@@ -12309,7 +12707,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) {
@@ -14009,6 +14407,7 @@ function configStatus() {
         // not a secret — the settings picker shows it; "" = follow the system
         language: cfg.language ?? "",
         rooms: { turnTimeoutMinutes: roomTurnTimeoutMinutes(cfg) },
+        mcp: { callTimeoutMinutes: mcpCallTimeoutMinutes(cfg) },
         automaticRecovery: cfg.automaticRecovery ?? { enabled: false },
         // absent effort = no level is sent, so clients can tell it from any level
         newBots: cfg.newBots?.effort ? { effort: cfg.newBots.effort } : {},
@@ -14124,6 +14523,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 = {
@@ -14360,15 +14763,22 @@ function serveStatic(res, path) {
     try {
         const data = readFileSync(file);
         const type = MIME[extname(file)] ?? "application/octet-stream";
-        res.writeHead(200, { "content-type": type, ...(type === "text/html" ? PAGE_HEADERS : {}) });
+        // Vite puts a content hash in the name of every file it writes under
+        // /assets/, so a URL there never changes: the browser keeps it instead of
+        // downloading the bundle on every load. That only holds while public/ has
+        // no assets/ dir (index.test.ts checks). Pages are revalidated, so a new
+        // build shows up on the next load.
+        const cache = type === "text/html" ? "no-cache" : safe.startsWith("/assets/") ? "public, max-age=31536000, immutable" : null;
+        res.writeHead(200, { "content-type": type, ...(type === "text/html" ? PAGE_HEADERS : {}), ...(cache ? { "cache-control": cache } : {}) });
         res.end(data);
         return true;
     }
     catch {
-        // SPA fallback
+        // SPA fallback. Never immutable: a missing chunk answered with the page
+        // must not stay cached under the chunk's URL.
         try {
             const data = readFileSync(join(STATIC_DIR, "index.html"));
-            res.writeHead(200, { "content-type": "text/html", ...PAGE_HEADERS });
+            res.writeHead(200, { "content-type": "text/html", "cache-control": "no-cache", ...PAGE_HEADERS });
             res.end(data);
             return true;
         }
@@ -14483,6 +14893,15 @@ ROUTES.push(createBotMemoryRoutes({
     },
 }));
 ROUTES.push(createDeciderRoutes({ decider }));
+// "Switch them too": a bot's threads on a model of their own follow its model again.
+ROUTES.push(createThreadModelRoutes({
+    bot: (id) => store.bot(id),
+    busy: (botId, threadId) => threadBusy(botId, threadId),
+    follow: (botId, threadIds) => store.followBotModel(botId, threadIds, (from, to) => hostedModels?.resetTask(from, to) ?? {}),
+    // Like updateBotDefault on a thread: on a Cloud home, the owner's alone.
+    mayChangeModel: (auth) => !CLOUD_HOME || cloudOwnerSession(auth),
+    reply: (botId) => publicBot(store.bot(botId)),
+}));
 ROUTES.push(createAntigravityLeftoverRoutes({
     hosted: Boolean(hostedModels),
     isAntigravity: (instanceId) => registry.get(instanceId)?.driverKind === "antigravityAgent",
@@ -14552,7 +14971,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 +15466,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 +15649,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 +15663,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 +15769,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 +16622,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 +16791,7 @@ const handleRequest = async (req, res) => {
                         sourceThreadId: fromThreadId,
                         sourceBotId: currentFrom.id,
                         routineRunId: activeRoutineRunForThread(fromThreadId)?.id,
+                        ...externalCompletion(internalCapability),
                     });
                     store.appendMessage(fromThreadId, {
                         role: "bot",
@@ -16566,7 +16996,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 +17976,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 +18014,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 +18109,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") {
@@ -17772,6 +18210,9 @@ const handleRequest = async (req, res) => {
                     const message = store.appendMessage(threadId, {
                         role: "bot",
                         kind: "connector",
+                        // Read only by clients that predate the card (older phones draw
+                        // an unknown kind by its text); see connector-card-text.ts.
+                        text: connectorCardText(toolkit.label, item.alias),
                         ...(owner.group ? { from: { botId: owner.bot.id, name: owner.bot.name, color: owner.bot.color } } : {}),
                         connector: {
                             slug: item.slug,
@@ -18184,7 +18625,7 @@ const handleRequest = async (req, res) => {
             return json(res, 200, {
                 bots: shownBots.map((bot) => memberBot({
                     ...wireBot(bot),
-                    tasks: store.tasks(bot.id).map(wireTask),
+                    tasks: store.tasks(bot.id).map((task) => wireTask(task, bot.modelSelection)),
                     ...messagePage(bot.threadId, limit),
                 }, visible)),
                 botQueuedMessages: visible.everything ? queued : Object.fromEntries(Object.entries(queued).filter(([threadId]) => visible.thread(threadId))),
@@ -19148,7 +19589,7 @@ const handleRequest = async (req, res) => {
             if (!body || typeof body !== "object" || Array.isArray(body)) {
                 return json(res, 400, { error: "body must be a JSON object" });
             }
-            const allowed = new Set(["title", "pinned"]);
+            const allowed = new Set(["title", "pinned", "turnTimeoutMinutes"]);
             if (Object.keys(body).some((key) => !allowed.has(key)))
                 return json(res, 400, { error: "unsupported channel thread setting" });
             const existing = store.groupTaskByThread(group.id, m[2]);
@@ -19156,12 +19597,16 @@ const handleRequest = async (req, res) => {
                 return json(res, 404, { error: "no such channel task" });
             const pinning = body.pinned !== undefined;
             const renaming = body.title !== undefined;
-            if (!pinning && !renaming)
+            const limiting = Object.prototype.hasOwnProperty.call(body, "turnTimeoutMinutes");
+            if (!pinning && !renaming && !limiting)
                 return json(res, 400, { error: "unsupported channel thread setting" });
             if (pinning && typeof body.pinned !== "boolean")
                 return json(res, 400, { error: "pinned must be a boolean" });
             if (renaming && typeof body.title !== "string")
                 return json(res, 400, { error: "title must be a string" });
+            const parsedLimit = limiting ? parseConversationTurnTimeout(body.turnTimeoutMinutes) : null;
+            if (parsedLimit && !parsedLimit.ok)
+                return json(res, 400, { error: parsedLimit.error });
             // Echoing the current title lets a newer client pin on an older server
             // without the old handler turning a missing title into "Untitled".
             // That echo is not a rename. A real rename stays blocked while working.
@@ -19169,10 +19614,19 @@ const handleRequest = async (req, res) => {
             const notYours = titleChange ? cloudThreadRefusal(auth, m[2]) : null;
             if (notYours)
                 return json(res, 403, { error: notYours });
-            if (channelTaskBlocked(group) && !(pinning && !titleChange)) {
+            // A longer limit applies to the next turn, so it can be saved while
+            // this one is still running. A rename still waits.
+            const settingsOnly = !titleChange && (pinning || limiting);
+            if (channelTaskBlocked(group) && !settingsOnly) {
                 return json(res, 409, { error: "this channel is working or waiting on you — finish that turn first" });
             }
             let task = existing;
+            if (limiting && parsedLimit?.ok) {
+                const limited = store.setGroupTaskTurnTimeout(group.id, m[2], parsedLimit.minutes);
+                if (!limited)
+                    return json(res, 404, { error: "no such channel task" });
+                task = limited;
+            }
             if (pinning) {
                 const pinned = store.setGroupTaskPinned(group.id, m[2], body.pinned === true);
                 if (!pinned)
@@ -20006,10 +20460,12 @@ const handleRequest = async (req, res) => {
             }
             // patchBot persists first and emits the canonical bot change, which the
             // store listener above turns into the slim wire-format SSE broadcast.
+            // Every thread that follows the bot moves with it; the selected thread
+            // follows it from now on too, as if picked there.
             const bot = store.patchBot(existing.id, { modelSelection: checked.selection });
             if (!bot)
                 return json(res, 404, { error: "no such bot" });
-            store.patchTask(bot.id, selected.threadId, { modelSelection: checked.selection,
+            store.patchTask(bot.id, selected.threadId, { modelSelection: undefined,
                 ...hostedModels?.resetTask(selected.modelSelection, checked.selection) });
             return json(res, 200, { bot: wireBot(bot) });
         }
@@ -20695,8 +21151,10 @@ const handleRequest = async (req, res) => {
             // and pins that already match stay; returning to Auto sweeps nothing.
             if (computerSpecified && requestedComputer !== undefined)
                 store.clearAutoSurfacePins(m[1], requestedComputer);
+            // A new bot model moves every thread that follows the bot; the selected
+            // thread follows it from now on too.
             if (normalizedSelection && selectedTask)
-                store.patchTask(bot.id, selectedTask.threadId, { modelSelection: normalizedSelection,
+                store.patchTask(bot.id, selectedTask.threadId, { modelSelection: undefined,
                     ...hostedModels?.resetTask(selectedTask.modelSelection, normalizedSelection) });
             if (existingBot && (bot.browserProfile !== beforeBrowserProfile || bot.browser !== beforeBrowserEnabled)) {
                 browserLive.closeForBot(bot.id);
@@ -21493,12 +21951,15 @@ const handleRequest = async (req, res) => {
             if (phoneSecretSubmissions.hasThread(bot.threadId)) {
                 return json(res, 409, { error: "this task is securely saving a credential — try again when it finishes" });
             }
-            if (!registry.get(bot.modelSelection.instanceId)) {
+            // A thread's own model that can't run gives way to the bot's when the
+            // rerun starts (healThreadModel), so check the model it will run on.
+            const rerunSelection = turnSelection(bot.id, bot.threadId) ?? bot.modelSelection;
+            if (!registry.get(rerunSelection.instanceId)) {
                 return json(res, 409, {
-                    error: `provider instance "${bot.modelSelection.instanceId}" is unavailable — pick another model in settings`,
+                    error: `provider instance "${rerunSelection.instanceId}" is unavailable — pick another model in settings`,
                 });
             }
-            const rerunInstance = registry.get(bot.modelSelection.instanceId);
+            const rerunInstance = registry.get(rerunSelection.instanceId);
             const rerunRefusal = policyModelRefusal(rerunInstance);
             if (rerunRefusal)
                 return json(res, 409, { error: rerunRefusal });
@@ -21929,7 +22390,7 @@ const handleRequest = async (req, res) => {
             // Who opened it decides who may answer its cards on a shared workspace.
             if (auth.kind === "session")
                 threadStarters.set(task.threadId, actorKey(auth));
-            return json(res, 201, { bot: publicBot(store.bot(bot.id)), task: wireTask(task) });
+            return json(res, 201, { bot: publicBot(store.bot(bot.id)), task: wireTask(task, store.bot(bot.id).modelSelection) });
         }
         m = path.match(/^\/api\/bots\/([\w-]+)\/tasks\/([\w-]+)$/);
         if (m && method === "POST") {
@@ -21947,7 +22408,7 @@ const handleRequest = async (req, res) => {
             const switched = store.switchTask(bot.id, m[2]);
             if (!switched)
                 return json(res, 404, { error: "no such task" });
-            const switchedSettings = { ...wireBot(switched), tasks: store.tasks(switched.id).map(wireTask) };
+            const switchedSettings = { ...wireBot(switched), tasks: store.tasks(switched.id).map((task) => wireTask(task, switched.modelSelection)) };
             // "0" is settings only, a positive page is a bounded transcript, and no
             // parameter is the whole thread — the one branch that materialises it.
             // Search results land through that branch (src/lib/focus-message.ts):
@@ -22029,7 +22490,7 @@ const handleRequest = async (req, res) => {
                 const task = store.refreshTaskPermissions(profile.id, m[2]);
                 if (!task)
                     return json(res, 404, { error: "no such task" });
-                return json(res, 200, { task: wireTask(task), bot: publicBot(store.bot(profile.id)) });
+                return json(res, 200, { task: wireTask(task, store.bot(profile.id).modelSelection), bot: publicBot(store.bot(profile.id)) });
             }
             const patch = {};
             if (body.projectId !== undefined) {
@@ -22135,7 +22596,7 @@ const handleRequest = async (req, res) => {
             const task = patch.modelSelection
                 ? store.switchTaskModel(m[1], m[2], patch.modelSelection, body.updateBotDefault === true, body.resetApprovalToAsk === true, { ...patch, ...hostedModels?.resetTask(current.modelSelection, patch.modelSelection) })
                 : store.patchTask(m[1], m[2], patch);
-            return json(res, 200, { task: wireTask(task), bot: publicBot(store.bot(m[1])) });
+            return json(res, 200, { task: wireTask(task, store.bot(m[1]).modelSelection), bot: publicBot(store.bot(m[1])) });
         }
         if (m && method === "DELETE") {
             const bot = store.bot(m[1]);
@@ -22207,7 +22668,7 @@ const handleRequest = async (req, res) => {
                 const task = store.retitleTask(m[1], m[2], startedFrom, title) ?? store.taskByThread(m[1], m[2]);
                 if (!task)
                     return json(res, 404, { error: "no such task" });
-                return json(res, 200, { task: wireTask(task) });
+                return json(res, 200, { task: wireTask(task, store.bot(m[1]).modelSelection) });
             }
             finally {
                 titleRegenerations.delete(m[2]);
@@ -22252,8 +22713,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 +22751,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 +22771,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 +23093,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)
@@ -22782,7 +23246,17 @@ const handleRequest = async (req, res) => {
                 return json(res, 400, { error: "That does not look like an API key." });
             const url = typeof body?.url === "string" && body.url.trim() ? body.url.trim() : (saved && "url" in saved ? saved.url : undefined);
             res.setHeader("cache-control", "no-store");
-            return json(res, 200, await checkProviderKey({ provider: kind, key, url }));
+            const verdict = await checkProviderKey({ provider: kind, key, url });
+            // A Test is a real use the person chose: the engines on this key agree
+            // with its verdict. Claude runs its key through its CLI, not here.
+            if (kind !== "anthropic") {
+                const base = providerBaseUrl(kind, url);
+                if (verdict.ok)
+                    noteKeyAccepted(base, key);
+                else if (verdict.reason === "rejected")
+                    noteKeyRejected(base, key);
+            }
+            return json(res, 200, verdict);
         }
         if (method === "GET" && path === "/api/decisions") {
             const rawLimit = url.searchParams.get("limit");
@@ -23812,6 +24286,12 @@ const handleRequest = async (req, res) => {
                         browserCleanup.abort(request);
                     throw error;
                 }
+                // A saved or cleared key starts over: neither it nor the key it
+                // replaced stays marked as rejected.
+                const resetKeys = PROVIDER_KEY_KINDS.flatMap((kind) => {
+                    const next = patch[kind]?.key;
+                    return next === undefined ? [] : [cfg[kind]?.key, next];
+                });
                 let configWriteCommitted = false;
                 const externalSecretStorage = url.searchParams.get("secretStorage") === "external";
                 try {
@@ -23877,6 +24357,9 @@ const handleRequest = async (req, res) => {
                     }
                     throw error;
                 }
+                for (const key of resetKeys)
+                    if (key)
+                        forgetKey(key);
                 // Desktops already counting down move to the new window at once, in
                 // every isolation mode; busy work still defers its expiry.
                 if (patch.localVm?.idleTimeoutMinutes !== undefined) {
@@ -24285,9 +24768,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 +24944,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 {
@@ -24496,7 +24976,7 @@ const handleRequest = async (req, res) => {
     catch (e) {
         const status = e?.status ?? 500;
         const candidateCode = e?.code;
-        const code = typeof candidateCode === "string" && ["guarded_busy", "guarded_branch", "guarded_permissions", "guarded_request_changed", "guarded_request_untracked"].includes(candidateCode)
+        const code = typeof candidateCode === "string" && ["guarded_busy", "guarded_branch", "guarded_permissions", "guarded_request_changed", "guarded_request_untracked", "outside_workspace"].includes(candidateCode)
             ? candidateCode : undefined;
         return json(res, status, { error: e instanceof Error ? e.message : String(e), ...(code ? { code } : {}) });
     }
@@ -24646,12 +25126,22 @@ restoreChannelMessages();
     if (movedAutoPins)
         console.log(`Works on: moved ${movedAutoPins} auto-pinned thread(s) to their bot's current Works on`);
 }
-server.listen(PORT, "127.0.0.1", () => {
+server.listen(PORT, "127.0.0.1", async () => {
     companyRuntimeReady();
     console.log(`openmausbot server on http://127.0.0.1:${PORT}`);
+    // Words queued before the restart start first, ahead of anything sent from
+    // now on. Their turns wait for the engines read at start like every turn.
     followupsReady = true;
     drainQueuedSends();
     drainQueuedChannelSends();
+    // The work below wakes delegators, and a woken delegator keeps its session
+    // only on an engine that records what it was handed, which that read finds
+    // out: it starts once the read is done.
+    if (enginesRead) {
+        await enginesRead;
+        if (companyShutdown)
+            return;
+    }
     // Startup work uses the same turn dispatcher and local tool endpoint as
     // ordinary chat. Start only once every registry is initialized and the
     // endpoint is listening; earlier dispatch can hit uninitialized bindings.