openmausbot 0.1.95 → 0.1.97

package/dist-server/server/index.js

@@ -27,6 +27,9 @@ import { assertRequestTarget, guardedRequestPath, requestConflict, requestNeedsI
 import { botAvatarUrlFromStoredPath } from "../shared/bot-avatar.js";
 import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
 import { CLOUD_COMPUTER_BUSY_ERROR } from "../shared/computer-contention.js";
+import { failedTurnTool } from "../shared/failed-turn.js";
+import { phonePairingLink } from "../shared/pairing-link.js";
+import { canWorkOnCloud } from "../shared/cloud-computer.js";
 import { approvalModeFor, modelSwitchNeedsAsk, isEmergencyApprovalDowngrade, isApprovalMode, } from "../shared/approval-mode.js";
 import { createApprovalModeSupport } from "./harness-capabilities.js";
 import { escapeAttribute } from "../src/lib/composer-attachments.js";
@@ -50,6 +53,8 @@ import { avatarGenerationRequestSchema, avatarGenerationStateMatches, generateAv
 import { fitsOnOneLine, parseBotProfilePatch } from "./bot-profile.js";
 import { groupTurnCwd } from "./room-cwd.js";
 import { RoomTurnDeadline, RoomTurnStallRegistry, roomTurnTimeoutMessage } from "./room-turn-timeout.js";
+import { roomTurnEnd } from "./room-turn-end.js";
+import { pickComputer } from "./computer-selection.js";
 import * as boat from "./boat.js";
 import { cloudComputerRpc } from "./cloud-computer-tools.js";
 import { TeamComputers, teamComputerAssignment, teamComputerCreate, teamComputerOwner } from "./team-computers.js";
@@ -58,7 +63,7 @@ import { isPersistentQuestionCard, QUESTION_DISMISS_MESSAGE, shouldSettleRequest
 import { parseToolScope, toolScopeWidens } from "../shared/tool-scope.js";
 import { boatCreateRecoverySnapshot, retireDeletedBoatCreate } from "./boat-create-idempotency.js";
 import { boatDeletionSnapshot } from "./boat-delete-journal.js";
-import { liveDecisionRefusal } from "../shared/live-approval.js";
+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";
@@ -69,7 +74,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, computerClaimIdleReleaseEnabled, cloudOverflowAllowlistedThreads, cloudOverflowEnabled, cloudOverflowIdleStopMs, cloudOverflowPerSecondCostUsd, 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, } from "./config.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 { sweepThreadEventLogs } from "./thread-retention.js";
 import { ComputerControl } from "./computer-control.js";
 import { augmentedPath, findCliCandidates, resetPathCache } from "./env-path.js";
@@ -85,11 +90,11 @@ import { entitled } from "./enterprise.js";
 import { HOSTED_CONTRACT_HEADER, HOSTED_CONTRACT_METADATA, HOSTED_CONTRACT_VERSION } from "./hosted-contract.js";
 import { describeSpawnFailure, execCli } from "./procs.js";
 import { blockedTarget, buildNotification, buildSpendNotification } from "./notify.js";
-import { isModelVariant, TurnNotStartedError, newId, usesCloudComputer, } from "./contracts.js";
+import { isModelVariant, TurnNotStartedError, newId, } from "./contracts.js";
 import { RETRY_MAX_ATTEMPTS } from "./drivers/retry.js";
 import { recoveryCapabilityError } from "./automatic-recovery.js";
 import { decodeGeneratedImage } from "./generated-image.js";
-import { MAX_MCP_SERVERS, isRemoteMcpServer, listMcpServers, mcpServerNameError, parseMcpServerMutation, parseMcpServersImport, parseStoredMcpServer, } from "./mcp-registry.js";
+import { addDisabledMcpServer, MAX_MCP_SERVERS, isRemoteMcpServer, listMcpServers, mcpServerNameError, parseMcpServerMutation, parseMcpServersImport, parseStoredMcpServer, } from "./mcp-registry.js";
 import { McpOAuthError, McpSignInError, McpOAuthManager, mcpOAuthRedirectUri, withMcpSignIn, withoutPendingSignIn } from "./mcp-oauth.js";
 import { probeMcpServer } from "./mcp-probe.js";
 import { GROUP_GOAL_MAX_TURNS, groupGoalAssignmentKey, groupGoalCompletionTurnId, groupGoalCoordinatorInstructions, groupGoalWorkerInstructions, parseGroupGoalDecision, resolveGroupGoalMember, selectGroupGoalCoordinator, } from "./group-goal-run.js";
@@ -115,11 +120,13 @@ import { ProviderRegistry } from "./harness/registry.js";
 import { ManagedDesktopProviders } from "./managed-desktop.js";
 import { computerKindForResource, ManagedDesktopPolicy } from "./managed-policy.js";
 import { hostedModelPolicy, HOSTED_MODEL_POLICY_HEADER, HOSTED_PROVIDER_SETTINGS_ERROR } from "./hosted-models.js";
-import { boatNotConfiguredMessage, CLOUD_HOME_RESTART_EXIT_CODE, 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 } from "./cloud-move-http.js";
+import { createCloudMoveRoutes, workspaceShared } from "./cloud-move-http.js";
+import { RESTART_EXIT_CODE } from "./restart.js";
 import { holdIncludedServices } from "./included-services.js";
 import { selectDefaultModelSelection, withNewBotEffort } from "./default-model-selection.js";
+import { computerEngineMoveText, removedComputerInstanceIds, writeComputerEngineMoveLines } from "./computer-engine-removal.js";
 import { cancelPeerApprovalsFor, cancelPeerApprovalsForThread, dismissStalePeerCards, peerApprovalFailure, requestPeerApproval, resolvePeerComms } from "./peer-approval.js";
 import { peerDeliveryReceipt } from "./peer-delivery.js";
 import { peerProvenanceNote, withPeerProvenance } from "./peer-provenance.js";
@@ -132,13 +139,13 @@ 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";
 import { threadTitlePrompt, titleConversationExcerpt } from "./thread-title.js";
 import { TurnWatchdog } from "./turn-watchdog.js";
-import { TurnResources, workspaceResource } from "./turn-resources.js";
-import { IdleReleasePolicy } from "./claim-idle.js";
+import { TurnResources } from "./turn-resources.js";
 import { ensureWorkspace, ensureTaskWorkspace, workspaceLocationsPrompt, supportsWorkspaceFiles, updateMemory, appendMemoryLog, memorySystemPrompt, memorySourceLabel, searchMemoryFiles, SESSION_SEARCH_SYSTEM_PROMPT, TASK_WORKSPACES_DIR, readMemoryOnlyFromRegularFiles, workspaceDir, } from "./workspace.js";
 import { listMemoryTopics, memoryDate, readMemoryFile, readMemoryTopic, writeMemoryFile, writeMemoryTopic } from "./workspace.js";
 import { beginMemoryTurn, endMemoryTurn, flushAllMemoryJournals, journalMemoryWrite, } from "./memory-journal.js";
@@ -150,7 +157,7 @@ import { botSkillTemplateSchema, newBotDefaultsSchema, resolveBotCreationDefault
 import { expandLearnTurnText, learnSource } from "./skill-learn.js";
 import { expandSetupTurnText, setupModeActive, setupSystemPrompt } from "./setup-mode.js";
 import { checkSoulDrift, readSoulDrift, soulFile, writeSoulMirror } from "./bot-folder.js";
-import { buildSystemPrompt, userProfileSystemPrompt, cloudHomePrompt, computerPrompt, composioSystemPrompt, customMcpPrompt, CREDENTIAL_PROMPT, mentionPrompt, THREADS_PROMPT, LEARN_PROMPT, PROFILE_PROMPT, TEAM_MEMORY_PROMPT, ROUTINE_PROMPT, ROUTINE_EXECUTION_PROMPT, WEBHOOK_PROMPT, resolveComputerPromptKind, } from "./system-prompt.js";
+import { buildSystemPrompt, userProfileSystemPrompt, cloudHomePrompt, computerPrompt, composioSystemPrompt, customMcpPrompt, CREDENTIAL_PROMPT, mentionPrompt, THREADS_PROMPT, LEARN_PROMPT, PROFILE_PROMPT, TEAM_MEMORY_PROMPT, ROUTINE_PROMPT, ROUTINE_EXECUTION_PROMPT, WEBHOOK_PROMPT, resolveComputerPromptKind, teamAvailabilityPart, } from "./system-prompt.js";
 import { readCuaConnection, readCuaUnavailableReason, gatedLocalComputer } from "./local-computer.js";
 import { discoverExistingPerBotLocalVms, discoverExistingPoolLocalVms, localVmInventoryEntry, shouldArmLocalVmIdle, } from "./local-vm-inventory.js";
 import { localVmStopReason, recordLocalVmIdleStop } from "./local-vm-stop-reason.js";
@@ -165,7 +172,7 @@ import { CalendarCallManager } from "./calendar-calls.js";
 import { BUILT_IN_BROWSER_SYSTEM_PROMPT } from "./browser-engine.js";
 import { BrowserRuntime, browserRuntimeEnv } from "./browser-runtime.js";
 import { BrowserLive } from "./browser-live.js";
-import { agentBrowserFrame, agentBrowserIntegration, browserEngineEncryptionKey, prepareBrowserSessionState, clearBrowserSessionState, closeBrowserSession, ensureChrome, installAgentBrowserBinary, resolveAgentBrowserBinary, browserEngineStatus, browserSessionId, describeBrowserEngine, } from "./browser-engine.js";
+import { agentBrowserFrame, agentBrowserIntegration, browserEngineEncryptionKey, prepareBrowserSessionState, clearBrowserSessionState, closeBrowserSession, ensureChrome, installAgentBrowserBinary, resolveAgentBrowserBinary, browserEngineStatus, browserSessionId, describeBrowserEngine, setBrowserViewport, } from "./browser-engine.js";
 import { createScreenFrameSource } from "./screen-frame-source.js";
 import { screenFrameHash, screenSurfaceForTool, screenTouchingTool, settledFrameIsNews } from "./screen-frame-gate.js";
 import { asSchedule, RoutineRequestService } from "./routine-requests.js";
@@ -173,7 +180,6 @@ import { createOptionsCard } from "./options-card.js";
 import { buildBotOverview, connectedAppsFacts } from "./bot-overview.js";
 import { ProfileRequestService } from "./profile-requests.js";
 import { ModelRequestService } from "./model-requests.js";
-import { TighteningRequestService } from "./tightening-requests.js";
 import { TeamSetupError, TeamSetupRequestService } from "./team-setup-requests.js";
 import { profileRevision, profileSnapshot } from "./profile-revision.js";
 import { flushAllProfileHistory, flushProfileHistory, readHistory, recordProfileChange } from "./profile-versions.js";
@@ -206,11 +212,11 @@ import { createTeamBackup, importTeamBackup } from "./team-backup.js";
 import { MAX_TEAM_BACKUP_BYTES } from "../shared/team-backup.js";
 import { shouldMountLocalComputer } from "./local-routing.js";
 import { autoLocalVmAttachable } from "./container-computer.js";
-import { startAutoVmClaim } from "./auto-vm-claims.js";
+import { lazyClaimWaitMs, startAutoVmClaim } from "./auto-vm-claims.js";
 import { computerFreeAfterText, computerParkedText, computerStoppedWaitingText, computerWaitingText } from "./computer-wait.js";
-import { CloudOverflowConsent, CloudSeatLease, cloudOverflowAction, cloudOverflowConsentText, cloudOverflowOfferText, cloudSeatStartedText, cloudSeatStoppedText } from "./cloud-overflow.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";
@@ -243,6 +249,7 @@ import { localDesktopTarget, localVmViewerStatus, viewerTargetId } from "./deskt
 import { createAntigravityLeftoverRoutes } from "./routes/antigravity-leftovers.js";
 import { findAntigravityLeftovers, removeAntigravityLeftovers } from "./drivers/antigravity-temp.js";
 import { createLiveRoutes } from "./routes/live.js";
+import { withScopeHint } from "./connector-scope-hint.js";
 const PORT = Number(process.env.OMB_PORT || process.env.OGB_PORT || 8799);
 const WEBHOOK_PORT = Number(process.env.OMB_WEBHOOK_PORT || PORT + 1);
 // Behind a proxy or tunnel, the base URL senders should use (docs/self-hosting.md).
@@ -557,7 +564,7 @@ function cloudLendingTurn(capability) {
         generation: capability.generation,
         thread: store.messagesFor(capability.threadId),
         starters: cloudThreadStarters(capability.threadId),
-        reportsFromOthers: store.messagesFor(capability.threadId).some(cloudOthersRoutineReport),
+        reportsFromOthers: store.messagesFor(capability.threadId).some(cloudReportFromOthers),
         ownerPerson: cloudProvenOwnerPerson,
         cardAnswerer: cloudCardAnswerer,
         routineRun: () => {
@@ -600,11 +607,13 @@ function cloudThreadStarters(threadId) {
 function cloudLendingView(capability) {
     return CLOUD_HOME !== null && cloudHomeLendingRefusal(cloudLendingTurn(capability)) === null;
 }
-/** On a Cloud home: a routine's report (its lifecycle card, carrying what
- * the run said) of a routine the owner did not write, as it stands now. It
- * brings someone else's instructions' results into the conversation it
- * reports to. */
-function cloudOthersRoutineReport(line) {
+/** On a Cloud home: a line that brings someone else's words into the
+ * conversation it lands in: a "post" webhook's payload, or a routine's
+ * report (its lifecycle card, carrying what the run said) of a routine the
+ * owner did not write, as it stands now. */
+function cloudReportFromOthers(line) {
+    if (line.webhookPost)
+        return true;
     if (line.kind !== "routine.run" || !line.routineRun)
         return false;
     const routine = routines?.listRoutines().find((candidate) => candidate.id === line.routineRun.routineId);
@@ -626,7 +635,7 @@ function cloudOwnerOnlyThread(threadId) {
     const lastKey = last ? `${last.id}:${last.card?.answeredBy ? JSON.stringify(last.card.answeredBy) : ""}` : undefined;
     if (cached && cached.length === thread.length && cached.last === lastKey)
         return cached.owner;
-    const owner = ownerOnlyConversation(thread, cloudProvenOwnerPerson, cloudCardAnswerer) && !thread.some(cloudOthersRoutineReport);
+    const owner = ownerOnlyConversation(thread, cloudProvenOwnerPerson, cloudCardAnswerer) && !thread.some(cloudReportFromOthers);
     if (ownerOnlyCache.size > 5_000)
         ownerOnlyCache.clear();
     ownerOnlyCache.set(threadId, { length: thread.length, last: lastKey, owner });
@@ -862,7 +871,7 @@ function guestWorkThread(from, target, fromThreadId, brief) {
  * to have written, or a conversation or room a revoked session opened. What
  * the owner is told about one, and when its engine cannot be confined. */
 const ROUTINE_FROM_BEFORE = "This routine was made before this update. Open it and save it once to run it with full access.";
-const CONVERSATION_FROM_BEFORE = "This conversation is from before your Cloud was only yours, so this bot works in it without a shell. Start a new conversation to use it fully.";
+const CONVERSATION_FROM_BEFORE = "This conversation is from before My Cloud was only yours, so this bot works in it without a shell. Start a new conversation to use it fully.";
 function confinedWhy(threadId) {
     const run = activeRoutineRunForThread(threadId);
     const writer = run ? cloudRoutineAuthors?.writer(run.routineId) : undefined;
@@ -871,7 +880,7 @@ function confinedWhy(threadId) {
 function guestEngineRefusal(threadId) {
     const why = confinedWhy(threadId);
     return why === ROUTINE_FROM_BEFORE ? `This bot's engine can't run it that way. ${why}`
-        : "This conversation is from before your Cloud was only yours, and this bot's engine can't work in it. Start a new conversation.";
+        : "This conversation is from before My Cloud was only yours, and this bot's engine can't work in it. Start a new conversation.";
 }
 /** On a Cloud home: a turn a guest drives, which runs in Ask whatever the
  * bot's own level (no Full access, no Auto reviewer, no saved commands), with
@@ -1247,11 +1256,11 @@ function memberFrameContext(visible) {
         webhookBot: (webhookId) => webhooks.list().find((webhook) => webhook.id === webhookId)?.botId,
         freshBot: (botId) => {
             const bot = store.bot(botId);
-            return bot ? { ...wireBot(bot), tasks: store.tasks(bot.id).map(wireTask), ...messagePage(bot.threadId, DEFAULT_PAGE) } : undefined;
+            return bot ? publicBot(bot) : undefined;
         },
         freshGroup: (groupId) => {
             const group = store.group(groupId);
-            return group ? { ...publicGroupState(group), ...messagePage(group.threadId, DEFAULT_PAGE) } : undefined;
+            return group ? groupWithThread(group) : undefined;
         },
     };
 }
@@ -1669,8 +1678,6 @@ function computerPlaceRefusal(kind) {
     const managed = managedPolicy.computerRefusal(kind);
     return managed ? { message: managed, code: "managed_policy" } : undefined;
 }
-/** Cloud chosen with no Boat account: a Cloud home suggests the browser, not a Local VM. */
-const BOAT_NOT_CONFIGURED = boatNotConfiguredMessage(Boolean(CLOUD_HOME));
 /** Why the organisation refuses this instance for bots, or undefined. */
 function policyModelRefusal(instance) {
     const engine = BUILT_IN_DRIVERS.find(driver => driver.driverKind === instance.driverKind)?.metadata.displayName;
@@ -1754,6 +1761,8 @@ utilityParentPort?.on("message", event => {
     });
 });
 const MAX_ATTACHED_FILES_PER_TURN = 10;
+const MAX_ROOM_POSTS_PER_TURN = 3;
+const MAX_CREATED_BOTS_PER_TURN = 4;
 // A capability lives for the exact provider-turn generation, including while
 // that turn is parked on a human approval. The long ceiling is only an orphan
 // backstop for an impossible-to-settle adapter; normal terminal paths revoke
@@ -1784,6 +1793,11 @@ function externalRuntimeMayCall(method, path) {
         return path === "/api/internal/agents" || /^\/api\/internal\/delegations\/[\w-]+$/.test(path);
     return method === "POST" && (path === "/api/internal/ask-bot" || path === "/api/internal/delegate-bot");
 }
+/** An external runtime polls check/wait_delegation for what it hands off, so
+ * the result must not also wake the bot's own engine on the pinned thread. */
+function externalCompletion(capability) {
+    return capability.generation === EXTERNAL_RUNTIME_GENERATION ? { completionOwner: "external" } : {};
+}
 function externalRuntimeCapability(header) {
     const grant = authorizeExternalRuntime(EXTERNAL_RUNTIMES_FILE, header, id => store.bot(id));
     if (!grant)
@@ -1810,15 +1824,52 @@ function beginInternalCapabilityGeneration(threadId, generation = randomUUID())
     activeInternalGenerationByThread.set(threadId, generation);
     return generation;
 }
-function mintInternalCapability(capability) {
+// The bearer an integration's proxy holds is part of the engine's launch
+// contract (Claude's process key, ACP's session inputs): a new one every turn
+// meant a relaunch, a resumed transcript and new MCP servers every turn. So
+// the bearer stays the same while the same bot works the same thread with the
+// same grants and approval level, and only the record behind it is per turn:
+// between turns, and after any revoke, nothing honours it. A changed grant,
+// Stop, a stall, a deleted bot or thread or a provider reload gives the next
+// turn a new bearer, so whatever still holds the old one is never honoured
+// again.
+/** threadId → "botId kind" → the bearer and the grants it was minted for. */
+const sessionCredentials = new Map();
+/** What a bearer stands for: everything its record grants (a turn's counters
+ * all start at zero), plus the thread's approval level; not the turn. */
+function sessionGrants({ generation: _turn, ...grants }) {
+    const thread = botForThread(grants.botId, grants.threadId);
+    return JSON.stringify({ ...grants, approval: thread ? approvalModeFor(thread) : null });
+}
+/** The thread's bearer for this integration, new only when its grants changed. */
+function sessionBearer(capability) {
+    const credentials = sessionCredentials.get(capability.threadId) ?? new Map();
+    sessionCredentials.set(capability.threadId, credentials);
+    const slot = `${capability.botId} ${capability.kind}`;
+    const grants = sessionGrants(capability);
+    const held = credentials.get(slot);
+    if (held?.grants === grants)
+        return held.token;
+    const token = randomBytes(24).toString("hex");
+    credentials.set(slot, { grants, token });
+    return token;
+}
+function mintInternalCapability(capability, { perTurn = false } = {}) {
     if (activeInternalGenerationByThread.get(capability.threadId) !== capability.generation) {
         throw new Error("cannot mint an integration capability for an inactive turn");
     }
-    const token = randomBytes(24).toString("hex");
-    internalCapabilities.set(token, {
-        ...capability,
-        orphanExpiresAt: Date.now() + INTERNAL_CAPABILITY_ORPHAN_MS,
-    });
+    // perTurn: a bridge into a machine the harness stops and starts between
+    // turns (a Local VM, the VPS, a Boat). A warm engine never restarts a
+    // server whose machine went away, so such a turn gets a new bearer and
+    // starts its engine fresh.
+    const token = perTurn ? randomBytes(24).toString("hex") : sessionBearer(capability);
+    // Minted twice in one turn: keep that turn's record and its counters.
+    if (internalCapabilities.get(token)?.generation !== capability.generation) {
+        internalCapabilities.set(token, {
+            ...capability,
+            orphanExpiresAt: Date.now() + INTERNAL_CAPABILITY_ORPHAN_MS,
+        });
+    }
     return token;
 }
 /** A turn that was not provably the owner's has ended: judge its bot's
@@ -1852,7 +1903,9 @@ function revokeInternalCapabilityGeneration(threadId, generation) {
     }
     internalGenerationByProviderTurn.deleteGeneration(threadId, generation);
 }
-function revokeInternalCapabilitiesForThread(threadId) {
+/** Before a new turn on this thread mints: nothing an earlier turn here was
+ * given stays honoured. The thread's bearers stay, so its engine stays warm. */
+function revokeEarlierTurnCapabilities(threadId) {
     computerSelectionTurns.delete(threadId);
     const generation = activeInternalGenerationByThread.get(threadId);
     if (generation)
@@ -1865,9 +1918,16 @@ function revokeInternalCapabilitiesForThread(threadId) {
             internalCapabilities.delete(token);
     }
 }
+/** Stop, a stall, a deleted bot or thread, a provider change: the thread's
+ * bearers are retired too, so nothing that still holds one is honoured again. */
+function revokeInternalCapabilitiesForThread(threadId) {
+    revokeEarlierTurnCapabilities(threadId);
+    sessionCredentials.delete(threadId);
+}
 function revokeAllInternalCapabilities() {
     computerSelectionTurns.clear();
     internalCapabilities.clear();
+    sessionCredentials.clear();
     // foreignTurns stays: a turn that is not provably the owner's can still
     // write while its engine is torn down, and its own end (which revokes its
     // generation by id) is what judges it (server/lending-memory.ts).
@@ -2031,6 +2091,64 @@ class ComputerWaitParked extends Error {
         this.generation = generation;
     }
 }
+/** 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;
+    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();
 // Only the latest direct request per thread is retained. A fresh user turn
@@ -2073,173 +2191,14 @@ const turnResources = new TurnResources();
 const sharedComputerControl = new SharedComputerControl(turnResources, () => store.bots.some(bot => botComputerControlSnapshot(bot.id).held));
 const turnResourceOwners = new Map();
 const turnComputerResources = new Map();
-/** Screen-touching computer calls that started before their turn's computer
- * claim was bound (#1653 over the lazy attach of #1361): the start event
- * finds no claim to fence, so it waits here and bindTurnComputer carries it
- * into the fresh claim, keeping the quiet window from releasing a seat
- * under a call the desktop is already executing. */
-const pendingComputerCallStarts = new Map();
 const teamComputerTurns = new Map();
 const settlingResourceOwners = new Map();
-/** Idle release for computer claims (#1653), disabled until the feature
- * flag is on: a seat that stays screen-quiet for the policy's window is
- * released to waiting turns while its holder's turn still lives, and the
- * previous holder re-claims directly inside the reclaim window — it
- * yields once another turn holds the seat. The durable VM profile keeps
- * its login state, so that re-claim is cheap. Read per claim: a flag
- * change applies to new claims, never to a seat held under the old
- * setting. computer:phone is excluded: it is the #1663 exclusivity lock,
- * claimed once per turn with no activity signal to renew it. */
-const COMPUTER_CLAIM_IDLE_POLICY = new IdleReleasePolicy();
-function computerClaimIdlePolicy(resource) {
-    return resource.startsWith("computer:") && resource !== "computer:phone" && computerClaimIdleReleaseEnabled(cfg) ? COMPUTER_CLAIM_IDLE_POLICY : undefined;
-}
-/** #1655: the consent ledger for local-wait cloud overflow, and the live
- * cloud seats it has started. One seat per bot — it is the bot's own Box,
- * shared by that bot's threads the way every other computer is. */
-const cloudOverflowConsent = new CloudOverflowConsent();
-const cloudSeatLeases = new Map();
-let cloudSeatSweepTimer;
-/** One stop attempt per seat at a time (#1655): the sweep ticks faster
- * than a Box sleeps, and a second stop call would race the first. */
-const cloudSeatStopsInFlight = new Set();
-/** The waits that may overflow: a turn queued for a local desktop, never
- * one already bound for a cloud or VPS seat. */
-function localComputerWait(resource) {
-    return resource === "computer:host" || resource.startsWith("computer:vm:");
-}
-function cloudOverflowSituation(owner, resource, started) {
-    if (!localComputerWait(resource))
-        return null;
-    if (!store.botByThread(owner.threadId))
-        return null;
-    const perSecondCostUsd = cloudOverflowPerSecondCostUsd(cfg);
-    return {
-        featureEnabled: cloudOverflowEnabled(cfg),
-        // An organisation that refuses the Box kind has nothing to offer, and
-        // the decision must fail closed before any card is written.
-        cloudConfigured: boat.boatConfigured(cfg) && managedPolicy.computerRefusal("box") === undefined,
-        perSecondCostUsd,
-        // Consent answers the priced card (#1655): a grant counts only at the
-        // rate its card showed, so a config change re-offers instead of
-        // starting at a price nobody approved.
-        consented: cloudOverflowConsent.consented(owner.threadId, cloudOverflowAllowlistedThreads(cfg), perSecondCostUsd ?? undefined),
-        offered: cloudOverflowConsent.offered(owner.threadId, perSecondCostUsd ?? undefined),
-        started,
-    };
-}
 function claimTurnResource(owner, resource) {
-    const idle = computerClaimIdlePolicy(resource);
-    if (!turnResources.claim(resource, owner, idle ? { idle } : {}))
+    if (!turnResources.claim(resource, owner))
         return false;
     turnResourceOwners.set(owner.threadId, owner);
     return true;
 }
-/** Start the waiting bot's cloud seat (#1655). True once handled — started
- * or terminally failed — so the wait never retries every poll; false when
- * another turn of this bot owns the Box lifecycle and a later poll may
- * still land. */
-async function startCloudSeat(owner) {
-    const bot = store.botByThread(owner.threadId);
-    if (!bot)
-        return true;
-    const perSecondCostUsd = cloudOverflowPerSecondCostUsd(cfg);
-    if (!perSecondCostUsd)
-        return true;
-    const boxBotResource = "computer:box-bot:" + bot.id;
-    if (!claimTurnResource(owner, boxBotResource))
-        return false;
-    try {
-        broadcast({ kind: "computer", botId: bot.id, state: "waking" });
-        const machine = await boat.readyBoat(cfg, bot.id);
-        if (!machine)
-            throw new Error("the cloud computer did not wake");
-        // Consent can be revoked while the Box wakes (#1655): a seat nobody
-        // consented to must not bill. It is released and put straight back to
-        // sleep — and if even that fails, leased as already idle so the sweep
-        // keeps retrying with backoff.
-        if (!cloudOverflowConsent.consented(owner.threadId, cloudOverflowAllowlistedThreads(cfg), perSecondCostUsd)) {
-            turnResources.releaseOne(boxBotResource, owner);
-            const idleStopMs = cloudOverflowIdleStopMs(cfg);
-            void boat.sleepBoat(cfg, bot.id).catch(() => {
-                cloudSeatLeases.set(bot.id, new CloudSeatLease({ botId: bot.id, threadId: owner.threadId, generation: owner.generation, now: Date.now() - idleStopMs - 1, idleStopMs }));
-                ensureCloudSeatSweep();
-            });
-            store.appendMessage(owner.threadId, {
-                role: "bot", kind: "activity",
-                tool: { name: "Cloud overflow consent was revoked while the cloud computer woke; it stops unbilled and the local wait continues.", ok: true },
-            });
-            return true;
-        }
-        cloudSeatLeases.set(bot.id, new CloudSeatLease({ botId: bot.id, threadId: owner.threadId, generation: owner.generation, idleStopMs: cloudOverflowIdleStopMs(cfg) }));
-        ensureCloudSeatSweep();
-        store.appendMessage(owner.threadId, {
-            role: "bot", kind: "activity",
-            tool: { name: cloudSeatStartedText({ perSecondCostUsd, idleStopMs: cloudOverflowIdleStopMs(cfg) }), ok: true },
-        });
-        return true;
-    }
-    catch (error) {
-        turnResources.releaseOne(boxBotResource, owner);
-        store.appendMessage(owner.threadId, {
-            role: "bot", kind: "activity",
-            tool: { name: "Cloud computer could not start (" + (error instanceof Error ? error.message : String(error)) + "); the local wait continues.", ok: false },
-        });
-        return true;
-    }
-}
-/** A per-second-billed seat must stop on idleness even when nothing else
- * touches the server, so this slice carries the one timer — unref'd, it
- * can never hold the process open, and it dies with the last lease. */
-function ensureCloudSeatSweep() {
-    if (cloudSeatSweepTimer)
-        return;
-    cloudSeatSweepTimer = setInterval(() => {
-        sweepIdleCloudSeats();
-        if (!cloudSeatLeases.size && cloudSeatSweepTimer) {
-            clearInterval(cloudSeatSweepTimer);
-            cloudSeatSweepTimer = undefined;
-        }
-    }, 15_000);
-    cloudSeatSweepTimer.unref?.();
-}
-/** Stop every cloud seat idle past its window (#1655): the machine is
- * archived, billing pauses, and the transcript says which wait's seat it
- * was. Only real computer tool completions refresh a lease — the poller's
- * preview frames never reach the touch call. */
-/** Stop one running cloud seat (#1655): the Box sleeps, and only a
- * successful stop clears the lease and its Box claim — a failed stop
- * stays leased and retryable with backoff, because the seat still bills
- * until it sleeps. The claim releases for the lease's own generation,
- * never a newer turn's. */
-function stopCloudSeat(botId, lease, stoppedName, now = Date.now()) {
-    if (cloudSeatStopsInFlight.has(botId))
-        return;
-    if (cloudSeatLeases.get(botId) !== lease)
-        return;
-    cloudSeatStopsInFlight.add(botId);
-    void boat.sleepBoat(cfg, botId)
-        .then(() => {
-        if (cloudSeatLeases.get(botId) === lease)
-            cloudSeatLeases.delete(botId);
-        // The stopped seat's Box claim goes with it, so a still-waiting
-        // turn may start a fresh seat for the same bot.
-        turnResources.releaseOne(`computer:box-bot:${botId}`, { threadId: lease.threadId, generation: lease.generation });
-        store.appendMessage(lease.threadId, { role: "bot", kind: "activity", tool: { name: stoppedName, ok: true } });
-    })
-        .catch(() => {
-        lease.deferSleep(now);
-        store.appendMessage(lease.threadId, { role: "bot", kind: "activity", tool: { name: "Cloud computer could not stop — the sweep retries with backoff; stop it from Settings if it stays awake. Billing continues until it sleeps.", ok: false } });
-    })
-        .finally(() => cloudSeatStopsInFlight.delete(botId));
-}
-function sweepIdleCloudSeats(now = Date.now()) {
-    for (const [botId, lease] of cloudSeatLeases) {
-        if (!lease.idleElapsed(now) || !lease.sleepDue(now))
-            continue;
-        stopCloudSeat(botId, lease, cloudSeatStoppedText(lease.idleFor(now)), now);
-    }
-}
 function releaseTurnResources(owner) {
     if (!owner)
         return;
@@ -2252,8 +2211,6 @@ function releaseTurnResources(owner) {
         turnResourceOwners.delete(owner.threadId);
     if (turnComputerResources.get(owner.threadId)?.owner.generation === owner.generation)
         turnComputerResources.delete(owner.threadId);
-    if (pendingComputerCallStarts.get(owner.threadId)?.generation === owner.generation)
-        pendingComputerCallStarts.delete(owner.threadId);
     const teamTurn = teamComputerTurns.get(owner.threadId);
     if (teamTurn?.owner.generation === owner.generation) {
         stopScreenPoller(teamTurn.botId, owner.threadId);
@@ -2283,10 +2240,6 @@ async function bindTurnComputer(owner, resource, exclusive = false) {
     // turn.wait_* events carry the same facts for the inspector log.
     let waitedSince;
     let waitEnded = false;
-    // #1655: whether this wait already started (or terminally failed to
-    // start) a cloud seat; the decision is re-evaluated every poll because
-    // consent can arrive mid-wait.
-    let overflowHandled = false;
     const waitEventBase = () => {
         const selection = store.botByThread(owner.threadId)?.modelSelection;
         const instance = selection ? registry.get(selection.instanceId) : null;
@@ -2360,32 +2313,7 @@ async function bindTurnComputer(owner, resource, exclusive = false) {
                     position,
                     ...(holder ? { holder } : {}),
                 });
-                // #1655: the wait is where an overflow choice gets made. The card
-                // names the per-second cost before anything can start, and only a
-                // turn genuinely waiting on a local desktop gets one. Fail closed:
-                // feature off, cloud unusable, or no operator-set rate means no
-                // card at all — Auto never offers, never starts.
-                const overflow = cloudOverflowSituation(owner, resource, overflowHandled);
-                const perSecondCostUsd = overflow?.perSecondCostUsd ?? null;
-                if (overflow && perSecondCostUsd !== null && cloudOverflowAction(overflow).kind === "offer") {
-                    store.appendMessage(owner.threadId, {
-                        role: "bot", kind: "activity",
-                        tool: { name: cloudOverflowOfferText({ perSecondCostUsd, idleStopMs: cloudOverflowIdleStopMs(cfg) }), ok: true },
-                    });
-                    cloudOverflowConsent.markOffered(owner.threadId, perSecondCostUsd);
-                }
             }
-            // #1655: consent can arrive mid-wait — the card's answer, or a
-            // thread the operator allowlisted — and only then may the cloud
-            // seat start, its cost chip landing beside the waiting one. The
-            // local wait itself is untouched: it still ends by acquisition,
-            // stop, or the ceiling (parking, once that stack lands).
-            if (!overflowHandled) {
-                const situation = cloudOverflowSituation(owner, resource, overflowHandled);
-                if (situation && cloudOverflowAction(situation).kind === "start")
-                    overflowHandled = await startCloudSeat(owner);
-            }
-            sweepIdleCloudSeats();
             if (Date.now() >= deadline) {
                 // ADR-2 (#1651): the ceiling parks the turn — settled, with a
                 // registered resume — instead of failing it. The owner mark lets the
@@ -2407,15 +2335,6 @@ async function bindTurnComputer(owner, resource, exclusive = false) {
     }
     turnResourceOwners.set(owner.threadId, owner);
     turnComputerResources.set(owner.threadId, { owner, resource });
-    // A screen call that started before this bind (#1653) fenced nothing
-    // because no claim existed yet: carry its pending start into the fresh
-    // claim so the idle window still defers to the running call.
-    const pendingStarts = pendingComputerCallStarts.get(owner.threadId);
-    if (pendingStarts?.generation === owner.generation && pendingStarts.count > 0) {
-        pendingComputerCallStarts.delete(owner.threadId);
-        for (let i = 0; i < pendingStarts.count; i += 1)
-            turnResources.beginComputerCall(resource, owner);
-    }
 }
 function botForThread(botId, threadId) {
     return directTurnBots.get(threadId) ?? store.projectBotForTask(botId, threadId) ?? store.bot(botId);
@@ -2461,15 +2380,9 @@ function canAdmitDirectTurn(botId, threadId) {
 /** Routine and webhook dispatch shares startTurn's admission preconditions
  * instead of waiting for whole-bot idleness: a free thread slot and no
  * active group turn. A group turn blocks scheduled starts the same way it
- * blocks every other turn kind; it does not consume a capacity slot.
- *
- * A fresh dispatch also pins to the bot's own project folder, exactly like
- * startTurn's cwd resolution: a free thread slot alone can miss a second
- * task of this bot landing in that one folder (#F-collide). Predicting that
- * collision here lets it defer through the same busy-target machinery as
- * capacity and group-turn contention, instead of reaching startTurn's own
- * workspace claim — which throws deep inside a detached dispatch that no
- * caller here awaits, so the run would otherwise fail permanently. */
+ * blocks every other turn kind; it does not consume a capacity slot. The
+ * bot's project folder is not a slot: a fresh run works there beside the
+ * bot's other threads (see startTurn's cwd resolution). */
 function unattendedDispatchState(botId) {
     const bot = store.bot(botId);
     const decision = admit("unattended", {}, {
@@ -2479,16 +2392,6 @@ function unattendedDispatchState(botId) {
     });
     if (decision.action === "refuse")
         return decision.code === "missing" ? "missing" : "busy";
-    if (bot?.cwd) {
-        try {
-            if (turnResources.blocker(workspaceResource(bot.cwd), { threadId: "", generation: "" }))
-                return "busy";
-        }
-        catch {
-            // An unresolvable folder is startTurn's own admission check to
-            // report; this prediction only ever adds a defer, never a refusal.
-        }
-    }
     return "ready";
 }
 function requestedTaskBot(botId, rawThreadId) {
@@ -2670,6 +2573,7 @@ const browserRuntime = new BrowserRuntime({
             browserLive.closeForSession(session);
         return closed;
     },
+    applyViewport: (spec) => setBrowserViewport(spec.command, spec.env),
 });
 const browserLive = new BrowserLive({ runtime: browserRuntime });
 // Temporary profiles last for this server run, but are never saved to disk.
@@ -2839,8 +2743,12 @@ const routineRequestEnvelopeSchema = z.discriminatedUnion("action", [
 ]);
 /** The loopback endpoint a bot's computer proxy polls before acting. With a
  * Boat id, the same turn-scoped token also serves that Boat's tools at
- * /api/internal/computer/mcp, and is revoked when the turn ends. */
-function controlIntegration(botId, threadId, generation, localVmTarget, boxId) {
+ * /api/internal/computer/mcp, and is revoked when the turn ends. This
+ * computer runs as long as the app does, so its bridge keeps the thread's
+ * bearer like every other integration; any other machine (a Local VM, the
+ * VPS, a Boat) gets a new bearer each turn. */
+function controlIntegration(botId, threadId, generation, machine = {}) {
+    const { localVmTarget, boxId } = machine === "this computer" ? {} : machine;
     return {
         url: `http://127.0.0.1:${PORT}/api/internal/computer-control?botId=${encodeURIComponent(botId)}`,
         token: mintInternalCapability({
@@ -2850,12 +2758,12 @@ function controlIntegration(botId, threadId, generation, localVmTarget, boxId) {
             depth: 0,
             kind: "computer",
             ...(localVmTarget ? { localVmTarget } : {}),
-            ...(boxId ? { boxId } : {}),
+            ...(boxId !== undefined ? { boxId } : {}),
             ...(teamComputerTurns.get(threadId) ? { teamComputerId: teamComputerTurns.get(threadId).computerId } : {}),
             skillAuthoring: false,
             createdBots: 0,
             openedThreads: 0,
-        }),
+        }, { perTurn: machine !== "this computer" }),
     };
 }
 function askBotAndWait(targetBotId, message, depth, fromBotId, fromThreadId, targetThreadId) {
@@ -2913,17 +2821,89 @@ function askBotAndWait(targetBotId, message, depth, fromBotId, fromThreadId, tar
         }).catch((err) => finish({ status: "error", text: `(couldn't start that bot: ${err instanceof Error ? err.message : String(err)})` }));
     });
 }
-// New bots honor setup's saved choice; unconfigured workspaces prefer Claude.
-// While enrolled, a Company model that can run beats a signed-out personal
-// engine, and the organisation's policy is respected; otherwise inert.
-async function defaultSelection() {
+// New bots honor setup's saved choice; without one, an engine that can run a
+// turn now (Claude first). While enrolled, a Company model that can run beats
+// a signed-out personal engine, and the organisation's policy is respected;
+// otherwise inert. `null` leaves the saved choice out (moveOffComputerEngine).
+async function defaultSelection(saved = cfg.defaultModelSelection ?? null) {
     if (hostedModels)
-        return hostedModels.select(cfg.defaultModelSelection);
-    return selectDefaultModelSelection(await registry.describe(), cfg.defaultModelSelection, {
+        return hostedModels.select(saved ?? undefined);
+    return selectDefaultModelSelection(await registry.describe(), saved ?? undefined, {
         company: (instanceId) => managedDesktop.owns(instanceId),
         refusal: (instance) => policyModelRefusal(instance),
     });
 }
+/** The Computer engine was removed: it ran a whole turn on Boat's own agent.
+ * Everything still set to it moves, once, to the engine a new bot gets
+ * (defaultSelection, the one picker), or the one a new bot would get without
+ * the saved choice when that cannot run: the saved default and new-bot
+ * defaults, each bot and conversation (Store.retireInstances keeps each one
+ * where it worked), and an automatic-recovery backup, which could never run
+ * and is cleared. Each moved conversation says so in one plain line. When no
+ * engine is available yet it runs again the next time the engines are read
+ * (describeInstances): an install, a sign-in, a key or a Company engine. At
+ * start it sees what a new bot made then would see; a policy that arrives
+ * later refuses an engine for a moved bot the way it does for any bot. A
+ * hosted workspace's reconcile has already moved every bot onto its own
+ * models. */
+async function moveOffComputerEngine() {
+    if (hostedModels)
+        return;
+    const removed = removedComputerInstanceIds(cfg.instances);
+    const named = (selection) => Boolean(selection && removed.has(selection.instanceId));
+    if (named(cfg.automaticRecovery?.backup)) {
+        saveConfig({ automaticRecovery: { enabled: false } });
+        cfg.automaticRecovery = { enabled: false };
+    }
+    const defaults = named(cfg.defaultModelSelection) || named(cfg.newBotDefaults?.profile.modelSelection);
+    if (!defaults && !store.bots.some(bot => named(bot.modelSelection) || bot.fallback?.some(named) ||
+        store.tasks(bot.id).some(task => named(task.modelSelection))))
+        return;
+    let replacement = named(cfg.defaultModelSelection) ? { instanceId: "", model: "" } : await defaultSelection();
+    if (!replacement.instanceId)
+        replacement = await defaultSelection(null);
+    if (!replacement.instanceId) {
+        console.warn("[engines] the Computer engine was removed and no other engine is available yet; its bots move when one is");
+        return;
+    }
+    if (defaults) {
+        // One write keeps both saved defaults on the replacement (saveConfig
+        // syncs them), and the copies in memory follow at once, so a bot made
+        // before the next start never lands on the removed engine.
+        const newBotDefaults = cfg.newBotDefaults && newBotDefaultsSchema.parse({
+            ...cfg.newBotDefaults, profile: { ...cfg.newBotDefaults.profile, modelSelection: replacement },
+        });
+        saveConfig(newBotDefaults ? { newBotDefaults } : { defaultModelSelection: replacement });
+        cfg.defaultModelSelection = replacement;
+        if (newBotDefaults)
+            cfg.newBotDefaults = newBotDefaults;
+    }
+    const instance = registry.get(replacement.instanceId);
+    const engine = instance?.displayName ?? instance?.driverKind ?? replacement.instanceId;
+    const moves = store.retireInstances(removed, replacement, {
+        driverKind: instance?.driverKind,
+        canWorkOnCloud: canWorkOnCloud(cloudEngine(instance)),
+        keepCloud: (bot) => boat.boatConfigured(cfg) && bot.cloudBackend !== "vps" && !inheritedTeamComputer(bot),
+    });
+    writeComputerEngineMoveLines(moves, (move) => {
+        const bot = store.bot(move.botId);
+        if (bot)
+            store.appendMessage(move.threadId, { role: "bot", kind: "activity", tool: { name: computerEngineMoveText(move, bot.name, engine), ok: true } });
+    });
+}
+let computerEngineMoveRunning = null;
+/** The move, once at a time; it returns at once when nothing names the
+ * removed engine any more. A failure is logged and never rejects, so it never
+ * stops this server from listening. Bots whose save failed are unchanged and
+ * move the next time the engines are read (describeInstances) or a turn
+ * reaches one of them (startTurn), so a server no app reads the engines from
+ * still moves them. */
+function retryComputerEngineMove() {
+    computerEngineMoveRunning ??= moveOffComputerEngine()
+        .catch((error) => console.warn(`[engines] moving bots off the removed Computer engine failed: ${error instanceof Error ? error.message : String(error)}`))
+        .finally(() => { computerEngineMoveRunning = null; });
+    return computerEngineMoveRunning;
+}
 function checkedModelSelection(raw, current, requireAvailableModel = false) {
     if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
         return { ok: false, status: 400, error: "modelSelection must be an object" };
@@ -3153,9 +3133,6 @@ function packageImportDeps(selection) {
                 return avatarUrl;
             },
         },
-        broadcast: (event) => event.kind === "bot"
-            ? broadcast({ kind: "bot", bot: publicBot(event.bot) })
-            : broadcast({ kind: "group", group: publicGroupState(event.group) }),
         defaultSelection: () => selection,
         presets: presetStore,
     };
@@ -3230,6 +3207,8 @@ const store = new Store(() => bootSelection, (selection) => withNewBotEffort(sel
 const teamComputers = new TeamComputers(join(DATA_DIR, "team-computers.json"), ENVIRONMENT_ID);
 let followupsReady = false;
 const sendSequencer = new SendSequencer();
+// Before the new-bot default is read: a saved default may name the engine.
+await retryComputerEngineMove();
 bootSelection = await defaultSelection();
 store.seedIfEmpty();
 hostedModels?.reconcile(store);
@@ -3294,7 +3273,7 @@ const wireTask = (task) => {
     return asleep ? { ...coordinated, snoozedUntil } : coordinated;
 };
 const wireBot = (bot) => {
-    const { resumeCursors: _resumeCursors, tasks, approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTighteningRequestId: _lastTighteningRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, packageBase: _packageBase, assignedSkills: _assignedSkills, ...rest } = bot;
+    const { resumeCursors: _resumeCursors, tasks, approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, packageBase: _packageBase, assignedSkills: _assignedSkills, ...rest } = bot;
     // An elevated selection is inert until the desktop confirms its exact
     // private reply. Every ordinary client sees the effective Ask state during
     // that two-phase window, never a grant that may still roll back.
@@ -3316,7 +3295,7 @@ function toolScopeForTurn(botId) {
 /** The correlated private response carries the requested value so Electron
  * can validate it before sending the confirmation that makes it effective. */
 const wireTrustedApprovalBot = (bot) => {
-    const { resumeCursors: _resumeCursors, tasks, approvalGrant: _approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTighteningRequestId: _lastTighteningRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, packageBase: _packageBase, assignedSkills: _assignedSkills, ...rest } = 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) } : {}) };
 };
 /** A settings-based preview, not a receipt of a dispatched turn. No
@@ -3339,7 +3318,6 @@ function previewSystemPrompt(bot) {
     const computerPromptKind = resolveComputerPromptKind({
         kind: previewComputer === "vm" ? "vm" : previewComputer === "cloud"
             ? bot.cloudBackend === "vps" ? "vps" : "box" : previewComputer === "local" ? "local" : null,
-        driverKind: instance?.driverKind,
         vmPrivate: localVmMode(cfg) === "per-bot",
     });
     const peers = reachablePeers(store.bots, bot);
@@ -3379,7 +3357,7 @@ function previewSystemPrompt(bot) {
                 computer: previewPlan.computer && previewPlan.computer !== "off" && computerPromptKind ? previewPlan.computer : null,
                 browser: previewPlan.computer === undefined ? false : previewPlan.browser,
             }, { note: previewPlan.note, cloudHome: Boolean(CLOUD_HOME) }) },
-        { id: "cloud-home", label: "OMB Cloud", text: CLOUD_HOME ? cloudHomePrompt(agentsMounted && lendingEnabled()) : "" },
+        { id: "cloud-home", label: "My Cloud", text: CLOUD_HOME ? cloudHomePrompt(agentsMounted && lendingEnabled()) : "" },
         { id: "composio", label: "Connected apps", text: caps?.composioMcp && bot.composio !== false && composio.configured(cfg) ? composioSystemPrompt(bot.connectorTools) + describeConnectorScopes(bot.connectorScopes) : "" },
         { id: "mcp", label: "MCP servers", text: caps?.customMcp ? customMcpPrompt(Object.keys(engineMcpServers(bot))) : "" },
         { id: "browser", label: "Browser", text: previewPlan.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
@@ -3389,6 +3367,7 @@ function previewSystemPrompt(bot) {
         { id: "profile", label: "Profile changes", text: agentsMounted ? PROFILE_PROMPT : "" },
         { id: "section-context", label: "Section context", text: sectionContextSystemPrompt(bot.section) },
         { id: "team-memory", label: "Team memory", text: teamMemory.systemPrompt(bot.section) + (agentsMounted ? TEAM_MEMORY_PROMPT : "") },
+        teamAvailabilityPart(agentsMounted && coordination ? peers : []),
         { id: "memory", label: "Memory", text: memorySystemPrompt(bot.id, { managedWrites: agentsMounted, fileTools: Boolean(privateWorkspace), enabled: bot.memoryEnabled !== false }) },
         { id: "skills", label: "Skills index", text: privateWorkspace ? skillsSystemPrompt(bot.id, skillsLibraryEnabled(cfg) ? bot.assignedSkills : undefined) : "" },
     ]);
@@ -3966,10 +3945,11 @@ function handleDesktopTrustedApprovalMessage(raw) {
  * fetched immediately and a deleted/guessed attachment id cannot become a
  * dangling profile reference. */
 const storedAvatarExists = (avatarUrl) => attachmentExists(avatarUrl.slice("/api/attachments/".length));
+/** A bot with its open thread's newest page, for HTTP replies and a
+ * member stream's first frame of it. */
 const publicBot = (bot) => ({
     ...wireBot(bot),
-    messages: store.messagesFor(bot.threadId),
-    activeLeafId: store.activeLeaf(bot.threadId),
+    ...messagePage(bot.threadId, DEFAULT_PAGE),
     tasks: store.tasks(bot.id).map(wireTask),
 });
 const publicBotQueuedMessages = () => queuedSteerSnapshot((botId, threadId) => Boolean(store.taskByThread(botId, threadId)));
@@ -4291,7 +4271,9 @@ function outstandingAssignmentsPrompt(threadId) {
         requestId: node.id,
         bot: store.bot(node.botId)?.name ?? "Teammate",
         assignment: node.text.slice(0, 1_000),
-        status: node.status === "queued" ? "waiting for that teammate to be free" : "working on it now",
+        status: node.status === "queued" ? "waiting for that teammate to be free"
+            : openPersonCard(node.threadId) ? "stopped on a card waiting for the person's approval or answer in that teammate's thread; tell the person to open it"
+                : "working on it now",
     }));
     return ` Assignments you already sent are still outstanding, and nothing in this conversation cancelled them: ${JSON.stringify(listed)}. Do not resend them, do not poll or wait for them, and do not tell the user they were lost. Each result returns to this conversation on its own and resumes you then. To change or add to one, send the change to the same teammate with coordinate_bots; it runs after the current work. Answer the message above with that work still in flight.`;
 }
@@ -4804,18 +4786,33 @@ function activeGroupTurnForBot(botId) {
     }
     return null;
 }
+/** A room with its open thread's newest page, for HTTP replies and a
+ * member stream's first frame of it. */
 const groupWithThread = (group) => ({
     ...publicGroupState(group),
-    messages: store.messagesFor(group.threadId),
-    activeLeafId: store.activeLeaf(group.threadId),
+    ...messagePage(group.threadId, DEFAULT_PAGE),
     ...(group.dm ? {} : { tasks: store.groupTasks(group.id) }),
 });
 // The store tells us what it wrote; this is the ONE place that turns those
 // into SSE frames. No mutation path can persist without emitting — the
 // property holds by construction, not by every call site remembering to
-// broadcast. Bot frames are the slim wire shape (no transcript); the few
-// endpoints whose callers need the transcript (task create/switch, imports)
-// still send their richer payload on top.
+// broadcast.
+//
+// A bot or room frame carries its open thread's newest page only when that
+// thread is not the one it last went out with: a switch, a new open thread,
+// deleting the open one, a new bot or room. Other windows swap transcripts
+// on exactly those frames (one whose open thread was deleted keeps its
+// composer locked until a page arrives). Every other frame stays slim, and
+// clients keep the transcript they hold when a frame carries none.
+const sentThreads = new Map();
+for (const record of [...store.bots, ...store.groups])
+    sentThreads.set(record.id, record.threadId);
+function pageIfThreadChanged(id, threadId) {
+    if (sentThreads.get(id) === threadId)
+        return {};
+    sentThreads.set(id, threadId);
+    return messagePage(threadId, DEFAULT_PAGE);
+}
 store.onChange((change) => {
     // Who owns which thread, and what each member may see, follow the fleet.
     if (change.type !== "message" && change.type !== "message.patch" && change.type !== "thread" && change.type !== "sections")
@@ -4824,11 +4821,12 @@ store.onChange((change) => {
         case "sections":
             broadcast({ kind: "sections", sections: store.sections });
             break;
+        // Live frames never carry screenshot pixels; clients load them by URL.
         case "message":
-            broadcast({ kind: "message", threadId: change.threadId, message: change.message });
+            broadcast({ kind: "message", threadId: change.threadId, message: slimMessage(change.message) });
             break;
         case "message.patch":
-            broadcast({ kind: "message.patch", threadId: change.threadId, message: change.message });
+            broadcast({ kind: "message.patch", threadId: change.threadId, message: slimMessage(change.message) });
             break;
         case "thread":
             broadcast({ kind: "thread", threadId: change.threadId, activeLeafId: change.activeLeafId });
@@ -4848,7 +4846,7 @@ store.onChange((change) => {
         case "bot": {
             const bot = store.bot(change.botId);
             if (bot)
-                broadcast({ kind: "bot", bot: wireBot(bot) });
+                broadcast({ kind: "bot", bot: { ...wireBot(bot), ...pageIfThreadChanged(bot.id, bot.threadId) } });
             // A new audience narrows the rooms this bot is in, for good.
             if (bot)
                 for (const group of store.groups.filter((candidate) => candidate.memberIds.includes(bot.id)))
@@ -4856,6 +4854,7 @@ store.onChange((change) => {
             break;
         }
         case "bot.deleted":
+            sentThreads.delete(change.botId);
             try {
                 commandAllowlist.clear(change.botId);
             }
@@ -4867,12 +4866,13 @@ store.onChange((change) => {
         case "group": {
             const group = store.group(change.groupId);
             if (group)
-                broadcast({ kind: "group", group: publicGroupState(group) });
+                broadcast({ kind: "group", group: { ...publicGroupState(group), ...pageIfThreadChanged(group.id, group.threadId) } });
             if (group)
                 settleRoomFloor(group);
             break;
         }
         case "group.deleted":
+            sentThreads.delete(change.groupId);
             broadcast({ kind: "group.deleted", groupId: change.groupId });
             break;
     }
@@ -4897,12 +4897,13 @@ function pageSize(raw) {
         return null;
     return Math.min(size, MESSAGE_PAGE_MAX);
 }
-/** A screen message without its pixels. The client fetches those from
- * `/api/threads/:threadId/messages/:id/image` when it actually shows one. */
+/** A screen message without its pixels, for live frames and pages alike.
+ * The client fetches those from `/api/threads/:threadId/messages/:id/image`
+ * when it actually shows one; `mime` stays so it can name a download. */
 function slimMessage(message) {
     if (message.kind !== "screen" || !message.png)
         return message;
-    const { png: _png, mime: _mime, ...rest } = message;
+    const { png: _png, ...rest } = message;
     return { ...rest, hasImage: true };
 }
 /** `limit === undefined` is the original, unpaginated shape. A bounded,
@@ -5309,7 +5310,7 @@ always, rememberCommand) {
 }
 /** A decision or answer on a provider/peer card, made on behalf of `auth`
  * (a Live call answers as the person who started the call). Harness-native
- * proposals (skill, routine, profile, default model, tightening, team setup)
+ * proposals (skill, routine, profile, default model, team setup)
  * are not handled here; they are reviewed on screen (liveDecisionRefusal).
  * Mirrors POST /api/threads/:id/respond. */
 async function respondToCard(input) {
@@ -5468,10 +5469,7 @@ const watchdog = new TurnWatchdog({
         repeats.settle(turn.threadId);
         const bot = botForThread(turn.botId, turn.threadId);
         const routineRun = activeRoutineRunForThread(turn.threadId);
-        const instance = bot
-            ? runningTurnInstance(bot, turn.threadId)
-            : runningTurnEngines.get(turn.threadId) ?? null;
-        void instance?.adapter.interruptTurn(turn.threadId).catch(() => { });
+        void runningTurnInstance(bot, turn.threadId)?.adapter.interruptTurn(turn.threadId).catch(() => { });
         const minutes = Math.round(TURN_STALL_MS / 60_000);
         if (routineRun?.target === "bot") {
             routines?.failThread(turn.threadId, `No activity for ${minutes} minutes — the routine was stopped`);
@@ -5481,7 +5479,7 @@ const watchdog = new TurnWatchdog({
         store.appendMessage(turn.threadId, {
             role: "bot",
             kind: "activity",
-            tool: { name: `error: no activity for ${minutes} minutes — the turn was stopped`, ok: false },
+            tool: failedTurnTool(`no activity for ${minutes} minutes — the turn was stopped`),
         });
         // a routine's stall reports through its own failure path
         if (bot && routineRun?.target !== "bot") {
@@ -5578,6 +5576,10 @@ bus.subscribe((event) => {
     else if (event.type !== "session.exited")
         watchdog.touch(event.threadId);
 });
+// Automatic continuity: a turn that died on its budget or on tool errors gets
+// a `Continue:` task on the same bot, seeded with the persisted handoff — the
+// work moves forward without a person noticing and re-dispatching.
+bus.subscribe(makeCapContinuationSubscriber({ store, startTurn }));
 // Memory journal turn boundary (server/memory-journal.ts). A bot's own
 // file-tool writes to MEMORY.md and memory/ have no hook to tap, so the
 // diff against the baseline taken at dispatch is made when the turn
@@ -5761,6 +5763,8 @@ bus.subscribe((event) => {
 });
 // Per-thread state the digest needs from before the turn: when it started,
 // and the checkpoint taken at dispatch (hash + folder) so settle can diff.
+// `pin` is the dispatch that pinned that commit in the shadow repo, so a
+// sibling thread's snapshot in the same folder cannot reclaim it mid-turn.
 const turnStartedAt = new Map();
 const turnCheckpoints = new Map();
 // The turn a thread is in, from the last event that named one. Not every
@@ -5768,9 +5772,18 @@ const turnCheckpoints = new Map();
 // a digest can only count activity it can attribute — so an unstamped tool
 // row is attributed to the thread's live turn instead of to nothing.
 const liveTurnByThread = new Map();
+/** Forget a thread's pre-turn checkpoint and drop its pin, so the shadow
+ * repo's next cleanup may reclaim that commit. */
+function forgetTurnCheckpoint(threadId) {
+    const checkpoint = turnCheckpoints.get(threadId);
+    if (!checkpoint)
+        return;
+    turnCheckpoints.delete(threadId);
+    void checkpoints.release(checkpoint.botId, checkpoint.cwd, checkpoint.pin);
+}
 function clearTurnDigestState(threadId) {
     turnStartedAt.delete(threadId);
-    turnCheckpoints.delete(threadId);
+    forgetTurnCheckpoint(threadId);
     liveTurnByThread.delete(threadId);
     memoryRowsByThread.delete(threadId);
 }
@@ -5839,9 +5852,8 @@ function ingestEngineHook(capability, body) {
     }
     return { ok: true };
 }
-/** Persist observed tools and memory immediately. Keep a direct turn's
- * workspace claimed while its bounded file snapshot settles, then enrich
- * that same row only if its task and active branch still exist. */
+/** Persist observed tools and memory immediately, then enrich that same
+ * row only if its task and active branch still exist. */
 async function scheduleTurnDigest(input) {
     const at = Date.now();
     const startedAt = turnStartedAt.get(input.threadId);
@@ -5886,6 +5898,8 @@ async function scheduleTurnDigest(input) {
         }
         if (!checkpoint)
             return;
+        // A folder-level diff: when a sibling thread of this bot works in the
+        // same folder, its edits since this turn's snapshot are listed here too.
         const controller = new AbortController();
         let timer;
         const capture = async () => {
@@ -5909,6 +5923,12 @@ async function scheduleTurnDigest(input) {
     catch (error) {
         console.error(`digest: could not record turn ${input.turnId} on ${input.threadId}:`, error instanceof Error ? error.message : error);
     }
+    finally {
+        // The pre-turn commit has had its last reader (the diff above is queued
+        // ahead of this in the shadow repo); the next snapshot may reclaim it.
+        if (checkpoint)
+            void checkpoints.release(checkpoint.botId, checkpoint.cwd, checkpoint.pin);
+    }
 }
 // Bots currently working with nobody at the keyboard — a webhook turn, or a
 // turn a webhook-driven bot handed to a teammate. Auto mode is a decision
@@ -6044,9 +6064,6 @@ const vpsJoinRequests = new Map();
 const orphanBoatLifecycleBusyIds = new Set();
 const boatInventoryRequestsBusyIds = new Set();
 const computerProviderConfigTransitions = new Set();
-// A restore mutates and cleans a project work tree. Claim the bot across the
-// entire async Git operation so a turn cannot start in that folder midway.
-const checkpointRestoreLeases = new Set();
 /** The effective idle window, read from config so a Settings change applies
  * to both new and already-armed timers (see the config route). */
 const localVmIdleMs = () => localVmIdleTimeoutMinutes(cfg) * 60_000;
@@ -6059,7 +6076,7 @@ function inheritedTeamComputer(bot) {
     return teamComputers.forBot(bot);
 }
 function teamComputerPrompt(computer) {
-    return computer ? `Your team shares the Boat computer ${JSON.stringify(computer.name)}. Its desktop files and desktop browser logins are shared with other Auto bots in your team; only one turn may drive it at a time. The separate built-in Browser is not this desktop and does not automatically share its logins.` : "";
+    return computer ? `Your team shares the cloud computer ${JSON.stringify(computer.name)}. Its desktop files and desktop browser logins are shared with other Auto bots in your team; only one turn may drive it at a time. The separate built-in Browser is not this desktop and does not automatically share its logins.` : "";
 }
 function botComputerControlKey(bot) {
     const computer = inheritedTeamComputer(bot);
@@ -6070,21 +6087,26 @@ async function computerCallGate(internalCapability) {
     const snapshot = botComputerControlSnapshot(botId, internalCapability.teamComputerId);
     const slot = autoVmClaims.get(internalCapability.threadId);
     const lazyClaim = slot && slot.owner.generation === internalCapability.generation ? slot : undefined;
-    if (!snapshot.held && lazyClaim?.lazy && !lazyClaim.begin) {
-        // First screen tools/call on a lazily-attached Auto VM (issue
+    const waitMs = snapshot.held ? null : lazyClaimWaitMs(lazyClaim, LAZY_VM_CLAIM_GRACE_MS);
+    if (lazyClaim && waitMs !== null) {
+        // First screen tools/call on a lazily-attached computer (issue
         // #1361): fire the exclusive claim — once — and give it a moment
         // to land. A free, ready VM claims in the time of one container
         // inspect, so this call then proceeds with an honest answer;
         // only a claim still queued behind another holder answers held
-        // below, and then the contention text is true. Keyed on the
-        // slot, never on the thread's turn-computer entry: a bind this
+        // below, and then the contention text is true. A cloud computer's
+        // claim creates or wakes it, so every call waits on that start
+        // (graceMs) instead of being told someone else holds it. Keyed on
+        // the slot, never on the thread's turn-computer entry: a bind this
         // turn abandoned earlier (a VPS that turned out to be asleep)
         // must not hide the unclaimed VM and let the call through.
         startAutoVmClaim(autoVmClaims, internalCapability.threadId, internalCapability.generation);
+        let timer;
         await Promise.race([
             lazyClaim.begin ?? Promise.resolve(),
-            new Promise((resolve) => setTimeout(resolve, LAZY_VM_CLAIM_GRACE_MS)),
+            new Promise((resolve) => { timer = setTimeout(resolve, waitMs); }),
         ]);
+        clearTimeout(timer);
     }
     if (!snapshot.held && lazyClaim?.failed === true) {
         // A rejected lazy claim (gate finding F1, issue #1361): the
@@ -6104,17 +6126,14 @@ 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);
-    // The screen call arriving here re-claims an idle-released seat directly
-    // (#1653): inside the reclaim window the previous holder picks its seat
-    // back up without re-entering the wait, and the successful claim
-    // restarts the quiet window. A seat another turn holds still refuses.
     if (!snapshot.held && computer && computer.owner.generation === internalCapability.generation &&
         !claimTurnResource(computer.owner, computer.resource)) {
         return {
@@ -6137,11 +6156,6 @@ function teamComputerInUse(computer) {
         [...teamComputerTurns.values()].some(turn => turn.computerId === computer.id) ||
         store.bots.some(bot => computer.section !== null && sectionKey(bot.section) === computer.section && (botHasActiveTurn(bot.id) || Boolean(routines?.activeRunForBot(bot.id)) || computerControl.snapshot(bot.id).held));
 }
-function assertTeamControlCanBeTaken(computerId) {
-    if ([...teamComputerTurns.values()].some(turn => turn.computerId === computerId && turn.remoteAgent)) {
-        throw Object.assign(new Error("Stop the Computer engine's active turn before taking control of this shared desktop"), { status: 409 });
-    }
-}
 function claimTeamComputerLifecycle(computer) {
     if (computerProviderConfigTransitions.has("box"))
         throw Object.assign(new Error(providerTransitionMessage("box")), { status: 409 });
@@ -6178,9 +6192,9 @@ async function teamComputersPayload() {
 }
 /** The same named Boat identity and whole-turn lease in chats and rooms.
  * Assignment authorizes waking, never replacing a missing paid machine. */
-async function attachTeamBoat(computer, botId, owner, canMount, remoteAgent) {
+async function attachTeamBoat(computer, botId, owner, canMount) {
     if (!canMount)
-        throw new Error("This model cannot use the team's Boat computer; choose a model provider with computer tools or an explicit bot destination");
+        throw new Error("This model cannot use the team's cloud computer; choose a model provider with computer tools or an explicit bot destination");
     if (!boat.boatConfigured(cfg))
         throw new Error("The team's Boat account is not configured; reconnect it in Settings");
     const ownerId = teamComputerOwner(computer.id);
@@ -6189,42 +6203,51 @@ async function attachTeamBoat(computer, botId, owner, canMount, remoteAgent) {
     if (computerControl.snapshot(ownerId).held)
         throw new Error("Release human control of the team computer before starting another turn");
     await bindTurnComputer(owner, `computer:box-bot:${ownerId}`, true);
-    teamComputerTurns.set(owner.threadId, { owner, computerId: computer.id, botId, remoteAgent });
+    teamComputerTurns.set(owner.threadId, { owner, computerId: computer.id, botId });
     let machine = await boat.findBoat(cfg, ownerId);
     if (!machine)
-        throw new Error("The team's Boat computer is missing; explicitly create or retry it from the Team map");
+        throw new Error("The team's cloud computer is missing; explicitly create or retry it from the Team map");
     await bindTurnComputer(owner, `computer:box:${machine.id}`, true);
-    const action = boat.boatTurnLifecycleAction({ explicitCloud: true, canMount: 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, canMount: 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),
     };
 }
-/** 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 } };
-    const control = controlIntegration(botId, owner.threadId, owner.generation, undefined, 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 {
-        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",
-        },
+        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 {
+        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
@@ -6245,14 +6268,18 @@ async function mountHostComputer(owner, botId, providerSupportsLocal) {
             : "CUA Driver is not ready for this computer — check permissions and restart OpenMausBot");
     }
     await bindTurnComputer(owner, "computer:host");
-    return gatedLocalComputer(cua, controlIntegration(botId, owner.threadId, owner.generation));
+    return gatedLocalComputer(cua, controlIntegration(botId, owner.threadId, owner.generation, "this computer"));
 }
 /** The bot's own VPS desktop, mounted into the local agent. The desktop lease
  * 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
@@ -6283,53 +6310,113 @@ async function mountBotVps(bot, owner, opts) {
         },
     };
 }
-/** The bot's own Boat. Explicit Cloud is the consent boundary: it may create a
- * missing machine and wake an archived one (~8s, and it un-pauses billing);
- * Auto only attaches a machine that is already running. */
-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,
-        canMount: opts.canMount,
-        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: opts.canMount ? cloudComputerMount(bot.id, owner, machine.id, opts.remoteAgent) : null,
-    };
+    return b && lifecycle === "attach" ? b : null;
 }
 function managedBoatOwners() {
     return [...store.bots.map((bot) => ({
@@ -6401,8 +6488,6 @@ function turnProvider(bot, runOn, threadId) {
     const wants = turnSurfacePlan(bot, runOn, threadId).computer;
     if (wants !== undefined && wants !== "cloud")
         return null;
-    if (registry.get(bot.modelSelection.instanceId)?.adapter.capabilities.remoteAgent === true)
-        return "box";
     return bot.cloudBackend === "vps" ? "vps" : wants === "cloud" ? "box" : null;
 }
 /** Preview requests carry the selected conversation, not whichever thread
@@ -6421,8 +6506,6 @@ async function computerPreviewSurface(bot, threadId) {
     if (plan.computer !== undefined)
         return plan.computer === "off" && plan.browser ? "browser" : plan.computer;
     const instance = registry.get(bot.modelSelection.instanceId);
-    if (instance?.adapter.capabilities.remoteAgent === true)
-        return "cloud";
     if (bot.cloudBackend === "vps") {
         const remote = await vps.vpsComputerStatus(cfg, bot.id);
         if (remote.ready)
@@ -6447,9 +6530,11 @@ async function computerPreviewSurface(bot, threadId) {
  * A Cloud home lists only the places it has (cloud-home.ts), so a bot never
  * tells the person to set up this computer or a Local VM there. */
 async function selectableComputers(bot) {
-    const caps = registry.get(bot.modelSelection.instanceId)?.adapter.capabilities;
+    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;
@@ -6463,24 +6548,31 @@ async function selectableComputers(bot) {
         try {
             if (off)
                 reason = "Computer access is Off in this bot's settings.";
+            else if (toolsLeaveOut && surface !== "browser")
+                reason = toolsLeaveOut;
             else if (surface === "cloud") {
                 if (bot.cloudBackend === "vps") {
-                    const status = localEngine && caps?.computerMcp ? 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) && caps !== undefined && usesCloudComputer(caps)) {
+                else if (boat.boatConfigured(cfg) && canWorkOnCloud(cloudEngine(instance))) {
                     const status = await boat.boatStatus(cfg, bot.id);
-                    const lifecycle = boat.boatTurnLifecycleAction({ explicitCloud: true, canMount: 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;
@@ -6553,7 +6645,7 @@ function continueComputerSelection(threadId, generation, succeeded) {
 const runningTurnEngines = new Map();
 function runningTurnInstance(bot, threadId) {
     // A turn always runs on the bot's own engine, wherever it works.
-    return runningTurnEngines.get(threadId) ?? registry.get(bot.modelSelection.instanceId);
+    return runningTurnEngines.get(threadId) ?? (bot ? registry.get(bot.modelSelection.instanceId) : null);
 }
 function providerTransitionForTurn(bot, runOn, threadId) {
     const provider = turnProvider(bot, runOn, threadId);
@@ -6934,38 +7026,6 @@ bus.subscribe((event) => {
                     if (touches || /computer|screenshot|click|type_text|press_key|scroll|open_url|wait_for|browser_/i.test(toolName)) {
                         pokeScreenPoller(event.threadId, touches, surface);
                     }
-                    // A completed screen-touching computer tool is real screen
-                    // activity (#1653): it restarts the idle clock on that turn's
-                    // computer claim. The poller's own frames never arrive here, so
-                    // they cannot keep a quiet seat held.
-                    if (touches && surface === "computer") {
-                        const computer = turnComputerResources.get(event.threadId);
-                        if (computer) {
-                            // A quiet window cannot expire while this call executes.
-                            turnResources.endComputerCall(computer.resource, computer.owner);
-                            turnResources.activity(computer.resource, computer.owner);
-                        }
-                        else {
-                            // The call never forwarded onto a bound desktop, or the lazy
-                            // bind never landed: drop its pending start so it cannot
-                            // fence a claim taken later (#1653).
-                            const pending = pendingComputerCallStarts.get(event.threadId);
-                            if (pending) {
-                                if (pending.count > 1)
-                                    pendingComputerCallStarts.set(event.threadId, { ...pending, count: pending.count - 1 });
-                                else
-                                    pendingComputerCallStarts.delete(event.threadId);
-                            }
-                        }
-                        // Real cloud-screen work refreshes the #1655 idle stop for
-                        // that seat; the poller's own frames never arrive here, so
-                        // preview traffic cannot keep a paid machine awake.
-                        if (computer?.resource.startsWith("computer:box:")) {
-                            const seatBot = store.botByThread(event.threadId);
-                            if (seatBot)
-                                cloudSeatLeases.get(seatBot.id)?.touch();
-                        }
-                    }
                 }
             }
             break;
@@ -6988,26 +7048,6 @@ bus.subscribe((event) => {
                 });
                 if (event.itemId)
                     toolMessageByItem.set(`${event.threadId}:${event.itemId}`, message.id);
-                // A screen-touching computer tool opening is an in-flight call on
-                // that turn's claim (#1653): the seat cannot be idle-released out
-                // from under I/O the desktop is still executing. Its completion —
-                // or the turn settling — drops the fence.
-                if (screenTouchingTool(name) && screenSurfaceForTool(name) === "computer") {
-                    const computer = turnComputerResources.get(event.threadId);
-                    if (computer) {
-                        turnResources.beginComputerCall(computer.resource, computer.owner);
-                    }
-                    else {
-                        // A lazy attach (#1361) may not have seated the claim yet: the
-                        // gate finishes the bind before the call forwards, so hold the
-                        // start here and let bindTurnComputer fence the fresh claim.
-                        const generation = activeInternalGenerationByThread.get(event.threadId);
-                        if (generation) {
-                            const pending = pendingComputerCallStarts.get(event.threadId);
-                            pendingComputerCallStarts.set(event.threadId, pending?.generation === generation ? { generation, count: pending.count + 1 } : { generation, count: 1 });
-                        }
-                    }
-                }
             }
             break;
         case "request.opened": {
@@ -7019,8 +7059,9 @@ bus.subscribe((event) => {
             // A permission request here is one the provider left for a person: its
             // own mode already ran (Ask, Edits, Auto's reviewer, Custom's config).
             // Only the person's explicit Full access or exact saved command answers.
-            // The app does not guess whether the action is safe. A QUESTION
-            // always reaches the human — even Full access never invents an answer.
+            // Approve for me allows a web search. The app does not guess whether
+            // the action is safe. A QUESTION always reaches the human — even Full
+            // access never invents an answer.
             const asker = bot ?? (speaker ? store.bot(speaker.botId) : undefined);
             const unattended = permission && asker && event.requestId ? isUnattended(asker.id, event.threadId) : false;
             // A turn a guest drives on a Cloud home is Ask, room turns included,
@@ -7082,9 +7123,9 @@ bus.subscribe((event) => {
                         if (outcome !== "unavailable")
                             pushMessage({
                                 role: "bot", kind: "activity",
-                                tool: { name: outcome === "rejected"
-                                        ? `The provider rejected this action despite ${verdict.source === "command-allowlist" ? "the saved command permission" : "Full access"}.`
-                                        : "error: could not deliver approval to the provider; retry the task after reconnecting.", ok: false },
+                                tool: outcome === "rejected"
+                                    ? { name: `The provider rejected this action despite ${verdict.source === "command-allowlist" ? "the saved command permission" : "Full access"}.`, ok: false }
+                                    : failedTurnTool("could not deliver approval to the provider; retry the task after reconnecting."),
                             });
                         return;
                     }
@@ -7176,6 +7217,8 @@ bus.subscribe((event) => {
                         store.setTaskActivity(bot.id, event.threadId, "waiting-on-you");
                     else if (asker.busy)
                         store.setActivity(asker.id, "waiting-on-you");
+                    if (event.requestId)
+                        showWaitingOnPersonChip(event.threadId, event.requestId, asker, permission ? "approval" : "answer");
                     const notificationBot = (routineRun && routineSourceOwner(routineRun)?.bot) || asker;
                     notify(buildNotification(permission ? "approval" : "question", notificationBot, (routineRun && routineSourceThread(routineRun)) || event.threadId, event.summary));
                 }
@@ -7185,6 +7228,8 @@ bus.subscribe((event) => {
         case "request.resolved": {
             if (event.requestId)
                 pendingCommandRules.delete(`${event.threadId}:${event.requestId}`);
+            if (event.requestId)
+                settleWaitingOnPersonChips(event.threadId, event.requestId);
             // answered (by whoever): the turn is working again, unless it settled
             const waiting = bot ?? (speaker ? store.bot(speaker.botId) : undefined);
             if (bot && store.taskByThread(bot.id, event.threadId)?.activity === "waiting-on-you") {
@@ -7230,14 +7275,7 @@ bus.subscribe((event) => {
             pushMessage({
                 role: "bot",
                 kind: "activity",
-                tool: {
-                    // a setup error carries its fix, which must not be cut mid-command
-                    name: `error: ${event.message.slice(0, event.setup ? 320 : 160)}`,
-                    ok: false,
-                    setup: event.setup,
-                    ...(event.terminal ? { terminal: true } : {}),
-                    ...(event.claudeUpdate ? { claudeUpdate: true } : {}),
-                },
+                tool: failedTurnTool(event.message, event),
             });
             // a setup error means the engine could not even start: the bot is
             // dead until something changes, not merely idle. The next successful
@@ -7255,6 +7293,7 @@ bus.subscribe((event) => {
             }
             break;
         case "turn.completed": {
+            settleWaitingOnPersonChips(event.threadId);
             // A peer-started turn settles as coordination, not as news. What keeps
             // that classification from outliving its turn is the rewrite at
             // dispatch, not this line — releasing it here too is hygiene, so a
@@ -7472,8 +7511,8 @@ bus.subscribe((event) => {
                     // still be in flight).
                     //
                     // Keep the thread busy until its bounded final capture releases
-                    // the screen AND workspace. Otherwise an accepted follow-up races
-                    // these claims and fails as though another thread owned its folder.
+                    // the screen: an accepted follow-up must not take the desktop
+                    // before the END-state frame is captured.
                     const settleLeafId = store.activePath(event.threadId).at(-1)?.id;
                     let timeout;
                     const screenSettled = Promise.race([
@@ -7565,6 +7604,57 @@ bus.subscribe((event) => {
  * channel that only ever shows requests is half a record. Mirror the
  * reply on success; mirror a failed/stopped terminal chip otherwise. */
 const delegationWatch = new Map();
+/** The card in this thread that is waiting on the person: an approval, a
+ * question or a proposal to review, newest first. */
+function openPersonCard(threadId) {
+    const messages = store.messagesFor(threadId);
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const card = messages[i].kind === "options" ? messages[i].card : undefined;
+        const kind = liveCardKind(card);
+        if (kind)
+            return { kind, tool: card?.tool };
+    }
+    return undefined;
+}
+/** The conversation waiting on work that runs in this thread: a Chief's
+ * delegate_bot task or coordinate_bots assignment. */
+function delegatorOf(threadId) {
+    const watch = delegationWatch.get(threadId);
+    if (watch?.sourceThreadId)
+        return { threadId: watch.sourceThreadId, botId: watch.sourceBotId };
+    const parent = roomHandoffs.assignerOf(threadId);
+    return parent ? { threadId: parent.threadId, botId: parent.botId } : undefined;
+}
+// MOCA-274: a delegated teammate's card used to live only in its own thread,
+// so the person talking to the Chief never saw that work was waiting on them.
+// A chip in the delegating conversation points at the card until it settles.
+const waitingOnPersonChips = new Map();
+function showWaitingOnPersonChip(threadId, requestId, asker, kind) {
+    const delegator = delegatorOf(threadId);
+    if (!delegator || delegator.threadId === threadId)
+        return;
+    const chip = store.appendMessage(delegator.threadId, { role: "bot", kind: "activity",
+        from: { botId: asker.id, name: asker.name, color: asker.color },
+        tool: { name: `Waiting on your ${kind} in @${asker.name}` },
+        threadRef: { botId: asker.id, threadId, title: store.taskByThread(asker.id, threadId)?.title ?? asker.name },
+    });
+    waitingOnPersonChips.set(`${threadId}:${requestId}`, { threadId: delegator.threadId, messageId: chip.id, name: asker.name, kind });
+}
+/** Settle the chip for one answered card, or every chip for this thread once
+ * its turn ends (a card nobody answered can no longer be answered). */
+function settleWaitingOnPersonChips(threadId, requestId) {
+    for (const [key, chip] of waitingOnPersonChips) {
+        if (requestId ? key !== `${threadId}:${requestId}` : !key.startsWith(`${threadId}:`))
+            continue;
+        waitingOnPersonChips.delete(key);
+        const existing = store.messagesFor(chip.threadId).find((message) => message.id === chip.messageId);
+        if (!existing?.tool)
+            continue;
+        store.patchMessage(chip.threadId, chip.messageId, {
+            tool: { ...existing.tool, name: requestId ? `@${chip.name} got your ${chip.kind}` : `@${chip.name} is no longer waiting on your ${chip.kind}`, ok: true },
+        });
+    }
+}
 // Peer wake: when a delegated reply lands, resume the source bot so it can
 // fold the result in and answer the user instead of sitting idle. Mirrors
 // the cardContinuation resume pattern used for connector/credential cards.
@@ -7608,10 +7698,7 @@ function dispatchDelegationWake(botId, threadId, targetName, failureReason, rout
         store.appendMessage(threadId, {
             role: "bot",
             kind: "activity",
-            tool: {
-                name: `error: could not resume after delegation — ${message.slice(0, 120)}`,
-                ok: false,
-            },
+            tool: failedTurnTool(`could not resume after delegation — ${message}`),
         });
         routines?.failThread(threadId, `Could not resume after delegation: ${message}`);
     });
@@ -7713,7 +7800,7 @@ function reportIncident(input) {
         store.appendMessage(incidents.threadId, {
             role: "bot",
             kind: "activity",
-            tool: { name: `error: the incident could not reach ${chief.name} — ${why.slice(0, 120)}`, ok: false },
+            tool: failedTurnTool(`the incident could not reach ${chief.name} — ${why}`),
         });
         tellThePerson();
     });
@@ -7998,12 +8085,15 @@ function finalizeDelegationWatch(threadId, ok, reply = "", failureName = "Delega
             // with the reply only visible in the thread (the "delegated and went
             // silent" gap). Failures wake it too — the user must hear the task did
             // not finish. Idle-checked and burst-capped so a busy source or a
-            // re-delegating loop cannot spin up runs.
-            if (ok) {
-                wakeDelegationSource(source, watched.sourceThreadId, targetName, undefined, watched.routineRunId);
-            }
-            else if (!ok) {
-                wakeDelegationSource(source, watched.sourceThreadId, targetName, failureName || "the delegated turn did not finish", watched.routineRunId);
+            // re-delegating loop cannot spin up runs. An external runtime polls
+            // for the receipt instead; waking would answer it a second time.
+            if (watched.completionOwner !== "external") {
+                if (ok) {
+                    wakeDelegationSource(source, watched.sourceThreadId, targetName, undefined, watched.routineRunId);
+                }
+                else {
+                    wakeDelegationSource(source, watched.sourceThreadId, targetName, failureName || "the delegated turn did not finish", watched.routineRunId);
+                }
             }
         }
     }
@@ -8058,7 +8148,7 @@ bus.subscribe((event) => {
 /** How a drained delegation becomes a real turn on the target. Shared by
  * the settle-time drain and the boot-time drain of what a previous process
  * left queued. */
-const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel, taskId, sourceBotId, openedThreadId, oneWay) => {
+const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel, taskId, sourceBotId, openedThreadId, oneWay, completionOwner) => {
     // startTurn REJECTS on an ordinary condition — busy target, deleted bot,
     // unavailable provider. Unhandled, that rejection is fatal to the
     // harness (Node's default), which in the packaged app kills the server
@@ -8092,6 +8182,7 @@ const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel,
             routineRunId: activeRoutineRunForThread(sourceThreadId)?.id,
             startedAtMs: Date.now(),
             ...(oneWay ? { oneWay: true } : {}),
+            ...(completionOwner ? { completionOwner } : {}),
         });
     }
     let failureReported = false;
@@ -8112,7 +8203,7 @@ const runDelegatedTurn = (toBotId, rawText, commsDepth, sourceThreadId, channel,
         store.appendMessage(sourceThreadId, {
             role: "bot",
             kind: "activity",
-            tool: { name: `error: delegation to @${bot?.name ?? toBotId} could not start — ${why.slice(0, 120)}`, ok: false },
+            tool: failedTurnTool(`delegation to @${bot?.name ?? toBotId} could not start — ${why}`),
         });
     };
     return startTurn(toBotId, text, {
@@ -8224,10 +8315,7 @@ function drainQueuedSends() {
         }).catch((err) => {
             store.appendMessage(threadId, {
                 role: "bot", kind: "activity",
-                tool: {
-                    name: `error: queued message could not start — ${(err instanceof Error ? err.message : String(err)).slice(0, 120)}`,
-                    ok: false,
-                },
+                tool: failedTurnTool(`queued message could not start — ${err instanceof Error ? err.message : String(err)}`),
             });
             resolve();
             // M2: only this group left the queue, and a turn that never
@@ -8284,10 +8372,7 @@ function drainAsideLane() {
             }).catch((err) => {
                 store.appendMessage(threadId, {
                     role: "bot", kind: "activity",
-                    tool: {
-                        name: `error: queued aside could not start — ${(err instanceof Error ? err.message : String(err)).slice(0, 120)}`,
-                        ok: false,
-                    },
+                    tool: failedTurnTool(`queued aside could not start — ${err instanceof Error ? err.message : String(err)}`),
                 });
                 resolve();
             }).catch(reject);
@@ -8579,7 +8664,7 @@ async function startOrQueueOpenedThread(botId, threadId, text, unattended) {
         store.appendMessage(threadId, {
             role: "bot",
             kind: "activity",
-            tool: { name: `error: this thread could not start — ${why.slice(0, 120)}`, ok: false },
+            tool: failedTurnTool(`this thread could not start — ${why}`),
         });
         return { state: "failed", error: why };
     }
@@ -8592,10 +8677,9 @@ const screenPollers = new Map();
 const SCREEN_POLL_MS = 6000;
 const SCREEN_MIN_GAP_MS = 3000;
 const SCREEN_SETTLE_TIMEOUT_MS = 10_000;
-/** `screenIsTheWork` starts the turn already counting as screen usage: a
- * boxAgent's whole session runs ON the boat, so every tool it calls acts on
- * that screen even though none of them is named like a computer tool. Its
- * shell-only turns are kept honest by the settle-time hash gate instead. */
+/** `screenIsTheWork` starts the poller already counting as screen usage: a
+ * poller restarted mid-turn (a lazy claim swapping in its capture) carries
+ * over whether the turn had touched its screen. */
 function startScreenPoller(botId, threadId, captures, { screenIsTheWork = false } = {}) {
     if (!captures.computer && !captures.browser)
         return;
@@ -8687,10 +8771,9 @@ function shownScreenHash(threadId) {
  * end state, not the previous action's. A turn that never touched the
  * screen settles nothing — and skips the capture, which is one less
  * command on the boat's single endpoint. A frame the reader can already see
- * settles nothing either: the boxAgent pre-touch counts every turn as
- * screen work, so without this its shell-only replies would all end in the
- * same idle desktop. Either way the poller is torn down here, so no
- * per-turn state survives the turn. */
+ * settles nothing either, so a turn never ends on the same idle desktop it
+ * already showed. Either way the poller is torn down here, so no per-turn
+ * state survives the turn. */
 async function finalScreenFrame(_botId, threadId) {
     const entry = screenPollers.get(threadId);
     const owner = turnResourceOwners.get(threadId);
@@ -8782,11 +8865,6 @@ async function startTurn(botId, text, opts) {
     // A workspace at its monthly spend limit starts no turn of any kind: a
     // person's message, a routine, a peer hop or a webhook all stop here.
     assertWithinBudget(cfg, DATA_DIR);
-    if (checkpointRestoreLeases.has(botId)) {
-        throw Object.assign(new Error("this bot's project files are being restored — wait for the restore to finish"), {
-            status: 409,
-        });
-    }
     if (boatLifecycleBusyBots.has(botId)) {
         throw Object.assign(new Error("this bot's cloud computer is being changed — wait for it to finish"), { status: 409 });
     }
@@ -8803,10 +8881,10 @@ async function startTurn(botId, text, opts) {
     // their results still return here (outstandingAssignmentsPrompt tells this
     // turn which are still out). Stop, in this conversation, is the gesture
     // that ends coordination — see interruptDirectThread.
-    // Retire anything a previous turn left behind before minting this turn's
-    // integrations. Completion and interrupt paths do the same; this is the
-    // final backstop against a retained proxy process.
-    revokeInternalCapabilitiesForThread(threadId);
+    // Revoke anything a previous turn left behind before minting this turn's
+    // integrations. Completion and interrupt paths do the same; a proxy the
+    // warm engine kept is honoured again only through this turn's records.
+    revokeEarlierTurnCapabilities(threadId);
     // a webhook turn, or one inherited from a bot already running unattended
     if (opts?.automationSource === "webhook" || opts?.unattended)
         markUnattended(bot.id, threadId);
@@ -8823,6 +8901,10 @@ async function startTurn(botId, text, opts) {
     const plan = turnSurfacePlan(bot, opts?.runOn, threadId);
     const instance = registry.get(bot.modelSelection.instanceId);
     if (!instance) {
+        // Still on the removed Computer engine: its move failed or found no
+        // engine. Try it again now, so the next message runs on the new engine.
+        if (removedComputerInstanceIds(cfg.instances).has(bot.modelSelection.instanceId))
+            void retryComputerEngineMove();
         throw Object.assign(new Error(`provider instance "${bot.modelSelection.instanceId}" is unavailable — pick another model in settings`), { status: 409 });
     }
     const policyRefusal = policyModelRefusal(instance);
@@ -9116,7 +9198,11 @@ async function startTurn(botId, text, opts) {
             const userTurnText = promptWithReply(skillAuthoring ? expandLearnTurnText(setupText) : setupText, opts?.replyTo, cfg.profile?.name?.trim() || "User");
             // Decided again at dispatch when setup outlasted a soul edit (config).
             const decideContext = (config) => {
-                const handedStale = Boolean(handed && (!unseen || (externalUpdate && handed.config !== config)));
+                // A Codex thread keeps the last effort it was sent and no turn can clear
+                // one: back on the default, a thread that holds a level is rebuilt from
+                // the transcript rather than resumed on that level.
+                const effortHeld = !effort && typeof handed?.effort === "string";
+                const handedStale = Boolean(handed && (!unseen || effortHeld || (externalUpdate && handed.config !== config)));
                 const { block: unseenBlock, placed } = unseen && !handedStale ? renderUnseen(unseen) : { block: "", placed: [] };
                 const { turnText: contextTurnText, resume } = buildTurnContext({
                     text: userTurnText,
@@ -9149,6 +9235,7 @@ async function startTurn(botId, text, opts) {
                     resumeCursor, sessionReset: !resume, recoveryText, recoveryIsReplay,
                     handoff: strictResume ? {
                         botId: bot.id, instanceId, config, resumeCursor: typeof resumeCursor === "string" ? resumeCursor : undefined,
+                        ...(instance.driverKind === "codex" ? { effort: effort ?? null } : {}),
                         started: sessionStart(contextOrder, contextTurnText !== userTurnText ? windowIds : [], carried),
                         recovery: sessionStart(contextOrder, recoveryText !== undefined ? windowIds : [], carried),
                         resumed: sessionStart(contextOrder, [], [...placed, ...carried]),
@@ -9221,8 +9308,7 @@ async function startTurn(botId, text, opts) {
             // because moving a live session would break resume.
             // A cloud run keeps the bot's own engine on this host, with the cloud
             // computer as one more tool, so it works in the same folder as any
-            // other turn (only the Computer engine runs on the Boat, and it has no
-            // workspace files).
+            // other turn.
             // On a Cloud home a conversation a guest opened is pinned to its own
             // folder when it first runs, not the bot's project folder the owner's
             // conversations share (what it leaves there reaches none of them). One
@@ -9231,14 +9317,16 @@ async function startTurn(botId, text, opts) {
             const pinnedCwd = privateWorkspace
                 ? store.pinTaskCwd(bot.id, threadId, privateWorkspace, { privateOnly: cloudGuestOpened(threadId) })
                 : null;
+            // A bot's threads run side by side in one project folder, like several
+            // Claude Code or Codex sessions open in one repo: the folder is never a
+            // turn-long claim. What truly needs one writer queues on its own — the
+            // per-turn snapshot per folder (server/checkpoints.ts), memory through
+            // memory_update — and the engines key their sessions by id, not folder.
             const cwd = pinnedCwd ?? undefined;
-            if (cwd && !claimTurnResource(resourceOwner, workspaceResource(cwd))) {
-                throw Object.assign(new Error("another thread is working in this project folder — wait for it to finish or choose a separate folder"), { status: 409, code: "workspace_busy" });
-            }
             // Checkpoint explicit project folders, where a bot can overwrite the
             // user's work. Its private OpenMaus workspace is app-owned and changes
             // on nearly every ordinary chat; snapshotting it would add hidden disk
-            // and process overhead without a user project to restore.
+            // and process overhead without a user project to list changes for.
             const checkpointCwd = cwd && cwd !== privateWorkspace ? cwd : undefined;
             // dweb is opt-in: without an explicit daemon URL, do not advertise
             // tools that would fail on every call or spawn an unnecessary proxy.
@@ -9261,11 +9349,6 @@ async function startTurn(botId, text, opts) {
             // landed. A team computer or a cloud routine is not this conversation's
             // choice, so those ignore the pin.
             const dispatchTask = store.taskByThread(bot.id, threadId);
-            if (plan.clearPin && dispatchTask)
-                store.patchTask(bot.id, threadId, { surface: undefined });
-            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.
@@ -9277,16 +9360,19 @@ async function startTurn(botId, text, opts) {
             // Where an explicit place came from, so its failure names the one
             // control that changes it (and a failed Auto-recorded pin is cleared).
             // Auto and a team's shared computer are nobody's per-turn choice.
-            const placeSource = teamComputer || wants === undefined || wants === "off" ? undefined
+            const namedPlace = teamComputer || wants === undefined || wants === "off" ? undefined : wants;
+            const placeSource = !namedPlace ? undefined
                 : 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(instance.adapter.capabilities, cloudBackend, placeSource);
+                const unsupported = cloudPlaceRefusal(cloudEngine(instance, bot.modelSelection.model), placeSource, bot.name)
+                    ?? computerToolsRefusal(toolScope, placeSource, bot.name);
                 if (unsupported)
-                    throw new PlaceUnavailableError("cloud", placeSource, unsupported);
+                    throw unsupported;
             }
             let previewCapture = null;
             let browserCapture = null;
@@ -9412,7 +9498,7 @@ async function startTurn(botId, text, opts) {
             // the newer turn. The gate's refusals stay fail-closed for any screen
             // call racing this teardown; the turn-failed buzz and incident follow
             // the dispatch-failure rules (person-started turns only).
-            const surfaceLazyClaimRejection = (label) => (failure) => {
+            const surfaceLazyClaimRejection = (label) => (failure, error) => {
                 if (activeInternalGenerationByThread.get(threadId) !== resourceOwner.generation || !threadBusy(bot.id, threadId))
                     return;
                 // The wait ceiling parked this turn (#1651): register the resume and
@@ -9431,11 +9517,16 @@ async function startTurn(botId, text, opts) {
                     void interruptDirectThread(bot.id, threadId, { preserveComputerResume: true }).catch(() => { });
                     return;
                 }
-                const message = `computer unavailable — ${label} could not be claimed for this turn (${failure})`;
+                // A place that failed (mountBotBoat) is already read as its one line
+                // and one way on, and never sticks as an Auto-recorded pin.
+                const placeFailure = error instanceof PlaceUnavailableError ? error : undefined;
+                if (placeFailure)
+                    clearFailedAutoPin(bot.id, threadId, placeFailure.place);
+                const message = placeFailure?.message ?? `computer unavailable — ${label} could not be claimed for this turn (${failure})`;
                 store.appendMessage(threadId, {
                     role: "bot",
                     kind: "activity",
-                    tool: { name: `error: ${message.slice(0, 160)}`, ok: false },
+                    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 }));
@@ -9444,8 +9535,26 @@ async function startTurn(botId, text, opts) {
                     // completion fold must not report this failure a second time.
                     resourceOwner.lazyClaimFailureReported = true;
                 }
+                // A routine, a delegation or a resume reports this exactly as it
+                // reports a place that failed at dispatch: with this cause, before
+                // the interrupt settles the turn as merely "interrupted".
+                opts?.onDispatchError?.(message);
                 void interruptDirectThread(bot.id, threadId).catch(() => { });
             };
+            /** A lazily claimed remote desktop (the VPS, the bot's Boat) streams
+             * from the moment its claim lands. The dispatch-site poller start saw
+             * no capture (the claim runs after dispatch), so restart the poller
+             * with this one, keeping any browser capture and whether this turn
+             * already touched its screen. Same still-running guard as dispatch: a
+             * poller started after its own turn.completed would never stop. */
+            const adoptClaimedCapture = (capture) => {
+                previewCapture = capture;
+                if (!threadBusy(bot.id, threadId))
+                    return;
+                const touched = screenPollers.get(threadId)?.touched ?? false;
+                stopScreenPoller(bot.id, threadId);
+                startScreenPoller(bot.id, threadId, { computer: capture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
+            };
             // Explicit destinations are strict. In particular, Local VM must never
             // fall through to host CUA and accidentally click on the user's Mac.
             // The Local VM attach, shared by explicit "Local VM" and by Auto. Explicit
@@ -9454,7 +9563,7 @@ async function startTurn(botId, text, opts) {
             // be recreated on demand after idling away — and never creates a first
             // VM on its own; every failure there is a quiet "not this place".
             const attachLocalVm = async (strict) => {
-                if (!mountsComputerMcp || instance.adapter.capabilities.remoteAgent === true) {
+                if (!mountsComputerMcp) {
                     if (!strict)
                         return false;
                     throw new Error("this model cannot use the Local VM — choose Claude or an ACP model provider, or select another computer destination");
@@ -9510,7 +9619,7 @@ async function startTurn(botId, text, opts) {
                                 // guard as dispatch: a poller started after its own
                                 // turn.completed would never be torn down.
                                 if (previewCapture && threadBusy(bot.id, threadId)) {
-                                    const touched = screenPollers.get(threadId)?.touched ?? instance.adapter.capabilities.remoteAgent === true;
+                                    const touched = screenPollers.get(threadId)?.touched ?? false;
                                     stopScreenPoller(bot.id, threadId);
                                     startScreenPoller(bot.id, threadId, { computer: previewCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
                                 }
@@ -9557,7 +9666,7 @@ async function startTurn(botId, text, opts) {
                 // the person explicitly opted this bot into remote lifecycle actions.
                 // On Auto an engine that cannot use a computer simply skips it.
                 if ((wants === "cloud" || (wants === undefined && managedPolicy.computerAllowed("vps"))) && cloudBackend === "vps" &&
-                    !cloudPlaceDriverError(instance.adapter.capabilities, "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
@@ -9574,12 +9683,7 @@ async function startTurn(botId, text, opts) {
                         // Local VM's lazy claim does.
                         onClaimed: (vpsCapture) => {
                             pinAutoSurface("cloud");
-                            previewCapture = vpsCapture;
-                            if (threadBusy(bot.id, threadId)) {
-                                const touched = screenPollers.get(threadId)?.touched ?? false;
-                                stopScreenPoller(bot.id, threadId);
-                                startScreenPoller(bot.id, threadId, { computer: vpsCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
-                            }
+                            adoptClaimedCapture(vpsCapture);
                         },
                         onRejected: surfaceLazyClaimRejection("the VPS computer"),
                     });
@@ -9595,54 +9699,56 @@ async function startTurn(botId, text, opts) {
                         autoVpsProblem = mounted.problem ?? "the VPS computer could not be reached";
                     }
                 }
-                // Cloud is strict when selected. Every engine that can use it may also
-                // reuse an already-ready Boat on Auto.
                 if (teamComputer) {
-                    const attached = await attachTeamBoat(teamComputer, bot.id, resourceOwner, usesCloudComputer(instance.adapter.capabilities), 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";
                 }
-                if (!teamComputer && usesCloudComputer(instance.adapter.capabilities) && (wants === "cloud" || (wants === undefined && !computerPlaceRefusal("box"))) && cloudBackend === "box" && boat.boatConfigured(cfg)) {
-                    const attached = await attachBotBoat(bot, resourceOwner, {
-                        explicitCloud: wants === "cloud",
-                        canMount: usesCloudComputer(instance.adapter.capabilities),
-                        remoteAgent: instance.adapter.capabilities.remoteAgent === true,
+                // 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. 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"),
                     });
-                    if (attached) {
-                        previewCapture = attached.capture;
-                        if (attached.mount) {
-                            Object.assign(integrations, attached.mount);
-                            computerKind = "box";
-                        }
-                    }
+                    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");
                 }
             }
             catch (error) {
-                if (!placeSource || wants === undefined || wants === "off" || error instanceof DirectTurnSetupCancelled ||
-                    error instanceof ComputerWaitParked || error instanceof PlaceUnavailableError)
+                // Auto, Off and a team's shared computer name no place; they fail as
+                // they are.
+                if (!namedPlace || !placeSource)
                     throw error;
-                throw placeUnavailable(wants, placeSource, error instanceof Error ? error.message : String(error));
+                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") &&
@@ -9671,13 +9777,12 @@ async function startTurn(botId, text, opts) {
                             pinAutoSurface("local");
                         },
                     });
-                    integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId));
+                    integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId, "this computer"));
                     computerKind = "local";
                 }
             }
             if (wants === undefined &&
                 cloudBackend === "vps" &&
-                !integrations.computer &&
                 !integrations.localComputer &&
                 autoVpsProblem &&
                 !computerSelectionTurns.has(threadId)) {
@@ -9685,7 +9790,7 @@ async function startTurn(botId, text, opts) {
                     ? "This scheduled run tried to start the VPS computer and could not reach it. Check the VPS connection in Settings → API keys."
                     : bot.autoStartVps
                         ? "Check the VPS connection in Settings → API keys."
-                        : "Open Computer and enable Start VPS automatically, or choose Cloud to start it manually.";
+                        : "Open Computer and enable Start VPS automatically, or choose Cloud computer to start it manually.";
                 throw new Error(`${autoVpsProblem}. ${hint}`);
             }
             // Agent control tools include peer comms and the secure credential
@@ -9739,14 +9844,17 @@ async function startTurn(botId, text, opts) {
             // snapshot() absorbs failures, so checkpointing may delay but never fail
             // a turn.
             if (checkpointCwd) {
-                const before = await checkpoints.snapshot(bot.id, checkpointCwd, `turn ${threadId.slice(0, 8)}`);
+                // Pinned by this dispatch: a sibling thread's snapshot in the same
+                // folder must not reclaim this turn's "before" state while it runs.
+                const before = await checkpoints.snapshot(bot.id, checkpointCwd, `turn ${threadId.slice(0, 8)}`, undefined, { pin: dispatchClaimId });
                 if (!directTurnClaimIsCurrent(bot.id, dispatchClaimId, threadId)) {
+                    if (before)
+                        void checkpoints.release(bot.id, checkpointCwd, dispatchClaimId);
                     throw new DirectTurnSetupCancelled("turn stopped during checkpoint");
                 }
+                forgetTurnCheckpoint(threadId);
                 if (before)
-                    turnCheckpoints.set(threadId, { cwd: checkpointCwd, hash: before });
-                else
-                    turnCheckpoints.delete(threadId);
+                    turnCheckpoints.set(threadId, { botId: bot.id, cwd: checkpointCwd, hash: before, pin: dispatchClaimId });
             }
             if (!directTurnClaimIsCurrent(bot.id, dispatchClaimId, threadId)) {
                 throw new DirectTurnSetupCancelled("turn stopped before dispatch");
@@ -9805,8 +9913,8 @@ async function startTurn(botId, text, opts) {
             // Pin on use (issue #1650): every computer that registers a claim
             // slot — a ready Local VM, the VPS, the host fallback, a VM created
             // for this turn — records its pin inside the claim itself, so a turn
-            // that only mounted tools records nothing. A Box attached during
-            // dispatch 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;
@@ -9827,7 +9935,6 @@ async function startTurn(botId, text, opts) {
             }
             const computerPromptKind = resolveComputerPromptKind({
                 kind: computerKind,
-                driverKind: instance.driverKind,
                 vmPrivate: localVmMode(cfg) === "per-bot",
             });
             const coordinationNode = opts?.coordination ? roomHandoffs.nodes.get(opts.coordination.id) : undefined;
@@ -9844,7 +9951,7 @@ async function startTurn(botId, text, opts) {
                 { id: "computer", label: "Computer", text: computerPrompt(computerPromptKind) },
                 { id: "team-computer", label: "Team computer", text: teamComputerPrompt(teamComputer) },
                 { id: "plan", label: "Surface", text: surfacePrompt({ computer: mountedComputer, browser: Boolean(integrations.browser) }, { pinned: plan.pinned, note: plan.note, canSelect: computerSelectionTurns.has(threadId), cloudHome: Boolean(CLOUD_HOME) }) },
-                { id: "cloud-home", label: "OMB Cloud", text: CLOUD_HOME ? cloudHomePrompt(Boolean(integrations.agents) && lendingEnabled()) : "" },
+                { id: "cloud-home", label: "My Cloud", text: CLOUD_HOME ? cloudHomePrompt(Boolean(integrations.agents) && lendingEnabled()) : "" },
                 // gated on the integration, not the key: the hint only goes to a
                 // bot whose driver actually mounted the tools
                 { id: "composio", label: "Connected apps", text: integrations.composio ? composioSystemPrompt(liveBot?.connectorTools ?? bot.connectorTools) + describeConnectorScopes((liveBot ?? bot).connectorScopes) : "" },
@@ -9861,6 +9968,9 @@ async function startTurn(botId, text, opts) {
                 { id: "learn", label: "Skill authoring", text: learnPrompt },
                 { id: "section-context", label: "Section context", text: sectionContextSystemPrompt(bot.section) },
                 { id: "team-memory", label: "Team memory", text: teamMemory.systemPrompt(bot.section) + (integrations.agents ? TEAM_MEMORY_PROMPT : "") },
+                // who on the team roster is busy right now; volatile, so a teammate
+                // starting or finishing work never changes the stable half
+                teamAvailabilityPart(coordinationPrompt ? sectionPeers : []),
                 // what the bot said lately in its other conversations, so a task
                 // never redoes — or forgets — what another one already did
                 { id: "recent", label: "Recent work", text: recentWorkPrompt(recentWork(recentWorkSources(bot), bot, { userName: cfg.profile?.name?.trim() || "User", currentThreadId: threadId, ...recentWorkFilter() })) },
@@ -9974,7 +10084,7 @@ async function startTurn(botId, text, opts) {
             // keep polling the boat forever, carrying dead per-turn state. busy
             // is flipped false in the fold, so it is the honest "still running".
             if ((previewCapture || browserCapture) && threadBusy(bot.id, threadId)) {
-                startScreenPoller(bot.id, threadId, { ...(previewCapture ? { computer: previewCapture } : {}), ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: instance.adapter.capabilities.remoteAgent === true });
+                startScreenPoller(bot.id, threadId, { ...(previewCapture ? { computer: previewCapture } : {}), ...(browserCapture ? { browser: browserCapture } : {}) });
             }
             // An adapter may publish completion synchronously just before its
             // dispatch promise resolves. The event could not use the turn-id map
@@ -10068,16 +10178,10 @@ async function startTurn(botId, text, opts) {
                 drainDelegationWakes();
                 return;
             }
-            // A failed place never sticks. An Auto-recorded pin to it (a
-            // select_computer switch, or where an earlier Auto turn landed) is the
-            // machine's memory, not a choice: clear it so the next message runs on
-            // Auto. A person's pin stays, and the message names the composer.
-            if (e instanceof PlaceUnavailableError) {
-                const pinned = store.taskByThread(bot.id, threadId);
-                if (pinned?.surface === e.place && pinned.surfaceSource === "auto") {
-                    store.patchTask(bot.id, threadId, { surface: undefined, surfaceSource: undefined });
-                }
-            }
+            // A failed place never sticks; a person's pin stays, and the message
+            // names the composer.
+            if (e instanceof PlaceUnavailableError)
+                clearFailedAutoPin(bot.id, threadId, e.place);
             let message = e instanceof Error ? e.message : String(e);
             const current = store.projectBotForTask(bot.id, threadId);
             const backups = cfg.automaticRecovery?.enabled
@@ -10132,7 +10236,7 @@ async function startTurn(botId, text, opts) {
                 role: "bot",
                 kind: "activity",
                 turnSucceeded: false,
-                tool: { name: `error: ${message.slice(0, 160)}`, ok: false },
+                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
@@ -10393,16 +10497,22 @@ 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));
-        const bot = store.bot(botId);
-        if (task && bot)
-            broadcast({ kind: "bot", bot: publicBot(bot) });
+        // 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
+        // sidecar's 4 MiB event ceiling and ended the stream (MOCA-179).
         return task;
     },
     joinConversation: (run) => {
@@ -10457,11 +10567,8 @@ routines = new RoutineManager({
         discardDelegations(commsBus, threadId);
         cancelDirectTurnDispatch(botId, threadId);
         revokeInternalCapabilitiesForThread(threadId);
-        const instance = bot
-            ? runningTurnInstance(bot, threadId)
-            : runningTurnEngines.get(threadId) ?? null;
         try {
-            await instance?.adapter.interruptTurn(threadId);
+            await runningTurnInstance(bot, threadId)?.adapter.interruptTurn(threadId);
         }
         finally {
             closeOpenApprovals(threadId);
@@ -10617,25 +10724,25 @@ async function cloudRoutineReadiness(botId, threadId) {
     if (!boat.boatConfigured(cfg)) {
         return {
             ready: false,
-            reason: 'The Boat cloud computer needs a working Boat API key. For the bot’s configured computer, including a self-hosted VPS, set run_on="maus" instead.',
+            reason: `${boatNotConfigured(bot, "routine").message} For the bot's configured computer, including a self-hosted VPS, set run_on="maus" instead.`,
         };
     }
     const instance = registry.get(bot.modelSelection.instanceId);
     if (!instance)
         return { ready: false, reason: "The target bot's model is unavailable. Choose another model in the bot's settings." };
     // The same rule a cloud turn applies, before anything is provisioned.
-    const unsupported = cloudPlaceDriverError(instance.adapter.capabilities, "box");
+    const unsupported = cloudPlaceRefusal(cloudEngine(instance, bot.modelSelection.model), "routine", bot.name);
     if (unsupported)
-        return { ready: false, reason: "This model can't use a computer. Choose another model, or change where this routine runs." };
+        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.
@@ -10998,52 +11105,6 @@ const modelRequests = new ModelRequestService({
     validateModel: validateModelProposal,
     driverCapabilities: driverCapabilitiesFor,
 });
-const tighteningRequests = new TighteningRequestService({
-    store,
-    autoApply: fullAccessForSource,
-    canPersist: proposalPersistence,
-    // Same reach as a profile change: a Chief may tighten a section peer;
-    // anyone else only itself. Re-checked at confirm.
-    validateTarget: (proposerBotId, targetBotId) => {
-        const proposer = store.bot(proposerBotId);
-        const target = store.bot(targetBotId);
-        if (!target)
-            return "that bot no longer exists";
-        if (!proposer?.chiefOfStaff)
-            return "only a section's Chief of Staff can change another bot's permissions";
-        if (!canReachPeer(proposer, target))
-            return "that bot is not in a team this Chief is allowed to manage";
-        return null;
-    },
-    // The card judges the effective mounts, so the snapshot resolves the same
-    // way the engine does: through the config-aware custom-server filter.
-    mountedMcpServers: (bot) => Object.keys(engineMcpServers(bot)),
-    enabledSkills: (botId) => {
-        const record = store.bot(botId);
-        return (record ? listBotSkills(record) : listSkills(botId)).filter((skill) => skill.enabled).map((skill) => skill.name);
-    },
-    disableSkill: (botId, name) => {
-        const record = store.bot(botId);
-        // Private skills win collisions, including disabled/private copies.
-        // Disabling one must not reveal a same-named shared skill instead.
-        if (skillsLibraryEnabled(cfg) && !listSkills(botId).some((skill) => skill.name === name)
-            && record?.assignedSkills?.includes(name)) {
-            try {
-                const saved = store.patchBot(botId, { assignedSkills: record.assignedSkills.filter((assigned) => assigned !== name) });
-                return saved ? { ok: true } : { ok: false, error: "that bot no longer exists" };
-            }
-            catch (error) {
-                return { ok: false, error: error instanceof Error ? error.message : String(error) };
-            }
-        }
-        const disabled = setSkillEnabled(botId, name, false);
-        return typeof disabled === "object" && "error" in disabled ? { ok: false, error: disabled.error } : { ok: true };
-    },
-    // The owner's own routes stop a busy bot before touching its approval
-    // level or MCP mounts; the card asks for the same, except an emergency
-    // full/custom → ask downgrade, which applies first and stops after.
-    targetBusy: (botId) => Boolean(store.bot(botId)?.busy || activeGroupTurnForBot(botId)),
-});
 const teamSetupTeams = () => [...new Set(["", ...readSections(), ...store.bots.map((bot) => sectionKey(bot.section)), ...store.groups.map((group) => sectionKey(group.section))])];
 const teamSetupRequests = new TeamSetupRequestService({
     store, teams: teamSetupTeams, canAccessTeam, canPersist: proposalPersistence, maxBots: MAX_WORKSPACE_BOTS,
@@ -11355,46 +11416,6 @@ function resolveAndSendModel(res, args) {
     json(res, 200, { ok: true, outcome: "rejected" });
     return true;
 }
-function resolveAndSendTightening(res, args) {
-    const card = store.messagesFor(args.threadId).find((message) => message.card?.requestId === args.requestId && message.card.tighteningRequest)?.card;
-    if (!card)
-        return false;
-    const result = tighteningRequests.resolve(args);
-    if (!result.claimed)
-        return false;
-    if (result.state === "applied" || result.state === "denied") {
-        appendDecision(DATA_DIR, {
-            threadId: args.threadId, requestId: args.requestId, botId: args.botId, botName: args.botName,
-            tool: "tighten_permissions", summary: card.subtitle,
-            decision: result.state === "applied" ? "user-approved" : "user-denied", source: "user",
-        });
-    }
-    if (result.state === "applied") {
-        const target = store.bot(result.targetBotId);
-        if (target)
-            broadcast({ kind: "bot", bot: wireBot(target) });
-        if (result.emergencyStop) {
-            // Mirror the owner's own route: the fail-closed Ask is already
-            // persisted, then the exact turn still holding the elevated
-            // per-turn snapshot is stopped. The response never waits on it.
-            void stopBotForEmergencyApprovalDowngrade(result.targetBotId).catch((error) => {
-                console.warn(`[tightening] emergency stop failed for bot ${result.targetBotId}: ${error instanceof Error ? error.message : String(error)}. The fail-closed Ask is persisted, but the in-flight turn keeps its elevated access until it ends.`);
-            });
-        }
-        json(res, 200, { ok: true, outcome: "allowed-once", tighteningFields: result.fields });
-        return true;
-    }
-    if (result.state === "invalid") {
-        json(res, result.status, { error: result.error });
-        return true;
-    }
-    if (result.state === "already_settled") {
-        json(res, 200, { ok: true, outcome: result.behavior === "allow" ? "allowed-once" : "rejected", alreadySettled: true });
-        return true;
-    }
-    json(res, 200, { ok: true, outcome: "rejected" });
-    return true;
-}
 // Webhook definitions are independent from calendar schedules, but every
 // delivery joins the same RoutineManager queue. That keeps unattended work
 // ordered behind a busy MAUS and gives webhook runs the same durable receipts.
@@ -11414,7 +11435,7 @@ const webhooks = new WebhookManager({
     post: (botId, threadId, text) => {
         if (!store.bot(botId))
             return;
-        store.appendMessage(threadId, { role: "bot", kind: "text", text });
+        store.appendMessage(threadId, { role: "bot", kind: "text", text, webhookPost: true });
     },
     // Mirrors resolveResultsThread's routines wiring a few hundred lines up
     // in this same file: create-on-first-use, never activated (so it never
@@ -11589,7 +11610,7 @@ setupRetry = 0) {
         onDispatchError?.(`${bot.name}'s approval level is still being confirmed — skipped this round`);
         return true;
     }
-    revokeInternalCapabilitiesForThread(threadId);
+    revokeEarlierTurnCapabilities(threadId);
     spoken.add(botId);
     // Must be the SAME resolver the readiness re-check uses below, or a Chief's
     // delegated Full elevation makes the two disagree by construction: every
@@ -11617,7 +11638,7 @@ setupRetry = 0) {
             role: "bot",
             kind: "activity",
             from: { botId: bot.id, name: bot.name, color: bot.color },
-            tool: { name: `error: ${message}`, ok: false },
+            tool: failedTurnTool(message),
         });
         onDispatchError?.(message);
         return true;
@@ -11652,6 +11673,10 @@ setupRetry = 0) {
         noteForeignTurn(bot.id, threadId, internalGeneration);
     const resourceOwner = { threadId, generation: internalGeneration };
     turnResourceOwners.set(threadId, resourceOwner);
+    // Set when this member's cloud computer, claimed by its first computer
+    // call, could not start (or parked waiting for its seat): the turn ends on
+    // it, with this cause, instead of as merely interrupted.
+    let roomClaimFailure;
     let roomVmTarget = null;
     let retainRoomVmLease = false;
     let roomSpeaker;
@@ -11749,7 +11774,7 @@ setupRetry = 0) {
                 role: "bot",
                 kind: "activity",
                 from: { botId: bot.id, name: bot.name, color: bot.color },
-                tool: { name: `error: ${message}`, ok: false },
+                tool: failedTurnTool(message),
             });
             onDispatchError?.(message);
             return true;
@@ -11898,17 +11923,13 @@ setupRetry = 0) {
         const roomPlaceRefusal = roomKind && computerPlaceRefusal(roomKind);
         if (roomPlaceRefusal)
             throw Object.assign(new Error(roomPlaceRefusal.message), { code: roomPlaceRefusal.code });
-        // The Computer engine runs on the Boat; this computer has no tools it can
-        // reach, exactly as a bot thread refuses it.
-        if (roomPlan.computer === "local" && instance.adapter.capabilities.remoteAgent === true) {
-            throw new Error("the Computer engine works on the cloud computer — set Works on to Cloud, or choose another engine");
-        }
         // The same one rule as a bot thread, before anything is provisioned: an
         // engine that cannot use the cloud computer is refused, never swapped.
         if (!roomTeamComputer && roomPlan.computer === "cloud") {
-            const unsupported = cloudPlaceDriverError(instance.adapter.capabilities, 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", "works-on", unsupported);
+                throw unsupported;
         }
         // One place per room turn as well: a team computer reached on Auto means
         // no separate built-in browser.
@@ -11928,12 +11949,12 @@ setupRetry = 0) {
             return false;
         }
         if (roomTeamComputer) {
-            const attached = await attachTeamBoat(roomTeamComputer, readyBot.id, resourceOwner, usesCloudComputer(instance.adapter.capabilities), 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:
@@ -11941,6 +11962,51 @@ setupRetry = 0) {
         const roomSetupIsCurrent = () => !isCancelled?.() &&
             groupSpeakers.get(threadId) === roomSpeaker &&
             activeInternalGenerationByThread.get(threadId) === internalGeneration;
+        // A lazily claimed desktop (the VPS, the member's Boat) shows in the room
+        // from the moment its first computer call claims it.
+        const showClaimedScreen = (capture) => {
+            if (roomSetupIsCurrent() && store.group(readyGroup.id)?.busyBotId === readyBot.id) {
+                roomScreenBotId = readyBot.id;
+                startScreenPoller(readyBot.id, threadId, { computer: capture });
+            }
+        };
+        // The member's cloud computer could not start on its first computer call:
+        // the same row, report and parking a failure at setup gets (the catch at
+        // the end of this function), then the member's turn ends. Fenced to this
+        // member's still-running turn.
+        const failRoomClaim = (failure, error) => {
+            if (activeInternalGenerationByThread.get(threadId) !== internalGeneration || groupSpeakers.get(threadId) !== roomSpeaker)
+                return;
+            if (resourceOwner.computerParkedOn) {
+                registerComputerResume({
+                    botId: bot.id,
+                    threadId,
+                    resource: resourceOwner.computerParkedOn,
+                    generation: internalGeneration,
+                    afterMessageId: store.activePath(threadId).findLast((entry) => entry.role === "user")?.id,
+                });
+                roomClaimFailure = { parked: true };
+                if (orchestration)
+                    orchestration.result.stopReason = `${bot.name} parked waiting for the computer`;
+            }
+            else {
+                // Read as a room member's place (mountBotBoat): its one line, with no
+                // retry of its own.
+                const placeFailure = error instanceof PlaceUnavailableError ? error : undefined;
+                const message = placeFailure?.message ?? failure;
+                roomClaimFailure = { parked: false, message };
+                store.appendMessage(threadId, {
+                    role: "bot", kind: "activity",
+                    from: { botId: bot.id, name: bot.name, color: bot.color },
+                    tool: failedTurnTool(message, placeFailure ? { place: placeFailure.row } : {}),
+                });
+                onDispatchError?.(message);
+                // Claude settles the interrupt as exit_before_result: not a second
+                // incident for the same failure.
+                resourceOwner.lazyClaimFailureReported = true;
+            }
+            void instance.adapter.interruptTurn(threadId).catch(() => { });
+        };
         // An explicit place that cannot be attached fails the member's turn with
         // its cause and the one setting that changes it.
         try {
@@ -11954,15 +12020,7 @@ setupRetry = 0) {
                 if (turnProvider(readyBot) === "vps") {
                     vpsThreadStarted(readyBot.id, threadId);
                     roomVpsBotId = readyBot.id;
-                    const mounted = await mountBotVps(readyBot, resourceOwner, {
-                        start: true,
-                        onClaimed: (capture) => {
-                            if (roomSetupIsCurrent() && store.group(readyGroup.id)?.busyBotId === readyBot.id) {
-                                roomScreenBotId = readyBot.id;
-                                startScreenPoller(readyBot.id, threadId, { computer: capture });
-                            }
-                        },
-                    });
+                    const mounted = await mountBotVps(readyBot, resourceOwner, { start: true, onClaimed: showClaimedScreen });
                     if (!roomSetupIsCurrent())
                         return false;
                     if (!("integration" in mounted))
@@ -11972,25 +12030,18 @@ setupRetry = 0) {
                 }
                 else {
                     if (!boat.boatConfigured(cfg))
-                        throw new Error(BOAT_NOT_CONFIGURED);
-                    const remoteAgent = instance.adapter.capabilities.remoteAgent === true;
-                    const attached = await attachBotBoat(readyBot, resourceOwner, { explicitCloud: true,
-                        canMount: usesCloudComputer(instance.adapter.capabilities), remoteAgent });
-                    if (!roomSetupIsCurrent())
-                        return false;
-                    if (!attached?.mount)
-                        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) };
@@ -12023,17 +12074,14 @@ setupRetry = 0) {
                 if (owner?.threadId !== threadId || owner.botId !== readyBot.id) {
                     throw new Error("the Local VM lease expired while preparing the turn");
                 }
-                integrations.localComputer = containerComputerMcp(vm.runtime, controlIntegration(readyBot.id, threadId, internalGeneration, target), target);
+                integrations.localComputer = containerComputerMcp(vm.runtime, controlIntegration(readyBot.id, threadId, internalGeneration, { localVmTarget: target }), target);
             }
         }
         catch (error) {
             const place = roomPlan.computer;
             if (place !== "cloud" && place !== "vm" && place !== "local")
                 throw error;
-            if (error instanceof DirectTurnSetupCancelled || error instanceof ComputerWaitParked || error instanceof PlaceUnavailableError)
-                throw error;
-            // A room row is not cut, so the cause keeps all its words.
-            throw placeUnavailable(place, "works-on", error instanceof Error ? error.message : String(error), Infinity);
+            throw await asPlaceFailure(error, place, "room", readyBot, turnProvider(readyBot) === "vps" ? "vps" : "box");
         }
         const roster = readyGroup.memberIds
             .map((id) => store.bot(id))
@@ -12044,8 +12092,9 @@ setupRetry = 0) {
         // are who it cannot. The 1:1 prompt has carried a peer roster since #774,
         // and a room turn had nothing — the only advice it gave ("mention them
         // like @Name") sends the model after a teammate who will never see it.
-        // Same reachability rule as list_bots, minus the room's own members.
-        const outsideRoom = integrations.agents
+        // Same reachability rule as list_bots, minus the room's own members, and
+        // only on a turn that is not answering a room request.
+        const outsideRoom = integrations.agents && orchestration && !orchestration.roomHandoffId
             ? reachablePeers(store.bots, bot).filter((peer) => !readyGroup.memberIds.includes(peer.id))
             : [];
         const system = [
@@ -12055,7 +12104,7 @@ setupRetry = 0) {
             `Room members: ${roster}, and ${userName} (the human).`,
             readyGroup.bulletin.trim() && `Room bulletin (shared instructions for everyone):\n${readyGroup.bulletin.trim()}`,
             `Reply as yourself, briefly and conversationally. To bring a teammate in, mention them like @Name — they'll see the conversation and respond.`,
-            outsideRoom.length > 0 && orchestration && !orchestration.roomHandoffId && roomPeerRosterSystemPrompt(outsideRoom),
+            outsideRoom.length > 0 && roomPeerRosterSystemPrompt(outsideRoom),
             integrations.agents && (CREDENTIAL_PROMPT + (orchestration && !orchestration.roomHandoffId ? THREADS_PROMPT : "")).trim(),
             integrations.agents && (!orchestration || orchestration.roomHandoffId) && "For actual OpenMausBot teamwork, discover IDs with list_room_targets and use coordinate_bots for advice or work in this or another room. Do not substitute native coding helpers for these named bots. Consult only when needed to make a decision; no discussion step is mandatory. Give concrete responsibilities, exact accessible paths and acceptance checks. End your turn after assigning; busy teammates queue and results automatically resume you. When they return, finish the requested verification and give the user one final answer. Native helper names are not evidence that an OpenMausBot teammate participated. Plain @mentions are only for conversational replies in this room.",
             integrations.agents && ROUTINE_PROMPT.trim(),
@@ -12119,7 +12168,6 @@ setupRetry = 0) {
         const recentLines = recentWork(recentWorkSources(bot), bot, { userName, currentThreadId: threadId, ...recentWorkFilter() });
         const roomComputerPromptKind = resolveComputerPromptKind({
             kind: roomTeamComputer || roomComputerKind === "box" ? "box" : roomVmTarget ? "vm" : roomComputerKind,
-            driverKind: instance.driverKind,
             vmPrivate: localVmMode(cfg) === "per-bot",
         });
         {
@@ -12140,9 +12188,10 @@ 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),
             { id: "recent", label: "Recent work", text: recentWorkPrompt(recentLines) },
             { id: "section-context", label: "Section context", text: sectionContextSystemPrompt(bot.section) },
             { id: "team-memory", label: "Team memory", text: teamMemory.systemPrompt(bot.section) + (integrations.agents ? TEAM_MEMORY_PROMPT : "") },
@@ -12232,13 +12281,10 @@ setupRetry = 0) {
                 if (e.type === "item.completed" && e.itemType === "assistant_text")
                     replyText += `\n${e.text}`;
                 else if (e.type === "turn.completed") {
-                    if (orchestration && !e.ok) {
-                        orchestration.result.stopReason = e.stopReason ?? null;
-                        finish("provider_failed");
-                    }
-                    else {
-                        finish("settled");
-                    }
+                    const end = roomTurnEnd(e, Boolean(orchestration), roomClaimFailure);
+                    if (orchestration && end.stopReason !== undefined)
+                        orchestration.result.stopReason = end.stopReason;
+                    finish(end.outcome);
                 }
                 // Waiting on a person is not turn work: hold the ceiling while an
                 // approval or question card is open, so deciding slowly does not
@@ -12323,7 +12369,7 @@ setupRetry = 0) {
                     role: "bot",
                     kind: "activity",
                     from: { botId: bot.id, name: bot.name, color: bot.color },
-                    tool: { name: `error: ${message.slice(0, 140)}`, ok: false },
+                    tool: failedTurnTool(message),
                 });
                 onDispatchError?.(message);
                 watchdog.settle(threadId);
@@ -12427,7 +12473,7 @@ setupRetry = 0) {
             drainSecretResumes();
             drainTeamSetupResumes();
         }
-        if (outcome === "provider_failed") {
+        if (outcome === "provider_failed" || outcome === "parked") {
             if (skillAuthoring)
                 skillAuthoringClaim.claimed = false;
             return false;
@@ -12516,7 +12562,7 @@ setupRetry = 0) {
         store.appendMessage(threadId, {
             role: "bot", kind: "activity",
             from: { botId: bot.id, name: bot.name, color: bot.color },
-            tool: { name: `error: ${message}`, ok: false },
+            tool: failedTurnTool(message, error instanceof PlaceUnavailableError ? { place: error.row } : {}),
         });
         onDispatchError?.(message);
         if (orchestration) {
@@ -13125,10 +13171,7 @@ function drainQueuedChannelSends() {
             store.appendMessage(threadId, {
                 role: "bot",
                 kind: "activity",
-                tool: {
-                    name: `error: queued channel message could not start — ${(error instanceof Error ? error.message : String(error)).slice(0, 120)}`,
-                    ok: false,
-                },
+                tool: failedTurnTool(`queued channel message could not start — ${error instanceof Error ? error.message : String(error)}`),
             });
         }
         // A message with no eligible responder creates no operation. Continue
@@ -13335,9 +13378,9 @@ function proposalPersistence(botId, threadId) {
         return { ok: true };
     // Only cards on the visible branch can be acted on from the composer.
     // Abandoned branches must not permanently consume the proposal quota.
-    // Routine, profile, default-model, tightening and team-setup proposals
+    // Routine, profile, default-model and team-setup proposals
     // share one budget per bot per thread, so one thread cannot pile up 8 of each.
-    const openRequests = store.activePath(threadId).filter((message) => (message.card?.routineRequest?.botId === botId || message.card?.profileRequest?.botId === botId || message.card?.modelRequest?.botId === botId || message.card?.tighteningRequest?.botId === botId || message.card?.teamSetupRequest?.botId === botId) &&
+    const openRequests = store.activePath(threadId).filter((message) => (message.card?.routineRequest?.botId === botId || message.card?.profileRequest?.botId === botId || message.card?.modelRequest?.botId === botId || message.card?.teamSetupRequest?.botId === botId) &&
         !message.card.answered &&
         !message.card.dismissed && !message.card.expired).length;
     return openRequests >= 8
@@ -14199,7 +14242,8 @@ function configStatus() {
         // not a saved key
         box: boat.describeBoatAccount(cfg),
         vps: { configured: Boolean(vpsSshAlias(cfg)), sshAlias: vpsSshAlias(cfg) ?? "" },
-        opencodeGo: { configured: Boolean(cfg.opencodeGo?.apiKey) },
+        // names only: every provider key stays write-only
+        opencodeGo: { configured: Boolean(cfg.opencodeGo?.apiKey), providerKeys: Object.keys(openCodeProviderKeys(cfg)) },
         // the chosen voice is a setting, not a secret; the key is reported the
         // same configured-or-not way as every other credential
         tts: tts.describeVoice(cfg),
@@ -14281,6 +14325,7 @@ function configForAccess(status, admin) {
         edition: { edition: status.edition.edition, features: status.edition.features },
         signIn: { admins: [], members: [] },
         vps: { configured: status.vps.configured, sshAlias: "" },
+        opencodeGo: { configured: status.opencodeGo.configured, providerKeys: [] },
         profile: { name: status.profile.name, email: "" },
         browserProfiles: status.browserProfiles.map((profile) => Object.fromEntries(Object.entries(profile).filter(([key]) => key !== "partitionId"))),
     };
@@ -14332,6 +14377,10 @@ function persistMcpServers(next) {
 }
 async function describeInstances() {
     const configs = providerConfigs();
+    // Reading the engines is where this server learns one became available
+    // (an install, a sign-in, a key or a Company engine), so a bot still on the
+    // removed Computer engine moves now rather than at the next start.
+    void retryComputerEngineMove();
     return (await registry.describe()).map((instance) => {
         const entry = configs[instance.instanceId];
         const described = {
@@ -14508,7 +14557,7 @@ async function reloadProviders() {
             if (store.taskByThread(botId, threadId)) {
                 store.appendMessage(threadId, {
                     role: "bot", kind: "activity",
-                    tool: { name: "error: turn interrupted — provider settings changed", ok: false },
+                    tool: failedTurnTool("turn interrupted — provider settings changed"),
                 });
                 store.setTaskActivity(botId, threadId, "idle");
             }
@@ -14611,7 +14660,7 @@ const workspaceBackupAccess = {
             !routines?.isTicking && !calendarCalls?.isTicking &&
             !localVmImageBusy && !localVmProvisionBusy && !localVmModeChangeBusy &&
             !localVmLifecycleBusy.size && !boatLifecycleBusyBots.size && !vpsPreviewRequests.size && !orphanBoatLifecycleBusyIds.size &&
-            !computerProviderConfigTransitions.size && !checkpointRestoreLeases.size &&
+            !computerProviderConfigTransitions.size &&
             teamComputers.list().every(computer => !teamComputerInUse(computer)) &&
             store.bots.every((bot) => !botHasActiveTurn(bot.id) && !routines?.activeRunForBot(bot.id) && !botComputerControlSnapshot(bot.id).held) &&
             store.groups.every((group) => !groupIsWorking(group)),
@@ -14634,18 +14683,24 @@ const workspaceBackupRoutes = createWorkspaceBackupRoutes({
     restored: workspaceRestore,
     ...workspaceBackupAccess,
 });
-// Move to Cloud (server/cloud-move-http.ts): every server sizes its own
-// workspace for the desktop; only a Cloud home receives one. After its
-// restore commits, the Cloud home restarts so startup installs it.
-let cloudHomeRestartRequested = false;
+// Copy this computer here (server/cloud-move-http.ts, docs/copy-workspace.md):
+// every server sizes its own workspace for its desktop, and every server the
+// person owns receives one, a Cloud home included. A workspace shared with
+// other people never does (workspaceShared): a hosted organisation
+// workspace, or a server whose email sign-in lets someone besides its owner
+// in. After the restore commits, the server
+// exits with RESTART_EXIT_CODE and its launcher starts it again, so startup
+// installs it (server/restart.ts).
+let restartRequested = false;
 const cloudMoveRoutes = createCloudMoveRoutes({
     dataDir: DATA_DIR,
     appVersion: serverVersion(),
-    cloudHome: Boolean(CLOUD_HOME),
+    environmentId: ENVIRONMENT_ID,
+    sharedWorkspace: () => workspaceShared({ hosted: HOSTED_WORKSPACE, cloudHome: Boolean(CLOUD_HOME), signIn: signInAllowList() }),
     readBody,
     restored: workspaceRestore,
     ...workspaceBackupAccess,
-    restart: () => { cloudHomeRestartRequested = true; gracefulShutdown(); },
+    restart: () => { restartRequested = true; gracefulShutdown(); },
 });
 // Route modules (server/routes/README.md). `workspaceAccess` is assigned at
 // boot, after this line, so the dependency reads it per request.
@@ -14754,7 +14809,7 @@ const liveCalls = new LiveCallController({
     },
     broadcast: (frame) => broadcast(frame, { adminOnly: true }),
     settings: () => ({ key: cfg.live?.key ?? "", ...liveSettingsFor(cfg) }),
-    createSession: ({ key, sdp, botId, threadId, voice }) => createLiveSession({ key, sdp, voice, bot: liveBotFor(botId), history: liveHistoryFor(threadId) }),
+    createSession: ({ key, sdp, botId, threadId, voice }) => createLiveSession({ key, sdp, voice, bot: liveBotFor(botId), history: liveHistoryFor(threadId), cloudHome: Boolean(CLOUD_HOME) }),
     // Node's WebSocket (undici) accepts headers in its second argument.
     openSocket: (url, key) => new WebSocket(url, { headers: { authorization: `Bearer ${key}` } }),
     attachUrl: (sessionId) => liveAttachUrl(sessionId),
@@ -15135,9 +15190,7 @@ const handleRequest = async (req, res) => {
             // scheme the native companion scanners accept; it carries the
             // credential encoding because those scanners cannot take a typed code.
             const serverName = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED }).label;
-            const invite = base
-                ? `openmausbot://pair?address=${encodeURIComponent(base)}&token=${encodeURIComponent(opened.credential)}&name=${encodeURIComponent(serverName)}`
-                : null;
+            const invite = base ? phonePairingLink({ address: base, token: opened.credential, name: serverName }) : null;
             return json(res, 200, {
                 id: opened.id,
                 code,
@@ -15251,7 +15304,7 @@ const handleRequest = async (req, res) => {
                 // A Cloud home is one person's: only their own devices, which the
                 // Admin's pairing signs in with admin scope, may lend to it.
                 if (CLOUD_HOME && !auth.scopes.includes("admin"))
-                    return json(res, 403, { error: "Only your own computers can lend to your Cloud. Connect this computer to your Cloud from its OMB Cloud settings." });
+                    return json(res, 403, { error: "Only your own computers can lend to My Cloud. On this computer, open My Cloud from Settings → OpenMausBot Cloud first." });
                 sharedComputers.register(registration, { session: auth.session.id, person: CLOUD_HOME ? CLOUD_HOME_LENDER : personKey(auth.session) }, secret);
                 return json(res, 200, { ok: true });
             }
@@ -15401,6 +15454,9 @@ const handleRequest = async (req, res) => {
                     throw Object.assign(new Error("the internal turn capability has expired"), { status: 401 });
                 }
             };
+            const delegatedThisTurn = (taskId) => {
+                (internalCapability.delegatedThisTurn ??= new Set()).add(taskId);
+            };
             // Where an entry came from, as the person will read it in MEMORY.md:
             // the room or the thread title, never a bare id unless nothing else
             // names the conversation.
@@ -15431,9 +15487,13 @@ const handleRequest = async (req, res) => {
                     return json(res, 409, { error: "The user request ended before its computer was selected." });
                 if (unoffered)
                     return json(res, 409, { error: unoffered, options });
-                const option = requested === "auto"
-                    ? options.find(option => option.ready && option.surface === current) ?? options.find(option => option.ready && option.surface === "vm") ?? options.find(option => option.ready) ?? options.find(option => option.canStart) ?? options.find(option => option.canCreate && option.surface === "vm") ?? options.find(option => option.canCreate)
-                    : options.find(option => option.surface === requested);
+                // The computer this turn mounted is already selected, even before it
+                // is up when its first call starts it (the bot's cloud computer):
+                // switching to it would only restart the request.
+                const claim = autoVmClaims.get(internalCapability.threadId);
+                const startsOnFirstCall = claim?.owner.generation === internalCapability.generation && claim.startsComputer === true && !claim.failed;
+                const picked = pickComputer(options, requested, current, startsOnFirstCall);
+                const option = picked.option;
                 if (!option?.available)
                     return json(res, 409, { error: option?.reason ?? "No configured computer or browser is available. Open the Computer panel to set one up.", options });
                 if (source.selected) {
@@ -15441,8 +15501,11 @@ const handleRequest = async (req, res) => {
                         return json(res, 409, { error: "A computer switch is already pending. End this turn to continue there." });
                 }
                 else {
-                    if (option.surface === current && option.ready)
-                        return json(res, 200, { status: "ready", surface: current, message: "This computer is already selected. Use its mounted tools." });
+                    if (picked.current) {
+                        return json(res, 200, { status: "ready", surface: current, message: option.ready
+                                ? "This computer is already selected. Use its mounted tools."
+                                : "This computer is already selected. It starts on its first call; use its mounted tools." });
+                    }
                     source.selected = option.surface;
                     source.previousSurface = store.taskByThread(bot.id, bot.threadId)?.surface;
                 }
@@ -15544,17 +15607,19 @@ const handleRequest = async (req, res) => {
                 return json(res, 200, { result });
             }
             // The cloud computer's tools (harness-mcp-proxy computer): the turn's
-            // capability names its Boat, and the Boat credential stays here.
+            // capability names its Boat, and the Boat credential stays here. A
+            // capability minted before the Boat existed (boxId null) acts on the
+            // one its first call's claim created or woke (mountBotBoat).
             if (method === "POST" && path === "/api/internal/computer/mcp") {
                 const body = await readInternalBody();
-                const boxId = internalCapability.boxId;
-                if (!boxId)
+                if (internalCapability.boxId === undefined)
                     return json(res, 403, { error: "this turn has no cloud computer" });
                 const abort = new AbortController();
                 res.once("close", () => { if (!res.writableEnded)
                     abort.abort(); });
                 return json(res, 200, { result: await cloudComputerRpc(body, {
-                        cfg, boxId, signal: abort.signal,
+                        cfg, signal: abort.signal,
+                        boxId: () => internalCapability.boxId ?? claimedBoatId(internalCapability),
                         gate: () => computerCallGate(internalCapability),
                         assertActive: requireActiveInternalCapability,
                     }) });
@@ -16057,39 +16122,6 @@ const handleRequest = async (req, res) => {
                 });
                 return json(res, 201, proposed);
             }
-            if (method === "POST" && path === "/api/internal/tightening-requests") {
-                const parsed = z.object({
-                    fromBotId: z.string().min(1).max(128),
-                    fromThreadId: z.string().min(1).max(128),
-                    forBotId: z.string().max(128).optional(),
-                    intents: z.unknown(),
-                    reason: z.unknown(),
-                }).strict().safeParse(await readInternalBody());
-                if (!parsed.success)
-                    return json(res, 400, { error: "invalid tightening proposal" });
-                const body = parsed.data;
-                const from = store.bot(body.fromBotId);
-                if (!from)
-                    return json(res, 403, { error: "unknown sender" });
-                const owner = connectorThread(from.id, body.fromThreadId);
-                if (!owner)
-                    return json(res, 403, { error: "source conversation does not belong to sender" });
-                const targetBotId = body.forBotId?.trim() || from.id;
-                const proposed = tighteningRequests.submit({
-                    botId: from.id,
-                    threadId: body.fromThreadId,
-                    targetBotId,
-                    intents: body.intents,
-                    reason: body.reason,
-                    from: owner.group ? { botId: from.id, name: from.name, color: from.color } : undefined,
-                });
-                appendDecision(DATA_DIR, {
-                    threadId: body.fromThreadId, requestId: proposed.requestId, botId: from.id, botName: from.name,
-                    tool: "tighten_permissions", summary: proposed.detail, decision: proposed.state === "applied" ? "auto-approved" : "card-shown",
-                    source: proposed.state === "applied" ? "full-access" : "tightening",
-                });
-                return json(res, 201, proposed);
-            }
             if (method === "GET" && path === "/api/internal/team-setup-catalog") {
                 let chief = store.bot(internalCapability.botId);
                 if (!chief.chiefOfStaff || chief.hidden)
@@ -16428,7 +16460,8 @@ const handleRequest = async (req, res) => {
                     const guestThread = guestWorkThread(from, target, fromThreadId, message);
                     if (guestThread === null)
                         return json(res, 500, { error: "couldn't open a conversation for that work" });
-                    const queued = queueDelegation(commsBus, from, { toBotId, message, reason: "asked while busy", depth, approvalAlreadyGranted, ...(guestThread ? { targetThreadId: guestThread } : {}) }, MAX_COMMS_DEPTH, fromThreadId);
+                    const queued = queueDelegation(commsBus, from, { toBotId, message, reason: "asked while busy", depth, approvalAlreadyGranted, ...(guestThread ? { targetThreadId: guestThread } : {}),
+                        ...externalCompletion(internalCapability) }, MAX_COMMS_DEPTH, fromThreadId);
                     if ((queued.result !== "ok" || !queued.id) && guestThread)
                         store.deleteTask(toBotId, guestThread);
                     if (queued.result !== "ok" || !queued.id)
@@ -16442,6 +16475,7 @@ const handleRequest = async (req, res) => {
                     if (internalCapability.generation === EXTERNAL_RUNTIME_GENERATION && !threadBusy(from.id, fromThreadId)) {
                         drainThreadDelegations(fromThreadId);
                     }
+                    delegatedThisTurn(queued.id);
                     return json(res, 200, { busy: true, taskId: queued.id, toBotName: target.name, receipt: peerDeliveryReceipt({
                             botId: toBotId, botName: target.name, outcome: "queued", taskId: queued.id,
                             detail: "the teammate was busy; the ask was queued as a delegation instead",
@@ -16595,12 +16629,14 @@ const handleRequest = async (req, res) => {
                         sourceThreadId: fromThreadId,
                         sourceBotId: currentFrom.id,
                         routineRunId: activeRoutineRunForThread(fromThreadId)?.id,
+                        ...externalCompletion(internalCapability),
                     });
                     store.appendMessage(fromThreadId, {
                         role: "bot",
                         kind: "activity",
                         tool: { name: `@${currentTarget.name} is still working — ask converted to a delegation` },
                     });
+                    delegatedThisTurn(taskId);
                     return json(res, 200, { timeout: true, taskId, toBotName: currentTarget.name, waitedMs: ASK_BOT_TIMEOUT_MS,
                         receipt: peerDeliveryReceipt({ botId: toBotId, botName: currentTarget.name, outcome: "injected", taskId,
                             detail: "the teammate's turn started and is still running; only the synchronous wait ended" }) });
@@ -16639,6 +16675,9 @@ const handleRequest = async (req, res) => {
             const delegationMatch = method === "GET" ? path.match(/^\/api\/internal\/delegations\/([\w-]{4,64})$/) : null;
             if (delegationMatch) {
                 const taskId = delegationMatch[1];
+                if (internalCapability.delegatedThisTurn?.has(taskId)) {
+                    return json(res, 409, { error: `Task ${taskId} was delegated during this turn. Finish your response now so the other bot can work; its result will be delivered to this conversation automatically. Do not check or wait for a newly delegated task until a later turn.` });
+                }
                 const fromThreadId = internalCapability.threadId;
                 const from = internalSender;
                 if (!connectorThread(from.id, fromThreadId))
@@ -16680,7 +16719,10 @@ const handleRequest = async (req, res) => {
                     if (!sender || (target && !canReachPeer(sender, target))) {
                         return json(res, 403, { error: "Result withheld: team access changed while the teammate was working" });
                     }
-                    if (Date.now() >= deadline) {
+                    // Nothing moves while the teammate's card waits on the person, so
+                    // say so now rather than holding the long-poll to its deadline.
+                    const awaitingPerson = running && runningEntry ? openPersonCard(runningEntry[0]) : undefined;
+                    if (Date.now() >= deadline || awaitingPerson) {
                         if (running && runningEntry) {
                             const recent = summarizeDelegatedActivity(store.messagesFor(runningEntry[0]), running.startedAtMs ?? Date.now());
                             return json(res, 200, {
@@ -16688,6 +16730,12 @@ const handleRequest = async (req, res) => {
                                 toBotName: store.bot(toBotId)?.name ?? toBotId,
                                 elapsedMs: Math.max(0, Date.now() - (running.startedAtMs ?? Date.now())),
                                 recentActivity: recent,
+                                ...(awaitingPerson ? {
+                                    awaitingPerson: {
+                                        ...awaitingPerson,
+                                        threadTitle: store.taskByThread(toBotId, runningEntry[0])?.title,
+                                    },
+                                } : {}),
                             });
                         }
                         const queuedTarget = store.bot(toBotId);
@@ -16786,7 +16834,7 @@ const handleRequest = async (req, res) => {
                 const guestThread = guestWorkThread(from, target, fromThreadId, reason ?? message);
                 if (guestThread === null)
                     return json(res, 500, { error: "couldn't open a conversation for that work" });
-                const queued = queueDelegation(commsBus, from, { toBotId, message, reason, depth, ...(guestThread ? { targetThreadId: guestThread } : {}) }, MAX_COMMS_DEPTH, fromThreadId);
+                const queued = queueDelegation(commsBus, from, { toBotId, message, reason, depth, ...(guestThread ? { targetThreadId: guestThread } : {}), ...externalCompletion(internalCapability) }, MAX_COMMS_DEPTH, fromThreadId);
                 if ((queued.result !== "ok" || !queued.id) && guestThread)
                     store.deleteTask(toBotId, guestThread);
                 if (queued.result !== "ok" || !queued.id) {
@@ -16804,6 +16852,7 @@ const handleRequest = async (req, res) => {
                             detail: `${refusal} — nothing was queued`,
                         }) });
                 }
+                delegatedThisTurn(queued.id);
                 const targetName = store.bot(toBotId)?.name ?? toBotId;
                 // The queue normally drains when the source thread's turn completes. A
                 // caller this server did not spawn (an external runtime) has no live
@@ -17032,6 +17081,12 @@ const handleRequest = async (req, res) => {
                 if (!groupId || !message) {
                     return json(res, 400, { error: "post_to_room needs group_id (from list_rooms) and message" });
                 }
+                // One turn's worth of posts is a handful; past it the turn has
+                // stopped reporting and started broadcasting. Counted per turn, on
+                // top of the room's own budget below.
+                if ((internalCapability.roomPosts ?? 0) >= MAX_ROOM_POSTS_PER_TURN) {
+                    return json(res, 429, { error: `You have already posted ${MAX_ROOM_POSTS_PER_TURN} times this turn, which is the limit. Do not retry — finish your turn and say anything further to the user directly.` });
+                }
                 if (message.length > ROOM_POST_MAX_CHARS) {
                     return json(res, 400, {
                         error: `a room post is at most ${ROOM_POST_MAX_CHARS} characters — post the short version and keep the detail in your own reply`,
@@ -17160,6 +17215,7 @@ const handleRequest = async (req, res) => {
                     peerPost: unattended ? { unattended: true } : {},
                     ...(attachedVoiceNote ? { attachments: stagedAttachments } : {}),
                 });
+                internalCapability.roomPosts = (internalCapability.roomPosts ?? 0) + 1;
                 detachParkedAudio?.();
                 store.patchGroup(room.id, { unread: true });
                 // The same visibility contract the peer tools keep: whatever a bot
@@ -17203,7 +17259,7 @@ const handleRequest = async (req, res) => {
                 if (!fitsOnOneLine(title))
                     return json(res, 400, { error: "title must fit on one line" });
                 if (internalCapability.openedThreads >= MAX_THREADS_OPENED_PER_TURN) {
-                    return json(res, 429, { error: `you can open at most ${MAX_THREADS_OPENED_PER_TURN} threads in one turn` });
+                    return json(res, 429, { error: `You have already opened ${MAX_THREADS_OPENED_PER_TURN} threads this turn, which is the limit. Do not retry — finish your turn and tell the person which threads you still wanted to open, so they can open them or ask you again.` });
                 }
                 const toBotId = typeof body.toBotId === "string" && body.toBotId.trim() ? body.toBotId.trim() : from.id;
                 const target = store.bot(toBotId);
@@ -17302,6 +17358,7 @@ const handleRequest = async (req, res) => {
                 }
                 store.setTaskOpenedBy(target.id, task.threadId, { botId: from.id, name: from.name, delegationId: queued.id, at: task.openedBy?.at ?? Date.now() });
                 internalCapability.openedThreads += 1;
+                delegatedThisTurn(queued.id);
                 // An honest forecast, not a promise: the handoff starts when this
                 // turn ends, and by then the target's slots are taken by whatever is
                 // running there plus the threads this turn already opened ahead.
@@ -17331,8 +17388,8 @@ const handleRequest = async (req, res) => {
                 if (!chief.chiefOfStaff) {
                     return json(res, 403, { error: "only a section's Chief of Staff can create operator bots" });
                 }
-                if (internalCapability.createdBots >= 4) {
-                    return json(res, 429, { error: "you can create at most 4 bots in one turn" });
+                if (internalCapability.createdBots >= MAX_CREATED_BOTS_PER_TURN) {
+                    return json(res, 429, { error: `You can create at most ${MAX_CREATED_BOTS_PER_TURN} bots in one turn. Use the team you have before adding more.` });
                 }
                 if (store.bots.length >= MAX_WORKSPACE_BOTS) {
                     return json(res, 409, { error: `this workspace is limited to ${MAX_WORKSPACE_BOTS} bots` });
@@ -17381,8 +17438,9 @@ const handleRequest = async (req, res) => {
                 if (store.bot(chief.id) !== chief || chief.hidden || !chief.chiefOfStaff || !connectorThread(chief.id, fromThreadId)) {
                     return json(res, 403, { error: "only an active Chief of Staff can create operator bots" });
                 }
-                if (internalCapability.createdBots >= 4)
-                    return json(res, 429, { error: "you can create at most 4 bots in one turn" });
+                if (internalCapability.createdBots >= MAX_CREATED_BOTS_PER_TURN) {
+                    return json(res, 429, { error: `You can create at most ${MAX_CREATED_BOTS_PER_TURN} bots in one turn. Use the team you have before adding more.` });
+                }
                 if (store.bots.length >= MAX_WORKSPACE_BOTS)
                     return json(res, 409, { error: `this workspace is limited to ${MAX_WORKSPACE_BOTS} bots` });
                 const duplicate = store.bots.find((candidate) => !candidate.hidden &&
@@ -17501,6 +17559,36 @@ const handleRequest = async (req, res) => {
                 const updated = updateChannel(room.id, patch);
                 return json(res, 200, { ok: true, memberIds: updated.memberIds, memberCount: updated.memberIds.length, message: `Updated room “${updated.name}”.` });
             }
+            if (method === "POST" && path === "/api/internal/mcp-servers") {
+                // Same single-flight lock as POST /api/mcp/servers: two writers must
+                // not interleave a read of cfg.mcpServers with a save.
+                if (mcpConfigBusy)
+                    return json(res, 409, { error: "MCP servers are already being updated." });
+                mcpConfigBusy = true;
+                try {
+                    const body = await readInternalBody();
+                    const added = addDisabledMcpServer(cfg.mcpServers ?? {}, body);
+                    if (!added.ok)
+                        return json(res, added.status, { error: added.error });
+                    const refusal = mcpPolicyRefusal(added.name, added.server);
+                    if (refusal)
+                        return json(res, 403, { error: refusal, code: "managed_policy" });
+                    persistMcpServers(added.next);
+                    const server = added.server;
+                    const remote = isRemoteMcpServer(server);
+                    return json(res, 201, {
+                        name: added.name,
+                        enabled: false,
+                        transport: remote ? server.type : "command",
+                        target: remote ? server.url : server.command,
+                        envKeys: remote ? [] : Object.keys(server.env).sort(),
+                        headerKeys: remote ? Object.keys(server.headers).sort() : [],
+                    });
+                }
+                finally {
+                    mcpConfigBusy = false;
+                }
+            }
             if (method === "POST" && path === "/api/internal/request-credential") {
                 const body = await readInternalBody();
                 const from = internalSender;
@@ -17726,8 +17814,15 @@ const handleRequest = async (req, res) => {
                     const policy = currentSender.outbound ?? DEFAULT_OUTBOUND_POLICY;
                     const threadId = internalCapability.threadId;
                     const { app } = describeTool(outboundTool);
-                    const summary = outboundCalls.map((call) => {
+                    // One entry per call, in the summary's order, so a phone can say
+                    // "Send to Linear? Create linear comment ×2" without parsing the
+                    // raw arguments out of the subtitle.
+                    const calls = outboundCalls.map((call) => {
                         const described = describeTool(call.slug);
+                        return { app: described.app, label: described.label };
+                    });
+                    const summary = outboundCalls.map((call, index) => {
+                        const described = calls[index];
                         const argsText = call.arguments === undefined ? "" : JSON.stringify(call.arguments);
                         return `${described.app ? `${described.app} · ` : ""}${described.label}${argsText ? `\n${argsText.slice(0, 400)}${argsText.length > 400 ? "… [arguments truncated]" : ""}` : ""}`;
                     }).join("\n\n");
@@ -17757,7 +17852,7 @@ const handleRequest = async (req, res) => {
                                 tool: outboundTool,
                                 held: HELD_NOTE["approval.held.outbound"],
                                 heldCode: "approval.held.outbound",
-                                outboundRequest: { tool: outboundTool, app },
+                                outboundRequest: { tool: outboundTool, app, calls },
                             },
                         });
                         appendDecision(DATA_DIR, {
@@ -17852,7 +17947,8 @@ const handleRequest = async (req, res) => {
                 if (upstream.transportSessionId)
                     headers["mcp-session-id"] = upstream.transportSessionId;
                 res.writeHead(upstream.status, headers);
-                return res.end(Buffer.from(upstream.bytes));
+                // A missing OAuth permission gets a note on what fixes it (MOCA-273).
+                return res.end(Buffer.from(withScopeHint(upstream.bytes, upstream.contentType, connectorCalls.map((call) => call.slug))));
             }
             // ── computer control: proxies read the hold, bots plead for help ──
             if (path === "/api/internal/computer-control") {
@@ -18353,12 +18449,10 @@ const handleRequest = async (req, res) => {
             const limit = pageSize(url.searchParams.get("messages"));
             if (limit === null)
                 return json(res, 400, { error: "messages must be a non-negative whole number" });
-            // wireBot(), not publicBot(): publicBot() pulls the whole transcript via
-            // messagesFor() just to have it overwritten below by messagePage(),
-            // which — for a bounded request — never needs the full transcript.
-            // tasks stays explicit, because that is the one field publicBot() adds
-            // that messagePage() does not: wireBot() omits the key entirely for a
-            // bot record carrying no tasks, where publicBot() always sent [].
+            // wireBot(), not publicBot(): this snapshot answers with the page it
+            // was asked for, not the default one. tasks stays explicit, as in
+            // publicBot(): wireBot() omits the key entirely for a bot record
+            // carrying no tasks, where clients expect [].
             // A member on a workspace with a restricted bot gets only what they may
             // see (bot-visibility.ts); for everyone else these filters keep all.
             const shownBots = store.bots.filter((bot) => visible.bot(bot.id));
@@ -18382,47 +18476,6 @@ const handleRequest = async (req, res) => {
             });
         }
         // scrollback: the page before a message the client already holds
-        // #1655: the consent card's answer, per conversation. Explicit and
-        // revocable; a thread allowlisted in config carries the same standing
-        // consent without ever seeing a card.
-        m = path.match(/^\/api\/threads\/([\w-]+)\/cloud-overflow$/);
-        if (m && method === "POST") {
-            const threadId = m[1];
-            if (!store.botByThread(threadId))
-                return json(res, 404, { error: "no such conversation" });
-            const body = await readBody(req);
-            if (!body || typeof body !== "object" || Array.isArray(body))
-                return json(res, 400, { error: "body must be a JSON object" });
-            if (typeof body.consent !== "boolean")
-                return json(res, 400, { error: "consent must be a boolean" });
-            if (body.consent) {
-                // Consent answers the priced card, never a guess: without a prior
-                // offer the rate was never shown, so a seat must not start yet.
-                // The grant binds to the rate the card showed (#1655): a config
-                // change re-offers instead of starting at a new price silently.
-                const offeredRate = cloudOverflowConsent.offeredRate(threadId);
-                if (offeredRate === null)
-                    return json(res, 409, { error: "no cloud overflow offer" });
-                cloudOverflowConsent.grant(threadId, offeredRate);
-            }
-            else {
-                cloudOverflowConsent.revoke(threadId);
-                // Revocation must reach the machine (#1655): the ledger alone
-                // would leave this conversation's seat billing to its idle
-                // timeout. A start still waking is caught by its own revoke
-                // check once readyBox resolves.
-                const seatBot = store.botByThread(threadId);
-                const lease = seatBot ? cloudSeatLeases.get(seatBot.id) : undefined;
-                if (seatBot && lease && lease.threadId === threadId) {
-                    stopCloudSeat(seatBot.id, lease, "Cloud computer stopped because overflow consent was revoked — billing pauses while it sleeps.");
-                }
-            }
-            store.appendMessage(threadId, {
-                role: "bot", kind: "activity",
-                tool: { name: cloudOverflowConsentText(body.consent, cloudOverflowIdleStopMs(cfg)), ok: true },
-            });
-            return json(res, 200, { consented: body.consent });
-        }
         m = path.match(/^\/api\/threads\/([\w-]+)\/messages$/);
         if (m && method === "GET") {
             const threadId = m[1];
@@ -19172,8 +19225,11 @@ const handleRequest = async (req, res) => {
                     return json(res, 400, { error: "Import backups alongside your existing bots; project mode is only for templates" });
                 try {
                     const imported = importTeamBackup(store, routines, body, await defaultSelection(), { visibility: importVisibility });
+                    // A restore writes its transcripts without store events, after the
+                    // store's own frames announced each bot and room, so these frames
+                    // are what carries the restored pages to other clients.
                     const bots = imported.bots.map((bot) => publicBot(bot));
-                    const groups = imported.groups.map((group) => ({ ...publicGroupState(group), ...messagePage(group.threadId, undefined) }));
+                    const groups = imported.groups.map((group) => groupWithThread(group));
                     for (const bot of bots)
                         broadcast({ kind: "bot", bot });
                     for (const group of groups)
@@ -19323,9 +19379,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));
-            const fresh = groupWithThread(store.group(group.id));
-            broadcast({ kind: "group", group: fresh });
-            return json(res, 201, { group: fresh, task });
+            return json(res, 201, { group: groupWithThread(store.group(group.id)), task });
         }
         m = path.match(/^\/api\/groups\/([\w-]+)\/tasks\/([\w-]+)$/);
         if (m && method === "POST") {
@@ -19350,15 +19404,6 @@ const handleRequest = async (req, res) => {
             if (!switched)
                 return json(res, 404, { error: "no such channel task" });
             const switchedSettings = { ...publicGroupState(switched), tasks: store.groupTasks(switched.id) };
-            // The frame says the channel moved; it is not a transcript delivery.
-            // A long room's whole history over SSE is the payload `?messages=`
-            // exists to avoid, and it would also overwrite a bounded snapshot on
-            // every other client. One default page is enough to render the switch;
-            // anything earlier pages back through /api/threads/:id/messages.
-            broadcast({
-                kind: "group",
-                group: { ...switchedSettings, ...messagePage(switched.threadId, DEFAULT_PAGE) },
-            });
             // "0" predates paging and means settings only — no `messages` key at
             // all, which clients tell apart from an empty page. A positive page is
             // the transcript a client can actually hold; omitting the parameter
@@ -19366,9 +19411,7 @@ const handleRequest = async (req, res) => {
             // materialises it.
             const responseGroup = requestedMessages === "0"
                 ? switchedSettings
-                : switchLimit === undefined
-                    ? groupWithThread(switched)
-                    : { ...switchedSettings, ...messagePage(switched.threadId, switchLimit) };
+                : { ...switchedSettings, ...messagePage(switched.threadId, switchLimit) };
             return json(res, 200, { group: responseGroup });
         }
         if (m && method === "PATCH") {
@@ -19441,14 +19484,12 @@ const handleRequest = async (req, res) => {
             lastReply.delete(m[2]);
             cancelTeamSetupResumesForThread(m[2]);
             const updated = store.deleteGroupTask(group.id, m[2]);
-            if (updated)
-                clearTurnDigestState(m[2]);
             if (!updated)
                 return json(res, 400, { error: "a channel keeps at least one task" });
+            clearTurnDigestState(m[2]);
+            revokeInternalCapabilitiesForThread(m[2]);
             rejectDeletedThreadSkillStages(stagedSkillCleanups);
-            const fresh = groupWithThread(updated);
-            broadcast({ kind: "group", group: fresh });
-            return json(res, 200, { group: fresh });
+            return json(res, 200, { group: groupWithThread(updated) });
         }
         m = path.match(/^\/api\/groups\/([\w-]+)$/);
         if (m && method === "PATCH") {
@@ -21412,54 +21453,6 @@ const handleRequest = async (req, res) => {
             broadcast({ kind: "bot", bot: visible });
             return json(res, 200, { bot: visible });
         }
-        // ── workspace checkpoints: per-turn shadow-git snapshots ────────────
-        // The list endpoint is the source of truth (turns store nothing), and
-        // `enabled` tells the UI whether snapshots can happen here at all —
-        // false for refused folders (home, Desktop…), a missing git, or a bot
-        // whose checkpoints failed earlier this session.
-        m = path.match(/^\/api\/bots\/([\w-]+)\/checkpoints$/);
-        if (m && method === "GET") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            const cwd = url.searchParams.get("cwd") ?? "";
-            if (!cwd.trim())
-                return json(res, 400, { error: "cwd query parameter required" });
-            return json(res, 200, {
-                checkpoints: await checkpoints.listCheckpoints(m[1], cwd),
-                enabled: await checkpoints.checkpointsEnabled(m[1], cwd),
-            });
-        }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/checkpoints\/restore$/);
-        if (m && method === "POST") {
-            const bot = store.bot(m[1]);
-            if (!bot)
-                return json(res, 404, { error: "no such bot" });
-            const parsed = z
-                .object({ cwd: z.string().min(1), hash: z.string().regex(/^[0-9a-f]{40}$/) })
-                .safeParse(await readBody(req));
-            if (!parsed.success) {
-                return json(res, 400, { error: "cwd (absolute path) and hash (full 40-character checkpoint hash) required" });
-            }
-            // Claim synchronously with the busy check. startTurn checks the same
-            // lease before reserving the bot, so no turn can enter during the
-            // awaited Git operation.
-            if (bot.busy)
-                return json(res, 409, { error: "the bot is working — stop the turn before restoring files" });
-            if (checkpointRestoreLeases.has(bot.id)) {
-                return json(res, 409, { error: "this bot's project files are already being restored" });
-            }
-            checkpointRestoreLeases.add(bot.id);
-            let result;
-            try {
-                result = await checkpoints.restore(bot.id, parsed.data.cwd, parsed.data.hash);
-            }
-            finally {
-                checkpointRestoreLeases.delete(bot.id);
-            }
-            if (!result.ok)
-                return json(res, 400, { error: result.error });
-            return json(res, 200, { ok: true });
-        }
         // onboarding/ask cards persist their answered/dismissed state
         m = path.match(/^\/api\/bots\/([\w-]+)\/cards\/([\w-]+)$/);
         if (m && method === "PATCH") {
@@ -21863,14 +21856,6 @@ const handleRequest = async (req, res) => {
                     behavior,
                 }))
                     return;
-                if (resolveAndSendTightening(res, {
-                    botId: bot.id,
-                    botName: bot.name,
-                    threadId: bot.threadId,
-                    requestId: String(body.requestId),
-                    behavior,
-                }))
-                    return;
                 if (sendSkillResolution(res, resolveSkillRequest({
                     botId: bot.id,
                     botName: bot.name,
@@ -22011,21 +21996,6 @@ const handleRequest = async (req, res) => {
                     }))
                         return;
                 }
-                const tighteningCard = store.messagesFor(threadId).find((message) => message.card?.requestId === requestId && message.card.tighteningRequest);
-                if (tighteningCard?.card?.tighteningRequest) {
-                    const tighteningBotId = tighteningCard.from?.botId ?? store.botByThread(threadId)?.id;
-                    if (!tighteningBotId)
-                        return json(res, 400, { error: "this tightening request has no valid owner" });
-                    const tighteningOwner = store.bot(tighteningBotId);
-                    if (resolveAndSendTightening(res, {
-                        botId: tighteningBotId,
-                        botName: tighteningOwner?.name,
-                        threadId,
-                        requestId,
-                        behavior,
-                    }))
-                        return;
-                }
                 // peer-approval intercept (see /api/bots/:id/respond above). A peer card
                 // belongs to the bus rather than to a speaker, so resolve it before we go
                 // looking for one — a room between turns has no speaker to find.
@@ -22148,15 +22118,8 @@ const handleRequest = async (req, res) => {
             return json(res, 200, { ok: true });
         }
         // ── tasks: a bot's separate contexts ────────────────────────────────
-        // The bot record answers with its messages because switching tasks
-        // changes which transcript is live, and a partial patch would leave
-        // the client showing the previous task's conversation.
-        const botWithThread = (bot) => ({
-            ...wireBot(bot),
-            messages: store.messagesFor(bot.threadId),
-            activeLeafId: store.activeLeaf(bot.threadId),
-            tasks: store.tasks(bot.id).map(wireTask),
-        });
+        // Replies carry the open thread's newest page: a create or delete can
+        // change which transcript is live. The frames come from store.onChange.
         // Folders organize one bot's threads; they never own settings,
         // transcripts or working directories. The project wire names stay stable.
         m = path.match(/^\/api\/bots\/([\w-]+)\/projects\/order$/);
@@ -22173,7 +22136,7 @@ const handleRequest = async (req, res) => {
             const projects = store.reorderProjects(bot.id, body.projectIds);
             if (!projects)
                 return json(res, 400, { error: "projectIds must include each of this bot's folders exactly once" });
-            return json(res, 200, { projects, bot: botWithThread(bot) });
+            return json(res, 200, { projects, bot: publicBot(bot) });
         }
         m = path.match(/^\/api\/bots\/([\w-]+)\/projects(?:\/([\w-]+))?$/);
         if (m && ((method === "POST" && !m[2]) || (method === "PATCH" && m[2]) || (method === "DELETE" && m[2]))) {
@@ -22184,7 +22147,7 @@ const handleRequest = async (req, res) => {
                 return json(res, 404, { error: "no such folder" });
             if (method === "DELETE") {
                 const updated = store.deleteProject(bot.id, m[2]);
-                return json(res, 200, { bot: botWithThread(updated) });
+                return json(res, 200, { bot: publicBot(updated) });
             }
             const body = await readBody(req);
             if (!body || typeof body !== "object" || Array.isArray(body))
@@ -22207,7 +22170,7 @@ const handleRequest = async (req, res) => {
             const project = method === "POST"
                 ? store.createProject(bot.id, patch.name, patch.emoji)
                 : store.patchProject(bot.id, m[2], patch);
-            return json(res, method === "POST" ? 201 : 200, { project, bot: botWithThread(bot) });
+            return json(res, method === "POST" ? 201 : 200, { project, bot: publicBot(bot) });
         }
         m = path.match(/^\/api\/bots\/([\w-]+)\/tasks$/);
         if (m && method === "POST") {
@@ -22242,9 +22205,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));
-            const fresh = botWithThread(store.bot(bot.id));
-            broadcast({ kind: "bot", bot: fresh });
-            return json(res, 201, { bot: fresh, task: wireTask(task) });
+            return json(res, 201, { bot: publicBot(store.bot(bot.id)), task: wireTask(task) });
         }
         m = path.match(/^\/api\/bots\/([\w-]+)\/tasks\/([\w-]+)$/);
         if (m && method === "POST") {
@@ -22263,18 +22224,13 @@ const handleRequest = async (req, res) => {
             if (!switched)
                 return json(res, 404, { error: "no such task" });
             const switchedSettings = { ...wireBot(switched), tasks: store.tasks(switched.id).map(wireTask) };
-            // Bounded for the same reason as the channel switch above.
-            broadcast({
-                kind: "bot",
-                bot: { ...switchedSettings, ...messagePage(switched.threadId, DEFAULT_PAGE) },
-            });
             // "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):
+            // the hit can be older than one page.
             const responseBot = requestedMessages === "0"
                 ? switchedSettings
-                : switchLimit === undefined
-                    ? botWithThread(switched)
-                    : { ...switchedSettings, ...messagePage(switched.threadId, switchLimit) };
+                : { ...switchedSettings, ...messagePage(switched.threadId, switchLimit) };
             return json(res, 200, { bot: responseBot });
         }
         if (m && method === "PATCH") {
@@ -22349,9 +22305,7 @@ const handleRequest = async (req, res) => {
                 const task = store.refreshTaskPermissions(profile.id, m[2]);
                 if (!task)
                     return json(res, 404, { error: "no such task" });
-                const fresh = botWithThread(store.bot(profile.id));
-                broadcast({ kind: "bot", bot: fresh });
-                return json(res, 200, { task: wireTask(task), bot: fresh });
+                return json(res, 200, { task: wireTask(task), bot: publicBot(store.bot(profile.id)) });
             }
             const patch = {};
             if (body.projectId !== undefined) {
@@ -22457,9 +22411,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);
-            const fresh = botWithThread(store.bot(m[1]));
-            broadcast({ kind: "bot", bot: fresh });
-            return json(res, 200, { task: wireTask(task), bot: fresh });
+            return json(res, 200, { task: wireTask(task), bot: publicBot(store.bot(m[1])) });
         }
         if (m && method === "DELETE") {
             const bot = store.bot(m[1]);
@@ -22482,12 +22434,11 @@ const handleRequest = async (req, res) => {
             if (!updated)
                 return json(res, 404, { error: "no such task" });
             clearTurnDigestState(m[2]);
+            revokeInternalCapabilitiesForThread(m[2]);
             handoffs.forget(m[2]);
             settleDirectFollowup(directTurnGenerationByThread.get(m[2]));
             rejectDeletedThreadSkillStages(stagedSkillCleanups);
-            const fresh = botWithThread(updated);
-            broadcast({ kind: "bot", bot: fresh });
-            return json(res, 200, { bot: fresh });
+            return json(res, 200, { bot: publicBot(updated) });
         }
         // Regenerate title (#1858): name the thread again from its conversation
         // as it is now. The person asked, so the result replaces any title, but
@@ -22577,8 +22528,6 @@ const handleRequest = async (req, res) => {
                 const key = teamComputerOwner(found.id);
                 if (parsed.data.action === "take" && boatLifecycleBusyBots.has(key))
                     return json(res, 409, { error: "Wait for this computer's action to finish before taking control" });
-                if (parsed.data.action === "take")
-                    assertTeamControlCanBeTaken(found.id);
                 if (parsed.data.controlLeaseId) {
                     const result = parsed.data.action === "take"
                         ? computerControl.acquireLease(key, parsed.data.controlLeaseId)
@@ -22617,7 +22566,7 @@ const handleRequest = async (req, res) => {
             if (method === "POST" && !computerId) {
                 const parsed = teamComputerCreate.safeParse(body);
                 if (!parsed.success)
-                    return json(res, 400, { error: "Provide requestId (UUID), a name, and acknowledgeCost: true to create a paid Boat" });
+                    return json(res, 400, { error: "Provide requestId (UUID), a name, and acknowledgeCost: true to create a paid cloud computer" });
                 if (!boat.boatConfigured(cfg))
                     return json(res, 409, { error: "Configure Boat in Settings before creating a cloud computer" });
                 const computer = teamComputers.create(parsed.data.name, parsed.data.requestId);
@@ -22637,7 +22586,7 @@ const handleRequest = async (req, res) => {
             }
             if (method === "POST" && found && action && action !== "control") {
                 if (action === "provision" && body?.acknowledgeCost !== true)
-                    return json(res, 400, { error: "Confirm Boat creation or wake costs with acknowledgeCost: true" });
+                    return json(res, 400, { error: "Confirm cloud computer creation or wake costs with acknowledgeCost: true" });
                 // A ready-only join never wakes, provisions or steals an agent's turn.
                 // The caller takes a separate explicit human-control lease first.
                 if (action === "join") {
@@ -22959,7 +22908,12 @@ const handleRequest = async (req, res) => {
         // The bots' browser engine: install it on this machine (agent-browser +
         // a Chrome for Testing, a one-time download), or ask how that is going.
         // One install at a time; the config frame's browserEngine tells the rest.
+        // JSON only, so a form posted from another local page cannot start it.
         if (method === "POST" && path === "/api/browser-engine/install") {
+            const mediaType = String(req.headers["content-type"] ?? "").split(";", 1)[0].trim().toLowerCase();
+            if (mediaType !== "application/json") {
+                return json(res, 415, { error: "content-type must be application/json" });
+            }
             if (!browserEngineInstall) {
                 const status = browserEngineStatus();
                 if (status.kind === "unavailable" && !status.installable)
@@ -24112,6 +24066,15 @@ const handleRequest = async (req, res) => {
                     if (conflict)
                         return json(res, 409, { error: conflict });
                 }
+                // A change names only the OpenCode provider keys it saves or removes;
+                // the rest stay. Merged with no await before the save below, so it
+                // starts from what is saved at that moment.
+                if (patch.opencodeGo?.providerKeys) {
+                    const merged = mergeOpenCodeProviderKeys(cfg, patch.opencodeGo.providerKeys);
+                    if (!merged.ok)
+                        return json(res, 400, { error: merged.error });
+                    patch.opencodeGo = { ...patch.opencodeGo, providerKeys: merged.keys };
+                }
                 const browserCleanupRequests = [];
                 if (profileControlConflict())
                     return json(res, 409, { error: "Release browser control before deleting its profile." });
@@ -24601,9 +24564,6 @@ const handleRequest = async (req, res) => {
                 if (!currentBot)
                     return json(res, 404, { error: "no such bot" });
                 const controlKey = botComputerControlKey(currentBot);
-                const teamComputer = inheritedTeamComputer(currentBot);
-                if (action === "take" && teamComputer)
-                    assertTeamControlCanBeTaken(teamComputer.id);
                 const leaseResult = body.controlLeaseId === undefined
                     ? null
                     : controlLeaseIdSchema.safeParse(body.controlLeaseId);
@@ -24780,12 +24740,12 @@ const handleRequest = async (req, res) => {
             }
             if (bot.computer !== "cloud" && !threadPreview) {
                 return json(res, 409, {
-                    error: "Choose Cloud before changing or opening this Boat. Auto only checks existing computer state.",
+                    error: "Choose Cloud computer before changing or opening this cloud computer. Auto only checks existing computer state.",
                 });
             }
             if (m[2] === "remove") {
                 // Boats sleep and wake; only the VPS backend has a container to remove.
-                return json(res, 409, { error: "the cloud Boat backend has no container to remove — use sleep instead" });
+                return json(res, 409, { error: "a cloud computer has no container to remove — put it to sleep instead" });
             }
             const releaseComputerLifecycle = claimBotComputerLifecycle(botId);
             try {
@@ -25050,6 +25010,8 @@ const gracefulShutdown = createGracefulShutdown({
     // the shutdown deadline), immediately before the process exits, so no new
     // server can overlap with a still-mutating old one.
     exit: (code) => {
+        // Streamed text the bus is still merging reaches the log and clients.
+        bus.flush();
         try {
             sessions.close();
         }
@@ -25062,8 +25024,8 @@ const gracefulShutdown = createGracefulShutdown({
         closeMessageDb();
         mcpOAuth.dispose();
         releaseDataDirLeaseAtExit();
-        // A Cloud home's launcher starts the server again on this code only.
-        process.exit(cloudHomeRestartRequested && code === 0 ? CLOUD_HOME_RESTART_EXIT_CODE : code);
+        // Every launcher in this repo starts the server again on this code (server/restart.ts).
+        process.exit(restartRequested && code === 0 ? RESTART_EXIT_CODE : code);
     },
 });
 for (const signal of ["SIGINT", "SIGTERM"]) {