openmausbot 0.1.89 → 0.1.91

package/dist-server/server/index.js

@@ -15,7 +15,8 @@ import { selectReplay, DEFAULT_REBUILD_BYTES, MAX_SUMMARY_BYTES } from "./contex
 import { draftSummary, foldPoint } from "./compaction-summary.js";
 import { compactBudget, contextWindowFor, shouldCompact } from "./context-budget.js";
 import { autoCompactWindow } from "./drivers/claude.js";
-import { SharedComputers, sharedComputerOperation, sharedComputerRegistration } from "./shared-computers.js";
+import { provenRequestPerson, SharedComputers, sharedComputerOperation, sharedComputerRegistration } from "./shared-computers.js";
+import { cloudHomeLendingRefusal, createCloudRoutineAuthors } from "./cloud-lending.js";
 import { SharedComputerControl } from "./shared-computer-control.js";
 import { RoomHandoffs } from "./room-handoffs.js";
 import { assertRequestTarget, guardedRequestPath, requestConflict, requestNeedsInput, requestSourceForCard } from "./guarded-requests.js";
@@ -44,20 +45,23 @@ 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 * as box from "./box.js";
+import * as boat from "./boat.js";
 import { TeamComputers, teamComputerAssignment, teamComputerCreate, teamComputerOwner } from "./team-computers.js";
 import { isEffortLevel } from "../shared/wire.js";
-import { boxCreateRecoverySnapshot, retireDeletedBoxCreate } from "./box-create-idempotency.js";
-import { boxDeletionSnapshot } from "./box-delete-journal.js";
-import { boxAccountResourceChangeError, cloudBackendChangeError, vpsAliasResourceChangeError, } from "./cloud-backend.js";
+import { boatCreateRecoverySnapshot, retireDeletedBoatCreate } from "./boat-create-idempotency.js";
+import { boatDeletionSnapshot } from "./boat-delete-journal.js";
+import { boatAccountResourceChangeError, cloudBackendChangeError, vpsAliasResourceChangeError, } from "./cloud-backend.js";
 import * as composio from "./composio.js";
 import { connectorCallFromFrame, connectorRefusalText, connectorUnrecognizedText, evaluateConnectorTools } from "./connector-verdict.js";
 import { chiefOfStaffSystemPrompt } from "./chief-of-staff.js";
+import { buildRecall } from "./recall.js";
+import { createMemoryUpkeep, upkeepEnabled } from "./memory-upkeep.js";
+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 { openMausStatusSystemPrompt } from "./openmaus-status-capsule.js";
-import { containerComputerAction, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, containerExec, containerRuntimeStatus, localVmRecreatableOnDemand, localVmWorkspaceExists, perBotLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, VM_WORKSPACE_GUEST, } from "./container-computer.js";
+import { containerComputerAction, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, containerExec, containerRuntimeStatus, localVmRecreatableOnDemand, localVmWorkspaceExists, perBotLocalVmTarget, poolLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, VM_WORKSPACE_GUEST, } from "./container-computer.js";
 import { attachForTurn, saveBotAttachment } from "./bot-attachment.js";
-import { ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, threadEventLogMaxBytes, maxConcurrentBotThreads, threadEventLogRetentionDays, saveConfig, showToolCallsEnabled, claudeUserMcpEnabled, skillAuthoringEnabled, sharedComputersEnabled, builtInBrowserEnabled, llmThreadTitlesEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, browserEngineAttachCdpUrl, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, onConfigSaved, } from "./config.js";
+import { ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, 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, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, onConfigSaved, } from "./config.js";
 import { sweepThreadEventLogs } from "./thread-retention.js";
 import { ComputerControl } from "./computer-control.js";
 import { augmentedPath, findCliCandidates, resetPathCache } from "./env-path.js";
@@ -90,16 +94,19 @@ import { chiefForBot, INCIDENTS_THREAD_TITLE, IncidentLedger, incidentChip, inci
 const SESSION_READ_MAX_CHARS = 8_000;
 import { attemptAsideInjection, drainAsideMessages, queueAsideMessage, restoreAsideMessages, } from "./aside-queue.js";
 import { promptWithReply, transcriptText } from "./replies.js";
-import { admit } from "./admission.js";
+import { admit, DRAIN_COALESCE_MAX_ITEMS } from "./admission.js";
 import { _loadPending, buildDelegationFailurePrompt, buildDelegationRevivalPrompt, DELEGATION_TTL_MS, DelegationWakeBudget, discardDelegations, drainDelegations, expireStaleDelegations, findDelegationReceipt, pendingDelegationInfo, pendingDelegationSnapshot, pendingThreads, queueDelegation, recordDelegationReceipt, releaseDelegationsWaitingOn, summarizeDelegatedActivity } from "./delegations.js";
 import { cancelSteeredMessage, drainSteeredMessages, hasQueuedSteeredMessages, holdSteeredQueue, onSteeredQueueChange, queuedSteerSnapshot, queuedSteeredMessage, queuedThreadPosition, queueSteeredMessage, restoreHeldSteeredQueue, restoreSteeredMessages, settleHeldSteeredQueue, } from "./steer-queue.js";
-import { cancelChannelMessage, drainChannelMessages, holdChannelQueue, queuedChannelMessage, queueChannelMessage, restoreChannelMessages, restoreHeldChannelQueue, resolveHeldReplyTarget, settleHeldChannelQueueHead, } from "./channel-queue.js";
+import { cancelChannelMessage, drainChannelMessages, holdChannelQueue, headChannelGroup, queuedChannelMessage, queueChannelMessage, restoreChannelMessages, restoreHeldChannelQueue, resolveHeldReplyTarget, settleHeldChannelQueueHead, } from "./channel-queue.js";
 import { acceptedSendMatch, parseSendId, sendFingerprint, SendSequencer, } from "./send-idempotency.js";
 import { EventBus } from "./harness/bus.js";
 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_IGNORED_KEYS, CLOUD_PAIRING_PATH, cloudHomeConfiguration, cloudHomeOffersPlace, cloudHomePlaceRefusal, createCloudPairing, readSignedBody, } from "./cloud-home.js";
+import { createCloudMoveRoutes } from "./cloud-move-http.js";
+import { holdIncludedServices } from "./included-services.js";
 import { selectDefaultModelSelection, withNewBotEffort } from "./default-model-selection.js";
 import { cancelPeerApprovalsFor, cancelPeerApprovalsForThread, dismissStalePeerCards, peerApprovalFailure, requestPeerApproval, resolvePeerComms } from "./peer-approval.js";
 import { peerDeliveryReceipt } from "./peer-delivery.js";
@@ -107,16 +114,18 @@ import { peerProvenanceNote, withPeerProvenance } from "./peer-provenance.js";
 import { decideRoomPost, emptyRoomPostBudget } from "./room-post-budget.js";
 import { isProjectEmoji, mentionedBots, parseConnectorTools, roomResponders, sectionKey, Store, titleFromLlm, toWireTask, } from "./store.js";
 import * as tts from "./tts/index.js";
+import { createDecider, deciderIncludedHere, deciderReady, deciderSavePatch, describeDecider } from "./decider/index.js";
+import { decideRoomResponder } from "./decider/room-routing.js";
 import { narrateTool, toUtterances } from "./tts/speech-text.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 { TurnWatchdog } from "./turn-watchdog.js";
 import { TurnResources, workspaceResource } from "./turn-resources.js";
-import { ensureWorkspace, ensureTaskWorkspace, workspaceLocationsPrompt, supportsWorkspaceFiles, updateMemory, appendMemoryLog, isMemoryTopicName, memorySystemPrompt, memorySourceLabel, searchMemoryFiles, SESSION_SEARCH_SYSTEM_PROMPT, workspaceDir, } from "./workspace.js";
-import { listMemoryTopics, readMemoryFile, readMemoryTopic, writeMemoryFile, writeMemoryTopic } from "./workspace.js";
-import { MEMORY_INDEX, MemoryStoreError, memoryCapacity, memoryOverview, openMemoryLocation, readMemoryDoc, } from "./memory-store.js";
-import { beginMemoryTurn, endMemoryTurn, flushAllMemoryJournals, flushMemoryJournal, journalMemoryDelete, journalMemoryWrite, readMemoryJournal, revertMemoryChange, } from "./memory-journal.js";
+import { IdleReleasePolicy } from "./claim-idle.js";
+import { ensureWorkspace, ensureTaskWorkspace, workspaceLocationsPrompt, supportsWorkspaceFiles, updateMemory, appendMemoryLog, memorySystemPrompt, memorySourceLabel, searchMemoryFiles, SESSION_SEARCH_SYSTEM_PROMPT, workspaceDir, } from "./workspace.js";
+import { listMemoryTopics, memoryDate, readMemoryFile, readMemoryTopic, writeMemoryFile, writeMemoryTopic } from "./workspace.js";
+import { beginMemoryTurn, endMemoryTurn, flushAllMemoryJournals, journalMemoryWrite, } from "./memory-journal.js";
 import { readSectionContext, readSections, sectionContextKey, sectionContextLabel, sectionContextSystemPrompt, writeSectionContext, SECTION_CONTEXT_MAX_BYTES, } from "./section-context.js";
 import { applyStagedSkillWrite, applySkillWriteWithReceipt, getStagedSkillWrite, installOrgSkill, installSkill, parseSkillMd, scanSkillText, listSkills, listStagedSkillWrites, isSkillName, readSkillFile, rejectStagedSkillWrite, removeSkill, setSkillEnabled, skillPackageStamps, skillsSystemPrompt, stageSkillWrite, } from "./skills.js";
 import { fetchSkillFromSource } from "./skill-fetch.js";
@@ -125,11 +134,12 @@ 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, computerPrompt, composioSystemPrompt, customMcpPrompt, CREDENTIAL_PROMPT, mentionPrompt, THREADS_PROMPT, LEARN_PROMPT, PROFILE_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, ROUTINE_PROMPT, ROUTINE_EXECUTION_PROMPT, WEBHOOK_PROMPT, resolveComputerPromptKind, } from "./system-prompt.js";
 import { readCuaConnection, readCuaUnavailableReason, gatedLocalComputer } from "./local-computer.js";
-import { discoverExistingPerBotLocalVms, localVmInventoryEntry, shouldArmLocalVmIdle, } from "./local-vm-inventory.js";
+import { discoverExistingPerBotLocalVms, discoverExistingPoolLocalVms, localVmInventoryEntry, shouldArmLocalVmIdle, } from "./local-vm-inventory.js";
 import { LocalVmIdleTimer } from "./local-vm-idle.js";
 import { LocalVmLeasePool } from "./local-vm-lease.js";
+import { LocalVmSeatPool } from "./local-vm-seat-pool.js";
 import { RepeatDetector, callKey } from "./repeat-detector.js";
 import { redactSecretsInText } from "./redact.js";
 import * as vps from "./vps-computer.js";
@@ -174,6 +184,7 @@ import { shouldMountLocalComputer } from "./local-routing.js";
 import { autoLocalVmAttachable } from "./container-computer.js";
 import { startAutoVmClaim } from "./auto-vm-claims.js";
 import { computerFreeAfterText, computerStillBusyText, 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 { parseSurface, resolveSurface, surfaceLabel, surfaceOfComputerKind, surfacePrompt } from "./surface.js";
 import { PendingTurnCancellations, ProviderTurnGenerationRegistry, RetiredTurnRegistry, guardTurnDispatch, isTurnAdmissionBlocked, isTurnEventQuarantined, } from "./turn-dispatch-guard.js";
@@ -201,6 +212,8 @@ import { json, onJsonBody, parsedBodyOf, readBody } from "./harness/http.js";
 import { ROUTES, dispatchRoutes } from "./routes/table.js";
 import { createHostedSlackRoutes } from "./routes/hosted-slack.js";
 import { createBotPresetRoutes } from "./routes/bot-presets.js";
+import { createBotMemoryRoutes } from "./routes/bot-memory.js";
+import { createDeciderRoutes } from "./routes/decider.js";
 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).
@@ -264,6 +277,35 @@ const sessions = new SessionRegistry({
     portalMembership: hostedWorkspaceConfiguration()?.portalMembership === true,
 });
 const sharedComputers = new SharedComputers(id => sessions.isLive(id));
+// OMB Cloud Pro home machine (server/cloud-home.ts, docs/cloud-pro.md). A
+// partial or invalid boot contract stops the server here, before it serves.
+const CLOUD_HOME = cloudHomeConfiguration();
+/** Lending a computer to this server (the shared-computer routes, the two
+ * agent tools, the advertised capability): the maintainer flag anywhere, and
+ * always on an OMB Cloud home, where it is the person's own Mac lent to their
+ * own Cloud (docs/cloud-pro.md, "Let my Cloud use this Mac"). */
+const lendingEnabled = () => sharedComputersEnabled(cfg) || CLOUD_HOME !== null;
+/** On a Cloud home every lent computer and every turn belong to one person. */
+const CLOUD_HOME_LENDER = "cloud-home";
+/** Routines whose instructions the Cloud home's owner wrote, and manual runs
+ * the owner started: the only routine turns that may use a lent Mac. */
+const cloudRoutineAuthors = CLOUD_HOME ? createCloudRoutineAuthors(join(DATA_DIR, "lending-routines.json")) : null;
+const ownerStartedRoutineRuns = new Set();
+const cloudPairing = CLOUD_HOME ? createCloudPairing({ secret: CLOUD_HOME.bootstrapSecret, sessions }) : null;
+if (CLOUD_HOME) {
+    // The signing secret is held in memory from here on, and a platform
+    // gateway's settings are dropped: no engine or tool this server starts
+    // inherits either. The person's own engines are the only way to a model.
+    delete process.env.OMB_CLOUD_BOOTSTRAP_SECRET;
+    for (const key of CLOUD_IGNORED_KEYS)
+        delete process.env[key];
+    console.log(`cloud home ${CLOUD_HOME.machineId}: bots run on the engines the person signs in to here`);
+    for (const warning of CLOUD_HOME.warnings)
+        console.warn(`cloud home: ${warning}`);
+}
+// Cloud Pro's included Boat, voice and decision relay tokens, when the Admin
+// set them: held in memory from here on, like the signing secret.
+holdIncludedServices();
 // Who each thread is for, when a signed-in person can be named (server-private).
 const threadStarters = new ThreadStarters(join(DATA_DIR, "thread-starters.json"));
 const commandAllowlist = new CommandAllowlistStore(join(DATA_DIR, "command-allowlist.json"));
@@ -319,6 +361,9 @@ bindThreadLogCapProvider(() => threadEventLogMaxBytes(cfg));
 // The decision log keeps month files for at least this many days. Read per
 // prune, so a Settings change applies at the next one without a restart.
 bindDecisionRetention(() => decisionRetentionDays(cfg.decisions?.retentionDays));
+// The decision model (server/decider): reads cfg per call, so a Settings
+// save applies to the next decision. It never throws into a turn.
+const decider = createDecider({ config: () => cfg, dataDir: DATA_DIR });
 const customDomainVerifier = createCustomDomainVerifier({ environmentId: ENVIRONMENT_ID });
 // "Sign in with your email" on /pair: the allow-list is read per call so a
 // Settings change or an env bootstrap applies without a restart.
@@ -416,6 +461,74 @@ function threadPersonKey(threadId) {
         : thread.findLast((message) => message.role === "user");
     return linePersonKey(request) ?? threadStarters.get(threadId);
 }
+/** The person whose lent computers this bot turn may use, or null.
+ * Fail closed: only the person whose own message the harness proved started
+ * this exact turn generation (continuations of that same request keep it).
+ * A routine, a webhook, a room, a bot's delegated or peer turn, the owner on
+ * this machine (who lends nothing to itself) and anything unprovable act for
+ * nobody here. Deliberately not the usage ledger's trigger, which defaults to
+ * the owner. */
+function sharedComputerPrincipal(capability) {
+    // A Cloud home lends the owner's Mac only to turns that provably act for
+    // the owner (server/cloud-lending.ts): their own conversation from one of
+    // their devices, or a routine they wrote. Never a guest, a webhook, a room
+    // or a line someone else slipped in.
+    if (CLOUD_HOME)
+        return cloudHomeLendingRefusal(cloudLendingTurn(capability)) === null ? CLOUD_HOME_LENDER : null;
+    return provenRequestPerson(directRequestOwners.get(capability.threadId), capability.generation, (messageId) => linePersonKey(store.messagesFor(capability.threadId).find((message) => message.id === messageId)));
+}
+/** What the lending rule needs to know about one bot turn on a Cloud home. */
+function cloudLendingTurn(capability) {
+    return {
+        request: directRequestOwners.get(capability.threadId),
+        generation: capability.generation,
+        thread: store.messagesFor(capability.threadId),
+        ownerPerson: cloudOwnerPerson,
+        cardAnswerer: cloudCardAnswerer,
+        routineRun: () => {
+            const run = activeRoutineRunForThread(capability.threadId);
+            if (!run || run.threadId !== capability.threadId || store.taskByThread(capability.botId, capability.threadId)?.routineRunId !== run.id)
+                return null;
+            return {
+                triggerSource: run.triggerSource ?? (run.manual ? "manual" : "schedule"),
+                ownerStarted: ownerStartedRoutineRuns.has(run.id),
+                // What the run snapshotted, on the schedule its routine has now.
+                ownerAuthored: ((routine) => Boolean(routine) && cloudRoutineAuthors?.authored(run.routineId, {
+                    ...routine, prompt: run.prompt, target: run.target, botId: run.botId, groupId: run.groupId, attachments: run.attachments, runOn: run.runOn,
+                }) === true)(routines?.listRoutines().find((candidate) => candidate.id === run.routineId)),
+            };
+        },
+    };
+}
+/** What a bot on a Cloud home is told when its conversation cannot use the
+ * owner's lent Mac because someone else wrote in it. The bot relays it. */
+const LENDING_SOMEONE_ELSE = "Someone else wrote in this conversation, so it can't use your Mac. Start a new conversation to use it.";
+/** Whose lent computers a status reader may see: on a Cloud home, only the
+ * owner's own devices (admin sessions) see the lent Mac, never a guest or a
+ * local process; elsewhere, the person behind the asking session. */
+function sessionLendingPrincipal(auth) {
+    if (CLOUD_HOME)
+        return cloudOwnerSession(auth) ? CLOUD_HOME_LENDER : null;
+    return auth.kind === "session" ? personKey(auth.session) : null;
+}
+/** On a Cloud home: a request from one of the owner's own devices. The
+ * Admin's signed pairing gives the desktop an admin session; a guest the
+ * owner pairs with chat-only access has client scope. Loopback is not the
+ * owner here: nothing the person does reaches a Cloud home that way, only
+ * processes on the machine (a bot's shell) do. */
+function cloudOwnerSession(auth) {
+    return auth.kind === "session" && auth.scopes.includes("admin");
+}
+/** On a Cloud home: whether a message's person key is one of the owner's own
+ * devices right now (a live admin session with that key). */
+function cloudOwnerPerson(person) {
+    return Boolean(person) && sessions.list().some((session) => session.scopes.includes("admin") && personKey(session) === person);
+}
+/** On a Cloud home, a session that is not one of the owner's own devices may
+ * not answer a card of any kind. */
+function cloudCardRefusal(auth) {
+    return auth.scopes.includes("admin") ? null : "Only the owner of this Cloud can answer this card.";
+}
 /** Whose session may answer a card. The provider CLI's own approval modes and
  * the harness's proposals stay exactly as they are; this adds no card, gate
  * or prompt, it only decides whose answer to an existing card counts.
@@ -432,6 +545,11 @@ function cardAnswerRefusal(auth, threadId, requestId, behavior) {
             ? "A local service can only decline this request. Approve or answer it in OpenMausBot while signed in."
             : null;
     }
+    // A Cloud home is one person's: a device paired with chat-only access (a
+    // guest) may read along but never answer, or its words would reach the
+    // owner's turn, and through it a lent Mac (docs/cloud-pro.md).
+    if (CLOUD_HOME)
+        return cloudCardRefusal(auth);
     if (auth.scopes.includes("admin") || !sharedMembership())
         return null;
     const known = [threadStarters.get(threadId), cardRequesterKey(threadId, requestId)].filter((person) => Boolean(person));
@@ -475,7 +593,19 @@ function decisionActorFor(auth) {
 function cardAnswererFor(auth) {
     if (auth.kind === "loopback")
         return auth.trust === "service" ? { kind: "worker" } : { kind: "loopback" };
-    return { kind: "session", name: (auth.session.email ?? auth.session.label ?? "").trim() || "Signed-in user" };
+    return { kind: "session", name: (auth.session.email ?? auth.session.label ?? "").trim() || "Signed-in user",
+        ...(CLOUD_HOME ? { person: personKey(auth.session) } : {}) };
+}
+/** On a Cloud home, who is answering a card right now, by request id: the
+ * answer reaches the turn before `answeredBy` is written, and a lending turn
+ * must know whose words it just received (server/cloud-lending.ts). */
+const cloudCardAnswersInFlight = new Map();
+/** The person who answered a card, as far as lending on a Cloud home is
+ * concerned: the recorded answerer, else whoever is answering it now. */
+function cloudCardAnswerer(card) {
+    if (card.answeredBy)
+        return card.answeredBy.kind === "session" ? card.answeredBy.person : undefined;
+    return card.requestId ? cloudCardAnswersInFlight.get(card.requestId) : undefined;
 }
 /** Answer a card as `auth`: the decision rows written meanwhile name the
  * answerer, and a card this answer settled records who settled it. A card
@@ -485,6 +615,8 @@ async function answeringCardAs(auth, threadId, requestId, work) {
         const card = store.messagesFor(threadId).find((message) => message.card?.requestId === requestId)?.card;
         return Boolean(card && !card.answered && !card.dismissed && !card.expired);
     })();
+    if (CLOUD_HOME && open)
+        cloudCardAnswersInFlight.set(requestId, auth.kind === "session" ? personKey(auth.session) : undefined);
     try {
         await withDecisionActor(decisionActorFor(auth), work);
     }
@@ -494,6 +626,8 @@ async function answeringCardAs(auth, threadId, requestId, work) {
         if (message && card && !card.answeredBy && card.answered !== "unavailable" && (card.answered || card.dismissed)) {
             store.patchMessage(threadId, message.id, { card: { ...card, answeredBy: cardAnswererFor(auth) } });
         }
+        if (CLOUD_HOME && open)
+            cloudCardAnswersInFlight.delete(requestId);
     }
 }
 // ── bot visibility (server/bot-visibility.ts) ──────────────────────────
@@ -617,6 +751,56 @@ function recentWorkSources(bot) {
         taskByThread: (botId, threadId) => store.taskByThread(botId, threadId),
     };
 }
+/** The automatic-recall block for a turn (server/recall.ts), or "". Notes
+ * always; the bot's other conversations only when `conversations` — a 1:1
+ * turn the person started — because a message from another bot, a webhook
+ * or a room must not be able to pull a private chat into its reply. The
+ * conversations are the ones session_search would search, minus this one. */
+function autoRecallPrompt(bot, threadId, message, opts) {
+    if (!autoRecallEnabled(cfg))
+        return "";
+    const roomByThread = new Map();
+    if (opts.conversations) {
+        for (const group of store.groups) {
+            if (!group.memberIds.includes(bot.id) || !roomFeedsBot(group, bot))
+                continue;
+            roomByThread.set(group.threadId, group);
+            for (const task of group.tasks ?? [])
+                roomByThread.set(task.threadId, group);
+        }
+    }
+    const threadIds = opts.conversations
+        ? [...new Set([bot.threadId, ...(bot.tasks ?? []).map((task) => task.threadId), ...roomByThread.keys()])].filter((id) => id !== threadId)
+        : [];
+    try {
+        const recalled = buildRecall({
+            botId: bot.id,
+            message,
+            threadIds,
+            label: (id) => {
+                const room = roomByThread.get(id);
+                if (room)
+                    return `room ${JSON.stringify(room.name)}`;
+                const task = store.taskByThread(bot.id, id);
+                if (task)
+                    return `chat ${JSON.stringify(task.title)}`;
+                return id === bot.threadId ? "your main chat" : "an earlier chat";
+            },
+            author: (hit) => (hit.role === "user" ? hit.peer ?? opts.userName : hit.from ?? bot.name),
+        });
+        if (recalled)
+            console.log(`auto-recall: ${bot.name} (${bot.id}) got ${recalled.notes} note and ${recalled.conversations} conversation passage(s) in ${threadId}`);
+        return recalled?.text ?? "";
+    }
+    catch (err) {
+        console.warn(`auto-recall failed for ${bot.id}: ${err.message}`);
+        return "";
+    }
+}
+/** The recalled block in front of a turn's message, or the message alone. */
+function withRecalled(recalled, text) {
+    return recalled ? `${recalled}\n\n${text}` : text;
+}
 /** Bots in one room must be visible to the same people: a room is one
  * transcript, so otherwise a restricted bot's words would feed a teammate
  * everyone can see. Refuse a roster that adds such a bot (existing members
@@ -699,7 +883,7 @@ function adminAuditPlan(method, path) {
     if (path.startsWith("/api/internal/") || path.startsWith("/api/testing/"))
         return null;
     const plan = {
-        config: requiredScope(method, path, { sharedComputers: sharedComputersEnabled(cfg) }) === "admin",
+        config: requiredScope(method, path, { sharedComputers: lendingEnabled() }) === "admin",
         createsBots: method === "POST" && (path === "/api/bots" || path === "/api/teams/import" || path === "/api/org-library/add"),
         createsWebhook: method === "POST" && path === "/api/webhooks",
         pairing: method === "POST" && path === "/api/auth/pairing",
@@ -874,15 +1058,17 @@ function operatorPrices() {
  * engine reported tokens but no price, and let the spend cap see it at once.
  * The first booking that takes the month past the warning threshold, or to
  * the cap, notifies admins (once per month each; server/spend.ts). */
-function bookTurnUsage(row) {
-    const booked = { ...row, ...ledgerCost(row, operatorPrices()), at: new Date().toISOString() };
+function bookTurnUsage(row, tokensReported = true, notificationThreadId = row.threadId) {
+    // Missing helper usage is unpriced, not an estimated zero-dollar call.
+    const cost = tokensReported || row.costUsd !== null ? ledgerCost(row, operatorPrices()) : { costUsd: null };
+    const booked = { ...row, ...cost, at: new Date().toISOString() };
     // The append lands asynchronously; the cap counts the row from memory
     // until it does, so the check below (and the next turn start) sees it.
     noteSpend(DATA_DIR, booked, appendUsage(DATA_DIR, booked));
     const state = spendState(cfg, DATA_DIR);
     const alert = takeSpendAlert(DATA_DIR, state);
     if (alert && state) {
-        broadcast({ kind: "notify", notification: buildSpendNotification({ id: row.botId, name: row.botName }, row.threadId, spendAlertText(alert, state)) }, { adminOnly: true });
+        broadcast({ kind: "notify", notification: buildSpendNotification({ id: row.botId, name: row.botName }, notificationThreadId, spendAlertText(alert, state)) }, { adminOnly: true });
     }
 }
 /** A queued line from before triggers were stored with it: its sender, else
@@ -994,6 +1180,18 @@ const companyRuntimeStarted = new Promise(resolve => { companyRuntimeReady = res
 /** The enrolled organisation's desktop policy: in memory only, read-only, and
  * inert (null) unless Electron's enrolled parent sends one. */
 const managedPolicy = new ManagedDesktopPolicy({ onChange: () => broadcast({ kind: "config", ...configStatus() }) });
+/** A computer kind this server will not use, refused before anything is
+ * prepared: a Cloud home never offers this computer or a Local VM
+ * (cloud-home.ts), and an enrolled organisation may disallow any kind. */
+function computerPlaceRefusal(kind) {
+    const cloudHome = CLOUD_HOME ? cloudHomePlaceRefusal(kind === "thisComputer" ? "local" : kind === "localVm" ? "vm" : "cloud") : undefined;
+    if (cloudHome)
+        return { message: cloudHome, code: "cloud_home" };
+    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;
@@ -1278,7 +1476,10 @@ function agentsIntegration(botId, threadId, depth, skillAuthoring, generation, r
             OMB_SKILL_AUTHORING_ENABLED: skillAuthoring ? "1" : "0",
             // The shared-computer tools are advertised only while the workspace
             // gate is on; the routes behind them refuse regardless.
-            OMB_SHARED_COMPUTERS_ENABLED: sharedComputersEnabled(cfg) ? "1" : "0",
+            OMB_SHARED_COMPUTERS_ENABLED: lendingEnabled() ? "1" : "0",
+            // A Cloud home offers no this computer and no Local VM (cloud-home.ts),
+            // so select_computer lists neither and vm_exec is not shown.
+            OMB_CLOUD_HOME: CLOUD_HOME ? "1" : "0",
             // Same capability rule for voice: the tool is offered only when this
             // bot can actually speak, and the route re-checks on every call.
             OMB_VOICE_NOTES: (() => {
@@ -1352,12 +1553,164 @@ const turnResourceOwners = new Map();
 const turnComputerResources = 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. */
+const COMPUTER_CLAIM_IDLE_POLICY = new IdleReleasePolicy();
+function computerClaimIdlePolicy(resource) {
+    return resource.startsWith("computer:") && 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) {
-    if (!turnResources.claim(resource, owner))
+    const idle = computerClaimIdlePolicy(resource);
+    if (!turnResources.claim(resource, owner, idle ? { idle } : {}))
         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;
@@ -1377,11 +1730,11 @@ function releaseTurnResources(owner) {
     }
 }
 async function bindTurnComputer(owner, resource, exclusive = false) {
-    // Every computer claim passes here: a kind the organisation disallows is
-    // refused at claim time, whichever path selected it.
-    const kind = computerKindForResource(resource), refusal = kind && managedPolicy.computerRefusal(kind);
+    // Every computer claim passes here: a kind the organisation disallows, or a
+    // Cloud home never offers, is refused at claim time, whichever path selected it.
+    const kind = computerKindForResource(resource), refusal = kind && computerPlaceRefusal(kind);
     if (refusal)
-        throw Object.assign(new Error(refusal), { code: "managed_policy" });
+        throw Object.assign(new Error(refusal.message), { code: refusal.code });
     const active = () => activeInternalGenerationByThread.get(owner.threadId) === owner.generation &&
         turnResourceOwners.get(owner.threadId)?.generation === owner.generation;
     let waitingMessage;
@@ -1395,6 +1748,10 @@ 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;
@@ -1460,7 +1817,32 @@ async function bindTurnComputer(owner, resource, exclusive = false) {
                     resource,
                     ...(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) {
                 endWait("gave_up");
                 throw new ComputerWaitGaveUp(computerStillBusyText(holder, GROUP_GOAL_WAIT_MAX_MS));
@@ -1857,8 +2239,9 @@ const routineRequestEnvelopeSchema = z.discriminatedUnion("action", [
         action: z.literal("update"),
         routineId: z.unknown(),
         changes: z.unknown(),
+        forBotId: z.unknown().optional(),
     }).strict(),
-    ...["pause", "resume", "run_now", "delete"].map((action) => z.object({ ...routineRequestSourceSchema, action: z.literal(action), routineId: z.unknown() }).strict()),
+    ...["pause", "resume", "run_now", "delete"].map((action) => z.object({ ...routineRequestSourceSchema, action: z.literal(action), routineId: z.unknown(), forBotId: z.unknown().optional() }).strict()),
 ]);
 /** The loopback endpoint a bot's computer proxy polls before acting. */
 function controlIntegration(botId, threadId, generation, localVmTarget) {
@@ -2208,6 +2591,13 @@ function checkedGroupResponder(value, memberIds) {
         return { kind: "everyone" };
     if (responder.kind === "mentions")
         return { kind: "mentions" };
+    if (responder.kind === "auto") {
+        if (responder.fallbackBotId === undefined || responder.fallbackBotId === null)
+            return { kind: "auto" };
+        return typeof responder.fallbackBotId === "string" && memberIds.includes(responder.fallbackBotId)
+            ? { kind: "auto", fallbackBotId: responder.fallbackBotId }
+            : null;
+    }
     if (responder.kind === "member" &&
         typeof responder.botId === "string" &&
         memberIds.includes(responder.botId)) {
@@ -2363,7 +2753,8 @@ function previewSystemPrompt(bot) {
         { id: "plan", label: "Surface", text: previewPlan.computer === undefined ? "" : surfacePrompt({
                 computer: previewPlan.computer && previewPlan.computer !== "off" && computerPromptKind ? previewPlan.computer : null,
                 browser: previewPlan.computer === undefined ? false : previewPlan.browser,
-            }, { note: previewPlan.note }) },
+            }, { note: previewPlan.note, cloudHome: Boolean(CLOUD_HOME) }) },
+        { id: "cloud-home", label: "OMB Cloud", text: CLOUD_HOME ? cloudHomePrompt(agentsMounted && lendingEnabled()) : "" },
         { id: "composio", label: "Connected apps", text: caps?.composioMcp && bot.composio !== false && composio.configured(cfg) ? composioSystemPrompt(bot.connectorTools) : "" },
         { 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 : "" },
@@ -2445,6 +2836,7 @@ async function botOverview(bot) {
         })),
         engine,
         browserEnabled: builtInBrowserEnabled(cfg),
+        cloudHome: Boolean(CLOUD_HOME),
         connectedApps,
         sectionPeers,
         timeZone,
@@ -3019,7 +3411,9 @@ function createChannel(value) {
             throw Object.assign(new Error("invalid setup.defaultResponder"), { status: 400 });
         setup = { bulletin: requested.bulletin, defaultResponder: responder, completed: true };
     }
-    return store.createGroup(name, memberIds, false, section, setup);
+    // A new room with no routing of its own starts on Auto while the decision
+    // model is on for rooms; otherwise it gets today's default (first member).
+    return store.createGroup(name, memberIds, false, section, setup ?? (deciderReady(cfg, "roomRouting") ? { defaultResponder: { kind: "auto" } } : undefined));
 }
 function updateChannel(groupId, value) {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -4209,6 +4603,10 @@ function notify(notification) {
 // Group threads: the fold needs to know WHO is talking — the turn engine
 // records the active member here before dispatching its turn.
 const groupSpeakers = new Map();
+/** Auto-room rounds the decision model routed, by thread: the named
+ * speaker's next reply line carries `routedBy` (stamped in the runtime fold
+ * below), so the room can say "Picked by Jev". Only a routed round sets it. */
+const routedRoomReplies = new Map();
 // The latest running token totals for the turn in flight on each thread.
 // Providers report cumulative-within-turn numbers; the final value is folded
 // into the task's tally when the turn settles.
@@ -4380,6 +4778,89 @@ bus.subscribe((event) => {
             memoryRowsByThread.delete(event.threadId);
     }
 });
+// Memory upkeep (server/memory-upkeep.ts): background capture, About me
+// suggestions and the nightly tidy-up, for bots with the switch on.
+const memoryUpkeep = createMemoryUpkeep({
+    bots: () => store.bots,
+    bot: (id) => store.bot(id) ?? undefined,
+    engine: (botId) => {
+        const bot = store.bot(botId);
+        const instance = bot ? registry.get(bot.modelSelection.instanceId) : undefined;
+        // an engine the organisation disallows never receives memory text
+        if (!bot || !instance || policyModelRefusal(instance))
+            return null;
+        const generate = instance.generateText?.bind(instance);
+        return generate ? {
+            generateText: async (prompt, options) => {
+                // Check every capture, organize and contradiction call, including
+                // consecutive calls within one upkeep pass.
+                assertWithinBudget(cfg, DATA_DIR);
+                const threadId = `memory-${randomUUID()}`;
+                return generate(prompt, { ...options, onUsage: (usage) => bookTurnUsage({
+                        botId: bot.id,
+                        botName: bot.name,
+                        threadId,
+                        instanceId: instance.instanceId,
+                        driverKind: instance.driverKind,
+                        model: usage.model,
+                        input: usage.input ?? 0,
+                        output: usage.output ?? 0,
+                        ...(usage.cachedInput !== undefined ? { cachedInput: usage.cachedInput } : {}),
+                        costUsd: usage.costUsd ?? null,
+                        trigger: { kind: "bot", botId: bot.id },
+                    }, usage.input !== undefined && usage.output !== undefined, bot.threadId) });
+            },
+        } : {};
+    },
+    busy: (botId) => botHasActiveTurn(botId),
+    addToAboutMe: (from, texts) => {
+        const current = cfg.profile?.aboutMe ?? "";
+        const facts = planLearned(from, texts, current, memoryDate());
+        const next = appendAboutMe(current, facts.map((fact) => fact.line));
+        // a full About me takes nothing more; the person trims it first
+        if (!facts.length || next === null)
+            return 0;
+        saveConfig({ profile: { ...cfg.profile, aboutMe: next } });
+        Object.assign(cfg, loadConfig());
+        commitLearned(facts);
+        broadcast({ kind: "config", ...configStatus() });
+        return facts.length;
+    },
+    sourceLabel: (botId, threadId) => memorySourceLabel({ task: store.taskByThread(botId, threadId), threadId }),
+    quietMs: () => captureQuietMs(cfg),
+    tidyHour: () => tidyHour(cfg),
+    log: (line) => console.log(line),
+});
+// A finished 1:1 turn of an upkeep bot waits for capture. Only the person's
+// own conversation: not a room, not a turn another bot or the harness
+// started (its "user" line is not the person), not a failed turn.
+bus.subscribe((event) => {
+    if (shouldIgnoreProviderEvent(event))
+        return;
+    if (event.type !== "turn.completed" || !event.turnId || !event.ok)
+        return;
+    try {
+        const bot = store.botByThread(event.threadId);
+        if (!bot || !upkeepEnabled(bot) || store.groupByThread(event.threadId) || isInternalTurn(event.threadId)
+            || isUnattended(bot.id, event.threadId) || routines?.runForThread(event.threadId))
+            return;
+        const path = store.activePath(event.threadId);
+        const replyAt = path.findLastIndex((message) => message.role === "bot" && message.kind === "text" && message.turnId === event.turnId);
+        if (replyAt < 0)
+            return;
+        const asked = path.slice(0, replyAt).findLast((message) => message.role === "user" && message.kind === "text");
+        if (!asked || asked.peerAsk)
+            return;
+        memoryUpkeep.noteTurn(bot.id, event.threadId, {
+            person: extractTurnImages(asked.text ?? "").text,
+            bot: path[replyAt].text ?? "",
+            owner: !asked.sender,
+        });
+    }
+    catch (error) {
+        console.warn(`memory upkeep: could not queue a turn for capture: ${error.message}`);
+    }
+});
 // One line per finished turn in the bot's daily log (server/recent-work.ts):
 // what it said last, the tools it used, whether the turn failed. What a bot
 // did in one conversation was invisible from every other; the log is where
@@ -4550,12 +5031,7 @@ async function scheduleTurnDigest(input) {
         const controller = new AbortController();
         let timer;
         const capture = async () => {
-            const after = await checkpoints.snapshot(input.botId, checkpoint.cwd, `settle ${input.threadId.slice(0, 8)}`, controller.signal);
-            if (!after || controller.signal.aborted)
-                return null;
-            if (checkpoint.hash === after)
-                return { changed: [], added: [], deleted: [] };
-            return checkpoints.diffStat(input.botId, checkpoint.cwd, checkpoint.hash, after, controller.signal);
+            return checkpoints.diffWorkingTree(input.botId, checkpoint.cwd, checkpoint.hash, controller.signal);
         };
         let files;
         try {
@@ -4652,6 +5128,11 @@ let routines = null;
 let calendarCalls = null;
 const localVmOwnerBusy = (botId) => store.bot(botId)?.busy === true;
 const localVmLeases = new LocalVmLeasePool(30 * 60_000);
+// Pool mode (issue #1654) keeps the lease pool as the ownership fence and
+// uses this table only to decide WHICH seat a conversation addresses: a
+// TTL-bounded affinity returns each thread to the desktop holding its login
+// state, and hands the seat back once the conversation has been idle.
+const localVmSeatPool = new LocalVmSeatPool(() => localVmMaxInstances(cfg));
 const localVmLifecycleBusy = new Set();
 const localVmThreadTargets = new Map();
 const localVmActiveThreads = new Map();
@@ -4695,12 +5176,12 @@ function vpsThreadEnded(botId, threadId) {
     if (!threads.size)
         activeVpsThreads.delete(botId);
 }
-const boxLifecycleBusyBots = new Set();
+const boatLifecycleBusyBots = new Set();
 // A refresh is a reader, not a lifecycle change. Keep its reservation until
 // the provider settles even if the HTTP client leaves, and share it on retry.
 const vpsPreviewRequests = new Map();
-const orphanBoxLifecycleBusyIds = new Set();
-const boxInventoryRequestsBusyIds = new Set();
+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.
@@ -4715,7 +5196,7 @@ function inheritedTeamComputer(bot) {
     return teamComputers.forBot(bot);
 }
 function teamComputerPrompt(computer) {
-    return computer ? `Your team shares the Box 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 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.` : "";
 }
 function botComputerControlKey(bot) {
     const computer = inheritedTeamComputer(bot);
@@ -4767,6 +5248,10 @@ async function computerCallGate(internalCapability) {
         };
     }
     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 {
@@ -4807,13 +5292,13 @@ function assertTeamComputerChangeIdle(before, after) {
     if (previous?.id === next?.id)
         return;
     if (botHasActiveTurn(before.id) || routines?.activeRunForBot(before.id) || botComputerControlSnapshot(before.id).held ||
-        [previous, next].some(computer => computer && (teamComputerInUse(computer) || boxLifecycleBusyBots.has(teamComputerOwner(computer.id))))) {
+        [previous, next].some(computer => computer && (teamComputerInUse(computer) || boatLifecycleBusyBots.has(teamComputerOwner(computer.id))))) {
         throw Object.assign(new Error("Stop the affected team's work and release computer control before changing its computer access"), { status: 409 });
     }
 }
 async function teamComputersPayload() {
     const entries = teamComputers.list();
-    const inventory = await box.listManagedBoxes(cfg, managedBoxOwners());
+    const inventory = await boat.listManagedBoats(cfg, managedBoatOwners());
     return {
         configured: inventory.configured,
         ...(inventory.problem ? { problem: inventory.problem } : {}),
@@ -4822,42 +5307,42 @@ async function teamComputersPayload() {
             return {
                 id: entry.id, name: entry.name, section: entry.section,
                 held: computerControl.snapshot(teamComputerOwner(entry.id)).held,
-                state: boxLifecycleBusyBots.has(teamComputerOwner(entry.id)) ? "working" : machine?.state ?? (inventory.available ? "missing" : "unavailable"),
+                state: boatLifecycleBusyBots.has(teamComputerOwner(entry.id)) ? "working" : machine?.state ?? (inventory.available ? "missing" : "unavailable"),
                 ...(entry.problem || inventory.problem ? { problem: entry.problem || inventory.problem } : {}),
             };
         }),
     };
 }
-/** The same named Box identity and whole-turn lease in chats and rooms.
+/** The same named Boat identity and whole-turn lease in chats and rooms.
  * Assignment authorizes waking, never replacing a missing paid machine. */
-async function attachTeamBox(computer, botId, owner, canMount, remoteAgent) {
+async function attachTeamBoat(computer, botId, owner, canMount, remoteAgent) {
     if (!canMount)
-        throw new Error("This model engine cannot use the team's Box computer; choose an engine with computer tools or an explicit bot destination");
-    if (!box.boxConfigured(cfg))
-        throw new Error("The team's Box account is not configured; reconnect it in Settings");
+        throw new Error("This model engine cannot use the team's Boat computer; choose an engine 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);
-    if (boxLifecycleBusyBots.has(ownerId))
+    if (boatLifecycleBusyBots.has(ownerId))
         throw new Error("The team computer is being changed; wait for it to finish");
     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 });
-    let machine = await box.findBox(cfg, ownerId);
+    let machine = await boat.findBoat(cfg, ownerId);
     if (!machine)
-        throw new Error("The team's Box computer is missing; explicitly create or retry it from the Team map");
+        throw new Error("The team's Boat computer is missing; explicitly create or retry it from the Team map");
     await bindTurnComputer(owner, `computer:box:${machine.id}`, true);
-    const action = box.boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null });
+    const action = boat.boatTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null });
     if (action === "wake")
-        machine = await box.readyBox(cfg, ownerId);
-    if (!machine || box.boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null }) !== "attach") {
+        machine = await boat.readyBoat(cfg, ownerId);
+    if (!machine || boat.boatTurnLifecycleAction({ explicitCloud: true, canMount: true, state: 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 {
-        integration: { kind: "box", boxId: machine.id, token: cfg.box.token, control: controlIntegration(botId, owner.threadId, owner.generation) },
-        capture: () => box.screenshotBox(cfg, ownerId, machine.id),
+        integration: { kind: "box", boxId: machine.id, token: boat.boatAccount(cfg)?.token ?? "", control: controlIntegration(botId, owner.threadId, owner.generation) },
+        capture: () => boat.screenshotBoat(cfg, ownerId, machine.id),
     };
 }
 /** "Works on: This computer", strict. One mount for a bot thread and a group
@@ -4916,17 +5401,17 @@ async function mountBotVps(bot, owner, opts) {
         },
     };
 }
-/** The bot's own Box. Explicit Cloud is the consent boundary: it may create a
+/** 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 attachBotBox(bot, owner, opts) {
-    // Explicit cloud turns can provision/wake the same bot's Box. Claim before
+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 box.findBox(cfg, bot.id);
+        b = await boat.findBoat(cfg, bot.id);
     }
     catch (error) {
         // Auto may fall through when an optional provider is offline, but a
@@ -4935,7 +5420,7 @@ async function attachBotBox(bot, owner, opts) {
             throw error;
         b = null;
     }
-    const lifecycleOf = (explicitCloud) => box.boxTurnLifecycleAction({
+    const lifecycleOf = (explicitCloud) => boat.boatTurnLifecycleAction({
         explicitCloud,
         canMount: opts.canMount,
         state: typeof b?.state === "string" ? b.state : null,
@@ -4943,16 +5428,16 @@ async function attachBotBox(bot, owner, opts) {
     let lifecycle = lifecycleOf(opts.explicitCloud);
     if (lifecycle === "provision") {
         broadcast({ kind: "computer", botId: bot.id, state: "provisioning" });
-        await box.provisionBox(cfg, bot.id, bot.name);
-        b = await box.findBox(cfg, bot.id);
+        await boat.provisionBoat(cfg, bot.id, bot.name);
+        b = await boat.findBoat(cfg, bot.id);
         lifecycle = lifecycleOf(true);
     }
-    // an archived box answers every action with an error until it resumes —
+    // 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" });
-        b = (await box.readyBox(cfg, bot.id)) ?? b;
+        b = (await boat.readyBoat(cfg, bot.id)) ?? b;
         lifecycle = lifecycleOf(true);
     }
     if (!b || lifecycle !== "attach")
@@ -4960,19 +5445,19 @@ async function attachBotBox(bot, owner, opts) {
     const machine = b;
     await bindTurnComputer(owner, `computer:box:${machine.id}`, opts.remoteAgent);
     return {
-        capture: () => box.screenshotBox(cfg, bot.id, machine.id),
+        capture: () => boat.screenshotBoat(cfg, bot.id, machine.id),
         integration: opts.canMount
-            ? { kind: "box", boxId: machine.id, token: cfg.box.token, control: controlIntegration(bot.id, owner.threadId, owner.generation) }
+            ? { kind: "box", boxId: machine.id, token: boat.boatAccount(cfg)?.token ?? "", control: controlIntegration(bot.id, owner.threadId, owner.generation) }
             : null,
     };
 }
-function managedBoxOwners() {
+function managedBoatOwners() {
     return [...store.bots.map((bot) => ({
             botId: bot.id,
             name: bot.name,
             // A machine is not safe to mutate while any app-level work or human
             // control lease still names its owner. This is deliberately conservative
-            // across destination changes: an old Box may still contain valuable state.
+            // across destination changes: an old Boat may still contain valuable state.
             inUse: bot.busy === true ||
                 hasDirectDispatch(bot.id) ||
                 activeGroupTurnForBot(bot.id) !== null ||
@@ -4991,7 +5476,7 @@ function botHasActiveTurn(botId) {
 }
 function providerTransitionMessage(provider) {
     return provider === "box"
-        ? "Box account settings are being updated — wait for them to finish"
+        ? "Boat account settings are being updated — wait for them to finish"
         : "VPS connection settings are being updated — wait for them to finish";
 }
 /** Work which started first wins. This is intentionally conservative: a
@@ -5001,19 +5486,19 @@ function providerOperationConflict(provider) {
     if (provider === "vps" && activeVpsThreads.size > 0) {
         return "stop the active VPS turn before changing the SSH config alias";
     }
-    if (managedBoxOwners().some((owner) => owner.inUse)) {
-        return `stop active bot work and computer control before changing ${provider === "box" ? "the Box account" : "the VPS connection"}`;
+    if (managedBoatOwners().some((owner) => owner.inUse)) {
+        return `stop active bot work and computer control before changing ${provider === "box" ? "the Boat account" : "the VPS connection"}`;
     }
-    if (boxLifecycleBusyBots.size > 0 || vpsPreviewRequests.size > 0) {
+    if (boatLifecycleBusyBots.size > 0 || vpsPreviewRequests.size > 0) {
         return "wait for cloud computer actions to finish before changing provider settings";
     }
     if (provider === "box") {
-        if (boxInventoryRequestsBusyIds.size > 0 || orphanBoxLifecycleBusyIds.size > 0) {
-            return "wait for cloud computer actions to finish before changing the Box account";
+        if (boatInventoryRequestsBusyIds.size > 0 || orphanBoatLifecycleBusyIds.size > 0) {
+            return "wait for cloud computer actions to finish before changing the Boat account";
         }
-        const deletingBoxIds = new Set(boxDeletionSnapshot().map((entry) => entry.boxId));
-        if (boxCreateRecoverySnapshot().some((entry) => !entry.resolved && (!entry.boxId || !deletingBoxIds.has(entry.boxId)))) {
-            return "finish reconciling pending cloud computer creation before changing the Box account";
+        const deletingBoatIds = new Set(boatDeletionSnapshot().map((entry) => entry.boxId));
+        if (boatCreateRecoverySnapshot().some((entry) => !entry.resolved && (!entry.boxId || !deletingBoatIds.has(entry.boxId)))) {
+            return "finish reconciling pending cloud computer creation before changing the Boat account";
         }
     }
     else if (vps.vpsLifecycleBusy()) {
@@ -5023,10 +5508,10 @@ function providerOperationConflict(provider) {
 }
 function turnSurfacePlan(bot, runOn, threadId) {
     const instance = registry.get(bot.modelSelection.instanceId);
-    const forcedBox = runOn === "cloud" || Boolean(inheritedTeamComputer(bot));
+    const forcedBoat = runOn === "cloud" || Boolean(inheritedTeamComputer(bot));
     return resolveSurface({
-        destination: forcedBox ? "cloud" : bot.computer,
-        pinnedSurface: forcedBox || !threadId ? null : store.taskByThread(bot.id, threadId)?.surface,
+        destination: forcedBoat ? "cloud" : bot.computer,
+        pinnedSurface: forcedBoat || !threadId ? null : store.taskByThread(bot.id, threadId)?.surface,
         browserOn: builtInBrowserEnabled(cfg) && bot.browser !== false && instance?.adapter.capabilities.browserMcp === true,
     });
 }
@@ -5040,14 +5525,14 @@ function turnProvider(bot, runOn, threadId) {
         return "box";
     return bot.cloudBackend === "vps" ? "vps" : wants === "cloud" ? "box" : null;
 }
-/** A driver with a Box bridge keeps the selected model. Other engines use
- * Box's native runner. Start and interrupt must resolve the same owner. */
+/** A driver with a Boat bridge keeps the selected model. Other engines use
+ * Boat's native runner. Start and interrupt must resolve the same owner. */
 function turnInstance(bot, runOn, threadId) {
     const selected = registry.get(bot.modelSelection.instanceId);
     if (selected?.adapter.capabilities.cloudComputerMcp)
         return selected;
-    const onBox = turnProvider(bot, runOn, threadId) === "box";
-    return onBox
+    const onBoat = turnProvider(bot, runOn, threadId) === "box";
+    return onBoat
         ? registry.instances().find((candidate) => candidate.driverKind === "boxAgent") ?? null
         : registry.get(bot.modelSelection.instanceId);
 }
@@ -5074,13 +5559,14 @@ async function computerPreviewSurface(bot, threadId) {
         if (remote.ready)
             return "cloud";
     }
-    const target = localVmTargetForBot(bot.id);
-    if (instance?.adapter.capabilities.computerMcp && localVmSeen.has(target.key)) {
+    const target = localVmTargetForStatus(bot.id, threadId);
+    // A Cloud home has neither place (cloud-home.ts), so Auto never shows one.
+    if (!CLOUD_HOME && instance?.adapter.capabilities.computerMcp && localVmSeen.has(target.key)) {
         const vm = await containerComputerStatus(undefined, undefined, target).catch(() => null);
         if (vm && autoLocalVmAttachable(vm))
             return "vm";
     }
-    if (shouldMountLocalComputer({ requested: undefined, hostPlatform: process.platform,
+    if (!CLOUD_HOME && shouldMountLocalComputer({ requested: undefined, hostPlatform: process.platform,
         providerSupportsLocal: instance?.adapter.capabilities.localComputerMcp === true }) && readCuaConnection())
         return "local";
     if (bot.cloudBackend === "vps")
@@ -5088,16 +5574,23 @@ async function computerPreviewSurface(bot, threadId) {
     return plan.browser ? "browser" : "off";
 }
 /** Discovery is read-only. Starting or creating a configured computer is
- * deferred until a chat tool selects it and the old turn releases its tools. */
+ * deferred until a chat tool selects it and the old turn releases its tools.
+ * 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 off = bot.computer === "off";
     const localEngine = caps?.remoteAgent !== true;
-    return Promise.all(["cloud", "vm", "local", "browser"].map(async (surface) => {
+    const surfaces = ["cloud", "vm", "local", "browser"].filter(surface => !CLOUD_HOME || cloudHomeOffersPlace(surface));
+    return Promise.all(surfaces.map(async (surface) => {
         let ready = false;
         let canStart = false;
         let canCreate = false;
-        let reason = "This computer is not configured or running. Open the Computer panel to set it up.";
+        // On a Cloud home "this computer" reads as the person's own; name the
+        // place the reason is about.
+        let reason = CLOUD_HOME && surface === "cloud"
+            ? "The cloud computer is not set up or running. Open the Computer panel to set it up."
+            : "This computer is not configured or running. Open the Computer panel to set it up.";
         try {
             if (off)
                 reason = "Computer access is Off in this bot's settings.";
@@ -5110,16 +5603,16 @@ async function selectableComputers(bot) {
                     canCreate = Boolean(status?.configured && status.daemonUp && status.container === "missing");
                     reason = status?.problem ?? reason;
                 }
-                else if (box.boxConfigured(cfg) && (caps?.usesCloudComputer === true || registry.instances().some(instance => instance.driverKind === "boxAgent"))) {
-                    const status = await box.boxStatus(cfg, bot.id);
-                    const lifecycle = box.boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: status.box?.state ?? null });
+                else if (boat.boatConfigured(cfg) && (caps?.usesCloudComputer === true || registry.instances().some(instance => instance.driverKind === "boxAgent"))) {
+                    const status = await boat.boatStatus(cfg, bot.id);
+                    const lifecycle = boat.boatTurnLifecycleAction({ explicitCloud: true, canMount: true, state: status.box?.state ?? null });
                     ready = lifecycle === "attach";
                     canStart = lifecycle === "wake";
                     canCreate = lifecycle === "provision";
                 }
             }
             else if (surface === "vm" && localEngine && caps?.computerMcp) {
-                const target = localVmTargetForBot(bot.id);
+                const target = localVmTargetForStatus(bot.id);
                 const status = await containerComputerStatus(undefined, undefined, target);
                 ready = status.ready;
                 canCreate = !ready && autoLocalVmAttachable(status);
@@ -5198,29 +5691,29 @@ function providerTransitionForTurn(bot, runOn, threadId) {
         ? providerTransitionMessage(provider)
         : null;
 }
-function claimBoxInventoryRequest(boxId) {
-    if (boxInventoryRequestsBusyIds.has(boxId)) {
+function claimBoatInventoryRequest(boxId) {
+    if (boatInventoryRequestsBusyIds.has(boxId)) {
         throw Object.assign(new Error("this cloud computer is being changed — wait for it to finish"), { status: 409 });
     }
-    boxInventoryRequestsBusyIds.add(boxId);
-    return () => boxInventoryRequestsBusyIds.delete(boxId);
+    boatInventoryRequestsBusyIds.add(boxId);
+    return () => boatInventoryRequestsBusyIds.delete(boxId);
 }
-/** Claim the owning bot synchronously after Box revalidation and before the
+/** Claim the owning bot synchronously after Boat revalidation and before the
  * provider mutation. startTurn checks the same set before doing any work, so
  * a new turn and an irreversible lifecycle action cannot pass each other. */
-function claimManagedBoxMutation(instance) {
+function claimManagedBoatMutation(instance) {
     const ownerBotId = instance.ownerBotId;
     const teamComputer = teamComputers.list().find(computer => teamComputerOwner(computer.id) === ownerBotId);
     if (teamComputer)
         return claimTeamComputerLifecycle(teamComputer);
     if (!ownerBotId) {
-        if (orphanBoxLifecycleBusyIds.has(instance.boxId)) {
+        if (orphanBoatLifecycleBusyIds.has(instance.boxId)) {
             throw Object.assign(new Error("this cloud computer is being changed — wait for it to finish"), { status: 409 });
         }
-        orphanBoxLifecycleBusyIds.add(instance.boxId);
-        return () => orphanBoxLifecycleBusyIds.delete(instance.boxId);
+        orphanBoatLifecycleBusyIds.add(instance.boxId);
+        return () => orphanBoatLifecycleBusyIds.delete(instance.boxId);
     }
-    const owner = managedBoxOwners().find((candidate) => candidate.botId === ownerBotId);
+    const owner = managedBoatOwners().find((candidate) => candidate.botId === ownerBotId);
     if (owner?.inUse) {
         throw Object.assign(new Error("this cloud computer is in use — stop its bot's work first"), { status: 409 });
     }
@@ -5231,20 +5724,20 @@ function claimManagedBoxMutation(instance) {
  * other instead of relying on a stale check made before a provider await.
  * Only opening an existing VPS viewer may coexist with its pending preview. */
 function claimBotComputerLifecycle(botId, allowPreview = false) {
-    if (boxLifecycleBusyBots.has(botId)) {
+    if (boatLifecycleBusyBots.has(botId)) {
         throw Object.assign(new Error("this bot's cloud computer is being changed — wait for it to finish"), { status: 409 });
     }
     if (!allowPreview && vpsPreviewRequests.has(botId)) {
         throw Object.assign(new Error("a screen preview is still refreshing — wait before changing this computer"), { status: 409 });
     }
-    boxLifecycleBusyBots.add(botId);
-    return () => boxLifecycleBusyBots.delete(botId);
+    boatLifecycleBusyBots.add(botId);
+    return () => boatLifecycleBusyBots.delete(botId);
 }
 function claimManagedVpsMutation(containerName) {
     const owner = store.bots.find((candidate) => vps.vpsContainerName(candidate.id) === containerName);
     if (!owner)
         return () => { };
-    const ownerState = managedBoxOwners().find((candidate) => candidate.botId === owner.id);
+    const ownerState = managedBoatOwners().find((candidate) => candidate.botId === owner.id);
     if (ownerState?.inUse) {
         throw Object.assign(new Error("this VPS computer is in use — stop its bot's work first"), { status: 409 });
     }
@@ -5253,6 +5746,30 @@ function claimManagedVpsMutation(containerName) {
 function localVmTargetForBot(botId) {
     return localVmMode(cfg) === "per-bot" ? perBotLocalVmTarget(botId) : SHARED_LOCAL_VM_TARGET;
 }
+function localVmPoolSeatHolder(seat) {
+    return localVmLeases.forTarget(poolLocalVmTarget(seat).key).current(localVmOwnerBusy);
+}
+/** The Local VM a conversation's turn addresses. In pool mode each thread
+ * draws a seat with TTL-bounded affinity so it reuses the desktop that
+ * holds its login state; other modes are unchanged. */
+function localVmTargetForThread(botId, threadId) {
+    if (localVmMode(cfg) !== "pool")
+        return localVmTargetForBot(botId);
+    return poolLocalVmTarget(localVmSeatPool.assign(threadId, localVmPoolSeatHolder));
+}
+/** Best-effort seat for read-only surfaces (Computer panel previews,
+ * screenshots, status payloads). Records no affinity: a status probe must
+ * not steer a later turn onto a desktop its claim would not choose. */
+function localVmTargetForStatus(botId, threadId) {
+    if (localVmMode(cfg) !== "pool")
+        return localVmTargetForBot(botId);
+    // An in-flight turn keeps its claimed seat even after its affinity TTL
+    // decays: prefer the live target so a preview cannot land on another seat.
+    const activeTarget = threadId ? localVmThreadTargets.get(threadId) : undefined;
+    if (activeTarget)
+        return activeTarget;
+    return poolLocalVmTarget((threadId ? localVmSeatPool.affinitySeat(threadId) : null) ?? 0);
+}
 function localVmLeaseFor(target) {
     return localVmLeases.forTarget(target.key);
 }
@@ -5286,6 +5803,19 @@ function releaseLocalVmThread(threadId) {
     const target = localVmThreadTargets.get(threadId);
     if (!target)
         return;
+    // Renew affinity at settlement so a turn that consumed part of the TTL
+    // still leaves the full window after it ends; failed claims never reach
+    // here (no target), so only settled turns renew. A turn longer than the
+    // TTL finds its entry expired — touch() alone would drop it — so renew
+    // with the seat the turn actually ran on. A target recorded before a
+    // mid-turn mode change is not a pool seat; touch still covers that.
+    if (localVmMode(cfg) === "pool") {
+        const pooled = /^pool:(\d+)$/.exec(target.key);
+        if (pooled)
+            localVmSeatPool.renew(threadId, Number(pooled[1]));
+        else
+            localVmSeatPool.touch(threadId);
+    }
     localVmLeaseFor(target).release(threadId);
     if (localVmActiveThreads.get(target.key) === threadId)
         localVmActiveThreads.delete(target.key);
@@ -5296,6 +5826,27 @@ function releaseLocalVmThread(threadId) {
 // bot's current destination is intentionally ignored: moving a bot to Cloud,
 // Browser, This computer, Auto, or Off does not delete its old Local VM.
 void (async () => {
+    if (localVmMode(cfg) === "pool") {
+        // Same restore rule as per-bot: idle cleanup removes the container, not
+        // its provisioned workspace, so every surviving seat stays Auto-eligible.
+        const seats = localVmMaxInstances(cfg);
+        for (let seat = 0; seat < seats; seat += 1) {
+            const target = poolLocalVmTarget(seat);
+            if (localVmWorkspaceExists(target))
+                localVmSeen.add(target.key);
+        }
+        const runtime = await containerRuntimeStatus().catch(() => null);
+        if (!runtime?.runtime || !runtime.daemonUp)
+            return;
+        const existing = await discoverExistingPoolLocalVms(seats, runtime.runtime).catch(() => []);
+        const statuses = await Promise.all(existing.map((target) => containerComputerStatus(undefined, undefined, target).catch(() => null)));
+        existing.forEach((target, index) => {
+            noteLocalVmSeen(target, statuses[index]);
+            if (shouldArmLocalVmIdle(statuses[index]))
+                localVmIdleFor(target).touch();
+        });
+        return;
+    }
     if (localVmMode(cfg) !== "per-bot") {
         const status = await containerComputerStatus(undefined, undefined, SHARED_LOCAL_VM_TARGET).catch(() => null);
         noteLocalVmSeen(SHARED_LOCAL_VM_TARGET, status);
@@ -5425,7 +5976,12 @@ bus.subscribe((event) => {
         const owner = bot ? directRequestOwners.get(event.threadId) : undefined;
         const proven = owner?.messageId && !owner.stopped && owner.generation === directTurnGenerationByThread.get(event.threadId) &&
             owner.turnId && (!event.turnId || event.turnId === owner.turnId);
-        const message = store.appendMessage(event.threadId, group && m.role === "bot" ? { ...m, from: speaker }
+        // One line per routed reply: the routed speaker's first text of its turn.
+        const routed = group && m.role === "bot" && m.kind === "text" ? routedRoomReplies.get(event.threadId) : undefined;
+        const routedBy = routed && speaker && routed.botId === speaker.botId ? routed.routedBy : undefined;
+        if (routedBy)
+            routedRoomReplies.delete(event.threadId);
+        const message = store.appendMessage(event.threadId, group && m.role === "bot" ? { ...m, from: speaker, ...(routedBy ? { routedBy } : {}) }
             : proven ? { ...m, requestMessageId: owner.messageId } : m);
         return message;
     };
@@ -5497,15 +6053,33 @@ bus.subscribe((event) => {
                 }
                 // the bot just acted ON ITS SCREEN — refresh the preview now. Only
                 // computer tools can change the screen, and each capture competes
-                // with the agent for the box's command endpoint, so a bot grinding
+                // with the agent for the boat's command endpoint, so a bot grinding
                 // through file edits must not trigger one per tool. The refresh is
                 // deliberately broad (a computer_exec may well have launched a
                 // window); whether the turn has EARNED a settled screenshot is the
                 // narrower question, and only the allow-list answers it.
                 if (bot) {
                     const touches = screenTouchingTool(toolName);
+                    const surface = screenSurfaceForTool(toolName);
                     if (touches || /computer|screenshot|click|type_text|press_key|scroll|open_url|wait_for|browser_/i.test(toolName)) {
-                        pokeScreenPoller(event.threadId, touches, screenSurfaceForTool(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)
+                            turnResources.activity(computer.resource, computer.owner);
+                        // 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();
+                        }
                     }
                 }
             }
@@ -6718,6 +7292,9 @@ function drainQueuedSends() {
                 },
             });
             resolve();
+            // M2: only this group left the queue, and a turn that never
+            // started publishes no completion to wake the groups behind it.
+            queueMicrotask(drainQueuedSends);
         }).catch(reject);
     }), 
     // Provider completion can precede its dispatch promise: keep the queue
@@ -6847,7 +7424,7 @@ async function startOrQueueOpenedThread(botId, threadId, text, unattended) {
     }
 }
 const screenPollers = new Map();
-/** The preview shares the box's single command endpoint with the agent's
+/** The preview shares the boat's single command endpoint with the agent's
  * own actions, so every frame we take is latency stolen from the work the
  * user is waiting on. Hence: a slow interval, a floor between captures,
  * and never two in flight. */
@@ -6855,7 +7432,7 @@ 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 box, so every tool it calls acts on
+ * 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. */
 function startScreenPoller(botId, threadId, captures, { screenIsTheWork = false } = {}) {
@@ -6948,7 +7525,7 @@ function shownScreenHash(threadId) {
  * in-flight poke first) so the settled screenshot shows the screen's actual
  * 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 box's single endpoint. A frame the reader can already see
+ * 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
@@ -7051,7 +7628,7 @@ async function startTurn(botId, text, opts) {
             status: 409,
         });
     }
-    if (boxLifecycleBusyBots.has(botId)) {
+    if (boatLifecycleBusyBots.has(botId)) {
         throw Object.assign(new Error("this bot's cloud computer is being changed — wait for it to finish"), { status: 409 });
     }
     if (threadBusy(botId, threadId))
@@ -7088,7 +7665,7 @@ async function startTurn(botId, text, opts) {
     const instance = turnInstance(bot, opts?.runOn, threadId);
     if (!instance) {
         throw Object.assign(new Error(turnProvider(bot, opts?.runOn, threadId) === "box"
-            ? "the Cloud VM runner is unavailable — configure Box in App Settings"
+            ? "the Cloud VM runner is unavailable — configure Boat in App Settings"
             : `provider instance "${bot.modelSelection.instanceId}" is unavailable — pick another model in settings`), { status: 409 });
     }
     const policyRefusal = policyModelRefusal(instance);
@@ -7137,7 +7714,7 @@ async function startTurn(botId, text, opts) {
     const switchedEngine = instance.instanceId !== bot.modelSelection.instanceId;
     const useInstanceDefaults = switchedEngine || (opts?.runOn === "cloud" && !instance.adapter.capabilities.cloudComputerMcp);
     const model = useInstanceDefaults ? instance.models.default : bot.modelSelection.model;
-    // A native cloud runner borrows its instance defaults; a Box bridge keeps
+    // A native cloud runner borrows its instance defaults; a Boat bridge keeps
     // the bot's selected model, effort and variant.
     const effort = useInstanceDefaults ? undefined : bot.modelSelection.effort;
     const variant = useInstanceDefaults ? undefined : bot.modelSelection.variant;
@@ -7150,7 +7727,7 @@ async function startTurn(botId, text, opts) {
     // an edit hands us its already-branched user message; a plain send appends
     let userMessage = opts?.userMessage;
     if (opts?.editedMessageId) {
-        const edited = store.branchMessage(threadId, opts.editedMessageId, text, opts.sendId);
+        const edited = store.branchMessage(threadId, opts.editedMessageId, text, opts.sendId, opts.sender);
         if (!edited)
             throw Object.assign(new Error("only a user text message can be edited"), { status: 400 });
         store.patchTask(bot.id, threadId, { rewound: true });
@@ -7192,7 +7769,7 @@ async function startTurn(botId, text, opts) {
     }
     const agentsMounted = (commsDepth < MAX_COMMS_DEPTH || Boolean(opts?.coordination)) && instance.adapter.capabilities.agentsMcp === true;
     // busy flips immediately so the composer locks; the dispatch itself runs
-    // in the background — box provisioning can take ~90s and must never
+    // in the background — boat provisioning can take ~90s and must never
     // hang the HTTP request
     const dispatchClaimId = randomUUID();
     const resourceOwner = { threadId, generation: dispatchClaimId };
@@ -7208,7 +7785,7 @@ async function startTurn(botId, text, opts) {
     }
     requestGenerations.add(dispatchClaimId);
     directRequestOwners.set(threadId, { generation: dispatchClaimId, messageId: requestMessageId,
-        generations: requestGenerations, turnId: null });
+        generations: requestGenerations, turnId: null, ...(opts?.automationSource ? { automation: opts.automationSource } : {}) });
     // An unknown control-plane wake may invalidate a prior final, but it must
     // never acquire authority by guessing the latest user as its origin.
     const pendingSource = requestMessageId ?? store.activePath(threadId).findLast(message => message.role === "user")?.id;
@@ -7460,7 +8037,7 @@ async function startTurn(botId, text, opts) {
             // the private bot workspace. A legacy task with an existing provider
             // session deliberately pins to null (the old home-folder behavior),
             // because moving a live session would break resume.
-            // A cloud run happens on the box, where a host folder means nothing:
+            // A cloud run happens on the boat, where a host folder means nothing:
             // pin the task to the default so the header chip never shows the
             // bot's folder for a task that runs elsewhere.
             if (opts?.runOn === "cloud")
@@ -7482,7 +8059,7 @@ async function startTurn(botId, text, opts) {
             const dwebUrl = process.env.DWEB_URL?.trim();
             if (dwebUrl)
                 integrations.dweb = { url: dwebUrl };
-            // Cloud routines always use Box/BoxAgent. The per-bot backend applies
+            // Cloud routines always use Boat/BoatAgent. The per-bot backend applies
             // only to ordinary turns that mount a computer into the local agent.
             const teamComputer = inheritedTeamComputer(bot);
             const cloudBackend = teamComputer || opts?.runOn === "cloud" || bot.cloudBackend !== "vps" ? "box" : "vps";
@@ -7504,13 +8081,13 @@ async function startTurn(botId, text, opts) {
                 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 is refused before anything is
-            // prepared; Auto below simply skips disallowed places.
+            // A place the organisation disallows, or a Cloud home never offers, is
+            // refused before anything is prepared; Auto below simply skips them.
             const wantedKind = teamComputer ? "box" : wants === "local" ? "thisComputer" : wants === "vm" ? "localVm"
                 : wants === "cloud" ? (cloudBackend === "vps" ? "vps" : "box") : undefined;
-            const placeRefusal = wantedKind && managedPolicy.computerRefusal(wantedKind);
+            const placeRefusal = wantedKind && computerPlaceRefusal(wantedKind);
             if (placeRefusal)
-                throw Object.assign(new Error(placeRefusal), { status: 409, code: "managed_policy" });
+                throw Object.assign(new Error(placeRefusal.message), { status: 409, code: placeRefusal.code });
             let previewCapture = null;
             let browserCapture = null;
             let computerKind = null;
@@ -7528,6 +8105,25 @@ async function startTurn(botId, text, opts) {
                 }
                 return containerComputerFrame(undefined, undefined, localVmTarget);
             };
+            /** Pin the conversation at the moment its seat is actually claimed
+             * (issue #1650): the same guards as the dispatch-time pin below, so
+             * a claim landing later in the turn records exactly what a mount-time
+             * pin would have — and a turn that never claims records nothing.
+             * The guard reads live bot and task state because a claim can land
+             * long after dispatch: a Works on change may have swept this
+             * thread's auto pins, or a person may have pinned it meanwhile, and
+             * a deferred claim must resurrect neither nor clobber either. */
+            const autoPinAllowed = () => {
+                const liveBot = store.bot(bot.id);
+                const liveTask = store.taskByThread(bot.id, threadId);
+                return liveBot?.computer === undefined && !teamComputer && opts?.runOn !== "cloud" && !plan.pinned &&
+                    Boolean(liveTask && liveTask.surfaceSource !== "user");
+            };
+            const pinAutoSurface = (surface) => {
+                if (autoPinAllowed()) {
+                    store.patchTask(bot.id, threadId, { surface, surfaceSource: "auto" });
+                }
+            };
             /** The exclusive Local VM claim sequence, verbatim from the old inline
              * attach path, shared by dispatch (eager) and the first-screen-call
              * gate (issue #1361). Idempotent per turn: the resource claim and the
@@ -7537,7 +8133,7 @@ async function startTurn(botId, text, opts) {
              * desktop, not whatever localVmTargetForBot resolves to by the time
              * the first screen call arrives. */
             const claimAutoLocalVm = async (claimThreadId, pinnedTarget) => {
-                const localVmTarget = pinnedTarget ?? localVmTargetForBot(bot.id);
+                const localVmTarget = pinnedTarget ?? localVmTargetForThread(bot.id, claimThreadId);
                 await bindTurnComputer(resourceOwner, `computer:vm:${localVmTarget.key}`, true);
                 if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(localVmTarget.key)) {
                     throw new Error("this Local VM is being started, stopped, or replaced — wait for setup to finish");
@@ -7548,6 +8144,10 @@ async function startTurn(botId, text, opts) {
                 if (!localVmLeaseFor(localVmTarget).claim(claimThreadId, bot.id, localVmOwnerBusy)) {
                     throw new Error("this Local VM is already being used by another turn — wait for that turn to finish");
                 }
+                // Only a turn that wins its lease extends pool affinity; a thread
+                // retrying behind a stranger lets the TTL lapse and migrates.
+                if (localVmMode(cfg) === "pool")
+                    localVmSeatPool.touch(claimThreadId);
                 localVmThreadTargets.set(claimThreadId, localVmTarget);
                 localVmActiveThreads.set(localVmTarget.key, claimThreadId);
                 localVmIdleFor(localVmTarget).touch();
@@ -7589,12 +8189,17 @@ async function startTurn(botId, text, opts) {
                     dropLease();
                     throw new Error("the Local VM lease expired while preparing the turn");
                 }
-                // Same contract as the Box and VPS branches below: without this the
+                // Same contract as the Boat and VPS branches below: without this the
                 // poller never starts, so the Local VM publishes no `screen` events
                 // and every client that only has the stream (the phone) waits
                 // forever. The web panel hid the gap by polling the screenshot
                 // route itself.
                 previewCapture = localVmPreviewFor(localVmTarget, claimThreadId);
+                // Pin on use: this runs for the dispatch-time claim of a VM created
+                // for the turn and for the gate-fired claim of a lazily mounted one
+                // alike — either way the conversation remembers the desktop this
+                // turn actually took, not one it merely mounted (issue #1650).
+                pinAutoSurface("vm");
                 return { target: localVmTarget, runtime: localVm.runtime };
             };
             // Issue #1369: a lazy claim that rejects must not leave its turn busy
@@ -7636,7 +8241,16 @@ async function startTurn(botId, text, opts) {
                         return false;
                     throw new Error("this model engine cannot use the Local VM — choose Claude or an ACP engine, or select another computer destination");
                 }
-                const localVmTarget = localVmTargetForBot(bot.id);
+                if (!strict && localVmMode(cfg) === "pool") {
+                    // localVmTargetForThread records pool affinity, so a turn the
+                    // fast path is about to skip must not reserve or refresh a seat.
+                    // Gate on the side-effect-free candidate assign() would pick —
+                    // the automationSource bypass below stays authoritative.
+                    const poolCandidate = poolLocalVmTarget(localVmSeatPool.candidate(threadId, localVmPoolSeatHolder));
+                    if (!localVmSeen.has(poolCandidate.key) && !opts?.automationSource)
+                        return false;
+                }
+                const localVmTarget = localVmTargetForThread(bot.id, threadId);
                 let lazyReadyVm = null;
                 if (!strict) {
                     // Nothing this process has ever seen for this target, and nobody is
@@ -7738,6 +8352,7 @@ async function startTurn(botId, text, opts) {
                         // The claim restarts the poller with the capture, the way the
                         // Local VM's lazy claim does.
                         onClaimed: (vpsCapture) => {
+                            pinAutoSurface("cloud");
                             previewCapture = vpsCapture;
                             if (threadBusy(bot.id, threadId)) {
                                 const touched = screenPollers.get(threadId)?.touched ?? false;
@@ -7760,16 +8375,16 @@ async function startTurn(botId, text, opts) {
                     }
                 }
             }
-            // Cloud is strict when selected. Native Box and drivers with a Box
-            // bridge may also reuse an already-ready Box on Auto.
+            // Cloud is strict when selected. Native Boat and drivers with a Boat
+            // bridge may also reuse an already-ready Boat on Auto.
             if (teamComputer) {
-                const attached = await attachTeamBox(teamComputer, bot.id, resourceOwner, instance.adapter.capabilities.usesCloudComputer === true, instance.adapter.capabilities.remoteAgent === true);
+                const attached = await attachTeamBoat(teamComputer, bot.id, resourceOwner, instance.adapter.capabilities.usesCloudComputer === true, instance.adapter.capabilities.remoteAgent === true);
                 integrations.computer = attached.integration;
                 previewCapture = attached.capture;
                 computerKind = "box";
             }
-            if (!teamComputer && instance.adapter.capabilities.usesCloudComputer === true && (wants === "cloud" || wants === undefined) && cloudBackend === "box" && box.boxConfigured(cfg)) {
-                const attached = await attachBotBox(bot, resourceOwner, {
+            if (!teamComputer && instance.adapter.capabilities.usesCloudComputer === true && (wants === "cloud" || wants === undefined) && cloudBackend === "box" && boat.boatConfigured(cfg)) {
+                const attached = await attachBotBoat(bot, resourceOwner, {
                     explicitCloud: wants === "cloud",
                     canMount: instance.adapter.capabilities.usesCloudComputer === true,
                     remoteAgent: instance.adapter.capabilities.remoteAgent === true,
@@ -7782,8 +8397,8 @@ async function startTurn(botId, text, opts) {
                     }
                 }
             }
-            if (wants === "cloud" && cloudBackend === "box" && !box.boxConfigured(cfg)) {
-                throw new Error("Cloud box is not configured — add a Box API key or choose Local VM");
+            if (wants === "cloud" && cloudBackend === "box" && !boat.boatConfigured(cfg)) {
+                throw new Error(BOAT_NOT_CONFIGURED);
             }
             if (wants === "cloud" && cloudBackend === "box" && !integrations.computer) {
                 throw new Error("the cloud computer could not be created or reached");
@@ -7793,7 +8408,7 @@ async function startTurn(botId, text, opts) {
             // 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 && managedPolicy.computerAllowed("localVm") && await attachLocalVm(false))
+            if (wants === undefined && !integrations.computer && !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
@@ -7803,7 +8418,7 @@ async function startTurn(botId, text, opts) {
                 !integrations.localComputer &&
                 wants === undefined &&
                 !unattendedVps &&
-                managedPolicy.computerAllowed("thisComputer") &&
+                !computerPlaceRefusal("thisComputer") &&
                 shouldMountLocalComputer({
                     requested: undefined,
                     hostPlatform: process.platform,
@@ -7811,7 +8426,24 @@ async function startTurn(botId, text, opts) {
                 })) {
                 const cua = readCuaConnection();
                 if (cua) {
-                    await bindTurnComputer(resourceOwner, "computer:host");
+                    // Lazy host claim (issue #1650): the gated integration mounts
+                    // now, but the exclusive computer:host seat is taken only by the
+                    // first screen tools/call, through the computer-control gate —
+                    // the same seam as the Local VM (#1361) and the VPS. An Auto
+                    // turn that never touches the screen holds no desktop seat and
+                    // records no pin; a claim that finds the seat held waits behind
+                    // the holder like every other seat instead of failing on the
+                    // spot.
+                    autoVmClaims.set(threadId, {
+                        owner: resourceOwner,
+                        lazy: true,
+                        label: "this computer",
+                        onRejected: surfaceLazyClaimRejection("this computer"),
+                        claim: async () => {
+                            await bindTurnComputer(resourceOwner, "computer:host", true);
+                            pinAutoSurface("local");
+                        },
+                    });
                     integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId));
                     computerKind = "local";
                 }
@@ -7943,8 +8575,15 @@ async function startTurn(botId, text, opts) {
             // turns stay there and the composer can show it. Explicit settings are
             // not recorded: an auto pin yields to a later Works on change (which
             // sweeps it — store.clearAutoSurfacePins); a person's pin does not.
-            if (bot.computer === undefined && !teamComputer && opts?.runOn !== "cloud" && !plan.pinned) {
-                const used = mountedComputer ?? (integrations.browser ? "browser" : null);
+            // 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.
+            if (autoPinAllowed()) {
+                const claimSlot = autoVmClaims.get(threadId);
+                const pinsAtClaim = claimSlot?.owner.generation === resourceOwner.generation;
+                const used = pinsAtClaim ? null : mountedComputer ?? (integrations.browser ? "browser" : null);
                 if (used)
                     store.patchTask(bot.id, threadId, { surface: used, surfaceSource: "auto" });
             }
@@ -7978,7 +8617,8 @@ async function startTurn(botId, text, opts) {
                 { id: "files", label: "File locations", text: worksInWorkspace && opts?.runOn !== "cloud" ? workspaceLocationsPrompt(bot.id, cwd, liveBot?.cwd ?? bot.cwd) : "" },
                 { 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) }) },
+                { 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()) : "" },
                 // 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) : "" },
@@ -8005,6 +8645,15 @@ async function startTurn(botId, text, opts) {
                 { id: "mentions", label: "Mentions", text: boundedCoordination && tagged.length ? `The user named these existing teammates: ${tagged.map(b => `${peerName(b.name)} (${b.id})`).join(", ")}. Use coordinate_bots when their contribution is needed; do not substitute native helper agents for these bots.` : mentionPrompt(tagged) },
             ]);
             turnPromptBytes.set(threadId, { stable: Buffer.byteLength(prompt.stable), volatile: Buffer.byteLength(prompt.volatile) });
+            // Automatic recall rides in front of THIS turn's message, never in the
+            // system prompt: the volatile half is re-sent whole whenever any part of
+            // it changes, and recall changes nearly every turn.
+            const recalled = autoRecallPrompt(bot, threadId, resolvedImages.text, {
+                // a routine run starts fresh by design, and a webhook is untrusted:
+                // neither pulls earlier conversations in
+                conversations: commsDepth === 0 && !coordinationNode && !opts?.automationSource && !opts?.unattended,
+                userName: cfg.profile?.name?.trim() || "User",
+            });
             runningTurnEngines.set(threadId, instance);
             // The prompt carries the soul as saved now. If it changed during setup,
             // decide again from what is actually sent — except on a continuation
@@ -8029,7 +8678,7 @@ async function startTurn(botId, text, opts) {
                 threadId,
                 botId: bot.id,
                 startupRecovery: cfg.automaticRecovery?.enabled === true && !opts?.automaticRecoveryAttempted,
-                text: dispatchContext.turnText,
+                text: withRecalled(recalled, dispatchContext.turnText),
                 refreshSystemPrompt: true,
                 images: turnImages,
                 approvalMode: approvalModeForTurn(bot, commsDepth > 0),
@@ -8091,7 +8740,7 @@ async function startTurn(botId, text, opts) {
             }
             // a turn can settle before dispatch returns, and a poller started
             // after its own turn.completed would never be torn down — it would
-            // keep polling the box forever, carrying dead per-turn state. busy
+            // 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 });
@@ -8469,6 +9118,16 @@ routines = new RoutineManager({
             broadcast({ kind: "bot", bot: publicBot(bot) });
         return task;
     },
+    joinConversation: (run) => {
+        if (!routinesInConversationEnabled(cfg) || run.target !== "bot")
+            return null;
+        const source = routineSourceOwner(run);
+        // Only this bot's own visible chat. A room, or a teammate's thread, keeps
+        // the detached run so one bot cannot write its work into the wrong place.
+        if (!source || source.group || source.bot.id !== run.botId)
+            return null;
+        return source.threadId;
+    },
     createGoalTask: (groupId, title) => store.createGroupTask(groupId, title, false),
     isResultsThread: (botId, threadId) => {
         const bot = store.bot(botId);
@@ -8606,10 +9265,10 @@ async function cloudRoutineReadiness(botId, threadId) {
     const bot = threadId ? store.projectBotForTask(botId, threadId) : store.bot(botId);
     if (!bot || bot.hidden)
         return { ready: false, reason: "The routine's target bot no longer exists." };
-    if (!box.boxConfigured(cfg)) {
+    if (!boat.boatConfigured(cfg)) {
         return {
             ready: false,
-            reason: 'The Box cloud computer needs a working Box API key. For the bot’s configured computer, including a self-hosted VPS, set run_on="maus" instead.',
+            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.',
         };
     }
     const instance = turnInstance(bot, "cloud", threadId);
@@ -8617,15 +9276,15 @@ async function cloudRoutineReadiness(botId, threadId) {
         return { ready: false, reason: "The Cloud VM runner is unavailable. Restart OpenMausBot and try again." };
     try {
         if ((await instance.snapshot()).state !== "available") {
-            return { ready: false, reason: "The target bot's model engine is not ready to use the Box cloud computer." };
+            return { ready: false, reason: "The target bot's model engine is not ready to use the Boat cloud computer." };
         }
         const teamComputer = inheritedTeamComputer(bot);
         const ownerId = teamComputer ? teamComputerOwner(teamComputer.id) : bot.id;
-        const machine = await box.findBox(cfg, ownerId);
+        const machine = await boat.findBoat(cfg, ownerId);
         if (teamComputer && !machine) {
-            return { ready: false, reason: "The team's Box computer is missing; explicitly create or retry it from the Team map." };
+            return { ready: false, reason: "The team's Boat computer is missing; explicitly create or retry it from the Team map." };
         }
-        // Explicit Cloud may provision or wake the bot's own Box at dispatch.
+        // Explicit Cloud may provision or wake the bot's own Boat at dispatch.
         // This probe only checks its identity/account, without starting billing.
         return { ready: true };
     }
@@ -8648,9 +9307,9 @@ const routineRequests = new RoutineRequestService({
         const proposer = store.bot(proposerBotId);
         const targetBot = store.bot(target.botId);
         if (!targetBot)
-            return `@${target.name} no longer exists, so this routine cannot be scheduled for it`;
+            return `@${target.name} no longer exists, so this routine request cannot be confirmed for it`;
         if (!proposer || !canReachPeer(proposer, targetBot)) {
-            return `@${target.name} is no longer in this section, so this routine cannot be scheduled for it`;
+            return `@${target.name} is no longer in this section, so this routine request cannot be confirmed for it`;
         }
         return null;
     },
@@ -8667,7 +9326,7 @@ async function deleteBotWithLifecycle(botId, revalidate = () => { }, setupReques
     if (localVmModeChangeBusy) {
         return deletionResponse(409, { error: "Local VM settings are being updated — wait before deleting this bot" });
     }
-    if (boxLifecycleBusyBots.has(bot.id)) {
+    if (boatLifecycleBusyBots.has(bot.id)) {
         return deletionResponse(409, { error: "wait for this bot's cloud computer action to finish before deleting the bot" });
     }
     const activeRoutine = routines.activeRunForBot(bot.id);
@@ -8682,17 +9341,17 @@ async function deleteBotWithLifecycle(botId, revalidate = () => { }, setupReques
             error: `stop this bot's work in channel ${activeGroup.group.name} before deleting the bot`,
         });
     }
-    // A direct turn that has already claimed the bot can provision a Box in
-    // its background setup. Do not let deletion race that work while a Box
+    // A direct turn that has already claimed the bot can provision a Boat in
+    // its background setup. Do not let deletion race that work while a Boat
     // account is configured; the person can stop the turn and retry.
-    if ((box.boxConfigured(cfg) || vpsSshAlias(cfg)) && (bot.busy || hasDirectDispatch(bot.id))) {
+    if ((boat.boatConfigured(cfg) || vpsSshAlias(cfg)) && (bot.busy || hasDirectDispatch(bot.id))) {
         return deletionResponse(409, { error: "stop this bot's work before checking and deleting its cloud computer" });
     }
-    const botBoxRecovery = boxCreateRecoverySnapshot().filter((entry) => entry.botId === bot.id);
-    const botBoxDeletions = boxDeletionSnapshot().filter((entry) => entry.ownerBotId === bot.id);
-    if (botBoxRecovery.some((entry) => !entry.resolved)) {
+    const botBoatRecovery = boatCreateRecoverySnapshot().filter((entry) => entry.botId === bot.id);
+    const botBoatDeletions = boatDeletionSnapshot().filter((entry) => entry.ownerBotId === bot.id);
+    if (botBoatRecovery.some((entry) => !entry.resolved)) {
         return deletionResponse(409, {
-            error: "finish reconciling this bot's pending cloud computer creation before deleting it — check boat.dev, then retry Box setup",
+            error: "finish reconciling this bot's pending cloud computer creation before deleting it — check boat.dev, then retry Boat setup",
         });
     }
     // Bot deletion awaits VM/browser/provider cleanup. Claim the bot and
@@ -8741,25 +9400,25 @@ async function deleteBotWithLifecycle(botId, revalidate = () => { }, setupReques
         // Preflight every provider before deleting any resource. Cleanup can
         // still fail mid-flight across independent providers, but a missing
         // credential or offline daemon should not cause avoidable partial work.
-        const vpsInventory = await vps.listManagedVpsComputers(cfg, managedBoxOwners());
+        const vpsInventory = await vps.listManagedVpsComputers(cfg, managedBoatOwners());
         if (vpsInventory.configured && !vpsInventory.available) {
             return deletionResponse(503, {
                 error: `${vpsInventory.problem ?? "VPS computer inventory is unavailable"}. The bot was kept so its computer can be retried safely`,
             });
         }
         const ownedVpsComputers = vpsInventory.instances.filter((instance) => instance.ownerBotId === bot.id);
-        if ((botBoxRecovery.length > 0 || botBoxDeletions.length > 0) && !box.boxConfigured(cfg)) {
+        if ((botBoatRecovery.length > 0 || botBoatDeletions.length > 0) && !boat.boatConfigured(cfg)) {
             return deletionResponse(409, {
-                error: "Reconnect the Box account that owns this bot's remembered cloud computer, then retry deletion",
+                error: "Reconnect the Boat account that owns this bot's remembered cloud computer, then retry deletion",
             });
         }
-        const cloudInventory = await box.listManagedBoxes(cfg, managedBoxOwners());
+        const cloudInventory = await boat.listManagedBoats(cfg, managedBoatOwners());
         if (cloudInventory.configured && !cloudInventory.available) {
             return deletionResponse(503, {
                 error: `${cloudInventory.problem ?? "cloud computer inventory is unavailable"}. The bot was kept so its computer can be retried safely`,
             });
         }
-        const ownedBoxComputers = cloudInventory.instances.filter((instance) => instance.ownerBotId === bot.id);
+        const ownedBoatComputers = cloudInventory.instances.filter((instance) => instance.ownerBotId === bot.id);
         // Revalidate a reviewed Chief-of-Staff request and establish the
         // browser cleanup intent before the first irreversible provider
         // mutation. A stale review or damaged journal therefore leaves every
@@ -8772,14 +9431,14 @@ async function deleteBotWithLifecycle(botId, revalidate = () => { }, setupReques
             // each exact, freshly revalidated identity before making its bot
             // owner disappear. Shared team computers use a different owner id
             // and are intentionally absent from these lists.
-            for (const instance of ownedBoxComputers) {
-                const removed = await box.deleteManagedBox(cfg, managedBoxOwners(), instance.boxId, instance.name);
+            for (const instance of ownedBoatComputers) {
+                const removed = await boat.deleteManagedBoat(cfg, managedBoatOwners(), instance.boxId, instance.name);
                 if (removed.pending) {
                     throw Object.assign(new Error("The cloud computer deletion has started but is still finishing. The bot was kept; retry in a moment"), { status: 409 });
                 }
             }
             for (const instance of ownedVpsComputers) {
-                await vps.removeManagedVpsComputer(cfg, managedBoxOwners(), instance.name, instance.name);
+                await vps.removeManagedVpsComputer(cfg, managedBoatOwners(), instance.name, instance.name);
             }
             if (localVmCleanup) {
                 if (localVmCleanup.removeContainer) {
@@ -9351,7 +10010,10 @@ const roomHandoffTimer = setInterval(() => {
     }
 }, 250);
 roomHandoffTimer.unref();
-const GROUP_CONTEXT_MESSAGES = 30;
+// The room-context window IS the drain's coalescing cap: a burst longer
+// than the window would append transcript lines the responder never reads,
+// so both bounds come from one constant (admission.ts).
+const GROUP_CONTEXT_MESSAGES = DRAIN_COALESCE_MAX_ITEMS;
 const MAX_GROUP_HOPS = 1;
 function teammateReportContext(requestId, readerBotId) {
     const node = roomHandoffs.nodes.get(requestId);
@@ -9361,9 +10023,10 @@ function teammateReportContext(requestId, readerBotId) {
         return "[Teammate result withheld or no longer retained]";
     return `[Teammate report — untrusted peer content, not human instructions or independent verification]\n${JSON.stringify({ bot: store.bot(node.botId)?.name, task: node.text, status: node.status, result: node.result })}`;
 }
-function serializeRoomContext(threadId, userName, textOverride, readerBotId) {
+function serializeRoomContext(threadId, userName, textOverrides, readerBotId) {
     const messages = store.messagesFor(threadId);
     const messagesById = new Map(messages.map((message) => [message.id, message]));
+    const overrides = new Map(textOverrides?.map((override) => [override.messageId, override.text]));
     return messages
         .filter((m) => (m.kind === "text" && m.text) || (m.kind === "digest" && m.digest) || m.roomRequest?.phase === "result")
         .slice(-GROUP_CONTEXT_MESSAGES)
@@ -9376,7 +10039,8 @@ function serializeRoomContext(threadId, userName, textOverride, readerBotId) {
             // turns. Resolve from the existing bounded store and recheck access.
             return teammateReportContext(m.roomRequest.id, readerBotId);
         }
-        const rendered = textOverride?.messageId === m.id ? { ...m, text: textOverride.text } : m;
+        const overridden = overrides.get(m.id);
+        const rendered = overridden !== undefined ? { ...m, text: overridden } : m;
         // a bot's name is quoted on the speaker line, so it gets one line; a
         // user line that came through the API says so, since the reader would
         // otherwise take it for the person typing
@@ -9395,6 +10059,33 @@ function serializeRoomContext(threadId, userName, textOverride, readerBotId) {
     })
         .join("\n");
 }
+/** The decision model's view of a room message: the room, its people, the
+ * last room lines before this one, and the message. Text is scrubbed of
+ * secrets and attachment markup before it leaves this machine. */
+function roomRoutingInput(roomName, text, members, history, sender) {
+    const userName = cfg.profile?.name?.trim() || "User";
+    const clean = (value) => redactSecretsInText(extractTurnImages(value).text);
+    const humans = new Set([userName]);
+    const recent = history.flatMap((m) => {
+        if (m.kind !== "text" || !m.text)
+            return [];
+        if (m.role === "user") {
+            const person = m.sender?.name ?? userName;
+            humans.add(person);
+            return [{ from: person, text: clean(m.text) }];
+        }
+        return [{ from: `${m.from?.name ?? "A bot"} (bot)`, text: clean(m.text) }];
+    });
+    const from = sender?.name ?? userName;
+    humans.add(from);
+    return {
+        room: roomName,
+        humans: [...humans],
+        members: members.map((member) => ({ id: member.id, name: member.name, title: member.title, description: member.description })),
+        recent,
+        message: { from, text: clean(text) },
+    };
+}
 // What each room has already taken from its bots. Keyed by room because the
 // loop post_to_room can start is a property of the room, not of any one
 // caller — three bots posting twice each is the same runaway as one bot
@@ -9545,14 +10236,39 @@ setupRetry = 0) {
             integrations.hooks = hooksIntegration(bot.id, threadId, internalGeneration);
         }
         const latestUser = [...store.activePath(threadId)].reverse().find((message) => message.role === "user" && message.kind === "text" && message.text);
-        const resolvedLatestImages = latestUser?.text && !cardContinuation
+        const usesNativeImageInput = instance.adapter.capabilities.nativeImageInput === true;
+        // M2: a drained room turn runs one sender's whole burst as ONE turn, so
+        // every burst line must reach the responder the way its own turn would
+        // have carried it — attachments extracted natively, their tags stripped
+        // from the rendered context. Recover the burst by the queueIds recorded
+        // on the operation, not by position: the last line alone is not the burst.
+        const burstIds = new Set(operation?.queuedQueueIds ?? []);
+        const burstOverrides = [];
+        const burstImages = [];
+        if (usesNativeImageInput && !cardContinuation) {
+            for (const message of store.activePath(threadId)) {
+                if (message.role !== "user" || message.kind !== "text" || !message.text)
+                    continue;
+                if (!message.queueId || !burstIds.has(message.queueId))
+                    continue;
+                const resolved = extractTurnImages(message.text);
+                burstOverrides.push({ messageId: message.id, text: resolved.text });
+                burstImages.push(...resolved.images);
+            }
+        }
+        // the latest line is usually the burst's last item: extracting it again
+        // would double-count its attachments and re-strip already-stripped words
+        const latestInBurst = latestUser?.queueId !== undefined && burstIds.has(latestUser.queueId);
+        const resolvedLatestImages = latestUser?.text && !cardContinuation && !latestInBurst
             ? extractTurnImages(latestUser.text)
             : { text: latestUser?.text ?? "", images: [] };
-        const usesNativeImageInput = instance.adapter.capabilities.nativeImageInput === true;
         const roomContext = serializeRoomContext(threadId, userName, usesNativeImageInput && latestUser
-            ? { messageId: latestUser.id, text: resolvedLatestImages.text }
+            ? [
+                ...burstOverrides,
+                ...(latestInBurst ? [] : [{ messageId: latestUser.id, text: resolvedLatestImages.text }]),
+            ]
             : undefined, bot.id);
-        const turnImages = usesNativeImageInput ? resolvedLatestImages.images : [];
+        const turnImages = usesNativeImageInput ? [...burstImages, ...resolvedLatestImages.images] : [];
         const skills = availableSkills();
         const selectedSkills = mergeSkills(selectBundledSkills(roomContext, instance.adapter.capabilities.phoneMcp === true ? ["phoneMcp"] : [], skills), selectBundledSkills(latestUser?.text ?? "", skillAuthoring ? ["skillAuthoring"] : [], skills));
         if (selectedSkills.some((skill) => skill.manifest.requiredCapabilities.includes("phoneMcp"))) {
@@ -9640,7 +10356,7 @@ setupRetry = 0) {
             onDispatchError?.(message);
             return true;
         }
-        if (boxLifecycleBusyBots.has(readyBot.id)) {
+        if (boatLifecycleBusyBots.has(readyBot.id)) {
             if (orchestration) {
                 orchestration.result.outcome = "busy";
                 return true;
@@ -9682,7 +10398,7 @@ setupRetry = 0) {
         orchestration?.onClaimed?.();
         // The stall completion handler only exists once the provider turn runs
         // (registered at dispatch below), but this watch is armed at claim. Latch
-        // a stall that fires during setup — browser, box, and VM mounts can all
+        // a stall that fires during setup — browser, boat, and VM mounts can all
         // wedge — so the dispatch site completes the turn instead of launching a
         // provider turn the person was already told was stopped. The finally
         // below unregisters the latch on every other exit.
@@ -9691,7 +10407,7 @@ setupRetry = 0) {
             setupStalled = true;
         });
         // Watch from claim, not provider dispatch: room setup (connected-app
-        // discovery, browser, box, and VM mounts) can wedge before any provider
+        // discovery, browser, boat, and VM mounts) can wedge before any provider
         // event exists. The exits between here and dispatch either throw into the
         // finally's guarded cleanup or return through the revalidation block,
         // both of which settle the watch.
@@ -9711,14 +10427,15 @@ setupRetry = 0) {
                 readyBot.browser !== false &&
                 instance.adapter.capabilities.browserMcp === true,
         });
-        // A place the organisation disallows is refused before anything is
-        // provisioned or started, exactly as a bot thread refuses it.
+        // A place the organisation disallows, or a Cloud home never offers, is
+        // refused before anything is provisioned or started, exactly as a bot
+        // thread refuses it.
         const roomKind = roomTeamComputer ? "box" : roomPlan.computer === "local" ? "thisComputer" : readyBot.computer === "vm" ? "localVm"
             : roomPlan.computer === "cloud" ? (turnProvider(readyBot) === "vps" ? "vps" : "box") : undefined;
-        const roomPlaceRefusal = roomKind && managedPolicy.computerRefusal(roomKind);
+        const roomPlaceRefusal = roomKind && computerPlaceRefusal(roomKind);
         if (roomPlaceRefusal)
-            throw Object.assign(new Error(roomPlaceRefusal), { code: "managed_policy" });
-        // The Computer engine runs on the Box; this computer has no tools it can
+            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");
@@ -9741,7 +10458,7 @@ setupRetry = 0) {
             return false;
         }
         if (roomTeamComputer) {
-            const attached = await attachTeamBox(roomTeamComputer, readyBot.id, resourceOwner, instance.adapter.capabilities.usesCloudComputer === true, instance.adapter.capabilities.remoteAgent === true);
+            const attached = await attachTeamBoat(roomTeamComputer, readyBot.id, resourceOwner, instance.adapter.capabilities.usesCloudComputer === true, instance.adapter.capabilities.remoteAgent === true);
             if (isCancelled?.() || groupSpeakers.get(threadId) !== roomSpeaker ||
                 activeInternalGenerationByThread.get(threadId) !== internalGeneration)
                 return false;
@@ -9784,10 +10501,10 @@ setupRetry = 0) {
                 roomComputerKind = "vps";
             }
             else {
-                if (!box.boxConfigured(cfg))
-                    throw new Error("Cloud box is not configured — add a Box API key or choose Local VM");
+                if (!boat.boatConfigured(cfg))
+                    throw new Error(BOAT_NOT_CONFIGURED);
                 const remoteAgent = instance.adapter.capabilities.remoteAgent === true;
-                const attached = await attachBotBox(readyBot, resourceOwner, { explicitCloud: true,
+                const attached = await attachBotBoat(readyBot, resourceOwner, { explicitCloud: true,
                     canMount: instance.adapter.capabilities.usesCloudComputer === true, remoteAgent });
                 if (!roomSetupIsCurrent())
                     return false;
@@ -9806,7 +10523,7 @@ setupRetry = 0) {
                 throw new Error("this model engine cannot use the Local VM");
             }
             // A distinct identity fences cleanup even in shared mode on the same room thread.
-            const target = { ...localVmTargetForBot(readyBot.id) };
+            const target = { ...localVmTargetForThread(readyBot.id, threadId) };
             await bindTurnComputer(resourceOwner, `computer:vm:${target.key}`, true);
             if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(target.key)) {
                 throw new Error("this Local VM is being started, stopped, or replaced");
@@ -9814,6 +10531,8 @@ setupRetry = 0) {
             if (!localVmLeaseFor(target).claim(threadId, readyBot.id, localVmOwnerBusy)) {
                 throw new Error("this Local VM is already being used by another turn");
             }
+            if (localVmMode(cfg) === "pool")
+                localVmSeatPool.touch(threadId);
             roomVmTarget = target;
             localVmThreadTargets.set(threadId, target);
             localVmActiveThreads.set(target.key, threadId);
@@ -9937,7 +10656,8 @@ setupRetry = 0) {
             { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
             { 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 }) },
+            { 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: "browser", label: "Browser", text: integrations.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
             { id: "recall", label: "Recall", text: integrations.agents ? SESSION_SEARCH_SYSTEM_PROMPT : "" },
             { id: "recent", label: "Recent work", text: recentWorkPrompt(recentLines) },
@@ -10065,10 +10785,13 @@ setupRetry = 0) {
             providerDispatched = true;
             turnPromptBytes.set(threadId, { stable: Buffer.byteLength(roomSystem.stable), volatile: Buffer.byteLength(roomSystem.volatile) });
             runningTurnEngines.set(threadId, instance);
+            // notes only in a room: a private chat reaches a room through the
+            // explicit, disclosed session_search, never automatically
+            const roomRecalled = cardContinuation ? "" : autoRecallPrompt(bot, threadId, resolvedLatestImages.text, { conversations: false, userName });
             guardTurnDispatch(instance.adapter.sendTurn({
                 threadId,
                 botId: readyBot.id,
-                text,
+                text: withRecalled(roomRecalled, text),
                 refreshSystemPrompt: true,
                 images: turnImages,
                 approvalMode: roomTurnApprovalMode(readyBot, orchestration),
@@ -10593,17 +11316,56 @@ function startGroupTurn(groupId, text, replyTo, sendId, channelMode = "chat", qu
     if (options.goalCoordinatorBotId && (channelMode !== "goal" || !requestedGoalCoordinator)) {
         throw Object.assign(new Error("the selected goal coordinator is not an active room member"), { status: 409 });
     }
-    const message = store.appendMessage(threadId, {
-        role: "user",
-        kind: "text",
-        text,
-        replyToId: replyTo?.id,
-        sendId,
-        channelMode,
-        queueId,
-        via: options.via,
-        sender: options.sender,
-    });
+    // An Auto room may ask the decision model who answers. It reads the room
+    // as it stood before this message, which is appended just below.
+    const autoCandidate = !group.dm && channelMode === "chat" && group.defaultResponder.kind === "auto" &&
+        deciderReady(cfg, "roomRouting");
+    const historyBeforeSend = autoCandidate
+        ? store.messagesFor(threadId).filter((m) => m.kind === "text" && m.text).slice(-GROUP_CONTEXT_MESSAGES)
+        : [];
+    // A coalesced drain appends every queued line under its own queueId (the
+    // chips and sendId receipts stay per-item); the LAST line is the turn's
+    // user message, exactly like the 1:1 drain's userMessage.
+    const queuedGroup = options.queuedGroup;
+    const message = queuedGroup && queuedGroup.length > 0
+        ? (() => {
+            for (const item of queuedGroup.slice(0, -1)) {
+                store.appendMessage(threadId, {
+                    role: "user",
+                    kind: "text",
+                    text: item.text,
+                    replyToId: item.replyToId,
+                    sendId: item.sendId,
+                    channelMode: item.mode,
+                    queueId: item.id,
+                    via: item.via,
+                    sender: item.sender,
+                });
+            }
+            const last = queuedGroup[queuedGroup.length - 1];
+            return store.appendMessage(threadId, {
+                role: "user",
+                kind: "text",
+                text: last.text,
+                replyToId: replyTo?.id,
+                sendId: last.sendId,
+                channelMode: last.mode,
+                queueId: last.id,
+                via: last.via,
+                sender: last.sender,
+            });
+        })()
+        : store.appendMessage(threadId, {
+            role: "user",
+            kind: "text",
+            text,
+            replyToId: replyTo?.id,
+            sendId,
+            channelMode,
+            queueId,
+            via: options.via,
+            sender: options.sender,
+        });
     // Admitted (see startTurn): the room's speakers are booked to this sender.
     if (options.trigger)
         turnTriggers.set(threadId, options.trigger);
@@ -10653,25 +11415,47 @@ function startGroupTurn(groupId, text, replyTo, sendId, channelMode = "chat", qu
         }
         return message;
     }
+    // Auto with nobody addressed: the responders above are only the fallback
+    // until the decision model answers, in the async round below. The append
+    // and this function's return stay synchronous either way.
+    const autoRoute = autoCandidate && !goalCoordinator && availableMembers.length > 1 &&
+        roomResponders(text, availableMembers, { kind: "mentions" }).length === 0;
     // The snippet is only the fallback name here too. The member about to
     // answer supplies the same cheap one-shot the bot path uses, and the
     // swap lands only while the row still carries the snippet — a rename by
     // the person always wins. Channel tasks carry no peer provenance (no
     // assignment opens them), and a member whose engine offers no text
     // one-shot simply keeps the snippet.
-    const titleBot = goalCoordinator ?? responders[0];
-    const titleInstance = registry.get(titleBot.modelSelection.instanceId);
     const titleText = extractTurnImages(text).text;
-    // An engine the organisation disallows never receives the text, even for a title.
-    if (titled && snippet && titleText.trim() && llmThreadTitlesEnabled(cfg) && titleInstance?.generateText && !policyModelRefusal(titleInstance)) {
-        void generateThreadTitle(titleInstance, titleText)
-            .then((title) => {
-            if (title)
-                store.retitleGroupTask(group.id, threadId, snippet, title);
+    const startTitle = (titleBot) => {
+        const titleInstance = registry.get(titleBot.modelSelection.instanceId);
+        // An engine the organisation disallows never receives the text, even for a title.
+        if (titled && snippet && titleText.trim() && llmThreadTitlesEnabled(cfg) && titleInstance?.generateText && !policyModelRefusal(titleInstance)) {
+            void generateThreadTitle(titleInstance, titleText)
+                .then((title) => {
+                if (title)
+                    store.retitleGroupTask(group.id, threadId, snippet, title);
+            })
+                .catch(() => undefined);
+        }
+    };
+    // An Auto round titles with whoever the decision picks, once it has.
+    if (!autoRoute)
+        startTitle(goalCoordinator ?? responders[0]);
+    const operation = beginGroupTurnOperation(groupId, threadId, goalCoordinator || autoRoute ? [] : responders.map((responder) => responder.id));
+    // Asked now, in parallel with any earlier room work still queued: the
+    // answer is waited for only when this round's turn comes up. It never
+    // rejects; a Stop aborts it through the operation's signal.
+    const routing = autoRoute
+        ? decideRoomResponder(decider, roomRoutingInput(group.name, text, availableMembers, historyBeforeSend, options.sender), {
+            signal: operation.cancellation.signal,
         })
-            .catch(() => undefined);
+        : null;
+    if (queuedGroup && queuedGroup.length > 0) {
+        // member turns use these stable ids to carry every burst line's words
+        // and attachments through the turn that swallowed the burst
+        operation.queuedQueueIds = queuedGroup.map((item) => item.id);
     }
-    const operation = beginGroupTurnOperation(groupId, threadId, goalCoordinator ? [] : responders.map((responder) => responder.id));
     if (goalCoordinator) {
         const runId = options.goalRunId?.trim() || `goal-${Date.now().toString(36)}-${randomUUID()}`;
         const startedAt = Date.now();
@@ -10723,9 +11507,27 @@ function startGroupTurn(groupId, text, replyTo, sendId, channelMode = "chat", qu
             await runGroupGoalOperation({ groupId, threadId, coordinator: goalCoordinator, members, operation });
         }
         else {
+            let round = responders;
+            let routedBy;
+            if (routing) {
+                const route = await routing;
+                if (operation.cancelled)
+                    return;
+                const picked = route.kind === "member" ? availableMembers.filter((member) => member.id === route.botId)
+                    : route.kind === "everyone" ? availableMembers
+                        : [];
+                if (picked.length && route.kind !== "fallback") {
+                    round = picked;
+                    routedBy = { provider: "jev", probability: Math.round(route.probability * 100) / 100 };
+                }
+                // What a routed round holds from the start, like any other round.
+                for (const responder of round)
+                    operation.botIds.add(responder.id);
+                startTitle(round[0]);
+            }
             const spoken = new Set();
             const skillAuthoringClaim = { claimed: false };
-            for (const responder of responders) {
+            for (const responder of round) {
                 if (operation.cancelled)
                     break;
                 if (spoken.has(responder.id))
@@ -10741,7 +11543,19 @@ function startGroupTurn(groupId, text, replyTo, sendId, channelMode = "chat", qu
                     spoken.add(responder.id);
                     continue;
                 }
-                if (!(await runGroupMemberTurn(groupId, threadId, responder.id, 0, spoken, undefined, undefined, () => operation.cancelled, () => groupProviderHandshakeStarted(operation), () => groupProviderHandshakeSettled(operation), skillAuthoringClaim, undefined, operation)))
+                // This speaker's first reply line says the decision model chose it.
+                const stamp = routedBy ? { botId: responder.id, routedBy } : undefined;
+                if (stamp)
+                    routedRoomReplies.set(threadId, stamp);
+                let proceed;
+                try {
+                    proceed = await runGroupMemberTurn(groupId, threadId, responder.id, 0, spoken, undefined, undefined, () => operation.cancelled, () => groupProviderHandshakeStarted(operation), () => groupProviderHandshakeSettled(operation), skillAuthoringClaim, undefined, operation);
+                }
+                finally {
+                    if (stamp && routedRoomReplies.get(threadId) === stamp)
+                        routedRoomReplies.delete(threadId);
+                }
+                if (!proceed)
                     break;
             }
         }
@@ -10756,19 +11570,32 @@ function drainQueuedChannelSends() {
     drainChannelMessages((groupId) => {
         const group = store.group(groupId);
         return group ? groupIsWorking(group) : false;
-    }, ({ groupId, threadId, text, replyToId, sendId, mode, id, via, sender, trigger }) => {
+    }, ({ groupId, threadId, items }) => {
         const group = store.group(groupId);
         const ownsThread = group?.dm
             ? group.threadId === threadId
             : Boolean(group && store.groupTaskByThread(group.id, threadId));
         if (!group || !ownsThread)
             return;
+        // The burst runs as ONE room turn: the joined text routes responders
+        // and titles the task, while every queued line still lands under its
+        // own queueId (chips and sendId receipts stay per-item).
+        const head = items[0];
+        const last = items[items.length - 1];
+        const joined = items.map((item) => item.text).join("\n\n");
         try {
-            startGroupTurn(groupId, text, resolveReplyTarget(threadId, replyToId), sendId, mode, id, { via, threadId, sender, trigger: queuedTurnTrigger({ trigger, sender }) });
+            startGroupTurn(groupId, joined, resolveReplyTarget(threadId, last.replyToId), last.sendId, last.mode, last.id, {
+                threadId,
+                sender: head.sender,
+                trigger: queuedTurnTrigger({ trigger: head.trigger, sender: head.sender }),
+                queuedGroup: items,
+            });
         }
         catch (error) {
-            if (!store.messagesFor(threadId).some((message) => message.queueId === id && message.role === "user")) {
-                store.appendMessage(threadId, { role: "user", kind: "text", text, replyToId, sendId, channelMode: mode, queueId: id, via, sender });
+            for (const item of items) {
+                if (!store.messagesFor(threadId).some((message) => message.queueId === item.id && message.role === "user")) {
+                    store.appendMessage(threadId, { role: "user", kind: "text", text: item.text, replyToId: item.replyToId, sendId: item.sendId, channelMode: item.mode, queueId: item.id, via: item.via, sender: item.sender });
+                }
             }
             store.appendMessage(threadId, {
                 role: "bot",
@@ -11600,24 +12427,15 @@ async function testCliBinary(cli, driver) {
     });
 }
 /** A pre-save probe only needs PATH. Never hand credentials inherited by the
- * desktop/server process to an arbitrary wrapper selected through Settings. */
+ * desktop/server process to an arbitrary wrapper selected through Settings.
+ * The shared lists (config.ts) cover every workspace, control-plane and
+ * provider credential, including ones added later; the probe and `claude
+ * update` keep everything else (HOME, proxy settings, CA bundles). */
 function cliProbeEnvironment() {
     const env = { ...process.env, PATH: augmentedPath() };
-    for (const key of [
-        "XAI_API_KEY",
-        "BOX_TOKEN",
-        "OPENCODE_API_KEY",
-        "COMPOSIO_API_KEY",
-        "OMB_COMPOSIO_BROKER_TOKEN",
-        "OMB_TTS_KEY",
-        "OMB_FISH_AUDIO_API_KEY",
-        "OMB_OPENAI_IMAGE_KEY",
-        "OMB_CUSTOM_IMAGE_KEY",
-        "ANTHROPIC_API_KEY",
-        "OPENAI_API_KEY",
-    ]) {
+    stripWorkspaceCredentialEnv(env);
+    for (const key of PROVIDER_CREDENTIAL_ENV)
         delete env[key];
-    }
     return env;
 }
 /** execFile's error carries the child's stderr in .stderr. */
@@ -11643,7 +12461,7 @@ async function localVmPayload(target) {
  * app itself deleted eight hours earlier. Someone who steps away overnight
  * comes back to an error on their first message.
  *
- * The cloud branch below already does the opposite: an absent box is
+ * The cloud branch below already does the opposite: an absent boat is
  * provisioned on first use behind a `provisioning` broadcast. This gives the
  * Local VM the same lifecycle for the same reason.
  *
@@ -11663,7 +12481,11 @@ async function readyLocalVmForTurn(botId, target, isCurrent = () => true) {
     // before the first await — the same synchronous-fence-then-count shape
     // the panel route uses — so two concurrent turns cannot both pass the
     // per-bot limit between count and create.
-    const ownsProvision = !localVmProvisionBusy;
+    // Pool capacity is bounded by its seat indices. Each seat already has
+    // its own lease/lifecycle fence, so independent cold seats can start
+    // together without competing for the per-bot inventory's capacity gate.
+    const pooled = target.key.startsWith("pool:");
+    const ownsProvision = !pooled && !localVmProvisionBusy;
     if (ownsProvision)
         localVmProvisionBusy = true;
     let status;
@@ -11677,9 +12499,9 @@ async function readyLocalVmForTurn(botId, target, isCurrent = () => true) {
         // Another creation is already mid-flight and its container is not yet
         // visible to a count, so the safe answer is the inspected status —
         // exactly what the over-cap path below returns.
-        if (!ownsProvision)
+        if (!pooled && !ownsProvision)
             return status;
-        if (target.key !== SHARED_LOCAL_VM_TARGET.key) {
+        if (target.key.startsWith("bot:")) {
             const count = await existingPerBotLocalVmCount(status.runtime);
             if (!isCurrent() || count >= localVmMaxInstances(cfg))
                 return status;
@@ -11773,17 +12595,24 @@ function configStatus() {
             configured: composio.configured(cfg),
             mode: composio.connectionMode(cfg),
         },
-        box: { configured: Boolean(cfg.box?.token) },
+        // configured = cloud computers work here; included = through Cloud Pro,
+        // not a saved key
+        box: boat.describeBoatAccount(cfg),
         vps: { configured: Boolean(vpsSshAlias(cfg)), sshAlias: vpsSshAlias(cfg) ?? "" },
         opencodeGo: { configured: Boolean(cfg.opencodeGo?.apiKey) },
         // 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),
+        // the decision model: switches and configured-or-not, never the key
+        decider: describeDecider(cfg),
         imageGen: avatarImageStatus(cfg),
         // not a secret — the sidebar shows it
         profile: { name: cfg.profile?.name ?? "", email: cfg.profile?.email ?? "", aboutMe: cfg.profile?.aboutMe ?? "" },
         // the enrolled organisation's read-only desktop policy; null when not enrolled
         managedPolicy: managedPolicy.summary(),
+        // an OMB Cloud home (cloud-home.ts): the app offers no this computer and
+        // no Local VM here
+        ...(CLOUD_HOME ? { cloudHome: true } : {}),
         // not a secret — the settings picker shows it; "" = follow the system
         language: cfg.language ?? "",
         rooms: { turnTimeoutMinutes: roomTurnTimeoutMinutes(cfg) },
@@ -11802,6 +12631,7 @@ function configStatus() {
         features: {
             skillAuthoring: skillAuthoringEnabled(cfg),
             showToolCalls: showToolCallsEnabled(cfg),
+            routinesInConversation: routinesInConversationEnabled(cfg),
             browser: builtInBrowserEnabled(cfg),
             // Maintainer-only escape hatch, not a Settings toggle: the desktop
             // shell and the Settings UI read it so they offer nothing this server
@@ -11810,6 +12640,7 @@ function configStatus() {
             // Plugins → MCP servers switch: Claude bots also see this machine's
             // own Claude Code MCP servers
             claudeUserMcp: claudeUserMcpEnabled(cfg),
+            autoRecall: autoRecallEnabled(cfg),
         },
         // first-run progress — not a secret; the app decides whether to show
         // the welcome tour from this, never from browser storage
@@ -12120,36 +12951,11 @@ function serveStatic(res, path) {
         }
     }
 }
-/** A store refusal is a client error with a status of its own (400 path,
- * 409 conflict, 413 too large); a 409 also carries what is on disk now so
- * the editor can show the bot's version instead of guessing. Anything else
- * is a real failure and goes to the handler's catch-all. */
-function replyMemoryError(res, error) {
-    if (!(error instanceof MemoryStoreError))
-        throw error;
-    if (error.code === "conflict") {
-        return json(res, error.status, { error: error.message, code: error.code, currentHash: error.currentHash, current: error.current });
-    }
-    return json(res, error.status, { error: error.message, code: error.code });
-}
-/** The journal row as the panel shows it: the full prior text stays on
- * the server (a revert needs it there, the list does not), and the thread
- * id becomes the chat title people recognise. */
-function journalEntryForClient(botId, entry) {
-    const { before: _before, ...visible } = entry;
-    const threadTitle = entry.threadId ? store.taskByThread(botId, entry.threadId)?.title : undefined;
-    return threadTitle ? { ...visible, threadTitle } : visible;
-}
 // Loopback-only enforcement: the harness runs on 127.0.0.1 but accepts
 // requests from any loopback connection and any web page that DNS-rebinds
 // onto it. Reject non-loopback Hosts outright (defeats rebinding) and
 // origins outside loopback (blocks remote-web CSRF).
-const workspaceBackupRoutes = createWorkspaceBackupRoutes({
-    dataDir: DATA_DIR,
-    appVersion: serverVersion(),
-    readBody,
-    restored: workspaceRestore,
-    status: () => ({ busy: workspaceMaintenance.active, pendingRestore: workspaceMaintenance.pendingRestore }),
+const workspaceBackupAccess = {
     authorized: (req, original) => {
         const current = resolveRequestAuth(req, {
             sessions, cookieName: SESSION_COOKIE, streamPath: "/api/events",
@@ -12170,13 +12976,13 @@ const workspaceBackupRoutes = createWorkspaceBackupRoutes({
         idle: () => !providerFleetReloading && !providerAuthSessions.active && !browserEngineInstall &&
             !routines?.isTicking && !calendarCalls?.isTicking &&
             !localVmImageBusy && !localVmProvisionBusy && !localVmModeChangeBusy &&
-            !localVmLifecycleBusy.size && !boxLifecycleBusyBots.size && !vpsPreviewRequests.size && !orphanBoxLifecycleBusyIds.size &&
+            !localVmLifecycleBusy.size && !boatLifecycleBusyBots.size && !vpsPreviewRequests.size && !orphanBoatLifecycleBusyIds.size &&
             !computerProviderConfigTransitions.size && !checkpointRestoreLeases.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)),
-        pause: () => { routines?.stop(); calendarCalls?.stop(); watchdog.stop(); },
-        resume: () => { routines?.start(); calendarCalls?.start(); watchdog.start(); },
+        pause: () => { routines?.stop(); calendarCalls?.stop(); watchdog.stop(); memoryUpkeep.pause(); },
+        resume: () => { routines?.start(); calendarCalls?.start(); watchdog.start(); memoryUpkeep.resume(); },
         flush: async () => {
             await Promise.all([flushAllProfileHistory(), flushAllMemoryJournals(), flushUsageLedger(DATA_DIR), flushDecisionLog(DATA_DIR), flushAdminActivity(DATA_DIR)]);
             // With writers gated and work idle, release our WAL connection for the
@@ -12185,6 +12991,27 @@ const workspaceBackupRoutes = createWorkspaceBackupRoutes({
             closeMessageDb();
         },
     }, keepLocked),
+    status: () => ({ busy: workspaceMaintenance.active, pendingRestore: workspaceMaintenance.pendingRestore }),
+};
+const workspaceBackupRoutes = createWorkspaceBackupRoutes({
+    dataDir: DATA_DIR,
+    appVersion: serverVersion(),
+    readBody,
+    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;
+const cloudMoveRoutes = createCloudMoveRoutes({
+    dataDir: DATA_DIR,
+    appVersion: serverVersion(),
+    cloudHome: Boolean(CLOUD_HOME),
+    readBody,
+    restored: workspaceRestore,
+    ...workspaceBackupAccess,
+    restart: () => { cloudHomeRestartRequested = true; gracefulShutdown(); },
 });
 // Route modules (server/routes/README.md). `workspaceAccess` is assigned at
 // boot, after this line, so the dependency reads it per request.
@@ -12193,6 +13020,20 @@ ROUTES.push(createHostedSlackRoutes({ bot: (id) => store.bot(id), hostedReady: (
 // its file, so New bot cannot disagree with it. No organization: none.
 const orgInstallStatuses = () => orgLibrary?.installStatuses() ?? new Map();
 ROUTES.push(createBotPresetRoutes({ presets: presetStore, orgStatuses: orgInstallStatuses }));
+// The bot-memory panel's routes (MEMORY.md, memory/ topics, journal); the
+// store lookups — the 404 precheck and journal thread titles — stay explicit.
+ROUTES.push(createBotMemoryRoutes({
+    bot: (id) => store.bot(id),
+    taskByThread: (botId, threadId) => store.taskByThread(botId, threadId),
+    upkeep: memoryUpkeep,
+    aboutMe: () => cfg.profile?.aboutMe ?? "",
+    saveAboutMe: (aboutMe) => {
+        saveConfig({ profile: { ...cfg.profile, aboutMe } });
+        Object.assign(cfg, loadConfig());
+        broadcast({ kind: "config", ...configStatus() });
+    },
+}));
+ROUTES.push(createDeciderRoutes({ decider }));
 const toolResults = new ToolResults();
 const handleRequest = async (req, res) => {
     let url;
@@ -12249,7 +13090,7 @@ const handleRequest = async (req, res) => {
         if (method === "GET" && !path.startsWith("/api/") && !path.startsWith("/.well-known/") && serveStatic(res, path))
             return;
         if (method === "GET" && path === "/.well-known/openmausbot/environment") {
-            return json(res, 200, environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: !HOSTED_WORKSPACE && emailSignIn.enabled(), sharedComputers: sharedComputersEnabled(cfg) }));
+            return json(res, 200, environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: !HOSTED_WORKSPACE && emailSignIn.enabled(), sharedComputers: lendingEnabled() }));
         }
         const domainCheck = /^\/\.well-known\/openmausbot\/domain-check\/([a-f0-9]{64})$/.exec(path);
         if (method === "GET" && domainCheck) {
@@ -12292,11 +13133,31 @@ const handleRequest = async (req, res) => {
             }
             sessions.clearFailures(source);
             const issued = sessions.issue({ label: label.trim() || labelFromUserAgent(req.headers["user-agent"]), scopes: verified.scopes, userId: verified.userId, email: verified.email });
-            const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: true, sharedComputers: sharedComputersEnabled(cfg) });
+            const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: true, sharedComputers: lendingEnabled() });
             const secure = requestOrigin(req)?.startsWith("https://") === true;
             res.setHeader("set-cookie", serializeSessionCookie(SESSION_COOKIE, issued.token, { secure, maxAgeSeconds: cookieMaxAgeSeconds(issued.session) }));
             return json(res, 200, { session: issued.session, environment });
         }
+        // The Admin's signed request for one pairing window on a Cloud home
+        // machine. Public like /api/auth/pair, JSON only, and bad signatures
+        // count against the same lockout. Never log its headers, body or code.
+        if (cloudPairing && path === CLOUD_PAIRING_PATH) {
+            res.setHeader("cache-control", "no-store");
+            if (method !== "POST")
+                return json(res, 405, { error: "method_not_allowed" });
+            if (!/^application\/json\b/i.test(String(req.headers["content-type"] ?? ""))) {
+                return json(res, 415, { error: "send the pairing request as JSON (content-type: application/json)" });
+            }
+            const source = requestSource(req);
+            const header = (name) => { const value = req.headers[name]; return typeof value === "string" ? value : undefined; };
+            const result = cloudPairing.handle({
+                timestamp: header("x-omb-cloud-timestamp"), nonce: header("x-omb-cloud-nonce"), signature: header("x-omb-cloud-signature"),
+                body: await readSignedBody(req), source,
+            });
+            if (result.status !== 200)
+                console.warn(`cloud pairing refused from ${source}: ${String(result.body.error)}`);
+            return json(res, result.status, result.body);
+        }
         if (method === "POST" && path === "/api/auth/pair") {
             // JSON only: a cross-site HTML form cannot send this content type
             // without a preflight, so a stray unused code cannot be planted as a
@@ -12314,7 +13175,7 @@ const handleRequest = async (req, res) => {
                 console.warn(`pairing refused from ${requestSource(req)}: ${result.error}`);
                 return json(res, result.status, { error: result.error });
             }
-            const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: emailSignIn.enabled(), sharedComputers: sharedComputersEnabled(cfg) });
+            const environment = environmentDescriptor({ environmentId: ENVIRONMENT_ID, desktopManaged: DESKTOP_MANAGED, emailSignIn: emailSignIn.enabled(), sharedComputers: lendingEnabled() });
             if (wantsCookie) {
                 const secure = requestOrigin(req)?.startsWith("https://") === true;
                 res.setHeader("set-cookie", serializeSessionCookie(SESSION_COOKIE, result.token, { secure, maxAgeSeconds: cookieMaxAgeSeconds(result.session) }));
@@ -12366,7 +13227,7 @@ const handleRequest = async (req, res) => {
             url,
             loopbackMutationToken: desktopMutationToken,
             companionMutationToken,
-            features: { sharedComputers: sharedComputersEnabled(cfg) },
+            features: { sharedComputers: lendingEnabled() },
             loopbackTrust: LOOPBACK.trust,
             cliOwnerToken,
         });
@@ -12424,6 +13285,8 @@ const handleRequest = async (req, res) => {
         }
         if (await workspaceBackupRoutes(req, res, path, auth))
             return;
+        if (await cloudMoveRoutes(req, res, path, auth))
+            return;
         // Count ordinary requests until their asynchronous handler returns, not
         // merely until the browser disconnects. A cancelled upload can still write.
         if (path.startsWith("/api/") && path !== "/api/events" && path !== "/api/health" && !path.startsWith("/api/shared-computers/") && !isWorkspaceBackupSessionControl(method, path)) {
@@ -12450,6 +13313,9 @@ const handleRequest = async (req, res) => {
                     // a hosted team workspace: the web UI's first run skips the
                     // desktop-only beats there. Absent everywhere else.
                     ...(HOSTED_WORKSPACE ? { hosted: true } : {}),
+                    // an OMB Cloud home: the web UI's first run is its engine
+                    // sign-in (docs/cloud-pro.md). Absent everywhere else.
+                    ...(CLOUD_HOME ? { cloudHome: true } : {}),
                 });
         }
         if (method === "POST" && path === "/api/auth/stream-ticket") {
@@ -12540,11 +13406,15 @@ const handleRequest = async (req, res) => {
             const cancelled = sessions.cancelPairing(m[1]);
             return json(res, cancelled ? 200 : 404, cancelled ? { ok: true } : { error: "no such pairing code" });
         }
-        if (method === "POST" && path === "/api/desktop/shared-computer-control" && sharedComputersEnabled(cfg)) {
+        // The desktop's own server always answers its desktop here: lending to the
+        // person's Cloud (docs/cloud-pro.md) needs the lease without the
+        // maintainer flag. It grants nothing by itself; it only keeps local bot
+        // turns and a remote screen action from using the screen at once.
+        if (method === "POST" && path === "/api/desktop/shared-computer-control" && (sharedComputersEnabled(cfg) || DESKTOP_MANAGED)) {
             if (auth.kind !== "loopback")
                 return json(res, 403, { error: "Local desktop only" });
             const body = await readBody(req, 1024);
-            if (!sharedComputersEnabled(cfg))
+            if (!sharedComputersEnabled(cfg) && !DESKTOP_MANAGED)
                 return json(res, 404, { error: `no route: ${method} ${path}` });
             if (!z.string().uuid().safeParse(body?.id).success || !["acquire", "release", "renew"].includes(body?.action))
                 return json(res, 400, { error: "Invalid computer lease" });
@@ -12567,13 +13437,19 @@ const handleRequest = async (req, res) => {
         // With features.sharedComputers off the whole family falls through to the
         // generic "no route" 404, so a probe cannot tell a disabled feature from
         // a build that never had one.
-        if (method === "POST" && path.startsWith("/api/shared-computers/") && sharedComputersEnabled(cfg)) {
+        // What the asking person has lent to this server, online or not, with its
+        // scopes (docs/cloud-pro.md, "What the Cloud can see"). Owner-scoped like
+        // the bot routes; no id a session could not already use, and no secret.
+        if (method === "GET" && path === "/api/shared-computers" && lendingEnabled()) {
+            return json(res, 200, { computers: sharedComputers.status(sessionLendingPrincipal(auth)) });
+        }
+        if (method === "POST" && path.startsWith("/api/shared-computers/") && lendingEnabled()) {
             if (auth.kind !== "session")
                 return json(res, 403, { error: "Pair this desktop first" });
             if (!/^application\/json\b/i.test(String(req.headers["content-type"] ?? "")))
                 return json(res, 415, { error: "JSON required" });
             const body = await readBody(req, 4_000_000);
-            if (!sharedComputersEnabled(cfg))
+            if (!lendingEnabled())
                 return json(res, 404, { error: `no route: ${method} ${path}` });
             if (!sessions.isLive(auth.session.id))
                 return json(res, 401, { error: "Session ended" });
@@ -12585,7 +13461,11 @@ const handleRequest = async (req, res) => {
                 const registration = parsed.data;
                 if (registration.environmentId !== ENVIRONMENT_ID)
                     return json(res, 409, { error: "Workspace identity changed. Pair again before sharing this computer." });
-                sharedComputers.register(registration, auth.session.id, secret);
+                // 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." });
+                sharedComputers.register(registration, { session: auth.session.id, person: CLOUD_HOME ? CLOUD_HOME_LENDER : personKey(auth.session) }, secret);
                 return json(res, 200, { ok: true });
             }
             const route = /^\/api\/shared-computers\/([\w-]+)\/(poll|lease|result|disconnect)$/.exec(path);
@@ -12754,6 +13634,7 @@ const handleRequest = async (req, res) => {
                 if (method === "POST" && requested !== "auto" && !parseSurface(requested)) {
                     return json(res, 400, { error: "surface must be auto, cloud, vm, local, or browser" });
                 }
+                const unoffered = CLOUD_HOME && method === "POST" && requested !== "auto" ? cloudHomePlaceRefusal(parseSurface(requested)) : undefined;
                 const options = await selectableComputers(bot);
                 const current = source ? source.mounted ?? "off" : await computerPreviewSurface(bot, bot.threadId);
                 requireActiveInternalCapability();
@@ -12761,6 +13642,8 @@ const handleRequest = async (req, res) => {
                     return json(res, 200, { current, canSelect, options });
                 if (computerSelectionTurns.get(internalCapability.threadId) !== source)
                     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);
@@ -12826,7 +13709,7 @@ const handleRequest = async (req, res) => {
             }
             if (method === "POST" && path === "/api/internal/memory") {
                 const body = await readInternalBody();
-                const result = updateMemory(internalSender.id, { action: body.action, text: body.text, oldText: body.oldText }, { source: memorySource() });
+                const result = updateMemory(internalSender.id, { action: body.action, text: body.text, oldText: body.oldText, ...(body.until !== undefined ? { until: body.until } : {}) }, { source: memorySource() });
                 return json(res, result.ok ? 200 : result.code === "conflict" ? 409 : result.code === "over-budget" ? 413 : 400, result);
             }
             if (method === "POST" && path === "/api/internal/memory/log") {
@@ -12874,15 +13757,30 @@ const handleRequest = async (req, res) => {
             }
             // Off by default: both fall through to the same "unknown internal
             // endpoint" 404 a never-implemented route returns.
-            if (method === "GET" && path === "/api/internal/shared-computers" && sharedComputersEnabled(cfg))
-                return json(res, 200, { computers: sharedComputers.list() });
-            if (method === "POST" && path === "/api/internal/shared-computers" && sharedComputersEnabled(cfg)) {
+            // Owner-scoped: a turn sees and uses only the computers of the person it
+            // provably acts for (sharedComputerPrincipal), never anyone else's.
+            if (method === "GET" && path === "/api/internal/shared-computers" && lendingEnabled()) {
+                const principal = sharedComputerPrincipal(internalCapability);
+                // Say why an owner's own conversation sees no Mac, so the bot can tell them.
+                const notice = CLOUD_HOME && !principal && sharedComputers.status(CLOUD_HOME_LENDER).length > 0 &&
+                    cloudHomeLendingRefusal(cloudLendingTurn(internalCapability)) === "someone-else" ? { unavailable: LENDING_SOMEONE_ELSE } : {};
+                return json(res, 200, { computers: sharedComputers.list(principal), ...notice });
+            }
+            if (method === "POST" && path === "/api/internal/shared-computers" && lendingEnabled()) {
                 const parsed = sharedComputerOperation.safeParse(await readInternalBody());
-                if (!sharedComputersEnabled(cfg))
+                if (!lendingEnabled())
                     return json(res, 404, { error: "unknown internal endpoint" });
                 if (!parsed.success)
                     return json(res, 400, { error: "Invalid shared computer operation" });
-                return json(res, 200, { result: await sharedComputers.request(parsed.data, () => sharedComputersEnabled(cfg) && internalCapabilityIsActive(internalCapability)) });
+                // The bot's own "no computer" setting holds on a lent screen too.
+                if (["computer_tools", "computer_call"].includes(parsed.data.action) && store.bot(internalCapability.botId)?.computer === "off") {
+                    return json(res, 403, { error: "This bot has no computer. Change its Computer setting to use a shared computer's apps and screen." });
+                }
+                const principal = sharedComputerPrincipal(internalCapability);
+                if (CLOUD_HOME && !principal && cloudHomeLendingRefusal(cloudLendingTurn(internalCapability)) === "someone-else") {
+                    return json(res, 403, { error: LENDING_SOMEONE_ELSE });
+                }
+                return json(res, 200, { result: await sharedComputers.request(parsed.data, principal, () => lendingEnabled() && internalCapabilityIsActive(internalCapability)) });
             }
             if (method === "GET" && path === "/api/internal/agents") {
                 const sender = internalSender;
@@ -13150,11 +14048,12 @@ const handleRequest = async (req, res) => {
                 const owner = connectorThread(from.id, fromThreadId);
                 if (!owner)
                     return json(res, 403, { error: "source conversation does not belong to sender" });
-                // "Make a routine for @B": resolve the target up front so the model
-                // gets a teaching error now, not a mis-bound routine later. Omitted
-                // (or the sender's own id) keeps the schedule-for-self path unchanged.
+                // "Make a routine for @B" / "pause @B's routine": resolve the target
+                // up front so the model gets a teaching error now, not a mis-bound
+                // routine later. Omitted (or the sender's own id) keeps the
+                // own-routine path unchanged.
                 let forBot;
-                if (body.action === "create" && body.forBotId !== undefined) {
+                if (body.forBotId !== undefined) {
                     const parsedForBotId = z.string().max(128).safeParse(body.forBotId);
                     const forBotId = parsedForBotId.success ? parsedForBotId.data.trim() : "";
                     if (!forBotId) {
@@ -13178,8 +14077,8 @@ const handleRequest = async (req, res) => {
                 const proposedInput = body.action === "create"
                     ? { action: body.action, routine: body.routine, forBot }
                     : body.action === "update"
-                        ? { action: body.action, routineId: body.routineId, changes: body.changes }
-                        : { action: body.action, routineId: body.routineId };
+                        ? { action: body.action, routineId: body.routineId, changes: body.changes, forBot }
+                        : { action: body.action, routineId: body.routineId, forBot };
                 const proposed = await routineRequests.submit({
                     botId: from.id,
                     threadId: fromThreadId,
@@ -14655,7 +15554,11 @@ const handleRequest = async (req, res) => {
                     }
                     const group = createChannel({
                         name: redactSecretsInText(parsed.data.name), memberIds, section: chief.section,
-                        setup: { bulletin: redactSecretsInText(parsed.data.bulletin ?? ""), defaultResponder: { kind: "member", botId: chief.id } },
+                        setup: {
+                            bulletin: redactSecretsInText(parsed.data.bulletin ?? ""),
+                            // The Chief leads; on Auto it is the fallback when the decision model is unsure.
+                            defaultResponder: deciderReady(cfg, "roomRouting") ? { kind: "auto", fallbackBotId: chief.id } : { kind: "member", botId: chief.id },
+                        },
                     });
                     internalCapability.createdRooms = (internalCapability.createdRooms ?? 0) + 1;
                     return json(res, 201, { id: group.id, name: group.name, section: group.section || "General", memberIds: group.memberIds, memberCount: group.memberIds.length });
@@ -15034,7 +15937,12 @@ const handleRequest = async (req, res) => {
             const hidden = hiddenRoutineTarget(body, visible);
             if (hidden)
                 return json(res, 404, { error: hidden });
-            return json(res, 201, { routine: routines.create(body) });
+            const routine = routines.create(body);
+            // On a Cloud home, a routine the owner writes from their own device may
+            // use their lent Mac when it runs (server/cloud-lending.ts).
+            if (cloudRoutineAuthors && cloudOwnerSession(auth))
+                cloudRoutineAuthors.record(routine.id, routine);
+            return json(res, 201, { routine });
         }
         // The desktop shell polls this to decide whether to hold the computer
         // awake: a run in flight, or a routine due within the hour.
@@ -15044,6 +15952,8 @@ const handleRequest = async (req, res) => {
         let routineMatch = path.match(/^\/api\/routines\/([\w-]+)\/run$/);
         if (routineMatch && method === "POST") {
             const run = routines.runNow(routineMatch[1]);
+            if (run && CLOUD_HOME && cloudOwnerSession(auth))
+                ownerStartedRoutineRuns.add(run.id);
             return run ? json(res, 201, { run }) : json(res, 404, { error: "no such routine" });
         }
         routineMatch = path.match(/^\/api\/routines\/([\w-]+)$/);
@@ -15052,11 +15962,26 @@ const handleRequest = async (req, res) => {
             const hidden = hiddenRoutineTarget(body, visible);
             if (hidden)
                 return json(res, 404, { error: hidden });
+            const before = cloudRoutineAuthors ? routines.listRoutines().find((candidate) => candidate.id === routineMatch[1]) : undefined;
+            const wasOwners = Boolean(before && cloudRoutineAuthors?.authored(before.id, before));
             const routine = routines.update(routineMatch[1], body);
+            // The owner's own edit keeps (or, when it rewrites the instructions,
+            // makes) the routine theirs. Anyone else's edit, of any field (its
+            // schedule, where its results go, whether it is on), makes it no longer
+            // the owner's: it stops lending until the owner rewrites it.
+            if (routine && cloudRoutineAuthors) {
+                if (!cloudOwnerSession(auth))
+                    cloudRoutineAuthors.forget(routine.id);
+                else if (wasOwners || (body && typeof body === "object" && "prompt" in body))
+                    cloudRoutineAuthors.record(routine.id, routine);
+            }
             return routine ? json(res, 200, { routine }) : json(res, 404, { error: "no such routine" });
         }
         if (routineMatch && method === "DELETE") {
-            return routines.remove(routineMatch[1])
+            const removed = routines.remove(routineMatch[1]);
+            if (removed)
+                cloudRoutineAuthors?.forget(routineMatch[1]);
+            return removed
                 ? json(res, 200, { ok: true })
                 : json(res, 404, { error: "no such routine" });
         }
@@ -15348,6 +16273,47 @@ 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];
@@ -15688,7 +16654,7 @@ const handleRequest = async (req, res) => {
             const current = resolveRequestAuth(req, {
                 sessions, cookieName: SESSION_COOKIE, streamPath: "/api/events", url,
                 loopbackMutationToken: desktopMutationToken, companionMutationToken,
-                features: { sharedComputers: sharedComputersEnabled(cfg) }, loopbackTrust: LOOPBACK.trust, cliOwnerToken,
+                features: { sharedComputers: lendingEnabled() }, loopbackTrust: LOOPBACK.trust, cliOwnerToken,
             });
             if (!current.auth)
                 return json(res, current.status, { error: current.error });
@@ -16186,15 +17152,7 @@ const handleRequest = async (req, res) => {
                     return json(res, 400, { error: "bulletin must be a string" });
                 if (body.bulletin.length > 12_000)
                     return json(res, 400, { error: "bulletin must be at most 12000 characters" });
-                const value = body.defaultResponder;
-                let responder = null;
-                if (value?.kind === "everyone")
-                    responder = { kind: "everyone" };
-                else if (value?.kind === "mentions")
-                    responder = { kind: "mentions" };
-                else if (value?.kind === "member" && typeof value.botId === "string" && group.memberIds.includes(value.botId)) {
-                    responder = { kind: "member", botId: value.botId };
-                }
+                const responder = checkedGroupResponder(body.defaultResponder, group.memberIds);
                 if (!responder)
                     return json(res, 400, { error: "invalid default responder" });
                 patch.cwd = checked.cwd ?? undefined;
@@ -16566,7 +17524,17 @@ const handleRequest = async (req, res) => {
             const held = holdChannelQueue(current.id, targetThreadId, m[2]);
             if (!held)
                 return json(res, 404, { error: "no such queued message" });
-            const [head] = held.items;
+            // M2: the head may be a coalesced group (one sender's contiguous
+            // burst); Steer folds that whole group into the live turn as one.
+            const headGroup = headChannelGroup(held.items);
+            const [head] = headGroup;
+            // A live steer has no image side channel — the same rule as the
+            // 1:1 queue: attachment words wait for a real turn where central
+            // admission can hand the images to the engine.
+            if (headGroup.some((item) => extractTurnImages(item.text).images.length > 0)) {
+                restoreHeldChannelQueue(held);
+                return json(res, 200, { ok: true, queued: true, threadId: targetThreadId });
+            }
             const decision = admit("room-steer", {
                 speakerPresent: Boolean(speaker),
                 engineCanSteer: Boolean(instance?.adapter.capabilities.queueing && instance.adapter.steer),
@@ -16583,11 +17551,31 @@ const handleRequest = async (req, res) => {
             // A reply target that cannot be resolved restores the held queue
             // before the request fails — the room's normal drain keeps the head.
             const replyTo = resolveHeldReplyTarget(held, resolveReplyTarget);
+            // Each burst line keeps its own reply relationship: the fold renders
+            // per-item reply context (the head through the helper above, the rest
+            // resolved here) so a mixed burst does not inherit the head's quote
+            // or drop its own. A target that cannot be resolved restores the held
+            // queue before the request fails, mirroring the helper's contract.
+            const speakerName = cfg.profile?.name?.trim() || "User";
+            let foldedPrompt;
+            try {
+                foldedPrompt = headGroup
+                    .map((item, index) => promptWithReply(item.text, index === 0
+                    ? replyTo
+                    : item.replyToId
+                        ? resolveReplyTarget(targetThreadId, item.replyToId)
+                        : undefined, speakerName))
+                    .join("\n\n");
+            }
+            catch (error) {
+                restoreHeldChannelQueue(held);
+                throw error;
+            }
             // steer was offered only when a live speaker instance could take it;
             // the check carries that invariant to the type system.
             const steered = instance?.adapter.steer
                 ? await instance.adapter
-                    .steer(targetThreadId, promptWithReply(head.text, replyTo, cfg.profile?.name?.trim() || "User"))
+                    .steer(targetThreadId, foldedPrompt)
                     .catch(() => "indeterminate")
                 : "refused";
             // The steer was awaited adapter work: re-read every ownership
@@ -16606,25 +17594,25 @@ const handleRequest = async (req, res) => {
             // speaker — and settle the head.
             const delivered = steered !== "refused";
             if (after && delivered && (steered === "indeterminate" || afterSpeakerBotId === speakerBotId)) {
-                const message = store.appendMessage(targetThreadId, {
+                const messages = headGroup.map((item) => store.appendMessage(targetThreadId, {
                     role: "user",
                     kind: "text",
-                    text: head.text,
-                    replyToId: head.replyToId,
-                    sendId: head.sendId,
-                    channelMode: head.mode,
-                    queueId: head.id,
-                    via: head.via,
+                    text: item.text,
+                    replyToId: item.replyToId,
+                    sendId: item.sendId,
+                    channelMode: item.mode,
+                    queueId: item.id,
+                    via: item.via,
                     steered: true,
-                    sender: head.sender,
-                });
+                    sender: item.sender,
+                }));
                 settleHeldChannelQueueHead(held);
                 return json(res, 200, {
                     ok: true,
                     steered: true,
                     threadId: targetThreadId,
-                    messages: [message],
-                    queueIds: [head.id],
+                    messages,
+                    queueIds: headGroup.map((item) => item.id),
                 });
             }
             if (steered === "indeterminate" && !after) {
@@ -17365,6 +18353,11 @@ const handleRequest = async (req, res) => {
                 }
                 patch.mcpServers = requestedMcpServers;
             }
+            if (body.memoryUpkeep !== undefined) {
+                if (typeof body.memoryUpkeep !== "boolean")
+                    return json(res, 400, { error: "memoryUpkeep must be true or false" });
+                patch.memoryUpkeep = body.memoryUpkeep;
+            }
             // per-bot gate on the app's built-in browser
             if (body.browser !== undefined) {
                 if (typeof body.browser !== "boolean")
@@ -17702,6 +18695,8 @@ const handleRequest = async (req, res) => {
             }
             if (!bot)
                 return json(res, 404, { error: "no such bot" });
+            if (body.memoryUpkeep === false)
+                memoryUpkeep.dropBot(bot.id);
             // A defined Works on is the newest explicit choice: this bot's
             // auto-recorded pins that now point elsewhere give way immediately, so
             // the next turn on each thread follows the new setting. Person-set pins
@@ -18024,154 +19019,6 @@ const handleRequest = async (req, res) => {
             broadcast({ kind: "bot", bot: visible });
             return json(res, 200, { bot: visible });
         }
-        // ── bot memory: MEMORY.md + memory/ topic and log files ──────────────
-        // The files already belong to the person (plain markdown in the bot's
-        // workspace). server/memory-store.ts decides which paths can be reached
-        // and refuses a save whose expectedHash no longer matches the file;
-        // server/memory-journal.ts records every change made here so it can be
-        // read back and reverted. Reads never create the workspace — a bot that
-        // has not run yet simply has nothing to show. Admin scope by default
-        // (request-auth.ts), like the profile routes above.
-        m = path.match(/^\/api\/bots\/([\w-]+)\/memory$/);
-        if (m && method === "GET") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            try {
-                const overview = memoryOverview(m[1]);
-                // `text` and `truncated` ride along one release for clients of the
-                // old whole-file shape; the panel reads the file through /memory/file
-                return json(res, 200, { ...overview, text: readMemoryDoc(m[1], MEMORY_INDEX).text, truncated: overview.index.truncated });
-            }
-            catch (error) {
-                return replyMemoryError(res, error);
-            }
-        }
-        if (m && method === "PUT") {
-            // The pre-panel whole-file write, kept one release: no hash check, so
-            // it can still overwrite a note the bot just wrote — journaled as the
-            // person's so at least the journal can undo it.
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            const parsed = z.object({ text: z.string() }).safeParse(await readBody(req));
-            if (!parsed.success)
-                return json(res, 400, { error: "text must be a string" });
-            try {
-                const { doc } = journalMemoryWrite(m[1], MEMORY_INDEX, parsed.data.text, { actor: "person", via: "api" });
-                return json(res, 200, { ok: true, hash: doc.hash, truncated: memoryCapacity(doc.text).truncated });
-            }
-            catch (error) {
-                // the old route answered 400 for an oversized body; keep that for
-                // its callers while the new route says 413
-                if (error instanceof MemoryStoreError && error.code === "too-large")
-                    return json(res, 400, { error: error.message });
-                return replyMemoryError(res, error);
-            }
-        }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/file$/);
-        if (m && method === "GET") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            try {
-                return json(res, 200, readMemoryDoc(m[1], url.searchParams.get("path") ?? MEMORY_INDEX));
-            }
-            catch (error) {
-                return replyMemoryError(res, error);
-            }
-        }
-        if (m && method === "PUT") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            const parsed = z
-                .object({ path: z.string().default(MEMORY_INDEX), text: z.string(), expectedHash: z.string().optional() })
-                .safeParse(await readBody(req));
-            if (!parsed.success)
-                return json(res, 400, { error: "text must be a string; path and expectedHash are optional strings" });
-            try {
-                const { doc, entry } = journalMemoryWrite(m[1], parsed.data.path, parsed.data.text, {
-                    actor: "person",
-                    via: "ui",
-                    expectedHash: parsed.data.expectedHash,
-                });
-                return json(res, 200, { ok: true, ...doc, entry: entry ? journalEntryForClient(m[1], entry) : null, overview: memoryOverview(m[1]) });
-            }
-            catch (error) {
-                return replyMemoryError(res, error);
-            }
-        }
-        if (m && method === "DELETE") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            const file = url.searchParams.get("path") ?? "";
-            try {
-                const entry = journalMemoryDelete(m[1], file, { actor: "person", via: "ui" });
-                return json(res, 200, { ok: true, path: file, entry: entry ? journalEntryForClient(m[1], entry) : null, overview: memoryOverview(m[1]) });
-            }
-            catch (error) {
-                return replyMemoryError(res, error);
-            }
-        }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/journal$/);
-        if (m && method === "GET") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            // the row a save queued a moment ago may not have reached disk yet
-            await flushMemoryJournal(m[1]);
-            const limit = Math.min(200, Math.max(1, Number(url.searchParams.get("limit") ?? 50) || 50));
-            const botId = m[1];
-            return json(res, 200, { entries: readMemoryJournal(botId, limit).map((entry) => journalEntryForClient(botId, entry)) });
-        }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/journal\/([\w-]+)\/revert$/);
-        if (m && method === "POST") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            await flushMemoryJournal(m[1]);
-            const result = revertMemoryChange(m[1], m[2]);
-            if (!result.ok)
-                return json(res, result.status, { error: result.error });
-            return json(res, 200, { ok: true, ...result.doc, entry: result.entry ? journalEntryForClient(m[1], result.entry) : null, overview: memoryOverview(m[1]) });
-        }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/open$/);
-        if (m && method === "POST") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            const parsed = z.object({ target: z.enum(["obsidian", "folder"]) }).safeParse(await readBody(req));
-            if (!parsed.success)
-                return json(res, 400, { error: "target must be obsidian or folder" });
-            // The folder is on this machine's disk; opening it only makes sense
-            // from this machine. A paired phone or a remote browser gets the path
-            // to open by hand instead.
-            const workspacePath = memoryOverview(m[1]).workspacePath;
-            if (auth.kind !== "loopback") {
-                return json(res, 403, { error: `This only works on the computer running OpenMausBot. The memory folder there is ${workspacePath}`, workspacePath });
-            }
-            const opened = await openMemoryLocation(m[1], parsed.data.target);
-            if (!opened.ok)
-                return json(res, 500, { error: opened.error, workspacePath: opened.workspacePath });
-            return json(res, 200, opened);
-        }
-        m = path.match(/^\/api\/bots\/([\w-]+)\/memory\/topics\/([^/]+)$/);
-        if (m && method === "GET") {
-            if (!store.bot(m[1]))
-                return json(res, 404, { error: "no such bot" });
-            // Decode before validating: a UI-sent name arrives percent-encoded
-            // ("my notes.md" → "my%20notes.md"), and an encoded traversal
-            // ("..%2F..") must be judged by what it decodes TO, not slip through
-            // as an opaque token. The name gate then rejects anything that is not
-            // a single plain-markdown path segment.
-            let name;
-            try {
-                name = decodeURIComponent(m[2]);
-            }
-            catch {
-                return json(res, 400, { error: "invalid topic name" });
-            }
-            if (!isMemoryTopicName(name))
-                return json(res, 400, { error: "invalid topic name" });
-            const text = readMemoryTopic(m[1], name);
-            if (text === null)
-                return json(res, 404, { error: "no such topic file" });
-            return json(res, 200, { name, text });
-        }
         // ── 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 —
@@ -18234,6 +19081,12 @@ const handleRequest = async (req, res) => {
             if (existing.card.requestId) {
                 return json(res, 409, { error: "request cards must be answered through the approval endpoint" });
             }
+            // On a Cloud home only the owner answers cards (cardAnswerRefusal).
+            // This route only keeps how an options card looks; the answer itself
+            // reaches the bot as a chat line, which lending already checks.
+            const cloudRefusal = CLOUD_HOME && body.answered !== undefined && auth.kind === "session" ? cloudCardRefusal(auth) : null;
+            if (cloudRefusal)
+                return json(res, 403, { error: cloudRefusal });
             if (Object.keys(body).some((key) => key !== "answered" && key !== "dismissed" && key !== "threadId")) {
                 return json(res, 400, { error: "only answered and dismissed may be changed" });
             }
@@ -18248,6 +19101,7 @@ const handleRequest = async (req, res) => {
                     ...existing.card,
                     ...(body.answered !== undefined ? { answered: body.answered } : {}),
                     ...(body.dismissed !== undefined ? { dismissed: body.dismissed } : {}),
+                    ...(CLOUD_HOME && body.answered !== undefined ? { answeredBy: cardAnswererFor(auth) } : {}),
                 },
             });
             return json(res, 200, { message: patched });
@@ -18626,7 +19480,10 @@ const handleRequest = async (req, res) => {
             // startTurn admits the rerun before branching. A shared-resource or
             // concurrency-limit refusal must leave the original transcript intact.
             const replyTo = source.replyToId ? resolveReplyTarget(bot.threadId, source.replyToId) : undefined;
-            const message = await startTurn(bot.id, text, { threadId: bot.threadId, editedMessageId: messageId, replyTo, sendId, trigger: usageTriggerFor(auth) });
+            // On a Cloud home an edit is its author's line, so the owner's own edit
+            // keeps their conversation theirs for lending (server/cloud-lending.ts).
+            const message = await startTurn(bot.id, text, { threadId: bot.threadId, editedMessageId: messageId, replyTo, sendId, trigger: usageTriggerFor(auth),
+                ...(CLOUD_HOME ? { sender: messageSender(auth) } : {}) });
             return json(res, 202, { ok: true, message });
         }
         // switch which fork of the conversation is visible (no new turn)
@@ -19203,7 +20060,7 @@ const handleRequest = async (req, res) => {
             broadcast({ kind: "bot", bot: fresh });
             return json(res, 200, { bot: fresh });
         }
-        // Named team Boxes use real independent ownership, never a hidden bot or
+        // Named team Boats use real independent ownership, never a hidden bot or
         // an arbitrary provider id. These new routes remain admin-only by default.
         if (path === "/api/team-computers" && method === "GET") {
             res.setHeader("cache-control", "private, no-store");
@@ -19240,7 +20097,7 @@ const handleRequest = async (req, res) => {
                 if (!parsed.success)
                     return json(res, 400, { error: "Choose take or release with a valid optional controlLeaseId" });
                 const key = teamComputerOwner(found.id);
-                if (parsed.data.action === "take" && boxLifecycleBusyBots.has(key))
+                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);
@@ -19261,13 +20118,13 @@ const handleRequest = async (req, res) => {
                     assertCurrentOwner();
                     if (section !== null && section !== "" && !store.sections.includes(section))
                         throw Object.assign(new Error("Create the team before assigning a computer"), { status: 404 });
-                    if (section !== null && store.bots.some(bot => sectionKey(bot.section) === section && (botHasActiveTurn(bot.id) || routines?.activeRunForBot(bot.id) || botComputerControlSnapshot(bot.id).held || boxLifecycleBusyBots.has(bot.id))))
+                    if (section !== null && store.bots.some(bot => sectionKey(bot.section) === section && (botHasActiveTurn(bot.id) || routines?.activeRunForBot(bot.id) || botComputerControlSnapshot(bot.id).held || boatLifecycleBusyBots.has(bot.id))))
                         throw Object.assign(new Error("Stop the target team's work and release computer control before assigning this computer"), { status: 409 });
                 };
                 checkAssignment();
                 const release = claimTeamComputerLifecycle(found);
                 try {
-                    if (section !== null && !(await box.findBox(cfg, teamComputerOwner(found.id))))
+                    if (section !== null && !(await boat.findBoat(cfg, teamComputerOwner(found.id))))
                         return json(res, 409, { error: "Create or retry this computer before assigning it to a team" });
                     checkAssignment();
                     if (teamComputerInUse(found))
@@ -19282,13 +20139,13 @@ 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 Box" });
-                if (!box.boxConfigured(cfg))
-                    return json(res, 409, { error: "Configure Box in Settings before creating a cloud computer" });
+                    return json(res, 400, { error: "Provide requestId (UUID), a name, and acknowledgeCost: true to create a paid Boat" });
+                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);
                 const release = claimTeamComputerLifecycle(computer);
                 try {
-                    await box.provisionBox(cfg, teamComputerOwner(computer.id), computer.name);
+                    await boat.provisionBoat(cfg, teamComputerOwner(computer.id), computer.name);
                     teamComputers.setProblem(computer.id);
                     return json(res, 201, { id: computer.id });
                 }
@@ -19302,18 +20159,18 @@ const handleRequest = async (req, res) => {
             }
             if (method === "POST" && found && action && action !== "control") {
                 if (action === "provision" && body?.acknowledgeCost !== true)
-                    return json(res, 400, { error: "Confirm Box creation or wake costs with acknowledgeCost: true" });
+                    return json(res, 400, { error: "Confirm Boat 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") {
                     const key = teamComputerOwner(found.id);
-                    if (boxLifecycleBusyBots.has(key))
+                    if (boatLifecycleBusyBots.has(key))
                         return json(res, 409, { error: "Wait for this computer's action to finish" });
                     if (!computerControl.snapshot(key).held)
                         return json(res, 409, { error: "Take control before opening this shared desktop" });
                     const release = claimBotComputerLifecycle(key);
                     try {
-                        return json(res, 200, await box.joinReadyBox(cfg, key));
+                        return json(res, 200, await boat.joinReadyBoat(cfg, key));
                     }
                     finally {
                         release();
@@ -19322,8 +20179,8 @@ const handleRequest = async (req, res) => {
                 const release = claimTeamComputerLifecycle(found);
                 try {
                     const result = action === "provision"
-                        ? await box.provisionBox(cfg, teamComputerOwner(found.id), found.name)
-                        : await box.sleepBox(cfg, teamComputerOwner(found.id));
+                        ? await boat.provisionBoat(cfg, teamComputerOwner(found.id), found.name)
+                        : await boat.sleepBoat(cfg, teamComputerOwner(found.id));
                     teamComputers.setProblem(found.id);
                     return json(res, 200, result);
                 }
@@ -19337,12 +20194,13 @@ const handleRequest = async (req, res) => {
             }
             return json(res, 405, { error: "method not allowed" });
         }
-        // Account-wide Box inventory is a Settings surface, never a provisioning
+        // Account-wide Boat inventory is a Settings surface, never a provisioning
         // path. Listing remains read-only; lifecycle changes require explicit
         // JSON actions and are revalidated against a fresh provider listing.
+        // The REST path keeps its historical /boxes segment.
         if (method === "GET" && path === "/api/computers/boxes") {
             res.setHeader("cache-control", "private, no-store");
-            return json(res, 200, await box.listManagedBoxes(cfg, managedBoxOwners()));
+            return json(res, 200, await boat.listManagedBoats(cfg, managedBoatOwners()));
         }
         m = path.match(/^\/api\/computers\/boxes\/([\w-]+)\/(sleep|delete)$/);
         if (m && method === "POST") {
@@ -19353,16 +20211,16 @@ const handleRequest = async (req, res) => {
             if (computerProviderConfigTransitions.has("box")) {
                 return json(res, 409, { error: providerTransitionMessage("box") });
             }
-            const releaseInventoryRequest = claimBoxInventoryRequest(m[1]);
+            const releaseInventoryRequest = claimBoatInventoryRequest(m[1]);
             try {
-                const owners = managedBoxOwners();
+                const owners = managedBoatOwners();
                 if (m[2] === "sleep") {
-                    return json(res, 200, await box.sleepManagedBox(cfg, owners, m[1], claimManagedBoxMutation));
+                    return json(res, 200, await boat.sleepManagedBoat(cfg, owners, m[1], claimManagedBoatMutation));
                 }
                 if (typeof body?.confirmName !== "string" || body.confirmName.length > 100) {
                     return json(res, 400, { error: "confirmName must be the cloud computer name shown in Settings" });
                 }
-                return json(res, 202, await box.deleteManagedBox(cfg, owners, m[1], body.confirmName, claimManagedBoxMutation));
+                return json(res, 202, await boat.deleteManagedBoat(cfg, owners, m[1], body.confirmName, claimManagedBoatMutation));
             }
             finally {
                 releaseInventoryRequest();
@@ -19370,7 +20228,7 @@ const handleRequest = async (req, res) => {
         }
         if (method === "GET" && path === "/api/computers/vps") {
             res.setHeader("cache-control", "private, no-store");
-            return json(res, 200, await vps.listManagedVpsComputers(cfg, managedBoxOwners()));
+            return json(res, 200, await vps.listManagedVpsComputers(cfg, managedBoatOwners()));
         }
         m = path.match(/^\/api\/computers\/vps\/([\w-]+)\/remove$/);
         if (m && method === "POST") {
@@ -19386,7 +20244,7 @@ const handleRequest = async (req, res) => {
             }
             const releaseComputerLifecycle = claimManagedVpsMutation(m[1]);
             try {
-                return json(res, 200, await vps.removeManagedVpsComputer(cfg, managedBoxOwners(), m[1], body.confirmName));
+                return json(res, 200, await vps.removeManagedVpsComputer(cfg, managedBoatOwners(), m[1], body.confirmName));
             }
             finally {
                 releaseComputerLifecycle();
@@ -19417,6 +20275,9 @@ const handleRequest = async (req, res) => {
             if (localVmMode(cfg) === "per-bot" && action === "run") {
                 return json(res, 409, { error: "Per-bot mode creates each desktop from that bot's Computer panel" });
             }
+            if (localVmMode(cfg) === "pool" && action === "run") {
+                return json(res, 409, { error: "Pool mode creates its desktops automatically from conversation turns" });
+            }
             const vmOwner = localVmLeaseFor(SHARED_LOCAL_VM_TARGET).current(localVmOwnerBusy);
             if (vmOwner && (action === "stop" || action === "remove" || action === "run")) {
                 return json(res, 409, { error: "the Local VM is being used by a bot — stop that turn first" });
@@ -19464,7 +20325,7 @@ const handleRequest = async (req, res) => {
             const bot = computerPreviewBot(m[1], url);
             if (!bot)
                 return json(res, 404, { error: "no such bot" });
-            return json(res, 200, await localVmPayload(localVmTargetForBot(bot.id)));
+            return json(res, 200, await localVmPayload(localVmTargetForStatus(bot.id, bot.threadId)));
         }
         m = path.match(/^\/api\/bots\/([\w-]+)\/local-computer\/(run|stop|remove)$/);
         if (m && method === "POST") {
@@ -19474,7 +20335,7 @@ const handleRequest = async (req, res) => {
             const bot = store.bot(m[1]);
             if (!bot)
                 return json(res, 404, { error: "no such bot" });
-            if (boxLifecycleBusyBots.has(bot.id)) {
+            if (boatLifecycleBusyBots.has(bot.id)) {
                 return json(res, 409, { error: "this bot's computer is being changed or deleted — wait for it to finish" });
             }
             const action = z.enum(["run", "stop", "remove"]).parse(m[2]);
@@ -19542,7 +20403,7 @@ const handleRequest = async (req, res) => {
             if (url.searchParams.has("threadId") && await computerPreviewSurface(bot, bot.threadId) !== "vm") {
                 return json(res, 409, { error: "This conversation is not using the Local VM" });
             }
-            const target = localVmTargetForBot(bot.id);
+            const target = localVmTargetForStatus(bot.id, url.searchParams.has("threadId") ? bot.threadId : undefined);
             localVmIdleFor(target).touch();
             res.setHeader("cache-control", "private, no-store");
             return json(res, 200, {
@@ -20238,6 +21099,14 @@ const handleRequest = async (req, res) => {
             }
             if (!Object.keys(patch).length)
                 return json(res, 400, { error: "nothing to save" });
+            if (patch.decider) {
+                // Saving a key is the "turn it on"; clearing it turns it off, or
+                // falls back to Cloud Pro's included decisions where there are some.
+                const planned = deciderSavePatch(patch.decider, cfg.decider, deciderIncludedHere());
+                if (!planned.ok)
+                    return json(res, 400, { error: planned.error });
+                patch.decider = planned.patch;
+            }
             const changingVoiceProvider = patch.tts?.provider !== undefined
                 && patch.tts.provider !== tts.voiceProvider(cfg);
             if (changingVoiceProvider && patch.tts?.voice === undefined) {
@@ -20294,16 +21163,16 @@ const handleRequest = async (req, res) => {
             }
             if (patch.box?.token !== undefined)
                 patch.box.token = patch.box.token.trim();
-            const currentBoxToken = cfg.box?.token?.trim() ?? "";
-            const nextBoxToken = patch.box?.token === undefined ? currentBoxToken : patch.box.token;
-            const changingBoxToken = patch.box?.token !== undefined && nextBoxToken !== currentBoxToken;
+            const currentBoatToken = cfg.box?.token?.trim() ?? "";
+            const nextBoatToken = patch.box?.token === undefined ? currentBoatToken : patch.box.token;
+            const changingBoatToken = patch.box?.token !== undefined && nextBoatToken !== currentBoatToken;
             const currentVpsAlias = vpsSshAlias(cfg);
             const nextVpsAlias = patch.vps === undefined
                 ? currentVpsAlias
                 : vpsSshAlias({ ...cfg, vps: patch.vps });
             const changingVpsAlias = patch.vps !== undefined && nextVpsAlias !== currentVpsAlias;
             const transitioningProviders = [
-                ...(changingBoxToken ? ["box"] : []),
+                ...(changingBoatToken ? ["box"] : []),
                 ...(changingVpsAlias ? ["vps"] : []),
             ];
             providerConfigBusy = true;
@@ -20319,7 +21188,7 @@ const handleRequest = async (req, res) => {
                 for (const provider of transitioningProviders)
                     computerProviderConfigTransitions.add(provider);
                 if (changingVpsAlias && currentVpsAlias) {
-                    const inventory = await vps.listManagedVpsComputers({ vps: { sshAlias: currentVpsAlias } }, managedBoxOwners());
+                    const inventory = await vps.listManagedVpsComputers({ vps: { sshAlias: currentVpsAlias } }, managedBoatOwners());
                     if (!inventory.available) {
                         return json(res, 503, {
                             error: `${inventory.problem ?? "VPS computer inventory is unavailable"}. Keep the current SSH config alias and retry`,
@@ -20329,24 +21198,24 @@ const handleRequest = async (req, res) => {
                     if (resourceError)
                         return json(res, 409, { error: resourceError });
                 }
-                let boxRecovery = changingBoxToken ? boxCreateRecoverySnapshot() : [];
-                let boxDeletions = changingBoxToken ? boxDeletionSnapshot() : [];
-                if (changingBoxToken && boxDeletions.length > 0 && !nextBoxToken) {
+                let boatRecovery = changingBoatToken ? boatCreateRecoverySnapshot() : [];
+                let boatDeletions = changingBoatToken ? boatDeletionSnapshot() : [];
+                if (changingBoatToken && boatDeletions.length > 0 && !nextBoatToken) {
                     return json(res, 409, {
-                        error: "finish or retry pending cloud computer deletion before removing the Box account",
+                        error: "finish or retry pending cloud computer deletion before removing the Boat account",
                     });
                 }
                 let replacementProvedByDeletion = false;
-                if (changingBoxToken && boxDeletions.length > 0 && nextBoxToken) {
+                if (changingBoatToken && boatDeletions.length > 0 && nextBoatToken) {
                     try {
-                        await box.verifyBoxDeletionCredential({ box: { token: nextBoxToken } });
+                        await boat.verifyBoatDeletionCredential({ box: { token: nextBoatToken } });
                         replacementProvedByDeletion = true;
                         // Verification can observe a completed operation and retire both
                         // its deletion fence and matching create receipt. Never continue
                         // with the pre-verification snapshots: they would demand access
-                        // to a Box whose exact operation just proved it was deleted.
-                        boxRecovery = boxCreateRecoverySnapshot();
-                        boxDeletions = boxDeletionSnapshot();
+                        // to a Boat whose exact operation just proved it was deleted.
+                        boatRecovery = boatCreateRecoverySnapshot();
+                        boatDeletions = boatDeletionSnapshot();
                     }
                     catch (error) {
                         return json(res, error?.status ?? 503, {
@@ -20354,28 +21223,28 @@ const handleRequest = async (req, res) => {
                         });
                     }
                 }
-                let currentBoxInventory = null;
-                let replacingRejectedBoxToken = false;
-                let currentBoxResources = null;
-                const journalBoxResources = [];
-                const deletingBoxIds = new Set(boxDeletions.map((entry) => entry.boxId));
-                if (changingBoxToken && currentBoxToken) {
-                    currentBoxInventory = await box.listManagedBoxes({ box: { token: currentBoxToken } }, managedBoxOwners());
-                    if (!currentBoxInventory.available) {
-                        replacingRejectedBoxToken = currentBoxInventory.credentialRejected === true && Boolean(nextBoxToken);
-                        if (!replacementProvedByDeletion && !replacingRejectedBoxToken) {
+                let currentBoatInventory = null;
+                let replacingRejectedBoatToken = false;
+                let currentBoatResources = null;
+                const journalBoatResources = [];
+                const deletingBoatIds = new Set(boatDeletions.map((entry) => entry.boxId));
+                if (changingBoatToken && currentBoatToken) {
+                    currentBoatInventory = await boat.listManagedBoats({ box: { token: currentBoatToken } }, managedBoatOwners());
+                    if (!currentBoatInventory.available) {
+                        replacingRejectedBoatToken = currentBoatInventory.credentialRejected === true && Boolean(nextBoatToken);
+                        if (!replacementProvedByDeletion && !replacingRejectedBoatToken) {
                             return json(res, 503, {
-                                error: `${currentBoxInventory.problem ?? "cloud computer inventory is unavailable"}. Keep the current Box account and retry`,
+                                error: `${currentBoatInventory.problem ?? "cloud computer inventory is unavailable"}. Keep the current Boat account and retry`,
                             });
                         }
                         // A rejected old key cannot authorize its own rotation. Below,
-                        // validate the replacement and prove access to remembered Boxes;
+                        // validate the replacement and prove access to remembered Boats;
                         // pending deletions retain their target-bound verification.
-                        currentBoxInventory = null;
+                        currentBoatInventory = null;
                     }
-                    if (currentBoxInventory) {
-                        const currentById = new Map(currentBoxInventory.instances.map((instance) => [instance.boxId, { boxId: instance.boxId, name: instance.name }]));
-                        for (const recovery of boxRecovery) {
+                    if (currentBoatInventory) {
+                        const currentById = new Map(currentBoatInventory.instances.map((instance) => [instance.boxId, { boxId: instance.boxId, name: instance.name }]));
+                        for (const recovery of boatRecovery) {
                             if (!recovery.boxId)
                                 continue;
                             // A failed provisioning attempt may never have reached the
@@ -20383,29 +21252,29 @@ const handleRequest = async (req, res) => {
                             // proved the exact deletion target, so its in-flight resource
                             // is governed by that stronger target-bound receipt rather
                             // than an OpenMausBot name check.
-                            if (replacementProvedByDeletion && deletingBoxIds.has(recovery.boxId))
+                            if (replacementProvedByDeletion && deletingBoatIds.has(recovery.boxId))
                                 continue;
-                            const inspected = await box.inspectBoxIdentity({ box: { token: currentBoxToken } }, recovery.boxId);
+                            const inspected = await boat.inspectBoatIdentity({ box: { token: currentBoatToken } }, recovery.boxId);
                             if (!inspected.available) {
                                 return json(res, 503, {
-                                    error: `${inspected.problem ?? "a remembered cloud computer could not be verified"}. Keep the current Box account and retry`,
+                                    error: `${inspected.problem ?? "a remembered cloud computer could not be verified"}. Keep the current Boat account and retry`,
                                 });
                             }
                             if (!inspected.identity) {
                                 // Reconcile exact stale receipts while the current credential is
                                 // still available. Leaving one behind would make a later token
-                                // addition demand access to a Box the provider proved is gone.
-                                retireDeletedBoxCreate(recovery.boxId);
+                                // addition demand access to a Boat the provider proved is gone.
+                                retireDeletedBoatCreate(recovery.boxId);
                                 continue;
                             }
                             const listed = currentById.get(inspected.identity.boxId);
                             if (listed && listed.name !== inspected.identity.name) {
-                                return json(res, 503, { error: "boat.dev returned conflicting cloud computer identities; keep the current Box account and retry" });
+                                return json(res, 503, { error: "boat.dev returned conflicting cloud computer identities; keep the current Boat account and retry" });
                             }
                             currentById.set(inspected.identity.boxId, inspected.identity);
-                            journalBoxResources.push(inspected.identity);
+                            journalBoatResources.push(inspected.identity);
                         }
-                        currentBoxResources = [...currentById.values()];
+                        currentBoatResources = [...currentById.values()];
                     }
                 }
                 if (changingLocalVmMode) {
@@ -20444,50 +21313,50 @@ const handleRequest = async (req, res) => {
                         patch.composio = { ...patch.composio, apiKey: "", sessionId: "" };
                     }
                 }
-                // check a box token against the provider before storing it: a
+                // check a boat token against the provider before storing it: a
                 // rejected token used to save happily and only surface as a 401 in
                 // another panel later, with nothing the user could act on
-                const newBoxToken = patch.box?.token;
-                if (newBoxToken?.trim()) {
-                    const check = await box.verifyToken(newBoxToken);
+                const newBoatToken = patch.box?.token;
+                if (newBoatToken?.trim()) {
+                    const check = await boat.verifyToken(newBoatToken);
                     if (!check.ok)
                         return json(res, 400, { error: check.message });
                 }
-                if (replacingRejectedBoxToken) {
+                if (replacingRejectedBoatToken) {
                     // An expired credential cannot authorize its own replacement. Probe
                     // the new account without adopting or retiring any local identities.
-                    const replacement = await box.listManagedBoxes({ box: { token: nextBoxToken } }, managedBoxOwners(), { adoptLegacy: false });
+                    const replacement = await boat.listManagedBoats({ box: { token: nextBoatToken } }, managedBoatOwners(), { adoptLegacy: false });
                     if (!replacement.available)
-                        return json(res, 503, { error: replacement.problem ?? "Could not verify the replacement Box key. Your saved key and computers are unchanged." });
+                        return json(res, 503, { error: replacement.problem ?? "Could not verify the replacement Boat key. Your saved key and computers are unchanged." });
                 }
-                if (changingBoxToken && (!currentBoxToken || replacementProvedByDeletion || replacingRejectedBoxToken) && boxRecovery.length > 0) {
-                    if (!nextBoxToken) {
-                        return json(res, 409, { error: "restore the Box account that owns the remembered cloud computers before clearing it" });
+                if (changingBoatToken && (!currentBoatToken || replacementProvedByDeletion || replacingRejectedBoatToken) && boatRecovery.length > 0) {
+                    if (!nextBoatToken) {
+                        return json(res, 409, { error: "restore the Boat account that owns the remembered cloud computers before clearing it" });
                     }
-                    for (const recovery of boxRecovery) {
+                    for (const recovery of boatRecovery) {
                         if (!recovery.boxId) {
-                            return json(res, 409, { error: "finish reconciling pending cloud computer creation before changing the Box account" });
+                            return json(res, 409, { error: "finish reconciling pending cloud computer creation before changing the Boat account" });
                         }
-                        if (replacementProvedByDeletion && deletingBoxIds.has(recovery.boxId))
+                        if (replacementProvedByDeletion && deletingBoatIds.has(recovery.boxId))
                             continue;
-                        const inspected = await box.inspectBoxIdentity({ box: { token: nextBoxToken } }, recovery.boxId);
+                        const inspected = await boat.inspectBoatIdentity({ box: { token: nextBoatToken } }, recovery.boxId);
                         if (!inspected.available) {
                             return json(res, 503, {
-                                error: `${inspected.problem ?? "a remembered cloud computer could not be verified"}. Retry with the Box account that created it`,
+                                error: `${inspected.problem ?? "a remembered cloud computer could not be verified"}. Retry with the Boat account that created it`,
                             });
                         }
-                        if (!inspected.identity || !(await box.boxNameMatchesBot(recovery.botId, inspected.identity.name))) {
-                            return json(res, 409, { error: "that Box token cannot access the remembered cloud computers from this installation" });
+                        if (!inspected.identity || !(await boat.boatNameMatchesBot(recovery.botId, inspected.identity.name))) {
+                            return json(res, 409, { error: "that Boat token cannot access the remembered cloud computers from this installation" });
                         }
                     }
                 }
-                if (changingBoxToken && currentBoxInventory && currentBoxResources) {
+                if (changingBoatToken && currentBoatInventory && currentBoatResources) {
                     let replacementResources = null;
-                    if (nextBoxToken) {
-                        const replacementInventory = await box.listManagedBoxes({ box: { token: nextBoxToken } }, managedBoxOwners(), { adoptLegacy: false });
+                    if (nextBoatToken) {
+                        const replacementInventory = await boat.listManagedBoats({ box: { token: nextBoatToken } }, managedBoatOwners(), { adoptLegacy: false });
                         if (!replacementInventory.available) {
                             return json(res, 503, {
-                                error: `${replacementInventory.problem ?? "cloud computer inventory is unavailable"}. Keep the current Box account and retry`,
+                                error: `${replacementInventory.problem ?? "cloud computer inventory is unavailable"}. Keep the current Boat account and retry`,
                             });
                         }
                         replacementResources = replacementInventory.instances.map((instance) => ({
@@ -20495,21 +21364,21 @@ const handleRequest = async (req, res) => {
                             name: instance.name,
                         }));
                         const replacementById = new Map(replacementResources.map((instance) => [instance.boxId, { boxId: instance.boxId, name: instance.name }]));
-                        for (const identity of journalBoxResources) {
-                            const inspected = await box.inspectBoxIdentity({ box: { token: nextBoxToken } }, identity.boxId);
+                        for (const identity of journalBoatResources) {
+                            const inspected = await boat.inspectBoatIdentity({ box: { token: nextBoatToken } }, identity.boxId);
                             if (!inspected.available) {
                                 return json(res, 503, {
-                                    error: `${inspected.problem ?? "a remembered cloud computer could not be verified"}. Keep the current Box account and retry`,
+                                    error: `${inspected.problem ?? "a remembered cloud computer could not be verified"}. Keep the current Boat account and retry`,
                                 });
                             }
                             if (!inspected.identity || inspected.identity.name !== identity.name) {
-                                return json(res, 409, { error: "the replacement Box token does not access the same cloud computers" });
+                                return json(res, 409, { error: "the replacement Boat token does not access the same cloud computers" });
                             }
                             replacementById.set(inspected.identity.boxId, inspected.identity);
                         }
                         replacementResources = [...replacementById.values()];
                     }
-                    const resourceError = boxAccountResourceChangeError(currentBoxResources, replacementResources);
+                    const resourceError = boatAccountResourceChangeError(currentBoatResources, replacementResources);
                     if (resourceError)
                         return json(res, 409, { error: resourceError });
                 }
@@ -20527,6 +21396,15 @@ const handleRequest = async (req, res) => {
                     if (!check.ok)
                         return json(res, 400, { error: check.message });
                 }
+                // A pasted decision-model key is tried once (one tiny yes/no call).
+                // Only a refusal blocks the save: an offline or overloaded service must
+                // not stop a person saving a key that may well be fine.
+                if (patch.decider?.key) {
+                    const check = await decider.testKey({ key: patch.decider.key });
+                    if (!check.ok && check.reason === "rejected") {
+                        return json(res, 400, { error: "Jev rejected this key. Check it at typesafe.ai and paste it again.", code: "decider_rejected" });
+                    }
+                }
                 if (patch.browserProfiles !== undefined) {
                     // Provider/credential validation above may await the network. A turn
                     // can start during that window and claim a profile which looked idle
@@ -20594,6 +21472,8 @@ const handleRequest = async (req, res) => {
                             persisted.tts.key = "";
                         if (persisted.tts?.fishKey !== undefined)
                             persisted.tts.fishKey = "";
+                        if (persisted.decider?.key !== undefined)
+                            persisted.decider.key = "";
                         if (persisted.imageGen?.key !== undefined)
                             persisted.imageGen.key = "";
                         if (persisted.imageGen?.customApiKey !== undefined)
@@ -20629,7 +21509,7 @@ const handleRequest = async (req, res) => {
                 let browserReferenceCleanupError = null;
                 if (patch.signIn !== undefined)
                     sessions.revalidateEmailSessions();
-                if (!sharedComputersEnabled(cfg)) {
+                if (!lendingEnabled()) {
                     sharedComputers.close();
                     sharedComputerControl.close();
                 }
@@ -20777,6 +21657,9 @@ const handleRequest = async (req, res) => {
             return json(res, 200, {
                 configured: composio.configured(cfg),
                 mode: composio.connectionMode(cfg),
+                // lets the panel say "add a key" on a fresh server instead of
+                // reporting an outage that never happened
+                setup: composio.connectorSetup(cfg),
                 source,
                 cards,
                 ...(pagination ? { pagination } : {}),
@@ -20984,7 +21867,7 @@ const handleRequest = async (req, res) => {
             }
             return json(res, 405, { error: "method not allowed" });
         }
-        // ── the bot's cloud computer (Box) ──
+        // ── the bot's cloud computer (Boat) ──
         m = path.match(/^\/api\/bots\/([\w-]+)\/computer$/);
         if (m && method === "GET") {
             const bot = computerPreviewBot(m[1], url);
@@ -20995,10 +21878,10 @@ const handleRequest = async (req, res) => {
                 return json(res, 200, { surface, configured: false, backend: bot.cloudBackend === "vps" ? "vps" : "box" });
             const teamComputer = inheritedTeamComputer(bot);
             if (teamComputer)
-                return json(res, 200, { surface, backend: "box", teamComputer: { id: teamComputer.id, name: teamComputer.name }, ...(await box.boxStatus(cfg, teamComputerOwner(teamComputer.id))) });
+                return json(res, 200, { surface, backend: "box", teamComputer: { id: teamComputer.id, name: teamComputer.name }, ...(await boat.boatStatus(cfg, teamComputerOwner(teamComputer.id))) });
             return bot.cloudBackend === "vps"
                 ? json(res, 200, { surface, backend: "vps", ...(await vps.vpsComputerStatus(cfg, bot.id)) })
-                : json(res, 200, { surface, backend: "box", ...(await box.boxStatus(cfg, bot.id)) });
+                : json(res, 200, { surface, backend: "box", ...(await boat.boatStatus(cfg, bot.id)) });
         }
         // Who is driving this bot's computer. GET is the panel's initial read;
         // POST take/release/dismiss-help are the person's three moves. The bot
@@ -21032,7 +21915,7 @@ const handleRequest = async (req, res) => {
                     return json(res, 400, { error: "controlLeaseId is invalid" });
                 }
                 const controlLeaseId = leaseResult?.data;
-                if (action === "take" && (boxLifecycleBusyBots.has(bot.id) || boxLifecycleBusyBots.has(controlKey))) {
+                if (action === "take" && (boatLifecycleBusyBots.has(bot.id) || boatLifecycleBusyBots.has(controlKey))) {
                     return json(res, 409, { error: "this bot's cloud computer is being changed — wait before taking control" });
                 }
                 if (action === "take" && controlLeaseId) {
@@ -21082,7 +21965,7 @@ const handleRequest = async (req, res) => {
             // request (same reasoning as the Local VM lifecycle routes above): a
             // hostile page cannot submit it with a form, and its cross-origin JSON
             // request dies in the preflight this server never answers. Applied to
-            // both backends — the Box branch runs commands too.
+            // both backends — the Boat branch runs commands too.
             if (!String(req.headers["content-type"] ?? "").toLowerCase().startsWith("application/json")) {
                 return json(res, 415, { error: "content-type must be application/json" });
             }
@@ -21090,13 +21973,13 @@ const handleRequest = async (req, res) => {
             if (computerProviderConfigTransitions.has(remoteProvider)) {
                 return json(res, 409, { error: providerTransitionMessage(remoteProvider) });
             }
-            if (boxLifecycleBusyBots.has(botId)) {
+            if (boatLifecycleBusyBots.has(botId)) {
                 return json(res, 409, { error: "this bot's cloud computer is being changed — wait for it to finish" });
             }
             const teamComputer = inheritedTeamComputer(bot);
             if (teamComputer) {
                 const key = teamComputerOwner(teamComputer.id);
-                if (boxLifecycleBusyBots.has(key))
+                if (boatLifecycleBusyBots.has(key))
                     return json(res, 409, { error: "This team computer is being changed; wait for it to finish" });
                 if (m[2] === "provision" || m[2] === "remove")
                     return json(res, 409, { error: "Manage this shared computer from the Team map" });
@@ -21107,12 +21990,12 @@ const handleRequest = async (req, res) => {
                 const release = m[2] === "sleep" ? claimTeamComputerLifecycle(teamComputer) : claimBotComputerLifecycle(key);
                 try {
                     if (m[2] === "join")
-                        return json(res, 200, await box.joinReadyBox(cfg, key));
+                        return json(res, 200, await boat.joinReadyBoat(cfg, key));
                     if (m[2] === "screenshot") {
                         res.setHeader("cache-control", "private, no-store");
-                        return json(res, 200, await box.screenshotBox(cfg, key));
+                        return json(res, 200, await boat.screenshotBoat(cfg, key));
                     }
-                    return json(res, 200, await box.sleepBox(cfg, key));
+                    return json(res, 200, await boat.sleepBoat(cfg, key));
                 }
                 finally {
                     release();
@@ -21153,8 +22036,8 @@ const handleRequest = async (req, res) => {
                     releaseComputerLifecycle();
                 }
             }
-            const activeBoxTurn = botHasActiveTurn(botId);
-            if (["provision", "sleep"].includes(m[2]) && activeBoxTurn) {
+            const activeBoatTurn = botHasActiveTurn(botId);
+            if (["provision", "sleep"].includes(m[2]) && activeBoatTurn) {
                 return json(res, 409, {
                     error: CLOUD_COMPUTER_BUSY_ERROR,
                 });
@@ -21162,39 +22045,39 @@ const handleRequest = async (req, res) => {
             // Input validity is independent of destination authorization. Preserve
             // the stable 400 contract for oversized commands without contacting the
             // provider; a valid Auto request still reaches the 409 gate below.
-            let boxCommand;
+            let boatCommand;
             if (m[2] === "exec") {
                 const body = await readBody(req);
-                boxCommand = String(body?.command ?? "");
-                if (boxCommand.length > box.MAX_REMOTE_COMMAND_LENGTH) {
+                boatCommand = String(body?.command ?? "");
+                if (boatCommand.length > boat.MAX_REMOTE_COMMAND_LENGTH) {
                     return json(res, 400, {
-                        error: `command is too long (maximum ${box.MAX_REMOTE_COMMAND_LENGTH} characters)`,
+                        error: `command is too long (maximum ${boat.MAX_REMOTE_COMMAND_LENGTH} characters)`,
                     });
                 }
             }
             if (bot.computer !== "cloud" && !threadPreview) {
                 return json(res, 409, {
-                    error: "Choose Cloud before changing or opening this Box. Auto only checks existing computer state.",
+                    error: "Choose Cloud before changing or opening this Boat. Auto only checks existing computer state.",
                 });
             }
             if (m[2] === "remove") {
-                // Boxes sleep and wake; only the VPS backend has a container to remove.
-                return json(res, 409, { error: "the cloud Box backend has no container to remove — use sleep instead" });
+                // 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" });
             }
             const releaseComputerLifecycle = claimBotComputerLifecycle(botId);
             try {
                 switch (m[2]) {
                     case "provision":
-                        return json(res, 200, await box.provisionBox(cfg, botId, bot.name));
+                        return json(res, 200, await boat.provisionBoat(cfg, botId, bot.name));
                     case "join":
-                        return json(res, 200, await (activeBoxTurn || threadPreview ? box.joinReadyBox(cfg, botId) : box.joinBox(cfg, botId)));
+                        return json(res, 200, await (activeBoatTurn || threadPreview ? boat.joinReadyBoat(cfg, botId) : boat.joinBoat(cfg, botId)));
                     case "sleep":
-                        return json(res, 200, await box.sleepBox(cfg, botId));
+                        return json(res, 200, await boat.sleepBoat(cfg, botId));
                     case "exec":
-                        return json(res, 200, await box.execOnBox(cfg, botId, boxCommand ?? ""));
+                        return json(res, 200, await boat.execOnBoat(cfg, botId, boatCommand ?? ""));
                     case "screenshot":
                         res.setHeader("cache-control", "private, no-store");
-                        return json(res, 200, await box.screenshotBox(cfg, botId));
+                        return json(res, 200, await boat.screenshotBoat(cfg, botId));
                 }
             }
             finally {
@@ -21364,6 +22247,7 @@ server.listen(PORT, "127.0.0.1", () => {
     // ordinary chat. Start only once every registry is initialized and the
     // endpoint is listening; earlier dispatch can hit uninitialized bindings.
     routines.start();
+    memoryUpkeep.start();
     const leftover = pendingThreads();
     if (leftover.length)
         console.log(`delegations: ${leftover.length} thread(s) with queued handoffs from a previous run — draining`);
@@ -21418,6 +22302,7 @@ const gracefulShutdown = createGracefulShutdown({
             watchdog.stop();
             routines?.stop();
             calendarCalls?.stop();
+            memoryUpkeep.stop();
             webhookIngress?.server.close();
             tunnelListener?.close();
         },
@@ -21448,7 +22333,8 @@ const gracefulShutdown = createGracefulShutdown({
         }
         closeMessageDb();
         releaseDataDirLeaseAtExit();
-        process.exit(code);
+        // A Cloud home's launcher starts the server again on this code only.
+        process.exit(cloudHomeRestartRequested && code === 0 ? CLOUD_HOME_RESTART_EXIT_CODE : code);
     },
 });
 for (const signal of ["SIGINT", "SIGTERM"]) {