openmausbot 0.1.67 → 0.1.68

package/dist-server/server/index.js

@@ -33,7 +33,7 @@ import { chiefOfStaffSystemPrompt } from "./chief-of-staff.js";
 import { peerAllowed, peerName, peerRosterSystemPrompt, reachablePeers, 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, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, saveConfig, showToolCallsEnabled, skillRecorderEnabled, builtInBrowserEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, } from "./config.js";
+import { ensureDirs, instanceConfigs, loadConfig, localVmMaxInstances, localVmMode, parseConfigPatch, roomTurnTimeoutMinutes, maxConcurrentBotThreads, saveConfig, showToolCallsEnabled, skillRecorderEnabled, builtInBrowserEnabled, browserProfileReplacementConflict, browserProfilePartitionTarget, syncCredentialEnv, withInstanceCli, persistableInstanceConfigs, vpsSshAlias, DATA_DIR, EVENTS_DIR, NATIVE_DIR, customMcpServers, } from "./config.js";
 import { ComputerControl } from "./computer-control.js";
 import { MAX_REMOTE_COMMAND_LENGTH } from "./remote-computer.js";
 import { augmentedPath, findCliCandidates, resetPathCache } from "./env-path.js";
@@ -63,7 +63,7 @@ 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 { mentionedBots, roomResponders, sectionKey, Store, } from "./store.js";
+import { isProjectEmoji, mentionedBots, roomResponders, sectionKey, Store, } from "./store.js";
 import * as tts from "./tts/index.js";
 import { narrateTool, toUtterances } from "./tts/speech-text.js";
 import { buildTurnContext, engineIsFresh } from "./turn-context.js";
@@ -78,7 +78,7 @@ import { fetchSkillFromSource } from "./skill-fetch.js";
 import { expandLearnTurnText, learnSource } from "./skill-learn.js";
 import { expandSetupTurnText, setupModeActive, setupSystemPrompt } from "./setup-mode.js";
 import { checkSoulDrift, readSoulDrift, soulFile, writeSoulMirror } from "./bot-folder.js";
-import { buildSystemPrompt, computerPrompt, mentionPrompt, COMPOSIO_PROMPT, CREDENTIAL_PROMPT, LEARN_PROMPT, PROFILE_PROMPT, ROUTINE_PROMPT, WEBHOOK_PROMPT, } from "./system-prompt.js";
+import { buildSystemPrompt, computerPrompt, mentionPrompt, COMPOSIO_PROMPT, CREDENTIAL_PROMPT, LEARN_PROMPT, PROFILE_PROMPT, ROUTINE_PROMPT, ROUTINE_EXECUTION_PROMPT, WEBHOOK_PROMPT, } from "./system-prompt.js";
 import { readCuaConnection, gatedLocalComputer } from "./local-computer.js";
 import { discoverExistingPerBotLocalVms, localVmInventoryEntry, shouldArmLocalVmIdle, } from "./local-vm-inventory.js";
 import { LocalVmIdleTimer } from "./local-vm-idle.js";
@@ -116,7 +116,7 @@ import { createTeamBackup, importTeamBackup } from "./team-backup.js";
 import { MAX_TEAM_BACKUP_BYTES } from "../shared/team-backup.js";
 import { shouldMountLocalComputer } from "./local-routing.js";
 import { resolveSurface } from "./surface.js";
-import { PendingTurnCancellations, ProviderTurnGenerationRegistry, RetiredTurnRegistry, guardTurnDispatch, isTurnEventQuarantined, } from "./turn-dispatch-guard.js";
+import { PendingTurnCancellations, ProviderTurnGenerationRegistry, RetiredTurnRegistry, guardTurnDispatch, isTurnAdmissionBlocked, isTurnEventQuarantined, } from "./turn-dispatch-guard.js";
 import { createGracefulShutdown } from "./graceful-shutdown.js";
 import { acquireDataDirLeaseForProcess } from "./data-dir-lease.js";
 import { describeEdition, editionStatus, loadEnterpriseLayer } from "./enterprise.js";
@@ -448,7 +448,6 @@ const directTurnGenerationByThread = new Map();
 // Keep the exact provider/profile settings that own a running conversation.
 // Selecting another thread or changing a default must not retarget its tools.
 const directTurnBots = new Map();
-const MAX_CONCURRENT_BOT_THREADS = 3;
 let providerFleetReloading = false;
 const turnResources = new TurnResources();
 const turnResourceOwners = new Map();
@@ -484,6 +483,11 @@ function botForThread(botId, threadId) {
 function threadBusy(botId, threadId) {
     return store.taskByThread(botId, threadId)?.busy === true || directTurnDispatchClaims.has(threadId);
 }
+function botAtThreadCapacity(botId) {
+    // Setup/dispatch reservations still occupy a slot even if an early
+    // completion event has already cleared the stored busy flag.
+    return store.tasks(botId).filter((task) => threadBusy(botId, task.threadId)).length >= maxConcurrentBotThreads(cfg);
+}
 function hasDirectDispatch(botId) {
     return [...directTurnDispatchClaims.values()].some((claim) => claim.botId === botId);
 }
@@ -1494,6 +1498,10 @@ function finishGroupGoalRun(groupId, operation, status, detail) {
     // A calendar-triggered team goal reuses its RoutineRun id for this card.
     // Manual goals have unrelated ids, so the manager safely ignores them.
     const routineRun = routines?.finishGoalRun(run.runId, status, safeDetail);
+    if (routineRun?.status === "cancelled") {
+        pendingDelegationWakes.delete(operation.threadId);
+        discardDelegations(commsBus, operation.threadId);
+    }
     // Member-level turn completions are intentionally private/intermediate for
     // a team goal, so the normal direct-routine notification path never fires.
     // Notify once from the correlated terminal receipt instead.
@@ -1502,13 +1510,15 @@ function finishGroupGoalRun(groupId, operation, status, detail) {
     if (routineRun?.status === "waiting") {
         const coordinator = store.bot(routineRun.botId);
         if (coordinator) {
-            notify(buildNotification("question", coordinator, routineSourceThread(routineRun) ?? routineRun.threadId ?? operation.threadId, safeDetail || `${routineRun.routineName} needs your input`, { avatarUrl: coordinator.avatarUrl }));
+            const notificationBot = routineSourceOwner(routineRun)?.bot ?? coordinator;
+            notify(buildNotification("question", notificationBot, routineSourceThread(routineRun) ?? routineRun.threadId ?? operation.threadId, safeDetail || `${routineRun.routineName} needs your input`, { avatarUrl: notificationBot.avatarUrl }));
         }
     }
     if (routineRun?.status === "completed") {
         const coordinator = store.bot(routineRun.botId);
         if (coordinator) {
-            notify(buildNotification("done", coordinator, routineSourceThread(routineRun) ?? routineRun.threadId ?? operation.threadId, safeDetail || routineRun.routineName, { avatarUrl: coordinator.avatarUrl }));
+            const notificationBot = routineSourceOwner(routineRun)?.bot ?? coordinator;
+            notify(buildNotification("done", notificationBot, routineSourceThread(routineRun) ?? routineRun.threadId ?? operation.threadId, safeDetail || routineRun.routineName, { avatarUrl: notificationBot.avatarUrl }));
         }
     }
     const group = store.group(groupId);
@@ -2033,9 +2043,17 @@ const watchdog = new TurnWatchdog({
         revokeInternalCapabilitiesForThread(turn.threadId);
         repeats.settle(turn.threadId);
         const bot = botForThread(turn.botId, turn.threadId);
-        const instance = bot ? registry.get(bot.modelSelection.instanceId) : null;
+        const routineRun = activeRoutineRunForThread(turn.threadId);
+        const instance = routineRun?.runOn === "cloud"
+            ? registry.instances().find((candidate) => candidate.driverKind === "boxAgent")
+            : bot ? registry.get(bot.modelSelection.instanceId) : null;
         void instance?.adapter.interruptTurn(turn.threadId).catch(() => { });
         const minutes = Math.round(TURN_STALL_MS / 60_000);
+        if (routineRun?.target === "bot") {
+            routines?.failThread(turn.threadId, `No activity for ${minutes} minutes — the routine was stopped`);
+            pendingDelegationWakes.delete(turn.threadId);
+            discardDelegations(commsBus, turn.threadId);
+        }
         store.appendMessage(turn.threadId, {
             role: "bot",
             kind: "activity",
@@ -2826,7 +2844,8 @@ bus.subscribe((event) => {
                     store.setTaskActivity(bot.id, event.threadId, "waiting-on-you");
                 else if (asker.busy)
                     store.setActivity(asker.id, "waiting-on-you");
-                notify(buildNotification(permission ? "approval" : "question", asker, (routineRun && routineSourceThread(routineRun)) || event.threadId, event.summary));
+                const notificationBot = (routineRun && routineSourceOwner(routineRun)?.bot) || asker;
+                notify(buildNotification(permission ? "approval" : "question", notificationBot, (routineRun && routineSourceThread(routineRun)) || event.threadId, event.summary));
             };
             if (reviewTask && reviewMode === "enforce") {
                 // Avoid buzzing the owner for a card the reviewer is about to answer.
@@ -2991,13 +3010,14 @@ bus.subscribe((event) => {
                 // A failed peer turn stays a chip too. The bot that delegated is woken
                 // with the failure and answers the person in its own thread — buzzing
                 // here as well would ring twice for one piece of news.
-                if (routineRun?.status !== "failed" && !internal) {
+                if ((!routineRun || routineRun.status === "completed") && !internal) {
                     // the frame carries the bot's avatar so every desktop client can
                     // show the notification under that bot's own face
                     const completionDetail = routineRun
                         ? reply || routineRun.output || routineRun.routineName
                         : reply;
-                    notify(buildNotification("done", bot, routineReportThread ?? event.threadId, completionDetail, { avatarUrl: bot.avatarUrl }));
+                    const notificationBot = (routineRun && routineSourceOwner(routineRun)?.bot) || bot;
+                    notify(buildNotification("done", notificationBot, routineReportThread ?? event.threadId, completionDetail, { avatarUrl: notificationBot.avatarUrl }));
                 }
                 if (screenPollers.has(event.threadId)) {
                     if (resourceOwner)
@@ -3064,9 +3084,22 @@ const delegationWatch = new Map();
 // the cardContinuation resume pattern used for connector/credential cards.
 const delegationWakeBudget = new DelegationWakeBudget();
 const pendingDelegationWakes = new Map();
-function dispatchDelegationWake(botId, threadId, targetName, failureReason) {
+function activeRoutineRunForThread(threadId) {
+    const run = routines?.runForThread(threadId);
+    return run && ["running", "waiting"].includes(run.status) ? run : null;
+}
+function routineDelegationCanResume(threadId, routineRunId) {
+    return !routineRunId || activeRoutineRunForThread(threadId)?.id === routineRunId;
+}
+function dispatchDelegationWake(botId, threadId, targetName, failureReason, routineRunId, budgetAcquired = false) {
     if (!store.taskByThread(botId, threadId))
         return;
+    if (!routineDelegationCanResume(threadId, routineRunId))
+        return;
+    if (!budgetAcquired && !delegationWakeBudget.tryAcquire(threadId)) {
+        routines?.failThread(threadId, "Delegation follow-up limit reached; review the run before retrying");
+        return;
+    }
     const prompt = failureReason
         ? buildDelegationFailurePrompt(targetName, failureReason)
         : buildDelegationRevivalPrompt(targetName);
@@ -3081,8 +3114,9 @@ function dispatchDelegationWake(botId, threadId, targetName, failureReason) {
             return;
         const message = error instanceof Error ? error.message : String(error);
         // Raced with a user turn claiming the bot — retry once it settles.
-        if (/already working/i.test(message)) {
-            pendingDelegationWakes.set(threadId, { botId, targetName, failureReason });
+        // This is the same logical wake, so keep its original budget charge.
+        if (isTurnAdmissionBlocked(error)) {
+            pendingDelegationWakes.set(threadId, { botId, targetName, failureReason, routineRunId, budgetAcquired: true });
             return;
         }
         store.appendMessage(threadId, {
@@ -3093,37 +3127,43 @@ function dispatchDelegationWake(botId, threadId, targetName, failureReason) {
                 ok: false,
             },
         });
+        routines?.failThread(threadId, `Could not resume after delegation: ${message}`);
     });
 }
-function wakeDelegationSource(source, threadId, targetName, failureReason) {
+function wakeDelegationSource(source, threadId, targetName, failureReason, routineRunId) {
     if (!store.taskByThread(source.id, threadId))
         return;
+    if (!routineDelegationCanResume(threadId, routineRunId))
+        return;
     // Busy? Hold the wake until the source settles, then drain it — the
     // delegated reply is already in the thread, so nothing is lost, and the
     // source processes it the moment it is free rather than only on a later
     // user nudge.
     if (threadBusy(source.id, threadId) || activeGroupTurnForBot(source.id)) {
-        pendingDelegationWakes.set(threadId, { botId: source.id, targetName, failureReason });
+        pendingDelegationWakes.set(threadId, { botId: source.id, targetName, failureReason, routineRunId });
         return;
     }
-    if (!delegationWakeBudget.tryAcquire(threadId))
-        return;
-    dispatchDelegationWake(source.id, threadId, targetName, failureReason);
+    dispatchDelegationWake(source.id, threadId, targetName, failureReason, routineRunId);
 }
 function drainDelegationWakes() {
     for (const [threadId, entry] of pendingDelegationWakes) {
-        if (!store.taskByThread(entry.botId, threadId)) {
+        if (!store.taskByThread(entry.botId, threadId) || !routineDelegationCanResume(threadId, entry.routineRunId)) {
             pendingDelegationWakes.delete(threadId);
             continue;
         }
         if (threadBusy(entry.botId, threadId) || activeGroupTurnForBot(entry.botId))
             continue;
         pendingDelegationWakes.delete(threadId);
-        if (!delegationWakeBudget.tryAcquire(threadId))
-            continue;
-        dispatchDelegationWake(entry.botId, threadId, entry.targetName, entry.failureReason);
+        dispatchDelegationWake(entry.botId, threadId, entry.targetName, entry.failureReason, entry.routineRunId, entry.budgetAcquired);
     }
 }
+function wakeUndispatchedDelegation(receipt, routineRunId) {
+    const source = store.botByThread(receipt.sourceThreadId);
+    if (!source)
+        return;
+    markTaskContextExternallyUpdated(source, receipt.sourceThreadId);
+    wakeDelegationSource(source, receipt.sourceThreadId, receipt.toBotName, receipt.result || "the handoff did not run", routineRunId);
+}
 // Provider-native sessions only know about messages produced inside their
 // own turns. A delegated result is appended later by the harness, so mark the
 // source task with a persisted, impossible-to-resume owner. Its next turn
@@ -3255,11 +3295,11 @@ function finalizeDelegationWatch(threadId, ok, reply = "", failureName = "Delega
             // silent" gap). Failures wake it too — the user must hear the task did
             // not finish. Idle-checked and burst-capped so a busy source or a
             // re-delegating loop cannot spin up runs.
-            if (ok && reply.trim()) {
-                wakeDelegationSource(source, watched.sourceThreadId, targetName);
+            if (ok) {
+                wakeDelegationSource(source, watched.sourceThreadId, targetName, undefined, watched.routineRunId);
             }
             else if (!ok) {
-                wakeDelegationSource(source, watched.sourceThreadId, targetName, failureName || "the delegated turn did not finish");
+                wakeDelegationSource(source, watched.sourceThreadId, targetName, failureName || "the delegated turn did not finish", watched.routineRunId);
             }
         }
     }
@@ -3329,6 +3369,7 @@ const runDelegatedTurn = (toBotId, text, commsDepth, sourceThreadId, channel, ta
             taskId,
             sourceThreadId,
             sourceBotId,
+            routineRunId: activeRoutineRunForThread(sourceThreadId)?.id,
             startedAtMs: Date.now(),
         });
     }
@@ -3365,6 +3406,10 @@ const runDelegatedTurn = (toBotId, text, commsDepth, sourceThreadId, channel, ta
         reportStartFailure(err);
     });
 };
+function drainThreadDelegations(threadId) {
+    const routineRunId = activeRoutineRunForThread(threadId)?.id;
+    drainDelegations(commsBus, approvalBus, threadId, runDelegatedTurn, (receipt) => wakeUndispatchedDelegation(receipt, routineRunId));
+}
 // Most waiting handoffs retry from a target's turn.completed event. Some
 // setup, cancellation, room, watchdog, and provider-reload paths release a
 // bot without that event, so every explicit idle release calls this same
@@ -3377,10 +3422,13 @@ function retryDelegationsWaitingOn(botId) {
     delegationRetryBots.add(botId);
     queueMicrotask(() => {
         delegationRetryBots.delete(botId);
+        // Explicit idle releases (room/setup/reload/watchdog fallbacks) may not
+        // publish turn.completed. They free a waiting source continuation too.
+        drainDelegationWakes();
         if (store.bot(botId)?.busy)
             return;
         for (const waitingThread of releaseDelegationsWaitingOn(botId)) {
-            drainDelegations(commsBus, approvalBus, waitingThread, runDelegatedTurn);
+            drainThreadDelegations(waitingThread);
         }
     });
 }
@@ -3395,7 +3443,7 @@ bus.subscribe((event) => {
     if (!event.ok)
         discardDelegations(commsBus, event.threadId);
     else
-        drainDelegations(commsBus, approvalBus, event.threadId, runDelegatedTurn);
+        drainThreadDelegations(event.threadId);
     // A settling bot frees itself as a delegation TARGET too: handoffs that
     // found it busy earlier were kept queued (bounded retries) on their own
     // source threads, and this is the moment they get their retry.
@@ -3441,7 +3489,24 @@ function drainQueuedSends() {
     }), 
     // Provider completion can precede its dispatch promise: keep the queue
     // intact until that exact handshake releases its runtime-only claim.
-    (botId, threadId) => threadBusy(botId, threadId) || Boolean(activeGroupTurnForBot(botId)));
+    (botId, threadId) => threadBusy(botId, threadId) || botAtThreadCapacity(botId) || Boolean(activeGroupTurnForBot(botId)));
+}
+/** Keep a person's words off the transcript until a direct-thread slot is
+ * available. Reuse the existing cancellable, idempotent composer queue. */
+async function startOrQueueDirectMessage(botId, threadId, text, replyTo, sendId) {
+    const capacity = botAtThreadCapacity(botId);
+    if (capacity || threadBusy(botId, threadId)) {
+        const reason = capacity ? "capacity" : undefined;
+        const queued = queueSteeredMessage(botId, threadId, text, {
+            replyToId: replyTo?.id,
+            sendId,
+            reason,
+            prompt: promptWithReply(text, replyTo, cfg.profile?.name?.trim() || "User"),
+        });
+        return { ok: true, queued: true, queueId: queued.id, threadId, reason };
+    }
+    const message = await startTurn(botId, text, { threadId, replyTo, sendId });
+    return { ok: true, threadId, message };
 }
 const screenPollers = new Map();
 /** The preview shares the box's single command endpoint with the agent's
@@ -3576,6 +3641,19 @@ async function startTurn(botId, text, opts) {
     if (!profile)
         throw Object.assign(new Error("no such bot"), { status: 404 });
     const threadId = opts?.threadId ?? profile.threadId;
+    const continuingRoutine = opts?.cardContinuation ? activeRoutineRunForThread(threadId) : null;
+    if (continuingRoutine) {
+        const onDispatchError = opts?.onDispatchError;
+        opts = {
+            ...opts,
+            runOn: continuingRoutine.runOn,
+            automationSource: continuingRoutine.triggerSource ?? (continuingRoutine.manual ? "manual" : "schedule"),
+            onDispatchError: (message) => {
+                routines?.failThread(threadId, message);
+                onDispatchError?.(message);
+            },
+        };
+    }
     const bot = store.projectBotForTask(botId, threadId);
     if (!bot)
         throw Object.assign(new Error("no such task"), { status: 404 });
@@ -3600,8 +3678,8 @@ async function startTurn(botId, text, opts) {
     if (activeGroupTurnForBot(botId)) {
         throw Object.assign(new Error("the bot is already working in a channel — wait for it to finish"), { status: 409, code: "thread_busy" });
     }
-    if (store.tasks(botId).filter((task) => task.busy).length >= MAX_CONCURRENT_BOT_THREADS) {
-        throw Object.assign(new Error("this bot is already working on three threads — wait for one to finish"), { status: 409, code: "thread_limit" });
+    if (botAtThreadCapacity(botId)) {
+        throw Object.assign(new Error(`this bot has reached its limit of ${maxConcurrentBotThreads(cfg)} parallel threads — wait for one to finish`), { status: 409, code: "thread_limit" });
     }
     // Retire anything a previous turn left behind before minting this turn's
     // integrations. Completion and interrupt paths do the same; this is the
@@ -4169,6 +4247,7 @@ async function startTurn(botId, text, opts) {
                 { id: "credential", label: "Credentials", text: credentialPrompt },
                 { id: "recall", label: "Recall", text: recallPrompt },
                 { id: "routine", label: "Routines", text: routinePrompt },
+                { id: "routine-execution", label: "Routine execution", text: opts?.automationSource === "schedule" || opts?.automationSource === "manual" ? ROUTINE_EXECUTION_PROMPT : "" },
                 { id: "profile", label: "Profile changes", text: profilePrompt },
                 { id: "learn", label: "Skill authoring", text: learnPrompt },
                 { id: "section-context", label: "Section context", text: sectionContextSystemPrompt(bot.section) },
@@ -4309,8 +4388,14 @@ function routineSourceOwner(run) {
     const bot = store.bot(run.botId);
     if (!bot)
         return null;
-    if (store.taskByThread(bot.id, threadId))
-        return { bot, group: undefined, threadId };
+    // The source is stamped from the confirmed request, never calendar input.
+    // A request for a teammate runs as that teammate but reports to the bot
+    // whose conversation held the card. Recheck their section before sharing
+    // a result, since either bot may have moved since confirmation.
+    const sourceBot = store.botByThread(threadId);
+    if (sourceBot && sectionKey(sourceBot.section) === sectionKey(bot.section)) {
+        return { bot: sourceBot, group: undefined, threadId };
+    }
     const group = store.groupByThread(threadId);
     return group?.memberIds.includes(bot.id) ? { bot, group, threadId } : null;
 }
@@ -4450,8 +4535,16 @@ async function stopBotForEmergencyApprovalDowngrade(botId) {
     }
     await directStop;
 }
+// Load queued handoffs before scheduler recovery can fail an interrupted
+// run. Its failure callback can then durably drop that work immediately;
+// nothing dispatches until the listener is ready below.
+const commsBus = { store, broadcast };
+_loadPending();
 routines = new RoutineManager({
     emit: broadcast,
+    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";
@@ -4488,6 +4581,8 @@ routines = new RoutineManager({
     },
     interruptTurn: async (botId, threadId, runOn) => {
         const bot = botForThread(botId, threadId);
+        pendingDelegationWakes.delete(threadId);
+        discardDelegations(commsBus, threadId);
         cancelDirectTurnDispatch(botId, threadId);
         revokeInternalCapabilitiesForThread(threadId);
         const instance = runOn === "cloud"
@@ -4505,11 +4600,16 @@ routines = new RoutineManager({
     interruptGoal: interruptRoutineGroupGoal,
     onRunChanged: syncRoutineRunToSource,
     onRunFailed: (run) => {
+        if (run.threadId) {
+            pendingDelegationWakes.delete(run.threadId);
+            discardDelegations(commsBus, run.threadId);
+        }
         const bot = store.bot(run.botId);
         if (!bot)
             return;
         const detail = run.error ? `${run.routineName}: ${run.error}` : run.routineName;
-        notify(buildNotification("routine-failed", bot, routineSourceThread(run) ?? run.threadId ?? bot.threadId, detail));
+        const notificationBot = routineSourceOwner(run)?.bot ?? bot;
+        notify(buildNotification("routine-failed", notificationBot, routineSourceThread(run) ?? run.threadId ?? bot.threadId, detail));
     },
 });
 // The scheduler receipt and room transcript live in separate durable stores.
@@ -4551,7 +4651,6 @@ if (recoveryOwners.length > 0) {
             : [];
     })));
 }
-routines.start();
 // Chat tools can prepare routine changes, but the harness applies them only
 // after the user confirms a durable card. Keeping this beside the scheduler
 // makes the card resolvable after an app restart without involving the model.
@@ -4806,10 +4905,6 @@ function serializeRoomContext(threadId, userName, textOverride, readerBotId) {
     })
         .join("\n");
 }
-// comms bus: passed into the visibility helpers in comms-visibility.ts so
-// they can mirror messages + chips without re-deriving SSE plumbing. Same
-// shape every comms entry point uses (ask_bot, delegate_bot).
-const commsBus = { store, broadcast };
 // What each room has already taken from its bots. Keyed by room because the
 // loop post_to_room can start is a property of the room, not of any one
 // caller — three bots posting twice each is the same runaway as one bot
@@ -4830,18 +4925,6 @@ const approvalBus = { store, broadcast, notify };
     if (stale)
         console.log(`peer approvals: dismissed ${stale} card(s) left by a previous run`);
 }
-// Handoffs a previous process queued but never ran: the source turn is
-// dead (no turn survives a restart) so they would otherwise wait forever.
-// Run them now, through the same drain — target and approvePeerComms are
-// re-checked there as always; a source bot that no longer exists is skipped.
-_loadPending();
-{
-    const leftover = pendingThreads();
-    if (leftover.length)
-        console.log(`delegations: ${leftover.length} thread(s) with queued handoffs from a previous run — draining`);
-    for (const threadId of leftover)
-        drainDelegations(commsBus, approvalBus, threadId, runDelegatedTurn);
-}
 async function runGroupMemberTurn(groupId, threadId, botId, hop, 
 // bots that already spoke for this user message — "@Scout ask @Pixel"
 // must not run Pixel twice (once chained, once as a direct responder)
@@ -6402,7 +6485,7 @@ function dispatchConnectorResume(entry) {
         onDispatchError: (message) => markConnectorResumeFailed(entry.threadId, entry.resumeKey, message),
     }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
-        if (/already working/i.test(message))
+        if (isTurnAdmissionBlocked(error))
             pendingConnectorResumes.set(`${entry.threadId}:${entry.resumeKey}`, entry);
         else
             markConnectorResumeFailed(entry.threadId, entry.resumeKey, message);
@@ -6529,7 +6612,7 @@ function dispatchSecretResume(entry) {
         onDispatchError: (message) => markSecretResumeFailed(entry.threadId, entry.messageId, message),
     }).catch((error) => {
         const message = error instanceof Error ? error.message : String(error);
-        if (/already working/i.test(message)) {
+        if (isTurnAdmissionBlocked(error)) {
             pendingSecretResumes.set(`${entry.threadId}:${entry.messageId}`, entry);
         }
         else {
@@ -6825,6 +6908,7 @@ function configStatus() {
         // not a secret — the settings picker shows it; "" = follow the system
         language: cfg.language ?? "",
         rooms: { turnTimeoutMinutes: roomTurnTimeoutMinutes(cfg) },
+        threads: { maxConcurrentPerBot: maxConcurrentBotThreads(cfg) },
         localVm: {
             mode: localVmMode(cfg),
             maxInstances: localVmMaxInstances(cfg),
@@ -7186,6 +7270,11 @@ const handleRequest = async (req, res) => {
         if (method === "GET" && path === "/api/health" && !gate.auth) {
             return json(res, 200, { app: "openmausbot" });
         }
+        // The brand is public too: the sign-in page must carry the deployment's
+        // name and icon before anyone has a session, and it holds nothing secret.
+        if (method === "GET" && path === "/api/brand" && !gate.auth) {
+            return json(res, 200, loadBrand());
+        }
         if (!gate.auth)
             return json(res, gate.status, { error: gate.error });
         const auth = gate.auth;
@@ -7872,6 +7961,7 @@ const handleRequest = async (req, res) => {
                         taskId,
                         sourceThreadId: fromThreadId,
                         sourceBotId: currentFrom.id,
+                        routineRunId: activeRoutineRunForThread(fromThreadId)?.id,
                     });
                     store.appendMessage(fromThreadId, {
                         role: "bot",
@@ -11094,7 +11184,7 @@ const handleRequest = async (req, res) => {
                         if (queued.text !== text || queued.replyToId !== replyTo?.id) {
                             throw Object.assign(new Error("sendId already belongs to another message"), { status: 409 });
                         }
-                        return { ok: true, queued: true, queueId: queued.id, threadId };
+                        return { ok: true, queued: true, queueId: queued.id, threadId, reason: queued.reason };
                     }
                 }
                 const currentAtStart = store.projectBotForTask(bot.id, threadId);
@@ -11155,8 +11245,7 @@ const handleRequest = async (req, res) => {
                         return { ok: true, steered: true, threadId, message };
                     }
                     if (!current.busy) {
-                        const message = await startTurn(bot.id, text, { threadId, replyTo, sendId });
-                        return { ok: true, threadId, message };
+                        return startOrQueueDirectMessage(bot.id, threadId, text, replyTo, sendId);
                     }
                     const queued = queueSteeredMessage(current.id, threadId, text, {
                         replyToId: replyTo?.id,
@@ -11165,8 +11254,7 @@ const handleRequest = async (req, res) => {
                     });
                     return { ok: true, queued: true, queueId: queued.id, threadId };
                 }
-                const message = await startTurn(bot.id, text, { threadId, replyTo, sendId });
-                return { ok: true, threadId, message };
+                return startOrQueueDirectMessage(bot.id, threadId, text, replyTo, sendId);
             });
             return json(res, 202, receipt);
         }
@@ -11437,6 +11525,22 @@ const handleRequest = async (req, res) => {
         });
         // Folders organize one bot's threads; they never own settings,
         // transcripts or working directories. The project wire names stay stable.
+        m = path.match(/^\/api\/bots\/([\w-]+)\/projects\/order$/);
+        if (m && method === "PATCH") {
+            const bot = store.bot(m[1]);
+            if (!bot)
+                return json(res, 404, { error: "no such bot" });
+            const body = await readBody(req);
+            if (!body || typeof body !== "object" || Array.isArray(body) ||
+                Object.keys(body).some((key) => key !== "projectIds") ||
+                !Array.isArray(body.projectIds) || body.projectIds.some((id) => typeof id !== "string")) {
+                return json(res, 400, { error: "projectIds must be an array of folder IDs" });
+            }
+            const projects = store.reorderProjects(bot.id, body.projectIds);
+            if (!projects)
+                return json(res, 400, { error: "projectIds must include each of this bot's folders exactly once" });
+            return json(res, 200, { projects, bot: botWithThread(bot) });
+        }
         m = path.match(/^\/api\/bots\/([\w-]+)\/projects(?:\/([\w-]+))?$/);
         if (m && ((method === "POST" && !m[2]) || (method === "PATCH" && m[2]) || (method === "DELETE" && m[2]))) {
             const bot = store.bot(m[1]);
@@ -11451,18 +11555,23 @@ const handleRequest = async (req, res) => {
             const body = await readBody(req);
             if (!body || typeof body !== "object" || Array.isArray(body))
                 return json(res, 400, { error: "body must be a JSON object" });
-            if (Object.keys(body).some((key) => key !== "name")) {
+            if (Object.keys(body).some((key) => key !== "name" && key !== "emoji")) {
                 return json(res, 400, { error: "unsupported folder setting" });
             }
             if ((method === "POST" || body.name !== undefined) &&
                 (typeof body.name !== "string" || !body.name.trim() || body.name.trim().length > 80)) {
                 return json(res, 400, { error: "folder name must be between 1 and 80 characters" });
             }
+            if (body.emoji !== undefined && body.emoji !== null && !isProjectEmoji(body.emoji)) {
+                return json(res, 400, { error: "folder emoji must be one emoji, or null to reset it" });
+            }
             const patch = {};
             if (body.name !== undefined)
                 patch.name = body.name.trim();
+            if (body.emoji !== undefined)
+                patch.emoji = body.emoji;
             const project = method === "POST"
-                ? store.createProject(bot.id, patch.name)
+                ? store.createProject(bot.id, patch.name, patch.emoji)
                 : store.patchProject(bot.id, m[2], patch);
             return json(res, method === "POST" ? 201 : 200, { project, bot: botWithThread(bot) });
         }
@@ -12567,6 +12676,7 @@ const handleRequest = async (req, res) => {
                     key !== "imageGen" &&
                     key !== "vps" &&
                     key !== "rooms" &&
+                    key !== "threads" &&
                     key !== "localVm" &&
                     key !== "features" &&
                     key !== "browserProfiles");
@@ -12604,6 +12714,12 @@ const handleRequest = async (req, res) => {
                         }
                         const status = configStatus();
                         broadcast({ kind: "config", ...status });
+                        if (patch.threads !== undefined) {
+                            drainQueuedSends();
+                            drainDelegationWakes();
+                            drainConnectorResumes();
+                            drainSecretResumes();
+                        }
                         if (mandatoryError)
                             throw mandatoryError;
                         return status;
@@ -13048,6 +13164,24 @@ catch (error) {
 }
 server.listen(PORT, "127.0.0.1", () => {
     console.log(`openmausbot server on http://127.0.0.1:${PORT}`);
+    // Startup work uses the same turn dispatcher and local tool endpoint as
+    // ordinary chat. Start only once every registry is initialized and the
+    // endpoint is listening; earlier dispatch can hit uninitialized bindings.
+    routines.start();
+    const leftover = pendingThreads();
+    if (leftover.length)
+        console.log(`delegations: ${leftover.length} thread(s) with queued handoffs from a previous run — draining`);
+    for (const threadId of leftover) {
+        const run = routines.runForThread(threadId);
+        // A person can reuse a completed run's task for unrelated work. Only
+        // discard the old run's handoffs, not a later user's persisted queue.
+        const reused = run?.finishedAt !== undefined && store.botByThread(threadId) &&
+            store.activePath(threadId).some((message) => message.role === "user" && message.at > run.finishedAt);
+        if (run && !["running", "waiting"].includes(run.status) && !reused)
+            discardDelegations(commsBus, threadId);
+        else
+            drainThreadDelegations(threadId);
+    }
 });
 // A second listener for `openmausbot serve --tunnel` (server/tunnel.ts): the
 // connector gateway on this machine forwards public traffic to this IPC path.