openmausbot 0.1.88 → 0.1.90

package/dist-server/server/index.js

@@ -22,7 +22,8 @@ import { assertRequestTarget, guardedRequestPath, requestConflict, requestNeedsI
 import { botAvatarUrlFromStoredPath } from "../shared/bot-avatar.js";
 import { BOT_PROFILE_LIMITS } from "../shared/bot-profile.js";
 import { CLOUD_COMPUTER_BUSY_ERROR } from "../shared/computer-contention.js";
-import { approvalModeFor, supportsApprovalMode, modelSwitchNeedsAsk, isEmergencyApprovalDowngrade, isApprovalMode, } from "../shared/approval-mode.js";
+import { approvalModeFor, modelSwitchNeedsAsk, isEmergencyApprovalDowngrade, isApprovalMode, } from "../shared/approval-mode.js";
+import { createApprovalModeSupport } from "./harness-capabilities.js";
 import { escapeAttribute } from "../src/lib/composer-attachments.js";
 import { CREDENTIAL_TARGETS, credentialResumeOutcome, credentialIsConfigured, isPendingCredentialRequest, isCredentialTargetId, } from "../shared/credential-request.js";
 import { approvalHeldNote, approvalHeldReason, approvalModeForOrigin, autoVerdict, deliverFullAccessApproval, delegationInheritsFullAccess } from "./auto-approve.js";
@@ -43,20 +44,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, 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, 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";
@@ -71,8 +75,9 @@ import { entitled } from "./enterprise.js";
 import { HOSTED_CONTRACT_HEADER, HOSTED_CONTRACT_METADATA, HOSTED_CONTRACT_VERSION } from "./hosted-contract.js";
 import { describeSpawnFailure, execCli } from "./procs.js";
 import { blockedTarget, buildNotification, buildSpendNotification } from "./notify.js";
-import { isModelVariant, newId, } from "./contracts.js";
+import { isModelVariant, TurnNotStartedError, newId, } from "./contracts.js";
 import { RETRY_MAX_ATTEMPTS } from "./drivers/retry.js";
+import { recoveryCapabilityError } from "./automatic-recovery.js";
 import { decodeGeneratedImage } from "./generated-image.js";
 import { MAX_MCP_SERVERS, listMcpServers, mcpServerNameError, parseMcpServerMutation, parseMcpServersImport, parseStoredMcpServer, } from "./mcp-registry.js";
 import { probeMcpServer } from "./mcp-probe.js";
@@ -88,16 +93,17 @@ 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 { CLOUD_IGNORED_KEYS, CLOUD_PAIRING_PATH, cloudHomeConfiguration, createCloudPairing, readSignedBody } from "./cloud-home.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";
@@ -111,10 +117,10 @@ import { Handoffs, handedStateUsable, recordHanded, renderUnseen, sessionStart,
 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";
@@ -123,11 +129,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, } from "./system-prompt.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 { 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";
@@ -172,6 +179,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";
@@ -199,6 +207,7 @@ 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";
 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).
@@ -262,6 +271,21 @@ 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();
+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}`);
+}
 // 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"));
@@ -343,6 +367,10 @@ function customDomainStatus() {
     };
 }
 const registry = new ProviderRegistry(BUILT_IN_DRIVERS);
+// The approval gates below hand this their model selection — or a driver
+// view they already hold — and let the registry resolve the driver, instead
+// of each site unwrapping registry.cliTarget(...)?.driverKind itself.
+const supportsApprovalMode = createApprovalModeSupport(registry);
 // Engines installed from Settings live under the data directory and win over
 // any other copy on PATH.
 registerEnginesBinDir();
@@ -611,6 +639,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
@@ -868,15 +946,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
@@ -1346,12 +1426,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;
@@ -1389,6 +1621,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;
@@ -1454,7 +1690,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));
@@ -1851,8 +2112,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) {
@@ -2314,13 +2576,13 @@ function previewSystemPrompt(bot) {
     const caps = instance?.adapter.capabilities;
     const teamComputer = inheritedTeamComputer(bot);
     const previewComputer = teamComputer ? "cloud" : bot.computer;
-    const computerPromptKind = previewComputer === "vm"
-        ? caps?.computerMcp ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : null
-        : previewComputer === "cloud"
-            ? instance?.driverKind === "boxAgent" ? "box-agent" : caps?.computerMcp ? bot.cloudBackend === "vps" ? "vps" : caps.cloudComputerMcp ? "box-chat" : "box" : null
-            : previewComputer === "local"
-                ? caps?.localComputerMcp ? "local" : null
-                : null;
+    const computerPromptKind = resolveComputerPromptKind({
+        kind: previewComputer === "vm" ? "vm" : previewComputer === "cloud"
+            ? bot.cloudBackend === "vps" ? "vps" : "box" : previewComputer === "local" ? "local" : null,
+        driverKind: instance?.driverKind,
+        cloudComputerMcp: caps?.cloudComputerMcp,
+        vmPrivate: localVmMode(cfg) === "per-bot",
+    });
     const peers = reachablePeers(store.bots, bot);
     const coordination = bot.chiefOfStaff
         ? chiefOfStaffSystemPrompt(bot.id, store.bots, true, openMausStatusSystemPrompt())
@@ -2455,7 +2717,7 @@ async function botOverview(bot) {
  * person gave the Chief covers the work the Chief hands out. */
 const approvalModeForTurn = (bot, peerInitiated = false) => {
     const mode = approvalModeForOrigin(approvalModeFor(bot), { peerInitiated });
-    if (!supportsApprovalMode(registry.cliTarget(bot.modelSelection.instanceId)?.driverKind, mode)) {
+    if (!supportsApprovalMode(bot.modelSelection, mode)) {
         return "ask";
     }
     return mode;
@@ -2528,8 +2790,8 @@ function handleDesktopTrustedApprovalMessage(raw) {
     const grantBusy = (bot) => bot.approvalGrant?.threadOnly
         ? threadBusy(bot.id, bot.approvalGrant.threadId) : bot.busy ||
         Boolean(bot.approvalGrant?.allThreads && store.tasks(bot.id).some(task => threadBusy(bot.id, task.threadId)));
-    const grantSupported = (bot, mode) => supportsApprovalMode(registry.cliTarget(grantTarget(bot)?.modelSelection.instanceId ?? "")?.driverKind, mode) &&
-        (!bot.approvalGrant?.allThreads || store.tasks(bot.id).every(task => supportsApprovalMode(registry.cliTarget((task.modelSelection ?? bot.modelSelection).instanceId)?.driverKind, mode)));
+    const grantSupported = (bot, mode) => supportsApprovalMode(grantTarget(bot)?.modelSelection, mode) &&
+        (!bot.approvalGrant?.allThreads || store.tasks(bot.id).every(task => supportsApprovalMode(task.modelSelection ?? bot.modelSelection, mode)));
     const clearGrant = (bot) => store.patchBot(bot.id, {
         ...(!bot.approvalGrant?.threadOnly ? { approvalMode: "ask", autoApprove: false } : {}),
         approvalGrant: undefined,
@@ -2762,7 +3024,7 @@ function handleDesktopTrustedApprovalMessage(raw) {
         void stopBotForEmergencyApprovalDowngrade(botId).then(() => respond({ ok: true, bot: wireBot(store.bot(botId) ?? updated) }), () => respond({ ok: false, error: "Approval was reset to Ask, but an active turn could not be stopped" }));
         return true;
     }
-    if (message.allThreads === true && (existing.approvalGrant || store.tasks(botId).some(task => threadBusy(botId, task.threadId) || !supportsApprovalMode(registry.cliTarget((task.modelSelection ?? existing.modelSelection).instanceId)?.driverKind, mode)))) {
+    if (message.allThreads === true && (existing.approvalGrant || store.tasks(botId).some(task => threadBusy(botId, task.threadId) || !supportsApprovalMode(task.modelSelection ?? existing.modelSelection, mode)))) {
         respond({ ok: false, error: "Finish this bot's active turns and approval changes first. Every thread's provider must support Full access." });
         return true;
     }
@@ -2782,7 +3044,7 @@ function handleDesktopTrustedApprovalMessage(raw) {
             respond({ ok: false, error: "Stop this thread and finish its pending approval change first" });
             return true;
         }
-        if (!supportsApprovalMode(registry.cliTarget(target.modelSelection.instanceId)?.driverKind, mode)) {
+        if (!supportsApprovalMode(target.modelSelection, mode)) {
             respond({ ok: false, error: "This thread's provider does not support that approval level" });
             return true;
         }
@@ -2842,7 +3104,7 @@ function handleDesktopTrustedApprovalMessage(raw) {
         respond({ ok: false, error: "Stop this bot's turn before changing its approval level" });
         return true;
     }
-    if (!supportsApprovalMode(registry.cliTarget(existing.modelSelection.instanceId)?.driverKind, mode)) {
+    if (!supportsApprovalMode(existing.modelSelection, mode)) {
         respond({
             ok: false,
             error: mode === "full"
@@ -4374,6 +4636,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
@@ -4544,12 +4889,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 {
@@ -4646,6 +4986,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();
@@ -4658,8 +5003,8 @@ const autoVmClaims = new Map();
  * answers held. A free, ready VM claims in the time of one container
  * inspect; only a claim queued behind another holder outlives this. */
 const LAZY_VM_CLAIM_GRACE_MS = 5_000;
-/** Local VM targets this process has seen ready or recreatable — at boot, in
- * the inventory, or in a turn. Auto probes the container runtime for a VM
+/** Local VM targets with a durable workspace or seen ready/recreatable — at
+ * boot, in the inventory, or in a turn. Auto probes the container runtime for a VM
  * only when one of these exists, so an ordinary Auto turn on a machine with
  * no VM never pays for a docker or podman call. */
 const localVmSeen = new Set();
@@ -4689,12 +5034,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.
@@ -4709,7 +5054,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);
@@ -4761,6 +5106,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 {
@@ -4801,13 +5150,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 } : {}),
@@ -4816,34 +5165,34 @@ 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 ||
@@ -4851,7 +5200,7 @@ async function attachTeamBox(computer, botId, owner, canMount, remoteAgent) {
         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),
+        capture: () => boat.screenshotBoat(cfg, ownerId, machine.id),
     };
 }
 /** "Works on: This computer", strict. One mount for a bot thread and a group
@@ -4910,17 +5259,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
@@ -4929,7 +5278,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,
@@ -4937,16 +5286,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")
@@ -4954,19 +5303,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) }
             : 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 ||
@@ -4985,7 +5334,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
@@ -4995,19 +5344,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()) {
@@ -5017,10 +5366,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,
     });
 }
@@ -5030,18 +5379,18 @@ function turnProvider(bot, runOn, threadId) {
     const wants = turnSurfacePlan(bot, runOn, threadId).computer;
     if (wants !== undefined && wants !== "cloud")
         return null;
-    if (registry.get(bot.modelSelection.instanceId)?.driverKind === "boxAgent")
+    if (registry.get(bot.modelSelection.instanceId)?.adapter.capabilities.remoteAgent === true)
         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);
 }
@@ -5061,14 +5410,14 @@ async function computerPreviewSurface(bot, threadId) {
     if (plan.computer !== undefined)
         return plan.computer === "off" && plan.browser ? "browser" : plan.computer;
     const instance = registry.get(bot.modelSelection.instanceId);
-    if (instance?.driverKind === "boxAgent")
+    if (instance?.adapter.capabilities.remoteAgent === true)
         return "cloud";
     if (bot.cloudBackend === "vps") {
         const remote = await vps.vpsComputerStatus(cfg, bot.id);
         if (remote.ready)
             return "cloud";
     }
-    const target = localVmTargetForBot(bot.id);
+    const target = localVmTargetForStatus(bot.id, threadId);
     if (instance?.adapter.capabilities.computerMcp && localVmSeen.has(target.key)) {
         const vm = await containerComputerStatus(undefined, undefined, target).catch(() => null);
         if (vm && autoLocalVmAttachable(vm))
@@ -5086,7 +5435,7 @@ async function computerPreviewSurface(bot, threadId) {
 async function selectableComputers(bot) {
     const caps = registry.get(bot.modelSelection.instanceId)?.adapter.capabilities;
     const off = bot.computer === "off";
-    const localEngine = registry.get(bot.modelSelection.instanceId)?.driverKind !== "boxAgent";
+    const localEngine = caps?.remoteAgent !== true;
     return Promise.all(["cloud", "vm", "local", "browser"].map(async (surface) => {
         let ready = false;
         let canStart = false;
@@ -5104,16 +5453,16 @@ async function selectableComputers(bot) {
                     canCreate = Boolean(status?.configured && status.daemonUp && status.container === "missing");
                     reason = status?.problem ?? reason;
                 }
-                else if (box.boxConfigured(cfg) && (caps?.cloudComputerMcp || 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);
@@ -5192,29 +5541,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 });
     }
@@ -5225,20 +5574,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 });
     }
@@ -5247,6 +5596,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);
 }
@@ -5280,6 +5653,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);
@@ -5290,6 +5676,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);
@@ -5297,6 +5704,13 @@ void (async () => {
             localVmIdleFor(SHARED_LOCAL_VM_TARGET).touch();
         return;
     }
+    // Idle cleanup removes the container, not its provisioned workspace. Restore
+    // Auto eligibility before runtime discovery, including when it is offline.
+    for (const bot of store.bots) {
+        const target = perBotLocalVmTarget(bot.id);
+        if (localVmWorkspaceExists(target))
+            localVmSeen.add(target.key);
+    }
     const runtime = await containerRuntimeStatus().catch(() => null);
     if (!runtime?.runtime || !runtime.daemonUp)
         return;
@@ -5484,15 +5898,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();
+                        }
                     }
                 }
             }
@@ -6705,6 +7137,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
@@ -6834,7 +7269,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. */
@@ -6842,7 +7277,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 } = {}) {
@@ -6935,7 +7370,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
@@ -7038,7 +7473,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))
@@ -7075,7 +7510,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);
@@ -7124,7 +7559,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;
@@ -7156,6 +7591,9 @@ async function startTurn(botId, text, opts) {
                 sender: opts?.sender,
             });
     }
+    const recoveryUserMessageId = opts?.coordination
+        ? store.activePath(threadId).findLast(m => m.role === "user" && m.kind === "text")?.id
+        : userMessage.id;
     // Admitted: every refusal above has passed and no other turn runs on this
     // thread, so this is the one moment the ledger's "who asked" may change.
     if (opts?.trigger)
@@ -7176,7 +7614,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 };
@@ -7444,7 +7882,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")
@@ -7466,12 +7904,11 @@ 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";
             const mountsComputerMcp = instance.adapter.capabilities.computerMcp === true;
-            const mountsCloudComputer = instance.driverKind === "boxAgent" || instance.adapter.capabilities.cloudComputerMcp === true;
             const mountsLocalComputer = instance.adapter.capabilities.localComputerMcp === true;
             // Where this turn's hands may land. The bot's "Works on" choice is
             // strict; a browser-only bot gets no computer at all, and a bot whose
@@ -7485,7 +7922,7 @@ async function startTurn(botId, text, opts) {
             const dispatchTask = store.taskByThread(bot.id, threadId);
             if (plan.clearPin && dispatchTask)
                 store.patchTask(bot.id, threadId, { surface: undefined });
-            if (plan.computer !== undefined && plan.computer !== "cloud" && instance.driverKind === "boxAgent") {
+            if (plan.computer !== undefined && plan.computer !== "cloud" && instance.adapter.capabilities.remoteAgent === true) {
                 throw new Error("the Computer engine works on the cloud computer — set Works on to Cloud, or choose another engine");
             }
             const wants = plan.computer;
@@ -7513,6 +7950,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
@@ -7522,7 +7978,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");
@@ -7533,6 +7989,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();
@@ -7574,12 +8034,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
@@ -7616,12 +8081,21 @@ async function startTurn(botId, text, opts) {
             // be recreated on demand after idling away — and never creates a first
             // VM on its own; every failure there is a quiet "not this place".
             const attachLocalVm = async (strict) => {
-                if (!mountsComputerMcp || instance.driverKind === "boxAgent") {
+                if (!mountsComputerMcp || instance.adapter.capabilities.remoteAgent === true) {
                     if (!strict)
                         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
@@ -7663,7 +8137,7 @@ async function startTurn(botId, text, opts) {
                                 // guard as dispatch: a poller started after its own
                                 // turn.completed would never be torn down.
                                 if (previewCapture && threadBusy(bot.id, threadId)) {
-                                    const touched = screenPollers.get(threadId)?.touched ?? instance.driverKind === "boxAgent";
+                                    const touched = screenPollers.get(threadId)?.touched ?? instance.adapter.capabilities.remoteAgent === true;
                                     stopScreenPoller(bot.id, threadId);
                                     startScreenPoller(bot.id, threadId, { computer: previewCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
                                 }
@@ -7723,6 +8197,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;
@@ -7745,19 +8220,19 @@ 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, mountsCloudComputer, instance.driverKind === "boxAgent");
+                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 && mountsCloudComputer && (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: mountsCloudComputer,
-                    remoteAgent: instance.driverKind === "boxAgent",
+                    canMount: instance.adapter.capabilities.usesCloudComputer === true,
+                    remoteAgent: instance.adapter.capabilities.remoteAgent === true,
                 });
                 if (attached) {
                     previewCapture = attached.capture;
@@ -7767,8 +8242,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("Cloud Boat is not configured — add a Boat API key or choose Local VM");
             }
             if (wants === "cloud" && cloudBackend === "box" && !integrations.computer) {
                 throw new Error("the cloud computer could not be created or reached");
@@ -7796,7 +8271,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";
                 }
@@ -7928,8 +8420,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" });
             }
@@ -7944,15 +8443,12 @@ async function startTurn(botId, text, opts) {
             if (!markDirectTurnDispatching(bot.id, dispatchClaimId, threadId)) {
                 throw new DirectTurnSetupCancelled("turn stopped before dispatch");
             }
-            const computerPromptKind = computerKind === "vm"
-                ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared"
-                : computerKind === "box"
-                    ? instance.driverKind === "boxAgent" ? "box-agent" : instance.adapter.capabilities.cloudComputerMcp ? "box-chat" : "box"
-                    : computerKind === "vps"
-                        ? "vps"
-                        : computerKind === "local"
-                            ? "local"
-                            : null;
+            const computerPromptKind = resolveComputerPromptKind({
+                kind: computerKind,
+                driverKind: instance.driverKind,
+                cloudComputerMcp: instance.adapter.capabilities.cloudComputerMcp,
+                vmPrivate: localVmMode(cfg) === "per-bot",
+            });
             const coordinationNode = opts?.coordination ? roomHandoffs.nodes.get(opts.coordination.id) : undefined;
             if (opts?.coordination && (!coordinationNode || coordinationNode.status !== "running" || roomHandoffProblem(coordinationNode, coordinationNode.parentId ? roomHandoffs.nodes.get(coordinationNode.parentId) : undefined))) {
                 throw new DirectTurnSetupCancelled("Coordination access changed before dispatch");
@@ -7993,6 +8489,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
@@ -8016,7 +8521,8 @@ async function startTurn(botId, text, opts) {
             const dispatch = await guardTurnDispatch(instance.adapter.sendTurn({
                 threadId,
                 botId: bot.id,
-                text: dispatchContext.turnText,
+                startupRecovery: cfg.automaticRecovery?.enabled === true && !opts?.automaticRecoveryAttempted,
+                text: withRecalled(recalled, dispatchContext.turnText),
                 refreshSystemPrompt: true,
                 images: turnImages,
                 approvalMode: approvalModeForTurn(bot, commsDepth > 0),
@@ -8078,10 +8584,10 @@ 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.driverKind === "boxAgent" });
+                startScreenPoller(bot.id, threadId, { ...(previewCapture ? { computer: previewCapture } : {}), ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: instance.adapter.capabilities.remoteAgent === true });
             }
             // An adapter may publish completion synchronously just before its
             // dispatch promise resolves. The event could not use the turn-id map
@@ -8098,7 +8604,17 @@ async function startTurn(botId, text, opts) {
                 drainDelegationWakes();
             }
         }
-        catch (e) {
+        catch (cause) {
+            let e = cause;
+            // Only the driver can prove that a task was never submitted and its
+            // old process is gone. A timeout/error string alone is not that proof.
+            const mayRecover = e instanceof TurnNotStartedError &&
+                directTurnClaimIsCurrent(bot.id, dispatchClaimId, threadId);
+            if (e instanceof TurnNotStartedError) {
+                retireProviderTurn(e.turnId);
+                if (!mayRecover)
+                    e = new DirectTurnSetupCancelled("turn stopped during provider setup");
+            }
             handoffs.abandon(threadId, dispatchClaimId);
             if (computerSelectionTurns.get(threadId)?.generation === dispatchClaimId)
                 computerSelectionTurns.delete(threadId);
@@ -8108,6 +8624,8 @@ async function startTurn(botId, text, opts) {
             const ownsLatestGeneration = directTurnGenerationByThread.get(threadId) === dispatchClaimId;
             releaseTurnResources(resourceOwner);
             if (ownsLatestGeneration) {
+                runningTurnEngines.delete(threadId);
+                endMemoryTurn(threadId);
                 clearTurnDigestState(threadId);
                 releaseLocalVmThread(threadId);
                 vpsThreadEnded(bot.id, threadId);
@@ -8136,7 +8654,47 @@ async function startTurn(botId, text, opts) {
                 settleDirectFollowup(dispatchClaimId);
                 return;
             }
-            const message = e instanceof Error ? e.message : String(e);
+            let message = e instanceof Error ? e.message : String(e);
+            const backup = cfg.automaticRecovery?.enabled ? cfg.automaticRecovery.backup : undefined;
+            const current = store.projectBotForTask(bot.id, threadId);
+            if (mayRecover && backup && current && !opts?.automaticRecoveryAttempted && (!opts?.cardContinuation || opts.coordination) &&
+                !directRequestOwners.get(threadId)?.stopped && !hasQueuedSteeredMessages(bot.id, threadId) &&
+                JSON.stringify(current.modelSelection) === JSON.stringify(bot.modelSelection) &&
+                (backup.instanceId !== instanceId || backup.model !== model) &&
+                store.activePath(threadId).findLast(m => m.role === "user" && m.kind === "text")?.id === recoveryUserMessageId) {
+                // No await between releasing the failed attempt and admitting its
+                // replacement: a newer send or Stop must never lose to a stale retry.
+                store.setTaskActivity(bot.id, threadId, "idle");
+                directTurnBots.delete(threadId);
+                const checked = checkedTaskModelSwitch(current, backup, false, false, true);
+                const target = checked.ok ? registry.get(checked.selection.instanceId) : null;
+                const refusal = !checked.ok ? checked.error : !target || !target.enabled ? "The backup engine is unavailable."
+                    : !store.taskByThread(bot.id, threadId)?.cwd ? "This older thread has no pinned working folder. Choose its backup manually."
+                        : policyModelRefusal(target) ?? recoveryCapabilityError({ driverKind: instance.driverKind, capabilities: instance.adapter.capabilities }, { driverKind: target.driverKind, capabilities: target.adapter.capabilities });
+                if (!refusal && checked.ok && target) {
+                    try {
+                        assertWithinBudget(cfg, DATA_DIR);
+                        store.switchTaskModel(bot.id, threadId, checked.selection, false, false, {
+                            ...hostedModels?.resetTask(current.modelSelection, checked.selection), rewound: true,
+                        });
+                        store.appendMessage(threadId, { role: "bot", kind: "activity", tool: {
+                                name: `recovery: Automatic recovery: ${instance.displayName || instance.driverKind} could not start. Trying ${target.displayName || target.driverKind} · ${checked.selection.model} once in this thread.`, ok: true,
+                            } });
+                        await startTurn(bot.id, text, { ...opts, threadId, userMessage, editedMessageId: undefined,
+                            automaticRecoveryAttempted: true });
+                        // The backup now owns these callbacks; don't publish a failed
+                        // routine/peer result or release a queued receipt in between.
+                        directFollowupSettlers.delete(dispatchClaimId);
+                        directCoordinationSettlers.delete(dispatchClaimId);
+                        return;
+                    }
+                    catch (failure) {
+                        message += ` Backup could not start: ${failure instanceof Error ? failure.message : String(failure)}`;
+                    }
+                }
+                else if (refusal)
+                    message = `Automatic recovery unavailable: ${refusal} Original error: ${message}`;
+            }
             settleDirectFollowup(dispatchClaimId, { ok: false, text: message });
             // The wait already wrote its failure resolution; keep all dispatch
             // failure bookkeeping below without adding the same error twice.
@@ -8404,6 +8962,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);
@@ -8541,10 +9109,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);
@@ -8552,15 +9120,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 };
     }
@@ -8583,9 +9151,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;
     },
@@ -8602,7 +9170,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);
@@ -8617,17 +9185,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
@@ -8676,25 +9244,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
@@ -8707,14 +9275,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) {
@@ -8836,7 +9404,7 @@ const validateModelProposal = (selection, current) => {
     if (current) {
         const mode = approvalModeFor(current);
         const driver = registry.cliTarget(selection.instanceId)?.driverKind;
-        if (!supportsApprovalMode(driver, mode) || ((mode === "full" || mode === "custom") && driver !== registry.cliTarget(current.modelSelection.instanceId)?.driverKind)) {
+        if (!supportsApprovalMode(selection, mode) || ((mode === "full" || mode === "custom") && driver !== registry.cliTarget(current.modelSelection.instanceId)?.driverKind)) {
             return `@${current.name}'s existing permissions are incompatible with that provider. Change its permissions in bot settings, then propose the model change again.`;
         }
     }
@@ -9286,7 +9854,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);
@@ -9296,9 +9867,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)
@@ -9311,7 +9883,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
@@ -9480,14 +10053,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"))) {
@@ -9575,7 +10173,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;
@@ -9617,7 +10215,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.
@@ -9626,7 +10224,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.
@@ -9653,9 +10251,9 @@ setupRetry = 0) {
         const roomPlaceRefusal = roomKind && managedPolicy.computerRefusal(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
+        // 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.driverKind === "boxAgent") {
+        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");
         }
         // One place per room turn as well: a team computer reached on Auto means
@@ -9676,12 +10274,12 @@ setupRetry = 0) {
             return false;
         }
         if (roomTeamComputer) {
-            const attached = await attachTeamBox(roomTeamComputer, readyBot.id, resourceOwner, instance.driverKind === "boxAgent" || instance.adapter.capabilities.cloudComputerMcp === true, instance.driverKind === "boxAgent");
+            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;
             integrations.computer = attached.integration;
-            startScreenPoller(readyBot.id, threadId, { computer: attached.capture }, { screenIsTheWork: instance.driverKind === "boxAgent" });
+            startScreenPoller(readyBot.id, threadId, { computer: attached.capture }, { screenIsTheWork: instance.adapter.capabilities.remoteAgent === true });
         }
         // The speaker's own explicit place, mounted exactly as its bot thread
         // mounts it. A channel has no conversation pin and no Auto fallback here:
@@ -9719,11 +10317,11 @@ 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");
-                const remoteAgent = instance.driverKind === "boxAgent";
-                const attached = await attachBotBox(readyBot, resourceOwner, { explicitCloud: true,
-                    canMount: remoteAgent || instance.adapter.capabilities.cloudComputerMcp === true, remoteAgent });
+                if (!boat.boatConfigured(cfg))
+                    throw new Error("Cloud Boat is not configured — add a Boat API key or choose Local VM");
+                const remoteAgent = instance.adapter.capabilities.remoteAgent === true;
+                const attached = await attachBotBoat(readyBot, resourceOwner, { explicitCloud: true,
+                    canMount: instance.adapter.capabilities.usesCloudComputer === true, remoteAgent });
                 if (!roomSetupIsCurrent())
                     return false;
                 if (!attached?.integration)
@@ -9737,11 +10335,11 @@ setupRetry = 0) {
         // Room and Goal turns use the speaker's desktop, never the coordinator's.
         // Claim the same lease as direct turns before asynchronous VM setup.
         if (readyBot.computer === "vm") {
-            if (instance.adapter.capabilities.computerMcp !== true || instance.driverKind === "boxAgent") {
+            if (instance.adapter.capabilities.computerMcp !== true || instance.adapter.capabilities.remoteAgent === true) {
                 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");
@@ -9749,6 +10347,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);
@@ -9850,6 +10450,11 @@ setupRetry = 0) {
         // (#754) the room is told, once per source thread, rather than the
         // crossing being blocked.
         const recentLines = recentWork(recentWorkSources(bot), bot, { userName, currentThreadId: threadId });
+        const roomComputerPromptKind = resolveComputerPromptKind({
+            kind: roomTeamComputer || roomComputerKind === "box" ? "box" : roomVmTarget ? "vm" : roomComputerKind,
+            driverKind: instance.driverKind, cloudComputerMcp: instance.adapter.capabilities.cloudComputerMcp,
+            vmPrivate: localVmMode(cfg) === "per-bot",
+        });
         {
             const crossing = claimRecallCrossings(threadId, recentLines.filter((line) => line.private).map((line) => line.threadId));
             if (crossing.count) {
@@ -9865,7 +10470,7 @@ setupRetry = 0) {
             { id: "user-profile", label: "About the user", text: userProfileSystemPrompt(cfg.profile) },
             { id: "files", label: "File locations", text: workspace ? workspaceLocationsPrompt(bot.id, cwd, readyBot.cwd) : "" },
             { id: "mcp", label: "MCP servers", text: customMcpPrompt(Object.keys(integrations.custom ?? {})) },
-            { id: "computer", label: "Computer", text: computerPrompt(roomTeamComputer || roomComputerKind === "box" ? instance.driverKind === "boxAgent" ? "box-agent" : instance.adapter.capabilities.cloudComputerMcp ? "box-chat" : "box" : roomVmTarget ? localVmMode(cfg) === "per-bot" ? "vm-private" : "vm-shared" : roomComputerKind) },
+            { 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: "browser", label: "Browser", text: integrations.browser ? BUILT_IN_BROWSER_SYSTEM_PROMPT : "" },
@@ -9995,10 +10600,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),
@@ -10523,17 +11131,49 @@ 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,
-    });
+    // 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);
@@ -10602,6 +11242,11 @@ function startGroupTurn(groupId, text, replyTo, sendId, channelMode = "chat", qu
             .catch(() => undefined);
     }
     const operation = beginGroupTurnOperation(groupId, threadId, goalCoordinator ? [] : responders.map((responder) => responder.id));
+    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);
+    }
     if (goalCoordinator) {
         const runId = options.goalRunId?.trim() || `goal-${Date.now().toString(36)}-${randomUUID()}`;
         const startedAt = Date.now();
@@ -10686,19 +11331,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",
@@ -11573,7 +12231,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.
  *
@@ -11593,7 +12251,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;
@@ -11607,9 +12269,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;
@@ -11717,6 +12379,7 @@ function configStatus() {
         // not a secret — the settings picker shows it; "" = follow the system
         language: cfg.language ?? "",
         rooms: { turnTimeoutMinutes: roomTurnTimeoutMinutes(cfg) },
+        automaticRecovery: cfg.automaticRecovery ?? { enabled: false },
         // absent effort = no level is sent, so clients can tell it from any level
         newBots: cfg.newBots?.effort ? { effort: cfg.newBots.effort } : {},
         threads: {
@@ -11731,6 +12394,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
@@ -11739,6 +12403,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
@@ -12049,26 +12714,6 @@ 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
@@ -12099,13 +12744,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
@@ -12122,6 +12767,19 @@ 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() });
+    },
+}));
 const toolResults = new ToolResults();
 const handleRequest = async (req, res) => {
     let url;
@@ -12226,6 +12884,26 @@ const handleRequest = async (req, res) => {
             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
@@ -12379,6 +13057,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") {
@@ -12755,7 +13436,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") {
@@ -13079,11 +13760,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) {
@@ -13107,8 +13789,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,
@@ -15277,6 +15959,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];
@@ -16495,7 +17218,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),
@@ -16512,11 +17245,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
@@ -16535,25 +17288,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) {
@@ -17029,7 +17782,7 @@ const handleRequest = async (req, res) => {
             if ([existing, selected].some((owner) => {
                 const mode = approvalModeFor(owner);
                 return (mode === "full" || mode === "custom") &&
-                    (!supportsApprovalMode(registry.cliTarget(checked.selection.instanceId)?.driverKind, mode) ||
+                    (!supportsApprovalMode(checked.selection, mode) ||
                         registry.cliTarget(checked.selection.instanceId)?.driverKind !== registry.cliTarget(owner.modelSelection.instanceId)?.driverKind);
             })) {
                 return json(res, 400, {
@@ -17294,6 +18047,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")
@@ -17391,14 +18149,14 @@ const handleRequest = async (req, res) => {
             if (normalizedSelection && selectedTask) {
                 const mode = approvalModeFor(selectedTask);
                 if ((mode === "full" || mode === "custom") &&
-                    (!supportsApprovalMode(registry.cliTarget(normalizedSelection.instanceId)?.driverKind, mode) ||
+                    (!supportsApprovalMode(normalizedSelection, mode) ||
                         registry.cliTarget(normalizedSelection.instanceId)?.driverKind !== registry.cliTarget(selectedTask.modelSelection.instanceId)?.driverKind)) {
                     return json(res, 400, { error: "Choose Ask for the selected thread before changing providers with elevated permissions" });
                 }
             }
             if ((requestedApprovalMode === "full" || requestedApprovalMode === "custom") &&
                 (body.approvalMode !== undefined || normalizedSelection !== undefined) &&
-                (!targetSelection || !supportsApprovalMode(registry.cliTarget(targetSelection.instanceId)?.driverKind, requestedApprovalMode) ||
+                (!targetSelection || !supportsApprovalMode(targetSelection, requestedApprovalMode) ||
                     (existingBot && normalizedSelection && registry.cliTarget(normalizedSelection.instanceId)?.driverKind !== registry.cliTarget(existingBot.modelSelection.instanceId)?.driverKind))) {
                 return json(res, 400, {
                     error: "This provider does not support the selected approval level, or changing providers requires choosing Ask first",
@@ -17631,6 +18389,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
@@ -17953,154 +18713,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 —
@@ -18926,7 +19538,7 @@ const handleRequest = async (req, res) => {
                 }
                 if (bot.approvalGrant)
                     return json(res, 409, { error: "the bot's approval mode is still being confirmed" });
-                if (!supportsApprovalMode(registry.cliTarget(bot.modelSelection.instanceId)?.driverKind, "full")) {
+                if (!supportsApprovalMode(bot.modelSelection, "full")) {
                     return json(res, 400, { error: "This provider does not support Full access" });
                 }
             }
@@ -19077,7 +19689,7 @@ const handleRequest = async (req, res) => {
                     return json(res, 403, { error: "Full and Custom access require trusted desktop confirmation" });
                 if (approvalModeFor(current) === "custom")
                     return json(res, 403, { error: "Leaving Custom approval requires confirmation in the packaged desktop app" });
-                if (!supportsApprovalMode(registry.cliTarget((patch.modelSelection ?? current.modelSelection).instanceId)?.driverKind, mode)) {
+                if (!supportsApprovalMode(patch.modelSelection ?? current.modelSelection, mode)) {
                     return json(res, 400, { error: "This provider does not support the selected approval level" });
                 }
                 if (threadBusy(current.id, current.threadId))
@@ -19132,7 +19744,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");
@@ -19169,7 +19781,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);
@@ -19190,13 +19802,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))
@@ -19211,13 +19823,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 });
                 }
@@ -19231,18 +19843,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();
@@ -19251,8 +19863,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);
                 }
@@ -19266,12 +19878,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") {
@@ -19282,16 +19895,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();
@@ -19299,7 +19912,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") {
@@ -19315,7 +19928,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();
@@ -19346,6 +19959,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" });
@@ -19393,7 +20009,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") {
@@ -19403,7 +20019,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]);
@@ -19471,7 +20087,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, {
@@ -20153,6 +20769,18 @@ const handleRequest = async (req, res) => {
                 if (!checked.ok)
                     return json(res, checked.status, { error: checked.error });
             }
+            if (patch.automaticRecovery?.enabled) {
+                const checked = checkedModelSelection(patch.automaticRecovery.backup, undefined, true);
+                if (!checked.ok)
+                    return json(res, checked.status, { error: checked.error });
+                const target = registry.get(checked.selection.instanceId);
+                if (!target.enabled)
+                    return json(res, 400, { error: "Enable the backup engine before selecting it for recovery." });
+                const refusal = policyModelRefusal(target);
+                if (refusal)
+                    return json(res, 403, { error: refusal, code: "managed_policy" });
+                patch.automaticRecovery.backup = checked.selection;
+            }
             if (!Object.keys(patch).length)
                 return json(res, 400, { error: "nothing to save" });
             const changingVoiceProvider = patch.tts?.provider !== undefined
@@ -20211,16 +20839,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;
@@ -20236,7 +20864,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`,
@@ -20246,24 +20874,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, {
@@ -20271,28 +20899,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
@@ -20300,29 +20928,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) {
@@ -20361,50 +20989,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) => ({
@@ -20412,21 +21040,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 });
                 }
@@ -20694,6 +21322,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 } : {}),
@@ -20901,7 +21532,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);
@@ -20912,10 +21543,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
@@ -20949,7 +21580,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) {
@@ -20999,7 +21630,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" });
             }
@@ -21007,13 +21638,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" });
@@ -21024,12 +21655,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();
@@ -21070,8 +21701,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,
                 });
@@ -21079,39 +21710,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 {
@@ -21281,6 +21912,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`);
@@ -21335,6 +21967,7 @@ const gracefulShutdown = createGracefulShutdown({
             watchdog.stop();
             routines?.stop();
             calendarCalls?.stop();
+            memoryUpkeep.stop();
             webhookIngress?.server.close();
             tunnelListener?.close();
         },