openmausbot 0.1.82 → 0.1.84

package/dist-server/server/index.js

@@ -2,7 +2,7 @@
 // (upstream rule): the React app dispatches typed commands over HTTP and
 // folds one SSE event stream; every provider process runs here.
 import { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
-import { existsSync, readFileSync, rmSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync, rmSync } from "node:fs";
 import { rm as removeDirectory } from "node:fs/promises";
 import { createServer } from "node:http";
 import { extname, join } from "node:path";
@@ -16,7 +16,7 @@ import { CLOUD_COMPUTER_BUSY_ERROR } from "../shared/computer-contention.js";
 import { approvalModeFor, supportsApprovalMode, modelSwitchNeedsAsk, isEmergencyApprovalDowngrade, isApprovalMode, } from "../shared/approval-mode.js";
 import { escapeAttribute } from "../src/lib/composer-attachments.js";
 import { CREDENTIAL_TARGETS, credentialResumeOutcome, credentialIsConfigured, isReusableCredentialRequest, isCredentialTargetId, } from "../shared/credential-request.js";
-import { approvalHeldNote, approvalHeldReason, approvalModeForOrigin, autoVerdict, deliverFullAccessApproval } from "./auto-approve.js";
+import { approvalHeldNote, approvalHeldReason, approvalModeForOrigin, autoVerdict, deliverFullAccessApproval, delegationInheritsFullAccess } from "./auto-approve.js";
 import { updateClaudeCli } from "./claude-update.js";
 import { configuredAccountDirectory, assertSeparateClaudeAccount, claudeAccountInfo, createClaudeAccountSchema, instanceSettingsSchema, newClaudeAccount } from "./claude-accounts.js";
 import { BrowserCleanupCoordinator, finalizeBrowserCleanupMutation, requireBrowserCleanupAcknowledged, } from "./browser-lifecycle-cleanup.js";
@@ -31,15 +31,17 @@ import { groupTurnCwd } from "./room-cwd.js";
 import { RoomTurnDeadline, RoomTurnStallRegistry, roomTurnTimeoutMessage } from "./room-turn-timeout.js";
 import * as box from "./box.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 * as composio from "./composio.js";
 import { chiefOfStaffSystemPrompt } from "./chief-of-staff.js";
-import { canAccessTeam, canReachPeer, peerAllowed, peerName, peerRosterSystemPrompt, peerStatus, peerStatusWords, reachablePeers, roomPeerRosterSystemPrompt, roomRosterLine } from "./peer-roster.js";
+import { canAccessTeam, canReachPeer, peerAllowed, peerName, peerRosterSystemPrompt, peerStatus, peerStatusWords, reachablePeers, resolveTeammate, roomPeerRosterSystemPrompt, roomRosterLine } from "./peer-roster.js";
 import { openMausStatusSystemPrompt } from "./openmaus-status-capsule.js";
 import { containerComputerAction, containerComputerExists, containerComputerFrame, containerComputerMcp, containerComputerScreenshot, containerComputerStatus, containerRuntimeStatus, localVmRecreatableOnDemand, perBotLocalVmTarget, SHARED_LOCAL_VM_TARGET, setupCommands, } from "./container-computer.js";
-import { ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, maxConcurrentBotThreads, threadEventLogMaxBytes, saveConfig, showToolCallsEnabled, claudeUserMcpEnabled, skillAuthoringEnabled, sharedComputersEnabled, builtInBrowserEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, } from "./config.js";
+import { ensureDirs, instanceConfigs, loadConfig, providerReloadKeys, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, threadEventLogMaxBytes, maxConcurrentBotThreads, threadEventLogRetentionDays, saveConfig, showToolCallsEnabled, claudeUserMcpEnabled, skillAuthoringEnabled, sharedComputersEnabled, builtInBrowserEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, roomHandoffLimits, } from "./config.js";
+import { sweepThreadEventLogs } from "./thread-retention.js";
 import { ComputerControl } from "./computer-control.js";
 import { augmentedPath, findCliCandidates, resetPathCache } from "./env-path.js";
 import { registerEnginesBinDir } from "./engine-install.js";
@@ -51,7 +53,7 @@ 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 } from "./notify.js";
-import { isEffortLevel, isModelVariant, newId, } from "./contracts.js";
+import { isModelVariant, newId, } from "./contracts.js";
 import { RETRY_MAX_ATTEMPTS } from "./drivers/retry.js";
 import { decodeGeneratedImage } from "./generated-image.js";
 import { MAX_MCP_SERVERS, listMcpServers, mcpServerNameError, parseMcpServerMutation, parseMcpServersImport, parseStoredMcpServer, } from "./mcp-registry.js";
@@ -62,13 +64,14 @@ import { getOrCreateChannel, mirrorActivity, mirrorExchange, mirrorReply } from
 import { readMessageText, recallMessages, recentMessages, searchMessages, closeMessageDb, chatFollowups, cancelledChatFollowup, settleChatFollowups } from "./message-db.js";
 import { briefCrossingLabel, claimRecallCrossings, recallCrossingLabel } from "./recall-disclosure.js";
 import { parseSince, recentWork, recentWorkPrompt, turnOutcomeLine } from "./recent-work.js";
+import { chiefForBot, INCIDENTS_THREAD_TITLE, IncidentLedger, incidentChip, incidentText } from "./incidents.js";
 /** A session_read answer competes with the transcript for the context
  * window; a computer-use turn's output can run to hundreds of KB. */
 const SESSION_READ_MAX_CHARS = 8_000;
 import { promptWithReply, transcriptText } from "./replies.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, onSteeredQueueChange, queuedSteerSnapshot, queuedSteeredMessage, queuedThreadPosition, queueSteeredMessage, restoreSteeredMessages, } from "./steer-queue.js";
-import { cancelChannelMessage, drainChannelMessages, queuedChannelMessage, queueChannelMessage, restoreChannelMessages, } from "./channel-queue.js";
+import { cancelSteeredMessage, drainSteeredMessages, 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 { acceptedSendMatch, parseSendId, sendFingerprint, SendSequencer, } from "./send-idempotency.js";
 import { EventBus } from "./harness/bus.js";
 import { ProviderRegistry } from "./harness/registry.js";
@@ -77,10 +80,11 @@ import { selectDefaultModelSelection } from "./default-model-selection.js";
 import { cancelPeerApprovalsFor, cancelPeerApprovalsForThread, dismissStalePeerCards, requestPeerApproval, resolvePeerComms } from "./peer-approval.js";
 import { peerProvenanceNote, withPeerProvenance } from "./peer-provenance.js";
 import { decideRoomPost, emptyRoomPostBudget } from "./room-post-budget.js";
-import { isProjectEmoji, mentionedBots, roomResponders, sectionKey, Store, } from "./store.js";
+import { isProjectEmoji, mentionedBots, roomResponders, sectionKey, Store, toWireTask, } from "./store.js";
 import * as tts from "./tts/index.js";
 import { narrateTool, toUtterances } from "./tts/speech-text.js";
-import { buildRecoveryText, buildTurnContext, engineIsFresh } from "./turn-context.js";
+import { buildRecoveryText, buildTurnContext, engineIsFresh, peerMessageText } from "./turn-context.js";
+import { Handoffs, handedStateUsable, recordHanded, renderUnseen, sessionStart, unseenMessages, withUnseenMessages } from "./delta-context.js";
 import { extractTurnImages } from "./turn-images.js";
 import { TurnWatchdog } from "./turn-watchdog.js";
 import { TurnResources, workspaceResource } from "./turn-resources.js";
@@ -135,6 +139,8 @@ import { createTeamBackup, importTeamBackup } from "./team-backup.js";
 import { MAX_TEAM_BACKUP_BYTES } from "../shared/team-backup.js";
 import { shouldMountLocalComputer } from "./local-routing.js";
 import { autoLocalVmAttachable } from "./container-computer.js";
+import { startAutoVmClaim } from "./auto-vm-claims.js";
+import { computerFreeText, computerStillBusyText, computerWaitEndedText, computerWaitingText } from "./computer-wait.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";
@@ -603,6 +609,8 @@ function claimTurnResource(owner, resource) {
 function releaseTurnResources(owner) {
     if (!owner)
         return;
+    if (autoVmClaims.get(owner.threadId)?.owner.generation === owner.generation)
+        autoVmClaims.delete(owner.threadId);
     if (settlingResourceOwners.get(owner.threadId) === owner.generation)
         settlingResourceOwners.delete(owner.threadId);
     turnResources.release(owner);
@@ -620,6 +628,9 @@ async function bindTurnComputer(owner, resource, exclusive = false) {
     const active = () => activeInternalGenerationByThread.get(owner.threadId) === owner.generation &&
         turnResourceOwners.get(owner.threadId)?.generation === owner.generation;
     let waitingMessage;
+    // Who holds the desktop, as the chip and the give-up error name them: a
+    // bot running a titled thread, or a room. Read once, when the wait begins.
+    let holder;
     const deadline = Date.now() + GROUP_GOAL_WAIT_MAX_MS;
     try {
         while (true) {
@@ -631,23 +642,25 @@ async function bindTurnComputer(owner, resource, exclusive = false) {
                 const blocker = turnResources.blocker(resource, owner);
                 const holderBot = blocker && store.botByThread(blocker.threadId);
                 const holderTask = holderBot && blocker && store.taskByThread(holderBot.id, blocker.threadId);
-                const holder = holderBot ? `${holderBot.name}${holderTask?.title ? ` / ${holderTask.title}` : ""}`
-                    : blocker && store.groupByThread(blocker.threadId)?.name;
+                const holderRoom = !holderBot && blocker ? store.groupByThread(blocker.threadId) : null;
+                holder = holderBot
+                    ? { name: holderBot.name, ...(holderTask?.title ? { task: holderTask.title } : {}) }
+                    : holderRoom ? { name: holderRoom.name } : undefined;
                 waitingMessage = store.appendMessage(owner.threadId, {
                     role: "bot", kind: "activity",
-                    tool: { name: `Waiting for computer${holder ? ` — ${holder} is using it` : ""}; will continue automatically` },
+                    tool: { name: computerWaitingText(holder) },
                     ...(holderBot && holderTask ? { threadRef: { botId: holderBot.id, threadId: holderTask.threadId, title: holderTask.title } } : {}),
                 });
             }
             if (Date.now() >= deadline)
-                throw new Error("Computer is still busy. Stop the turn using it, then retry.");
+                throw new Error(computerStillBusyText(holder, GROUP_GOAL_WAIT_MAX_MS));
             await new Promise(resolve => setTimeout(resolve, 100));
         }
     }
     finally {
         if (waitingMessage)
             store.patchMessage(owner.threadId, waitingMessage.id, {
-                tool: { name: active() && turnResources.owns(resource, owner) ? "Computer available — continuing" : "Computer wait ended", ok: true },
+                tool: { name: active() && turnResources.owns(resource, owner) ? computerFreeText() : computerWaitEndedText(), ok: true },
             });
     }
     turnResourceOwners.set(owner.threadId, owner);
@@ -676,6 +689,14 @@ function botAtThreadCapacity(botId) {
 function hasDirectDispatch(botId) {
     return [...directTurnDispatchClaims.values()].some((claim) => claim.botId === botId);
 }
+/** Routine and webhook dispatch shares startTurn's admission preconditions
+ * instead of waiting for whole-bot idleness: a free thread slot and no
+ * active group turn. A group turn blocks scheduled starts the same way it
+ * blocks every other turn kind; it does not consume a capacity slot. */
+function unattendedDispatchState(botId) {
+    const bot = store.bot(botId);
+    return !bot ? "missing" : botAtThreadCapacity(botId) || activeGroupTurnForBot(botId) ? "busy" : "ready";
+}
 function requestedTaskBot(botId, rawThreadId) {
     const profile = store.bot(botId);
     if (!profile)
@@ -1265,7 +1286,9 @@ if (browserCleanupReferencesReconciled)
  * than the desktop window did. Stripped here rather than at each call site
  * so a new broadcast cannot forget. */
 let activeCoordinationForThread = (_threadId) => false;
-const wireTask = ({ resumeCursors: _resumeCursors, lastInstanceId: _lastInstanceId, ...task }) => activeCoordinationForThread(task.threadId) && !task.busy ? { ...task, busy: true, activity: "working" } : task;
+const wireTask = (task) => activeCoordinationForThread(task.threadId) && !task.busy
+    ? { ...toWireTask(task), busy: true, activity: "working" }
+    : toWireTask(task);
 const wireBot = (bot) => {
     const { resumeCursors: _resumeCursors, tasks, approvalGrant, lastProfileRequestId: _lastProfileRequestId, lastTeamSetupReceipt: _lastTeamSetupReceipt, ...rest } = bot;
     // An elevated selection is inert until the desktop confirms its exact
@@ -1433,7 +1456,10 @@ async function botOverview(bot) {
  * approval semantics require an implemented provider mapping. The trusted transition enforces
  * this too, but no provider dispatch or later permission callback relies on
  * persistence having been produced exclusively by that route. Delegation
- * uses the receiving bot's grant, never the sender's — see approvalModeForOrigin. */
+ * uses the receiving bot's grant, never the sender's (approvalModeForOrigin) —
+ * with one deliberate exception: a Chief of Staff with Full access makes the
+ * threads it delegates Full too (delegatedFullAccess), so the grant the
+ * 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)) {
@@ -1454,6 +1480,48 @@ function fullAccessForSource(botId, threadId) {
 function peerReviewRequired(bot, threadId) {
     return Boolean(bot.approvePeerComms && !fullAccessForSource(bot.id, threadId));
 }
+/** Full access flows down a Chief of Staff's delegation. The person gave the
+ * Chief Full access so its work runs without prompts; a teammate stopping
+ * that same work to ask defeats the grant — and in practice the person was
+ * answering every one of those cards, all day, for the whole team. So a
+ * teammate a Full-access Chief delegates to runs Full for that work: the
+ * recipient switches, whatever its own level says. The recipient's engine
+ * has to implement Full (supportsApprovalMode); otherwise the work keeps the
+ * recipient's own level, as before. Only a Chief passes access on — an
+ * ordinary bot's delegation still uses the recipient's setting. */
+function delegatedFullAccess(from, fromThreadId, target) {
+    return delegationInheritsFullAccess({
+        senderIsChief: Boolean(from.chiefOfStaff),
+        senderHasFullAccess: fullAccessForSource(from.id, fromThreadId),
+        sameBot: from.id === target.id,
+        recipientDriverKind: registry.cliTarget(target.modelSelection.instanceId)?.driverKind,
+    });
+}
+/** Make a delegated thread Full and say so in it once, so the level the
+ * chip shows and the level the turns run at agree, and the person can see
+ * where the access came from. Idempotent: a pair conversation is reused
+ * across delegations and must not collect a chip per request. */
+function grantDelegatedFullAccess(from, target, threadId) {
+    if (store.taskByThread(target.id, threadId)?.approvalMode === "full")
+        return;
+    store.patchTask(target.id, threadId, { approvalMode: "full", autoApprove: false, alwaysAllow: [] });
+    store.appendMessage(threadId, {
+        role: "bot",
+        kind: "activity",
+        tool: { name: `Full access — delegated by ${from.name}, a Chief of Staff with Full access`, ok: true },
+    });
+}
+/** A room member's level for one turn. Work a Full-access Chief hands out
+ * in a room runs Full for that turn: the room thread is shared, so the
+ * level is not stored on it — it rides the handoff. */
+function roomTurnApprovalMode(bot, orchestration) {
+    const handoff = orchestration?.roomHandoffId ? roomHandoffs.nodes.get(orchestration.roomHandoffId) : undefined;
+    const source = handoff?.parentId ? roomHandoffs.nodes.get(handoff.parentId) : undefined;
+    const from = source ? store.bot(source.botId) : undefined;
+    if (from && source && delegatedFullAccess(from, source.threadId, bot))
+        return "full";
+    return approvalModeForTurn(bot, Boolean(orchestration?.roomHandoffId));
+}
 /** Privileged approval-mode transitions are deliberately absent from the
  * loopback HTTP authority model: a bot with shell access can curl that
  * surface itself. Only Electron's private utility-process channel can deliver
@@ -2260,7 +2328,7 @@ const roomHandoffs = new RoomHandoffs(join(DATA_DIR, "room-handoffs.json"), {
         await tracked;
         return { ok: result.outcome === "settled", text: result.stopReason || result.replyText || result.outcome || "The addressed agent could not run" };
     },
-});
+}, Date.now, roomHandoffLimits(cfg));
 activeCoordinationForThread = threadId => roomHandoffs.activeDirect(threadId);
 function publicGroupState(group) {
     return { ...group, working: groupIsWorking(group) || [...roomHandoffs.nodes.values()].some(n => n.groupId === group.id && !["completed", "failed", "cancelled"].includes(n.status)) };
@@ -2941,6 +3009,10 @@ const watchdog = new TurnWatchdog({
             kind: "activity",
             tool: { name: `error: no activity for ${minutes} minutes — the turn was stopped`, ok: false },
         });
+        // a routine's stall reports through its own failure path
+        if (bot && routineRun?.target !== "bot") {
+            reportIncident({ kind: "stalled", bot, threadId: turn.threadId, detail: `no activity for ${minutes} minutes — the turn was stopped` });
+        }
         settleDirectFollowup(stalledGeneration);
         finalizeDelegationWatch(turn.threadId, false, "", "Delegated turn stalled and was stopped");
         turnUsage.delete(turn.threadId);
@@ -2979,8 +3051,7 @@ const watchdog = new TurnWatchdog({
             const currentBot = store.bot(turn.botId);
             if (currentBot?.busy) {
                 stopScreenPoller(currentBot.id, turn.threadId);
-                if (activeVpsThreads.get(currentBot.id) === turn.threadId)
-                    activeVpsThreads.delete(currentBot.id);
+                vpsThreadEnded(currentBot.id, turn.threadId);
                 if (store.taskByThread(currentBot.id, turn.threadId))
                     store.setTaskActivity(currentBot.id, turn.threadId, "idle");
                 else
@@ -3152,6 +3223,15 @@ const localVmLeases = new LocalVmLeasePool(30 * 60_000);
 const localVmLifecycleBusy = new Set();
 const localVmThreadTargets = new Map();
 const localVmActiveThreads = new Map();
+// Lazy Auto-VM claims (issue #1361): a thread whose auto-resolved Local VM
+// attach deferred the exclusive claim registers here so the first screen
+// tools/call gate can fire it. Dispatch claims eagerly today, so entries
+// exist only as a no-op handoff to the gate.
+const autoVmClaims = new Map();
+/** How long the computer-control gate lets a lazy claim land before it
+ * 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
  * only when one of these exists, so an ordinary Auto turn on a machine with
@@ -3164,7 +3244,25 @@ function noteLocalVmSeen(target, status) {
 let localVmImageBusy = false;
 let localVmProvisionBusy = false;
 let localVmModeChangeBusy = false;
+/** Threads running with a bot's VPS computer mounted, per bot. Several run
+ * at once — only the desktop lease is exclusive, and it is claimed on the
+ * first screen call (see the VPS mount in dispatch) — so the alias and
+ * backend guards ask "any thread?", and a settling thread removes only
+ * itself, never a sibling still running. */
 const activeVpsThreads = new Map();
+function vpsThreadStarted(botId, threadId) {
+    const threads = activeVpsThreads.get(botId) ?? new Set();
+    threads.add(threadId);
+    activeVpsThreads.set(botId, threads);
+}
+function vpsThreadEnded(botId, threadId) {
+    const threads = activeVpsThreads.get(botId);
+    if (!threads)
+        return;
+    threads.delete(threadId);
+    if (!threads.size)
+        activeVpsThreads.delete(botId);
+}
 const boxLifecycleBusyBots = 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.
@@ -3577,6 +3675,10 @@ function localVmIdleFor(target) {
     return idle;
 }
 function releaseLocalVmThread(threadId) {
+    // Covers lazy claims too (issue #1361): every settle path funnels through
+    // here or through releaseTurnResources, so a turn that ends before its
+    // first screen call leaves no claim slot behind.
+    autoVmClaims.delete(threadId);
     const target = localVmThreadTargets.get(threadId);
     if (!target)
         return;
@@ -3712,6 +3814,8 @@ bus.subscribe((event) => {
         pushMessage({ role: "bot", kind: "text", text: coordinatorVisibleText, turnId: completedTurnId });
         lastReply.set(event.threadId, coordinatorVisibleText);
     }
+    if (bot)
+        handoffs.onEvent(event);
     switch (event.type) {
         case "session.started":
             if (bot && event.sessionId && event.providerInstanceId) {
@@ -4036,6 +4140,13 @@ bus.subscribe((event) => {
                 store.markTerminalAssistantMessage(event.threadId, completedTurnId);
             const reply = lastReply.get(event.threadId) ?? "";
             lastReply.delete(event.threadId);
+            // A run that broke — not one the person stopped, and not a routine's,
+            // which reports through its own failure path — is the Chief's to see.
+            if (!event.ok && event.stopReason !== "interrupted" && !routines?.runForThread(event.threadId)) {
+                const broken = bot ?? (speaker ? store.bot(speaker.botId) : undefined);
+                if (broken)
+                    reportIncident({ kind: "failed", bot: broken, threadId: event.threadId, detail: event.stopReason?.trim() || "the run ended without a result" });
+            }
             const lastReported = turnUsage.get(event.threadId);
             turnUsage.delete(event.threadId);
             turnContext.delete(event.threadId);
@@ -4053,8 +4164,7 @@ bus.subscribe((event) => {
                     const ownsResources = resourceOwner &&
                         turnResourceOwners.get(event.threadId)?.generation === resourceOwner.generation;
                     if (ownsResources) {
-                        if (activeVpsThreads.get(bot.id) === event.threadId)
-                            activeVpsThreads.delete(bot.id);
+                        vpsThreadEnded(bot.id, event.threadId);
                         releaseLocalVmThread(event.threadId);
                     }
                     releaseTurnResources(resourceOwner);
@@ -4283,6 +4393,93 @@ function wakeDelegationSource(source, threadId, targetName, failureReason, routi
     }
     dispatchDelegationWake(source.id, threadId, targetName, failureReason, routineRunId);
 }
+// ── incidents: a broken run reaches the Chief of Staff ──────────────────
+// A failed, stalled or unstartable run used to leave one chip in the thread
+// it died in and nothing anywhere else; the person found it hours later,
+// from a phone, by opening the desktop and reading every thread. The team
+// already has a role for this — the Chief coordinates the section — so the
+// incident becomes a turn of the Chief's, in its "Team incidents" thread,
+// with a link to the broken thread and retry_thread to act on it. The person
+// reads one place. Policy in server/incidents.ts.
+const incidentLedger = new IncidentLedger();
+/** What the broken thread was about: the last line the person (or the
+ * requester) sent there, and the last thing the bot said. */
+function incidentContext(threadId) {
+    const messages = [...store.messagesFor(threadId)].reverse();
+    return {
+        lastRequest: messages.find((message) => message.role === "user" && message.kind === "text" && message.text)?.text ?? null,
+        lastReply: messages.find((message) => message.role === "bot" && message.kind === "text" && message.text)?.text ?? null,
+    };
+}
+function reportIncident(input) {
+    const { bot, threadId } = input;
+    const task = store.taskByThread(bot.id, threadId);
+    // A thread another bot opened and is watching is that bot's to handle:
+    // the delegator is woken with the failure already (wakeDelegationSource).
+    if (task?.openedBy?.delegationId || delegationWatch.has(threadId) || roomHandoffs.activeDirect(threadId))
+        return;
+    const group = store.groupByThread(threadId);
+    const incident = {
+        kind: input.kind,
+        bot,
+        threadId,
+        title: task?.title ?? null,
+        room: group?.name ?? null,
+        detail: redactSecretsInText(input.detail),
+        ...incidentContext(threadId),
+    };
+    const count = incidentLedger.note(threadId);
+    // a crash loop is one incident, not a storm
+    if (count.muted)
+        return;
+    const chief = chiefForBot(store.bots, bot);
+    // A run that could not start and a failed routine have already buzzed
+    // the person (turn-failed, routine-failed) by the time they get here; a
+    // failure or stall mid-run has not. One notification per failure, never two.
+    const alreadyNotified = input.kind === "could-not-start" || input.kind === "routine-failed";
+    const tellThePerson = () => {
+        if (alreadyNotified)
+            return;
+        notify(buildNotification("incident", bot, threadId, incidentChip(incident), {
+            avatarUrl: bot.avatarUrl,
+            ...(group ? { group: { id: group.id, name: group.name } } : {}),
+        }));
+    };
+    // no Chief on duty, or the Chief itself broke: the person is next
+    if (!chief) {
+        tellThePerson();
+        return;
+    }
+    const incidents = store.tasks(chief.id).find((candidate) => candidate.title === INCIDENTS_THREAD_TITLE && !candidate.archivedAt)
+        ?? store.createTask(chief.id, INCIDENTS_THREAD_TITLE, false, undefined, { botId: chief.id, name: chief.name, at: Date.now() });
+    if (!incidents || incidents.threadId === threadId) {
+        tellThePerson();
+        return;
+    }
+    store.appendMessage(incidents.threadId, {
+        role: "bot",
+        kind: "activity",
+        tool: { name: incidentChip(incident), ok: false },
+        threadRef: { botId: bot.id, threadId, title: task?.title ?? (group ? group.name : `${bot.name}'s conversation`) },
+    });
+    const text = incidentText(incident, count);
+    // the report carries the broken bot's name as its provenance: it is about
+    // that bot's work and nobody was at the keyboard
+    const peerAsk = { botId: bot.id, name: bot.name, unattended: true };
+    if (botAtThreadCapacity(chief.id) || activeGroupTurnForBot(chief.id)) {
+        queueSteeredMessage(chief.id, incidents.threadId, text, { reason: "capacity", unattended: true, peerAsk });
+        return;
+    }
+    void startTurn(chief.id, text, { threadId: incidents.threadId, unattended: true, peerAsk }).catch((error) => {
+        const why = error instanceof Error ? error.message : String(error);
+        store.appendMessage(incidents.threadId, {
+            role: "bot",
+            kind: "activity",
+            tool: { name: `error: the incident could not reach ${chief.name} — ${why.slice(0, 120)}`, ok: false },
+        });
+        tellThePerson();
+    });
+}
 function drainDelegationWakes() {
     for (const [threadId, entry] of pendingDelegationWakes) {
         if (!store.taskByThread(entry.botId, threadId) || !routineDelegationCanResume(threadId, entry.routineRunId)) {
@@ -4317,12 +4514,36 @@ function markTaskContextExternallyUpdated(bot, threadId) {
     const task = store.taskByThread(bot.id, threadId);
     if (!task)
         return;
+    // An engine that records which messages its current session was handed
+    // keeps that session: its next turn is sent what it has not seen. Without a
+    // record for that exact session (another engine, one switched in since, a
+    // replaced session, or a task from before records existed) the next turn
+    // replays once, as before.
+    const owner = task.lastInstanceId;
+    const record = owner ? task.handedMessages?.[owner] : undefined;
+    if (owner && record?.session !== undefined && record.session === task.resumeCursors[owner] &&
+        turnInstance(botForThread(bot.id, threadId) ?? bot, undefined, threadId)?.instanceId === owner &&
+        registry.get(owner)?.adapter.capabilities.strictResume) {
+        store.patchTask(bot.id, threadId, { unread: true });
+        return;
+    }
     store.patchTask(bot.id, threadId, {
         resumeCursors: {},
         lastInstanceId: `${EXTERNAL_CONTEXT_MARKER_PREFIX}${randomUUID()}`,
         unread: true,
     });
 }
+/** Active-branch messages a provider reads as conversation context. */
+function isContextMessage(m) {
+    return Boolean((m.kind === "text" && m.text) || m.roomRequest?.phase === "result");
+}
+const handoffs = new Handoffs({
+    order: (threadId) => store.activePath(threadId).filter(isContextMessage).map((m) => m.id),
+    read: (botId, threadId, instanceId) => store.taskByThread(botId, threadId)?.handedMessages?.[instanceId],
+    write: (botId, threadId, instanceId, state) => store.setHandedMessages(botId, threadId, instanceId, state),
+    replies: (threadId, turnId) => store.activePath(threadId)
+        .filter((m) => m.role === "bot" && m.kind === "text" && !m.from && m.turnId === turnId).map((m) => m.id),
+});
 /** Consume one delegated-turn watch and mirror exactly one terminal state.
  * Some harness paths settle a busy bot without a provider turn.completed
  * event, so they call this same finalizer explicitly. */
@@ -5007,18 +5228,33 @@ async function startTurn(botId, text, opts) {
     // branch only — abandoned forks never reach the model
     const skipTranscript = new Set([userMessage.id, ...(opts?.excludeMessageIds ?? [])]);
     const activeMessages = store.activePath(threadId);
+    // This turn's own text carries the addressed request and, when resuming,
+    // every child result as JSON: neither is repeated from the transcript.
+    const coordinationChildren = opts?.coordination?.resumed
+        ? new Set(roomHandoffs.children(opts.coordination.id).map((child) => child.id)) : undefined;
+    for (const m of activeMessages) {
+        if (!opts?.coordination || !m.roomRequest)
+            continue;
+        if ((m.roomRequest.phase === "request" && m.roomRequest.id === opts.coordination.id) ||
+            (m.roomRequest.phase === "result" && coordinationChildren?.has(m.roomRequest.id)))
+            skipTranscript.add(m.id);
+    }
     // A flat reply may deliberately point across a fork in the same thread.
     // Resolve its quote from full storage, while the replay itself remains
     // strictly limited to the selected branch below.
     const messagesById = new Map(store.messagesFor(threadId).map((message) => [message.id, message]));
-    const transcript = activeMessages
-        .filter((m) => ((m.kind === "text" && m.text) || m.roomRequest?.phase === "result") && !skipTranscript.has(m.id))
-        .slice(-40)
-        .map((m) => ({
+    const context = activeMessages.filter(isContextMessage).map((m) => ({
+        id: m.id,
         role: m.role === "user" ? "user" : "assistant",
         text: m.roomRequest?.phase === "result" ? teammateReportContext(m.roomRequest.id, bot.id)
-            : transcriptText(m, messagesById, cfg.profile?.name?.trim() || "User"),
+            : m.role !== "user" && m.from ? peerMessageText(m.from.name, transcriptText(m, messagesById, cfg.profile?.name?.trim() || "User"))
+                : transcriptText(m, messagesById, cfg.profile?.name?.trim() || "User"),
+        keep: m.roomRequest?.phase === "result" || (m.role !== "user" && Boolean(m.from)),
+        ...(m.steered ? { steered: true } : {}),
     }));
+    const contextOrder = context.map((m) => m.id);
+    const replayable = context.filter((m) => !skipTranscript.has(m.id));
+    const transcript = replayable.slice(-40).map((m) => ({ role: m.role, text: m.text }));
     // After a rewind (edit / branch switch) the provider's native session
     // still contains the abandoned branch: start a fresh session instead of
     // resuming, and for cursor-resuming drivers replay the surviving path
@@ -5037,6 +5273,28 @@ async function startTurn(botId, text, opts) {
     const fresh = !rewound &&
         !externalContextMarker &&
         engineIsFresh({ instanceId, lastInstanceId: task.lastInstanceId, resumeCursors: task.resumeCursors, transcript });
+    // An engine that records what its session was handed resumes it with only
+    // the context messages outside that record. A record of another session
+    // (the one it replaced) or one that no longer lines up with the branch is
+    // not trusted: the session is rebuilt by the same replay as any other.
+    const strictResume = instance.adapter.capabilities.strictResume === true;
+    const cursor = task.resumeCursors[instanceId];
+    const handed = strictResume && !rewound && !fresh && !externalContextMarker && cursor !== undefined
+        ? task.handedMessages?.[instanceId] : undefined;
+    const unseen = handed && handedStateUsable(handed, cursor, contextOrder) ? unseenMessages(replayable, contextOrder, handed) : undefined;
+    // A teammate's result or reply: without records this turn would replay.
+    const externalUpdate = Boolean(opts?.coordination?.resumed || unseen?.some((m) => m.keep));
+    // What a resumed session keeps from its launch: the standing instructions
+    // (tools, servers and — for Claude — the model are passed on every launch),
+    // plus whatever this engine can only set when a session starts. Codex's
+    // thread/resume sends no model selection, and an effort it is not sent stays
+    // at the thread's last value, so both belong to the session there. An
+    // external update that finds any of it changed since the session started
+    // gets the fresh session and replay it always got, rather than a resume.
+    const persistentConfig = [bot.name, bot.title, bot.description, sectionContextSystemPrompt(bot.section),
+        ...(instance.driverKind === "codex" ? [model, effort ?? null] : [])];
+    const sessionConfig = (soul) => createHash("sha256").update(JSON.stringify([...persistentConfig, soul])).digest("hex").slice(0, 16);
+    const plannedConfig = sessionConfig(bot.soul);
     // Agent-tool gate shared by skill authoring, the /setup turn-text rewrite,
     // the setup prompt block, and the peer-comms integration below: a driver
     // that never mounts agent tools (or a turn already at the comms-depth cap)
@@ -5050,23 +5308,50 @@ async function startTurn(botId, text, opts) {
     // which also depends on the bot's soul/description — is decided below,
     // from the same bot snapshot the prompt's soul is built from.
     const setupText = agentsMounted ? expandSetupTurnText(providerText) : providerText;
-    const { turnText, resume } = buildTurnContext({
-        text: promptWithReply(skillAuthoring ? expandLearnTurnText(setupText) : setupText, opts?.replyTo, cfg.profile?.name?.trim() || "User"),
-        transcript,
-        rewound,
-        fresh,
-        externallyUpdated: Boolean(externalContextMarker),
-        replaysNatively: instance.driverKind === "grok",
-    });
-    // Snapshot the cursor alongside the context decision. An external result
-    // can arrive during async computer/setup work and clear the task cursor;
-    // this already-built turn must either keep its old session or replay on the
-    // following turn, never start a blank session with no transcript.
-    const resumeCursor = resume ? task.resumeCursors[instanceId] : undefined;
-    // A cursor the provider no longer honours must not brick the thread: the
-    // driver may fall back to ONE fresh session, and this is what it sends
-    // there, so the new session is not blank (server/resume-recovery.ts).
-    const recoveryText = resumeCursor !== undefined ? buildRecoveryText({ text: turnText, transcript }) : undefined;
+    const userTurnText = promptWithReply(skillAuthoring ? expandLearnTurnText(setupText) : setupText, opts?.replyTo, cfg.profile?.name?.trim() || "User");
+    // Decided again at dispatch when setup outlasted a soul edit (config).
+    const decideContext = (config) => {
+        const handedStale = Boolean(handed && (!unseen || (externalUpdate && handed.config !== config)));
+        const { block: unseenBlock, placed } = unseen && !handedStale ? renderUnseen(unseen) : { block: "", placed: [] };
+        const { turnText: contextTurnText, resume } = buildTurnContext({
+            text: userTurnText,
+            transcript,
+            rewound,
+            fresh,
+            externallyUpdated: Boolean(externalContextMarker) || handedStale,
+            replaysNatively: instance.driverKind === "grok",
+        });
+        // Snapshot the cursor alongside the context decision. An external result
+        // can arrive during async computer/setup work and clear the task cursor;
+        // this already-built turn must either keep its old session or replay on the
+        // following turn, never start a blank session with no transcript.
+        const resumeCursor = resume ? task.resumeCursors[instanceId] : undefined;
+        // A cursor the provider no longer honours must not brick the thread: the
+        // driver may fall back to ONE fresh session, and this is what it sends
+        // there, so the new session is not blank (server/resume-recovery.ts). A
+        // turn carrying an external update gets the replay it would have had.
+        const recoveryIsReplay = resumeCursor !== undefined && externalUpdate && transcript.length > 0;
+        const recoveryText = resumeCursor === undefined ? undefined : recoveryIsReplay
+            ? buildTurnContext({ text: userTurnText, transcript, rewound: false, fresh: false, externallyUpdated: true, replaysNatively: false }).turnText
+            : buildRecoveryText({ text: userTurnText, transcript });
+        // What this turn puts in front of the provider, for each session it can end
+        // up in (server/delta-context.ts). buildTurnContext prepends a replay only
+        // when it replays, so a changed text means the transcript was sent.
+        const carried = [...skipTranscript];
+        const windowIds = replayable.slice(-40).map((m) => m.id);
+        return {
+            turnText: withUnseenMessages(unseenBlock, contextTurnText),
+            resumeCursor, recoveryText, recoveryIsReplay,
+            handoff: strictResume ? {
+                botId: bot.id, instanceId, config, resumeCursor: typeof resumeCursor === "string" ? resumeCursor : undefined,
+                started: sessionStart(contextOrder, contextTurnText !== userTurnText ? windowIds : [], carried),
+                recovery: sessionStart(contextOrder, recoveryText !== undefined ? windowIds : [], carried),
+                resumed: sessionStart(contextOrder, [], [...placed, ...carried]),
+                placed, carried, own: [userMessage.id, ...(opts?.excludeMessageIds ?? [])],
+            } : undefined,
+        };
+    };
+    let dispatchContext = decideContext(plannedConfig);
     const persona = [
         `You are ${bot.name}, a personal bot in OpenMausBot.`,
         bot.title && `Role: ${bot.title}.`,
@@ -5094,6 +5379,8 @@ async function startTurn(botId, text, opts) {
     // follow-ups: any normal turn may ask teammates to coordinate work.
     directFollowupSettlers.set(dispatchClaimId, { threadId, settle: opts?.onTurnSettled });
     directTurnDispatchClaims.set(threadId, { id: dispatchClaimId, botId, threadId, phase: "setup" });
+    if (dispatchContext.handoff)
+        handoffs.begin(threadId, dispatchClaimId, dispatchContext.handoff);
     directTurnBots.set(threadId, bot);
     beginInternalCapabilityGeneration(threadId, dispatchClaimId);
     if (!opts?.computerSelectionContinuation && !opts?.cardContinuation && !opts?.automationSource && !opts?.unattended &&
@@ -5215,6 +5502,79 @@ async function startTurn(botId, text, opts) {
             let browserCapture = null;
             let computerKind = null;
             let autoVpsProblem = null;
+            /** The Local VM frame capture for the poller and the settled transcript
+             * screenshot. The shared desktop outlives the turn: once another thread
+             * owns it, a capture still in flight would picture ITS work under this
+             * bot's name — live and in the settled frame, which is taken after the
+             * lease is already released. No owner means the desktop is simply
+             * idle: that final frame is ours to keep. */
+            const localVmPreviewFor = (localVmTarget, claimThreadId) => () => {
+                const owner = localVmLeaseFor(localVmTarget).current(localVmOwnerBusy);
+                if (owner && owner.threadId !== claimThreadId) {
+                    throw new Error("the Local VM moved on to another turn");
+                }
+                return containerComputerFrame(undefined, undefined, localVmTarget);
+            };
+            /** 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
+             * lease both re-assert the same owner, so a re-entrant call from the
+             * gate no-ops once dispatch has already claimed. A lazy attach pins
+             * the target it mounted the tools against: the claim must lease that
+             * 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);
+                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");
+                }
+                // Claim before the first await. The lifecycle route performs its
+                // matching check synchronously, so neither side can enter while the
+                // other is between inspection and mutation.
+                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");
+                }
+                localVmThreadTargets.set(claimThreadId, localVmTarget);
+                localVmActiveThreads.set(localVmTarget.key, claimThreadId);
+                localVmIdleFor(localVmTarget).touch();
+                // The lease is held from here. An eager attach that fails below
+                // fails the turn and settle releases it; a lazy claim's rejection is
+                // swallowed into the slot's failed flag and the turn carries on, so
+                // without this the exclusive lease would sit held for the rest of a
+                // turn that never got the VM — the very serialisation #1361 removes.
+                const dropLease = () => {
+                    localVmLeaseFor(localVmTarget).release(claimThreadId);
+                    if (localVmActiveThreads.get(localVmTarget.key) === claimThreadId)
+                        localVmActiveThreads.delete(localVmTarget.key);
+                    localVmThreadTargets.delete(claimThreadId);
+                    // bindTurnComputer above also took the turn-level resource; a
+                    // later turn's exclusive bind queues behind it just the same.
+                    const resource = `computer:vm:${localVmTarget.key}`;
+                    turnResources.releaseOne(resource, resourceOwner);
+                    if (turnComputerResources.get(resourceOwner.threadId)?.resource === resource)
+                        turnComputerResources.delete(resourceOwner.threadId);
+                };
+                let localVm;
+                try {
+                    localVm = await readyLocalVmForTurn(bot.id, localVmTarget);
+                }
+                catch (error) {
+                    dropLease();
+                    throw error;
+                }
+                if (!localVm.ready || !localVm.runtime) {
+                    dropLease();
+                    throw new Error(`${localVm.problem ?? "the Local VM is not ready"} (App Settings → Computers)`);
+                }
+                // Same contract as the Box 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);
+                return { target: localVmTarget, runtime: localVm.runtime };
+            };
             // Explicit destinations are strict. In particular, Local VM must never
             // fall through to host CUA and accidentally click on the user's Mac.
             // The Local VM attach, shared by explicit "Local VM" and by Auto. Explicit
@@ -5229,6 +5589,7 @@ async function startTurn(botId, text, opts) {
                     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);
+                let lazyReadyVm = null;
                 if (!strict) {
                     // Nothing this process has ever seen for this target, and nobody is
                     // relying on an unattended run: do not pay for a runtime probe.
@@ -5239,43 +5600,52 @@ async function startTurn(botId, text, opts) {
                         return false;
                     if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(localVmTarget.key))
                         return false;
+                    if (seen.ready && seen.runtime)
+                        lazyReadyVm = { runtime: seen.runtime };
                 }
                 try {
-                    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");
-                    }
-                    // Claim before the first await. The lifecycle route performs its
-                    // matching check synchronously, so neither side can enter while the
-                    // other is between inspection and mutation.
-                    if (!localVmLeaseFor(localVmTarget).claim(threadId, bot.id, localVmOwnerBusy)) {
-                        throw new Error("this Local VM is already being used by another turn — wait for that turn to finish");
-                    }
-                    localVmThreadTargets.set(threadId, localVmTarget);
-                    localVmActiveThreads.set(localVmTarget.key, threadId);
-                    localVmIdleFor(localVmTarget).touch();
-                    const localVm = await readyLocalVmForTurn(bot.id, localVmTarget);
-                    if (!localVm.ready || !localVm.runtime) {
-                        throw new Error(`${localVm.problem ?? "the Local VM is not ready"} (App Settings → Computers)`);
+                    if (lazyReadyVm) {
+                        // Lazy exclusivity (issue #1361): a VM that is ready right now
+                        // mounts without claiming — screen-less Auto turns never touch
+                        // the lease, and the first screen tools/call fires the claim
+                        // through the computer-control gate. A VM that must be created
+                        // or recreated first keeps the eager claim below: the bridge
+                        // child needs the container to exist, and readyLocalVmForTurn
+                        // is what boots it.
+                        integrations.localComputer = containerComputerMcp(lazyReadyVm.runtime, controlIntegration(bot.id, threadId, dispatchClaimId), localVmTarget);
+                        autoVmClaims.set(threadId, {
+                            owner: resourceOwner,
+                            lazy: true,
+                            label: "the Local VM",
+                            claim: async () => {
+                                await claimAutoLocalVm(threadId, localVmTarget);
+                                // The dispatch-site poller start saw a null previewCapture
+                                // (this lazy mount runs before any claim exists), so this
+                                // turn would publish no live `screen` events and settle no
+                                // final computer frame. Restart the poller with the now-live
+                                // computer capture, keeping any browser capture and whether
+                                // this turn already touched its screen. Same still-running
+                                // guard as dispatch: a poller started after its own
+                                // turn.completed would never be torn down.
+                                if (previewCapture && threadBusy(bot.id, threadId)) {
+                                    const touched = screenPollers.get(threadId)?.touched ?? instance.driverKind === "boxAgent";
+                                    stopScreenPoller(bot.id, threadId);
+                                    startScreenPoller(bot.id, threadId, { computer: previewCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
+                                }
+                            },
+                        });
+                        return true;
                     }
-                    integrations.localComputer = containerComputerMcp(localVm.runtime, controlIntegration(bot.id, threadId, dispatchClaimId), localVmTarget);
-                    // Same contract as the Box 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 = () => {
-                        // The shared desktop outlives the turn. Once another thread owns
-                        // it, a capture still in flight would picture ITS work under this
-                        // bot's name — live and in the settled transcript frame, which is
-                        // taken after the lease is already released. No owner means the
-                        // desktop is simply idle: that final frame is ours to keep.
-                        const owner = localVmLeaseFor(localVmTarget).current(localVmOwnerBusy);
-                        if (owner && owner.threadId !== threadId) {
-                            throw new Error("the Local VM moved on to another turn");
-                        }
-                        return containerComputerFrame(undefined, undefined, localVmTarget);
-                    };
+                    const claimed = await claimAutoLocalVm(threadId);
+                    integrations.localComputer = containerComputerMcp(claimed.runtime, controlIntegration(bot.id, threadId, dispatchClaimId), claimed.target);
+                    // Hand the same claim to the first-screen-call gate. This eager
+                    // path has already claimed, so the gate's fire-once call can only
+                    // re-assert the same owner — a no-op (issue #1361).
+                    autoVmClaims.set(threadId, {
+                        owner: resourceOwner,
+                        label: "the Local VM",
+                        claim: async () => { await claimAutoLocalVm(threadId); },
+                    });
                     return true;
                 }
                 catch (error) {
@@ -5295,7 +5665,11 @@ async function startTurn(botId, text, opts) {
                     hostPlatform: process.platform,
                     providerSupportsLocal: mountsLocalComputer,
                 })) {
-                    throw new Error("this model engine cannot control this computer — choose Claude or an ACP engine, or select another destination");
+                    // Name the condition that actually failed: a person told "choose an
+                    // ACP engine" while already on one has nowhere to go.
+                    throw new Error(mountsLocalComputer
+                        ? `local computer control is not available on ${process.platform} — select another destination`
+                        : "this model engine cannot control this computer — choose Claude or an ACP engine, or select another destination");
                 }
                 const cua = readCuaConnection();
                 if (!cua)
@@ -5314,10 +5688,17 @@ async function startTurn(botId, text, opts) {
                 if (unsupported && wants === undefined)
                     autoVpsProblem = unsupported;
                 if (!unsupported) {
-                    // The remote lifecycle and container are shared by this bot. Keep
-                    // its explicit computer turns serialized; ordinary threads still run.
-                    await bindTurnComputer(resourceOwner, `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`, true);
-                    activeVpsThreads.set(bot.id, threadId);
+                    // The VPS "computer" is the desktop inside this bot's managed
+                    // container, and only screen work needs that desktop to itself.
+                    // So the lease is claimed on the first computer call, through the
+                    // computer-control gate (the Local VM's seam, #1361), never at
+                    // mount: a bot's turns that never touch the computer tools run
+                    // side by side, and its 3-hourly routine no longer queues behind
+                    // — or fails after 30 minutes behind — its own long-running task.
+                    // Container lifecycle (provision, start) is serialized by the
+                    // runner's per-container lock, not by this turn.
+                    const vpsResource = `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`;
+                    vpsThreadStarted(bot.id, threadId);
                     let remote;
                     remote = vps.vpsStartsForTurn({ wants, autoStartVps: bot.autoStartVps, automationSource: opts?.automationSource })
                         ? await vps.vpsComputerAction("provision", cfg, bot.id)
@@ -5331,10 +5712,28 @@ async function startTurn(botId, text, opts) {
                             env: { ...vpsMcp.env, OMB_CONTROL_URL: vpsControl.url, OMB_CONTROL_TOKEN: vpsControl.token },
                         };
                         computerKind = "vps";
-                        previewCapture = () => vps.vpsComputerScreenshot(targetCfg, bot.id);
+                        // Live frames only once this turn holds the desktop: a poller on
+                        // a desktop another turn is driving would publish that turn's
+                        // screen as this one's. The claim restarts the poller with the
+                        // capture, the way the Local VM's lazy claim does.
+                        const vpsCapture = () => vps.vpsComputerScreenshot(targetCfg, bot.id);
+                        autoVmClaims.set(threadId, {
+                            owner: resourceOwner,
+                            lazy: true,
+                            label: "the VPS computer",
+                            claim: async () => {
+                                await bindTurnComputer(resourceOwner, vpsResource, true);
+                                previewCapture = vpsCapture;
+                                if (threadBusy(bot.id, threadId)) {
+                                    const touched = screenPollers.get(threadId)?.touched ?? false;
+                                    stopScreenPoller(bot.id, threadId);
+                                    startScreenPoller(bot.id, threadId, { computer: vpsCapture, ...(browserCapture ? { browser: browserCapture } : {}) }, { screenIsTheWork: touched });
+                                }
+                            },
+                        });
                     }
                     else {
-                        activeVpsThreads.delete(bot.id);
+                        vpsThreadEnded(bot.id, threadId);
                         if (wants === "cloud") {
                             throw new Error(remote?.problem ?? "the VPS computer could not be created or reached");
                         }
@@ -5616,10 +6015,17 @@ 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) },
             ]);
             runningTurnEngines.set(threadId, instance);
+            // The prompt carries the soul as saved now. If it changed during setup,
+            // decide again from what is actually sent.
+            const dispatchedConfig = sessionConfig(liveBot?.soul ?? bot.soul);
+            if (strictResume && dispatchedConfig !== plannedConfig)
+                dispatchContext = decideContext(dispatchedConfig);
+            // Before sendTurn: an adapter may emit the whole turn before it resolves.
+            handoffs.dispatching(threadId, dispatchClaimId, dispatchContext.handoff);
             const dispatch = await guardTurnDispatch(instance.adapter.sendTurn({
                 threadId,
                 botId: bot.id,
-                text: turnText,
+                text: dispatchContext.turnText,
                 refreshSystemPrompt: true,
                 images: turnImages,
                 approvalMode: approvalModeForTurn(bot, commsDepth > 0),
@@ -5629,8 +6035,9 @@ async function startTurn(botId, text, opts) {
                 // a rewound thread never resumes the abandoned branch's session
                 // the active task's own session — another task's cursor would
                 // resume the wrong conversation and defeat the context bubble
-                resumeCursor,
-                ...(recoveryText !== undefined ? { recoveryText } : {}),
+                resumeCursor: dispatchContext.resumeCursor,
+                ...(dispatchContext.recoveryText !== undefined ? { recoveryText: dispatchContext.recoveryText } : {}),
+                ...(dispatchContext.recoveryIsReplay ? { recoveryIsReplay: true } : {}),
                 transcript,
                 system: prompt.text,
                 systemStable: prompt.stable,
@@ -5646,6 +6053,7 @@ async function startTurn(botId, text, opts) {
                 throw new DirectTurnSetupCancelled("turn stopped during provider setup");
             }
             bindInternalCapabilityToProviderTurn(threadId, dispatchClaimId, dispatch.value.turnId);
+            handoffs.bindTurn(threadId, dispatchClaimId, dispatch.value.turnId);
             if (directFollowupSettlers.has(dispatchClaimId) && dispatch.value.turnId &&
                 !directFollowupTurns.bind(threadId, dispatchClaimId, dispatch.value.turnId)) {
                 // This exact queued turn completed before its dispatch ACK arrived.
@@ -5688,6 +6096,7 @@ async function startTurn(botId, text, opts) {
             }
         }
         catch (e) {
+            handoffs.abandon(threadId, dispatchClaimId);
             if (computerSelectionTurns.get(threadId)?.generation === dispatchClaimId)
                 computerSelectionTurns.delete(threadId);
             settleDirectFollowup(dispatchClaimId);
@@ -5698,8 +6107,7 @@ async function startTurn(botId, text, opts) {
             releaseTurnResources(resourceOwner);
             if (ownsLatestGeneration) {
                 releaseLocalVmThread(threadId);
-                if (activeVpsThreads.get(bot.id) === threadId)
-                    activeVpsThreads.delete(bot.id);
+                vpsThreadEnded(bot.id, threadId);
                 watchdog.settle(threadId);
                 turnUsage.delete(threadId);
                 turnContext.delete(threadId);
@@ -5740,6 +6148,7 @@ async function startTurn(botId, text, opts) {
             // for it, in its own thread, so it does not need a second channel.
             if (opts?.automationSource === undefined && !opts?.commsDepth && !opts?.cardContinuation) {
                 notify(buildNotification("turn-failed", bot, threadId, redactSecretsInText(message), { avatarUrl: bot.avatarUrl }));
+                reportIncident({ kind: "could-not-start", bot, threadId, detail: message });
             }
             store.setTaskActivity(bot.id, threadId, "idle");
             directTurnBots.delete(threadId);
@@ -5958,10 +6367,7 @@ routines = new RoutineManager({
     hasPendingDelegations: (threadId) => pendingThreads().includes(threadId) ||
         [...delegationWatch.values()].some((watch) => watch.sourceThreadId === threadId) ||
         pendingDelegationWakes.has(threadId),
-    botState: (botId) => {
-        const bot = store.bot(botId);
-        return !bot ? "missing" : bot.busy ? "busy" : "ready";
-    },
+    botState: unattendedDispatchState,
     goalState: (groupId, coordinatorBotId) => {
         const group = store.group(groupId);
         const coordinator = store.bot(coordinatorBotId);
@@ -6000,6 +6406,7 @@ routines = new RoutineManager({
         const task = store.taskByThread(botId, threadId);
         if (task && !task.busy && !task.routineRunId && store.messagesFor(threadId).length === 0) {
             store.deleteTask(botId, threadId);
+            handoffs.forget(threadId);
         }
     },
     startTurn: (botId, threadId, prompt, runOn, triggerSource, onDispatchError) => startTurn(botId, prompt, { threadId, runOn, automationSource: triggerSource, onDispatchError })
@@ -6040,6 +6447,7 @@ routines = new RoutineManager({
         const detail = run.error ? `${run.routineName}: ${run.error}` : run.routineName;
         const notificationBot = routineSourceOwner(run)?.bot ?? bot;
         notify(buildNotification("routine-failed", notificationBot, routineSourceThread(run) ?? run.threadId ?? bot.threadId, detail));
+        reportIncident({ kind: "routine-failed", bot, threadId: run.threadId ?? bot.threadId, detail });
     },
     onRunDeferred: (run) => {
         const bot = store.bot(run.botId);
@@ -6342,12 +6750,6 @@ async function deleteBotWithLifecycle(botId, revalidate = () => { }, setupReques
             const acknowledged = await browserCleanup.ensure(committedCleanup);
             requireBrowserCleanupAcknowledged(acknowledged, `Browser data for ${bot.name}`);
         }
-        for (const dir of [EVENTS_DIR, NATIVE_DIR]) {
-            try {
-                unlinkSync(join(dir, `${bot.threadId}.ndjson`));
-            }
-            catch { }
-        }
         return deletionResponse(200, { ok: true });
     }
     finally {
@@ -6656,10 +7058,7 @@ function resolveAndSendProfile(res, args) {
 // ordered behind a busy MAUS and gives webhook runs the same durable receipts.
 const webhooks = new WebhookManager({
     emit: broadcast,
-    botState: (botId) => {
-        const bot = store.bot(botId);
-        return !bot ? "missing" : bot.busy ? "busy" : "ready";
-    },
+    botState: unattendedDispatchState,
     enqueue: (input) => routines.enqueueWebhook(input),
     findRun: (webhookId, deliveryId) => routines.webhookRunReceipt(webhookId, deliveryId),
     cancelQueued: (webhookId, message) => routines.cancelQueuedWebhook(webhookId, message),
@@ -6794,7 +7193,11 @@ setupRetry = 0) {
     }
     revokeInternalCapabilitiesForThread(threadId);
     spoken.add(botId);
-    const preparedApprovalMode = approvalModeForTurn(bot, Boolean(orchestration?.roomHandoffId));
+    // Must be the SAME resolver the readiness re-check uses below, or a Chief's
+    // delegated Full elevation makes the two disagree by construction: every
+    // such room turn then reads as "settings changed", retries once, and
+    // settles as busy without ever dispatching.
+    const preparedApprovalMode = roomTurnApprovalMode(bot, orchestration);
     const preparedSelection = { ...bot.modelSelection };
     const preparedComposio = bot.composio;
     const instance = turnInstance(bot);
@@ -6922,7 +7325,7 @@ setupRetry = 0) {
         if (!readyGroup || !stillOwnsThread || !readyGroup.memberIds.includes(readyBot.id))
             return false;
         const setupChanged = turnInstance(readyBot) !== instance ||
-            approvalModeForTurn(readyBot, Boolean(orchestration?.roomHandoffId)) !== preparedApprovalMode ||
+            roomTurnApprovalMode(readyBot, orchestration) !== preparedApprovalMode ||
             readyBot.modelSelection.instanceId !== preparedSelection.instanceId ||
             readyBot.modelSelection.model !== preparedSelection.model ||
             readyBot.modelSelection.effort !== preparedSelection.effort ||
@@ -7295,7 +7698,7 @@ setupRetry = 0) {
                 text,
                 refreshSystemPrompt: true,
                 images: turnImages,
-                approvalMode: approvalModeForTurn(readyBot, Boolean(orchestration?.roomHandoffId)),
+                approvalMode: roomTurnApprovalMode(readyBot, orchestration),
                 system: roomSystem.text,
                 systemStable: roomSystem.stable,
                 systemVolatile: roomSystem.volatile,
@@ -9111,8 +9514,7 @@ async function reloadProviders() {
             stopScreenPoller(botId, threadId);
             releaseLocalVmThread(threadId);
             releaseTurnResources(owner);
-            if (activeVpsThreads.get(botId) === threadId)
-                activeVpsThreads.delete(botId);
+            vpsThreadEnded(botId, threadId);
             watchdog.settle(threadId);
             closeOpenApprovals(threadId);
             directTurnBots.delete(threadId);
@@ -10408,19 +10810,27 @@ const handleRequest = async (req, res) => {
             if (method === "POST" && path === "/api/internal/ask-bot") {
                 const body = await readInternalBody();
                 const fromBotId = internalSender.id;
-                const toBotId = String(body.toBotId ?? "");
+                const toBotRef = String(body.toBotId ?? "");
                 const message = String(body.message ?? "").trim();
                 if (body.depth !== undefined &&
                     (!Number.isInteger(body.depth) || body.depth < 0 || body.depth !== internalCapability.depth)) {
                     return json(res, 403, { error: "the recursion depth does not match this turn" });
                 }
                 const depth = internalCapability.depth;
-                if (!toBotId || !message)
+                if (!toBotRef || !message)
                     return json(res, 400, { error: "toBotId and message required" });
-                if (toBotId === fromBotId)
+                if (toBotRef === fromBotId)
                     return json(res, 400, { error: "a bot cannot message itself" });
                 if (depth >= MAX_COMMS_DEPTH)
                     return json(res, 200, { error: "message chains are limited to one hop" });
+                // A unique reachable teammate name is accepted where an id is
+                // expected; see resolveTeammate for why.
+                const resolvedTo = resolveTeammate(store.bots, internalSender, toBotRef);
+                if ("error" in resolvedTo)
+                    return json(res, 404, { error: `no such bot: ${resolvedTo.error}` });
+                if (resolvedTo.id === fromBotId)
+                    return json(res, 400, { error: "a bot cannot message itself" });
+                const toBotId = resolvedTo.id;
                 const target = store.bot(toBotId);
                 if (!target)
                     return json(res, 404, { error: "no such bot" });
@@ -10621,9 +11031,55 @@ const handleRequest = async (req, res) => {
                     await new Promise((wake) => setTimeout(wake, 500));
                 }
             }
+            // A Chief resumes a teammate's broken thread (server/incidents.ts): the
+            // same thread, its conversation and files, one more turn, with a line
+            // saying who asked and why. Chief-only, for a teammate it can reach,
+            // never a room (coordinate there) and never a thread still running.
+            if (method === "POST" && path === "/api/internal/retry-thread") {
+                const body = await readInternalBody();
+                const from = internalSender;
+                const fromThreadId = internalCapability.threadId;
+                if (!from.chiefOfStaff || from.hidden)
+                    return json(res, 403, { error: "only a Chief of Staff can retry a teammate's thread" });
+                // `toBotId`/`toThreadId`: the guard above reads bare botId/threadId as
+                // the caller's own identity, the way every internal route does.
+                const botId = typeof body.toBotId === "string" ? body.toBotId : "";
+                const threadId = typeof body.toThreadId === "string" ? body.toThreadId : "";
+                const note = typeof body.note === "string" ? body.note.trim().slice(0, 300) : "";
+                const target = store.bot(botId);
+                if (!target || target.id === from.id)
+                    return json(res, 404, { error: "no such teammate" });
+                if (target.hidden || !canAccessTeam(from, target.section) || !peerAllowed(from, target.id)) {
+                    return json(res, 403, { error: "that bot is not on this Chief's team — call list_bots for the ones you can reach" });
+                }
+                if (store.groupByThread(threadId))
+                    return json(res, 400, { error: "that is a room thread — use coordinate_bots in the room instead" });
+                const task = store.taskByThread(target.id, threadId);
+                if (!task)
+                    return json(res, 404, { error: "no such thread on that bot" });
+                if (threadBusy(target.id, threadId) || queuedThreadPosition(target.id, threadId) !== null) {
+                    return json(res, 409, { error: "that thread is still running — wait for it to settle before retrying" });
+                }
+                requireActiveInternalCapability();
+                const unattended = isUnattended(from.id, fromThreadId);
+                const text = `[Retry requested by ${from.name}, your Chief of Staff, after this thread's last run stopped.${note ? ` Note from ${from.name}: ${note}` : ""} Continue the request above from where it stopped and finish it. If the same problem comes back, say exactly what is blocking and stop.]`;
+                try {
+                    await startTurn(target.id, text, { threadId, unattended, peerAsk: { botId: from.id, name: from.name, ...(unattended ? { unattended: true } : {}) } });
+                }
+                catch (error) {
+                    return json(res, 409, { error: error instanceof Error ? error.message : String(error) });
+                }
+                store.appendMessage(fromThreadId, {
+                    role: "bot",
+                    kind: "activity",
+                    tool: { name: `Retried ${target.name}'s thread #${task.title}`, ok: true },
+                    threadRef: { botId: target.id, threadId, title: task.title },
+                });
+                return json(res, 200, { started: true, message: `${target.name}'s thread #${task.title} is running again. Its result stays in that thread; you are not woken for it — check later with list_threads or session_search if you need to.` });
+            }
             if (method === "POST" && path === "/api/internal/delegate-bot") {
                 const body = await readInternalBody();
-                const toBotId = String(body.toBotId ?? "");
+                const toBotRef = String(body.toBotId ?? "");
                 const message = String(body.message ?? "").trim();
                 const reason = typeof body.reason === "string" && body.reason.trim() ? body.reason.trim() : undefined;
                 if (body.depth !== undefined &&
@@ -10631,9 +11087,13 @@ const handleRequest = async (req, res) => {
                     return json(res, 403, { error: "the recursion depth does not match this turn" });
                 }
                 const depth = internalCapability.depth;
-                if (!toBotId || !message)
+                if (!toBotRef || !message)
                     return json(res, 400, { error: "toBotId and message required" });
                 const from = internalSender;
+                const resolvedTo = resolveTeammate(store.bots, from, toBotRef);
+                if ("error" in resolvedTo)
+                    return json(res, 404, { error: `no such bot: ${resolvedTo.error}` });
+                const toBotId = resolvedTo.id;
                 const target = store.bot(toBotId);
                 if (!target)
                     return json(res, 404, { error: "no such bot" });
@@ -10704,11 +11164,35 @@ const handleRequest = async (req, res) => {
                     const destination = groupId ? store.group(groupId) : undefined;
                     if (groupId && !destination)
                         return json(res, 404, { error: "No such room; use list_room_targets." });
-                    const targets = parsed.data.botIds.map(botId => ({ groupId: destination?.id,
+                    // A slot may carry a teammate's name instead of its id — the
+                    // roster shows both, list_bots shows both, and a Chief reading its
+                    // prompt reaches for the name. A unique reachable name resolves;
+                    // anything else is refused with the id or name the caller sent
+                    // and the way to the real ids (peer-roster.ts).
+                    const botIds = [];
+                    for (const raw of parsed.data.botIds) {
+                        const resolved = resolveTeammate(store.bots, internalSender, raw);
+                        if ("error" in resolved)
+                            return json(res, 403, { error: resolved.error });
+                        botIds.push(resolved.id);
+                    }
+                    if (new Set(botIds).size !== botIds.length)
+                        return json(res, 400, { error: "bot_ids name the same teammate twice — send each teammate once" });
+                    const targets = botIds.map(botId => ({ groupId: destination?.id,
                         threadId: destination ? destination.id === source?.id ? address.threadId : destination.threadId : store.bot(botId)?.threadId ?? "", botId,
                     }));
                     for (const target of targets) {
-                        const eligibility = target.botId === internalSender.id ? "Choose a teammate, not yourself" : roomHandoffProblem(target, address);
+                        // roomHandoffProblem's "no longer exists" is written for a route
+                        // that was valid and went away. Here the id is the model's own
+                        // argument — usually a display name dropped into a bot_ids slot —
+                        // so say which id failed and where the real ones are, instead of
+                        // telling the model a teammate it can still reach is gone. Only
+                        // the id the caller sent is echoed back, never a bot's name.
+                        const addressed = store.bot(target.botId);
+                        const eligibility = target.botId === internalSender.id ? "Choose a teammate, not yourself"
+                            : !addressed ? `No bot with id "${target.botId}" — call list_bots and copy the exact id from the result`
+                                : addressed.hidden ? `The bot with id "${target.botId}" is no longer available — call list_bots for the ones you can reach`
+                                    : roomHandoffProblem(target, address);
                         if (eligibility)
                             return json(res, 403, { error: eligibility });
                     }
@@ -10744,6 +11228,9 @@ const handleRequest = async (req, res) => {
                                 target.threadId = resolved.task.threadId;
                                 if (resolved.created)
                                     createdThread = resolved.task.threadId;
+                                if (delegatedFullAccess(internalSender, internalCapability.threadId, store.bot(target.botId))) {
+                                    grantDelegatedFullAccess(internalSender, store.bot(target.botId), target.threadId);
+                                }
                             }
                             const { node, duplicate } = roomHandoffs.enqueue(address, internalCapability.generation, internalCapability.roomHandoffId, target, parsed.data.requestKey + ":" + target.botId, parsed.data.message, approvalGranted, parsed.data.rework, [...store.messagesFor(address.threadId)].reverse().find(m => m.role === "user" && m.kind === "text")?.text ?? "");
                             // A re-dispatched request_key is answered by the request it
@@ -11012,6 +11499,8 @@ const handleRequest = async (req, res) => {
                 const task = store.createTask(target.id, title, false, projectId, { botId: from.id, name: from.name, at: Date.now() });
                 if (!task)
                     return json(res, 500, { error: "couldn't create that thread" });
+                if (delegatedFullAccess(from, fromThreadId, target))
+                    grantDelegatedFullAccess(from, target, task.threadId);
                 const queued = queueDelegation(commsBus, from, { toBotId: target.id, message, depth, targetThreadId: task.threadId }, MAX_COMMS_DEPTH, fromThreadId);
                 if (queued.result !== "ok" || !queued.id) {
                     // nothing will ever run there: take the row back before the person
@@ -11258,6 +11747,48 @@ const handleRequest = async (req, res) => {
                     return json(res, 404, { error: "no such bot" });
                 if (method === "GET") {
                     const snapshot = botComputerControlSnapshot(botId, internalCapability.teamComputerId);
+                    const slot = autoVmClaims.get(internalCapability.threadId);
+                    const lazyClaim = slot && slot.owner.generation === internalCapability.generation ? slot : undefined;
+                    if (!snapshot.held && lazyClaim?.lazy && !lazyClaim.begin) {
+                        // First screen tools/call on a lazily-attached Auto VM (issue
+                        // #1361): fire the exclusive claim — once — and give it a moment
+                        // to land. A free, ready VM claims in the time of one container
+                        // inspect, so this call then proceeds with an honest answer;
+                        // only a claim still queued behind another holder answers held
+                        // below, and then the contention text is true. Keyed on the
+                        // slot, never on the thread's turn-computer entry: a bind this
+                        // turn abandoned earlier (a VPS that turned out to be asleep)
+                        // must not hide the unclaimed VM and let the call through.
+                        startAutoVmClaim(autoVmClaims, internalCapability.threadId, internalCapability.generation);
+                        await Promise.race([
+                            lazyClaim.begin ?? Promise.resolve(),
+                            new Promise((resolve) => setTimeout(resolve, LAZY_VM_CLAIM_GRACE_MS)),
+                        ]);
+                    }
+                    if (!snapshot.held && lazyClaim?.failed === true) {
+                        // A rejected lazy claim (gate finding F1, issue #1361): the
+                        // computer MCP mounted at dispatch is still live, and the claim
+                        // may even have left a turn-computer entry behind (it can reject
+                        // after bindTurnComputer succeeded — lease lost to a person,
+                        // lifecycle busy, boot failure). Either way this turn owns no
+                        // usable VM, so keep refusing every screen call for the rest of
+                        // the generation; the bridge must never forward one onto a VM
+                        // this turn never claimed. Turn settle GC clears the slot. Say
+                        // why, and say not to retry: the contention text would send the
+                        // model into a screenshot loop against a claim that cannot land.
+                        return json(res, 200, {
+                            held: true, helpOpen: false,
+                            blockedReason: `This turn could not claim ${lazyClaim.label ?? "this computer"}${lazyClaim.failure ? ` (${lazyClaim.failure})` : ""}. This call was not performed. Do not retry computer work in this turn; tell the person what you could not do.`,
+                        });
+                    }
+                    if (!snapshot.held && lazyClaim?.lazy && lazyClaim.begin && !lazyClaim.claimed) {
+                        // The claim fired and is still waiting on the exclusive bind:
+                        // another turn genuinely holds this desktop right now.
+                        return json(res, 200, {
+                            held: true, helpOpen: false,
+                            blockedReason: "Another thread is using this computer. This call was not performed. Pause computer work until that thread finishes, then take a fresh screenshot before acting.",
+                        });
+                    }
                     const computer = turnComputerResources.get(internalCapability.threadId);
                     if (!snapshot.held && computer && computer.owner.generation === internalCapability.generation &&
                         !claimTurnResource(computer.owner, computer.resource)) {
@@ -12567,14 +13098,6 @@ const handleRequest = async (req, res) => {
             routines.disableForGroup(group.id);
             store.deleteGroup(group.id);
             rejectDeletedThreadSkillStages(stagedSkillCleanups);
-            for (const threadId of threadIds) {
-                for (const dir of [EVENTS_DIR, NATIVE_DIR]) {
-                    try {
-                        unlinkSync(join(dir, `${threadId}.ndjson`));
-                    }
-                    catch { }
-                }
-            }
             return json(res, 200, { ok: true });
         }
         m = path.match(/^\/api\/groups\/([\w-]+)\/messages$/);
@@ -12682,6 +13205,112 @@ const handleRequest = async (req, res) => {
             }
             return json(res, 200, { ok: true });
         }
+        // Steer a queued room message into the RUNNING room turn (no interrupt).
+        // Only the head steers — room queues drain one item at a time — and the
+        // engine that receives it is the thread's live speaker. A room whose
+        // running driver cannot steer keeps its queue, exactly like an incapable
+        // 1:1 engine; this never ends the running turn.
+        m = path.match(/^\/api\/groups\/([\w-]+)\/queue\/([\w-]+)\/steer$/);
+        if (m && method === "POST") {
+            const body = await readBody(req);
+            if (body !== null && (typeof body !== "object" || Array.isArray(body))) {
+                return json(res, 400, { error: "body must be a JSON object" });
+            }
+            const threadId = typeof body?.threadId === "string" ? body.threadId : undefined;
+            if (threadId !== undefined && !/^[\w-]+$/.test(threadId)) {
+                return json(res, 400, { error: "threadId must be a task id" });
+            }
+            const group = store.group(m[1]);
+            if (!group)
+                return json(res, 404, { error: "no such room" });
+            const targetThreadId = threadId ?? group.threadId;
+            const ownsThread = group.dm
+                ? group.threadId === targetThreadId
+                : Boolean(store.groupTaskByThread(group.id, targetThreadId));
+            if (!ownsThread) {
+                return json(res, 409, { error: "the channel switched tasks before it could receive the message" });
+            }
+            noteTurnTrigger(targetThreadId, auth);
+            const current = store.group(group.id);
+            if (!current)
+                return json(res, 404, { error: "no such room" });
+            // Which engine owns the running room turn on this thread? The same
+            // resolution the room's own Stop uses: the live speaker, else the busy
+            // bot on the channel's main thread.
+            const speakerBotId = groupSpeakers.get(targetThreadId)?.botId ??
+                (targetThreadId === current.threadId ? current.busyBotId : undefined);
+            const speaker = speakerBotId ? store.bot(speakerBotId) : undefined;
+            const instance = speaker ? runningTurnInstance(speaker, targetThreadId) : undefined;
+            // Lift the queue atomically: the room settling can drain it as the
+            // next follow-up, or this request can steer its head into the live
+            // turn — never both for the same words.
+            const held = holdChannelQueue(current.id, targetThreadId, m[2]);
+            if (!held)
+                return json(res, 404, { error: "no such queued message" });
+            if (!speaker || !instance?.adapter.capabilities.queueing || !instance.adapter.steer) {
+                restoreHeldChannelQueue(held);
+                return json(res, 200, { ok: true, queued: true, threadId: targetThreadId });
+            }
+            const [head] = held.items;
+            if (!head || head.id !== m[2]) {
+                restoreHeldChannelQueue(held);
+                return json(res, 409, { error: "only the first queued message can steer" });
+            }
+            // 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);
+            const steered = await instance.adapter
+                .steer(targetThreadId, promptWithReply(head.text, replyTo, cfg.profile?.name?.trim() || "User"))
+                .catch(() => "indeterminate");
+            // The steer was awaited adapter work: re-read every ownership
+            // invariant before writing anything, exactly like the 1:1 path. A
+            // speaker change, a channel switch, or a settled room restores the
+            // queue instead of recording words the new turn never saw.
+            const after = store.group(current.id);
+            const afterSpeakerBotId = after
+                ? groupSpeakers.get(targetThreadId)?.botId ??
+                    (targetThreadId === after.threadId ? after.busyBotId : undefined)
+                : undefined;
+            // "indeterminate" (timeout after delivery, lost transport, a settle
+            // race) never restores: the words may already be folded into the turn
+            // that was live when they were sent, and replaying them into a new
+            // turn would run them twice. Record them once — even under a new
+            // speaker — and settle the head.
+            const delivered = steered !== "refused";
+            if (after && delivered && (steered === "indeterminate" || afterSpeakerBotId === speakerBotId)) {
+                const message = 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,
+                    steered: true,
+                });
+                settleHeldChannelQueueHead(held);
+                return json(res, 200, {
+                    ok: true,
+                    steered: true,
+                    threadId: targetThreadId,
+                    messages: [message],
+                    queueIds: [head.id],
+                });
+            }
+            if (steered === "indeterminate" && !after) {
+                // The room vanished while the answer was lost: settle the head so a
+                // restart cannot replay words the dead turn may already have run.
+                settleHeldChannelQueueHead(held);
+                return json(res, 404, { error: "no such room" });
+            }
+            restoreHeldChannelQueue(held);
+            // The room may have settled while the steer was refused; a queue that
+            // is now drainable must not strand behind a missed settle.
+            if (after && !groupIsWorking(after))
+                drainQueuedChannelSends();
+            return json(res, 200, { ok: true, queued: true, threadId: targetThreadId });
+        }
         m = path.match(/^\/api\/groups\/([\w-]+)\/interrupt$/);
         if (m && method === "POST") {
             const group = store.group(m[1]);
@@ -14055,15 +14684,16 @@ const handleRequest = async (req, res) => {
                 // existing server-side queue records it atomically for the next turn.
                 if (currentAtStart.busy) {
                     const instance = runningTurnInstance(currentAtStart, threadId);
-                    let steered = false;
+                    let steered = "refused";
                     // A live text steer has no image side channel. Keep an attachment
                     // message intact for the next ordinary turn, where central image
                     // admission can hand it to the provider natively.
                     const carriesImages = extractTurnImages(text).images.length > 0;
+                    const steerTarget = handoffs.current(threadId);
                     if (!carriesImages && !computerSelectionTurns.get(threadId)?.selected && instance?.adapter.capabilities.queueing && instance.adapter.steer) {
                         steered = await instance.adapter
                             .steer(threadId, promptWithReply(text, replyTo, cfg.profile?.name?.trim() || "User"))
-                            .catch(() => false);
+                            .catch(() => "indeterminate");
                     }
                     // steer() is awaited adapter work. The turn can settle, the task can
                     // switch, or the whole bot can be deleted before its acknowledgement
@@ -14077,10 +14707,15 @@ const handleRequest = async (req, res) => {
                     if (!store.taskByThread(bot.id, threadId)) {
                         throw Object.assign(new Error("the target task no longer exists"), { status: 409 });
                     }
-                    if (steered) {
-                        if (!current.busy) {
+                    const delivered = steered !== "refused";
+                    if (delivered) {
+                        if (steered === "steered" && !current.busy) {
                             throw Object.assign(new Error("the running turn ended before the steered message could be recorded"), { status: 409 });
                         }
+                        // "indeterminate" falls through to the same record: the words
+                        // may already be folded into a turn whose acknowledgement was
+                        // lost, and handing them back for a resend could run them
+                        // twice. Recording them once is the honest outcome.
                         // A person steering a webhook turn is present, and auto mode may
                         // follow them again. But this route is also reachable from the
                         // bot's own shell on a headless server (loopback is the owner
@@ -14099,6 +14734,8 @@ const handleRequest = async (req, res) => {
                             sendId,
                             steered: true,
                         });
+                        // Offered to the next turn again unless the person stops this one.
+                        handoffs.steered(threadId, steerTarget, instance?.instanceId, message.id);
                         return { ok: true, steered: true, threadId, message };
                     }
                     if (!current.busy) {
@@ -14126,6 +14763,81 @@ const handleRequest = async (req, res) => {
             }
             return json(res, 200, { ok: true });
         }
+        // Steer a queued message into the RUNNING turn (no interrupt). Engines
+        // without a live steer keep the queue; this never ends the current turn.
+        m = path.match(/^\/api\/bots\/([\w-]+)\/queue\/([\w-]+)\/steer$/);
+        if (m && method === "POST") {
+            const body = await readBody(req);
+            requirePinnedClientThread(m[1], body?.threadId);
+            const bot = requestedTaskBot(m[1], body?.threadId);
+            noteTurnTrigger(bot.threadId, auth);
+            // Lift the whole queue atomically: a settle racing this request can
+            // drain it as a follow-up, or this request can steer it into the live
+            // turn — never both for the same words.
+            const held = holdSteeredQueue(bot.id, bot.threadId, m[2]);
+            if (!held)
+                return json(res, 404, { error: "no such queued message" });
+            // A live steer has no image side channel. Attachment words wait for a
+            // real turn where central admission can hand the images to the engine.
+            if (held.items.some((item) => extractTurnImages(item.text).images.length > 0)) {
+                restoreHeldSteeredQueue(held);
+                return json(res, 200, { ok: true, queued: true, threadId: bot.threadId });
+            }
+            const currentAtStart = store.projectBotForTask(bot.id, bot.threadId);
+            const instance = currentAtStart?.busy ? runningTurnInstance(currentAtStart, bot.threadId) : undefined;
+            const prompt = held.items.map((item) => item.prompt).join("\n\n");
+            const steerTarget = handoffs.current(bot.threadId);
+            let steered = "refused";
+            if (currentAtStart?.busy && instance?.adapter.capabilities.queueing && instance.adapter.steer) {
+                steered = await instance.adapter
+                    .steer(bot.threadId, prompt)
+                    .catch(() => "indeterminate");
+            }
+            // The steer was awaited adapter work: re-read every ownership
+            // invariant before writing anything, exactly like the live-send path.
+            const current = store.projectBotForTask(bot.id, bot.threadId);
+            // "indeterminate" never restores: the words may already be folded into
+            // the turn that was live when they were sent, and replaying them into
+            // a fresh follow-up turn would run them twice. Record them whenever
+            // the destination still exists, busy or not.
+            if ((steered === "steered" && current?.busy ||
+                steered === "indeterminate" && current) &&
+                store.taskByThread(bot.id, bot.threadId)) {
+                if (auth.kind === "session" || DESKTOP_MANAGED)
+                    clearUnattended(bot.threadId);
+                const messages = held.items.map((item) => store.appendMessage(bot.threadId, {
+                    role: "user",
+                    kind: "text",
+                    text: item.text,
+                    replyToId: item.replyToId,
+                    sendId: item.sendId,
+                    queueId: item.messageId,
+                    peerAsk: item.peerAsk,
+                    steered: true,
+                }));
+                // Offered to the next turn again unless the person stops this one.
+                for (const message of messages)
+                    handoffs.steered(bot.threadId, steerTarget, instance?.instanceId, message.id);
+                const queueIds = held.items.map((item) => item.messageId);
+                settleHeldSteeredQueue(held);
+                return json(res, 200, { ok: true, steered: true, threadId: bot.threadId, messages, queueIds });
+            }
+            if (steered === "indeterminate") {
+                // No destination is left: settle so a restart cannot replay words a
+                // dead turn may already have run.
+                settleHeldSteeredQueue(held);
+                if (!store.taskByThread(bot.id, bot.threadId)) {
+                    throw Object.assign(new Error("the target task no longer exists"), { status: 409 });
+                }
+                throw Object.assign(new Error("no such bot"), { status: 404 });
+            }
+            restoreHeldSteeredQueue(held);
+            // The turn may have settled while the steer was refused; a queue that
+            // is now drainable must not strand behind a missed settle.
+            if (current && !current.busy)
+                drainQueuedSends();
+            return json(res, 200, { ok: true, queued: true, threadId: bot.threadId });
+        }
         // edit a user message → fork the conversation there and rerun the turn.
         // Rewinding a live thread is refused, exactly like switching versions
         // below: interrupting mid-flight and branching under the dying turn is
@@ -14342,8 +15054,10 @@ const handleRequest = async (req, res) => {
                 const routine = routines.activeBotRunForBot(bot.id);
                 if (routine?.threadId === expectedThreadId)
                     await routines.cancelRun(routine.id);
-                else
+                else {
+                    handoffs.stoppedByPerson(expectedThreadId);
                     await interruptDirectThread(bot.id, expectedThreadId);
+                }
                 return json(res, 200, { ok: true });
             }
             const directClaim = directTurnDispatchClaims.get(bot.threadId);
@@ -14379,6 +15093,7 @@ const handleRequest = async (req, res) => {
                 directClaim?.threadId !== expectedThreadId) {
                 return json(res, 409, { error: "the bot switched tasks before it could be interrupted" });
             }
+            handoffs.stoppedByPerson(expectedThreadId ?? bot.threadId);
             await interruptDirectThread(bot.id, expectedThreadId ?? bot.threadId);
             return json(res, 200, { ok: true });
         }
@@ -14611,6 +15326,7 @@ const handleRequest = async (req, res) => {
             const updated = store.deleteTask(m[1], m[2]);
             if (!updated)
                 return json(res, 404, { error: "no such task" });
+            handoffs.forget(m[2]);
             settleDirectFollowup(directTurnGenerationByThread.get(m[2]));
             rejectDeletedThreadSkillStages(stagedSkillCleanups);
             const fresh = botWithThread(updated);
@@ -16464,6 +17180,37 @@ try {
 catch (error) {
     console.warn(`attachments: startup partial cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
 }
+// #1280: retention for per-thread event logs. Off unless configured, and
+// even then it only removes log files — transcripts, thread records, and
+// workspace state stay untouched. A thread qualifies only when its newest
+// close or archive stamp is older than the window and it is not busy,
+// unread, or carrying an open direct handoff.
+const THREAD_LOG_RETENTION_SWEEP_MS = 24 * 60 * 60 * 1000;
+function sweepThreadEventLogsNow() {
+    const retentionDays = threadEventLogRetentionDays(cfg);
+    if (retentionDays === null)
+        return;
+    const candidates = store.bots.flatMap((bot) => (bot.tasks ?? []).map((task) => ({
+        threadId: task.threadId,
+        closedAt: task.closedBy?.at ?? null,
+        archivedAt: task.archivedAt ?? null,
+        unread: task.unread === true,
+        busy: threadBusy(bot.id, task.threadId),
+        openDirectHandoff: roomHandoffs.activeDirect(task.threadId),
+    })));
+    const swept = sweepThreadEventLogs(candidates, retentionDays);
+    if (swept > 0)
+        console.log(`[retention] removed event logs for ${swept} idle thread(s) past ${retentionDays} day(s)`);
+}
+try {
+    sweepThreadEventLogsNow();
+}
+catch (error) {
+    console.warn(`thread event log retention sweep failed: ${error instanceof Error ? error.message : String(error)}`);
+}
+// A days-scale window needs no tighter cadence; unref so the timer never
+// holds the process open.
+setInterval(sweepThreadEventLogsNow, THREAD_LOG_RETENTION_SWEEP_MS).unref();
 // A dispatch claim is deliberately committed before transcript/provider work.
 // If we died after that point, its outcome is unknown: recover the user's words
 // and a review notice, never hand them to a model for a second execution.
@@ -16479,12 +17226,17 @@ for (const row of chatFollowups()) {
     }
     settleChatFollowups([row.id], "interrupted");
     const messages = store.messagesFor(row.threadId);
-    if (!messages.some((message) => message.queueId === row.id && message.role === "user")) {
-        store.appendMessage(row.threadId, {
-            role: "user", kind: "text", text: row.payload.text, replyToId: row.payload.replyToId,
-            sendId: row.payload.sendId, queueId: row.id,
-            ...(row.kind === "channel" ? { channelMode: row.payload.mode, via: row.payload.via } : {}),
-        });
+    const recovered = messages.find((message) => message.queueId === row.id && message.role === "user") ?? store.appendMessage(row.threadId, {
+        role: "user", kind: "text", text: row.payload.text, replyToId: row.payload.replyToId,
+        sendId: row.payload.sendId, queueId: row.id,
+        ...(row.kind === "channel" ? { channelMode: row.payload.mode, via: row.payload.via } : {}),
+    });
+    // Nor as a message a resumed session has not seen: count it as handed.
+    const recoveredTask = row.kind === "bot" ? store.taskByThread(row.ownerId, row.threadId) : undefined;
+    const order = store.activePath(row.threadId).filter(isContextMessage).map((m) => m.id);
+    for (const [instanceId, state] of Object.entries(recoveredTask?.handedMessages ?? {})) {
+        if (state.session !== undefined)
+            store.setHandedMessages(row.ownerId, row.threadId, instanceId, recordHanded(state, order, [recovered.id]));
     }
     if (!messages.some((message) => message.queueId === row.id && message.kind === "activity")) {
         store.appendMessage(row.threadId, {