openmausbot 0.1.81 → 0.1.82

package/dist/index.html

@@ -5,7 +5,7 @@
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <link rel="icon" type="image/svg+xml" href="/app-icon.svg" />
     <title>OpenMausBot</title>
-    <script type="module" crossorigin src="/assets/index-peLFiSH8.js"></script>
+    <script type="module" crossorigin src="/assets/index-BLLsDK2F.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-CKysBq-V.css">
   </head>
   <body>

package/dist-server/index.js

@@ -40642,7 +40642,7 @@ function buildNotification(kind, bot, threadId, detail, extra) {
   if (bot.notifications === false) return null;
   const body = summarize(detail);
   const who = extra?.group ? `${bot.name} in ${extra.group.name}` : bot.name;
-  const title = kind === "approval" ? `${who} needs approval` : kind === "question" ? `${who} has a question` : kind === "takeover" ? `${who} needs your hands` : kind === "routine-failed" ? `${who}'s routine failed` : kind === "turn-failed" ? `${who} couldn't start` : `${who} finished`;
+  const title = kind === "approval" ? `${who} needs approval` : kind === "question" ? `${who} has a question` : kind === "takeover" ? `${who} needs your hands` : kind === "routine-failed" ? `${who}'s routine failed` : kind === "routine-deferred" ? `${who}'s routine is waiting` : kind === "turn-failed" ? `${who} couldn't start` : `${who} finished`;
   if (kind === "done" && !body) return null;
   const notification = { kind, botId: bot.id, botName: bot.name, threadId, title, body };
   if (extra?.avatarUrl) notification.avatarUrl = extra.avatarUrl;
@@ -41468,7 +41468,7 @@ function createAcpDriver(support11) {
           return { turnId };
         }
         const resolvedModel = support11.resolveTurnModel?.(turn.model, env);
-        support11.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model });
+        support11.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
         const cliTurn = resolvedModel !== void 0 && resolvedModel !== turn.model ? { ...turn, model: resolvedModel } : turn;
         const mcpServers = acpMcpServers(turn);
         let launch;
@@ -47714,6 +47714,28 @@ var support7 = (loadCatalog2) => ({
   modelVariants: true,
   resolveTurnModel: (model2, env) => model2 ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model2, env), env) : model2,
   transformEnv: stripForeignProviderKeys,
+  applyTurnEnv: (env, { fullAuto }) => {
+    if (!fullAuto) return;
+    env.OPENCODE_PERMISSION = JSON.stringify(Object.fromEntries([
+      "*",
+      "external_directory",
+      "read",
+      "edit",
+      "bash",
+      "glob",
+      "grep",
+      "list",
+      "task",
+      "lsp",
+      "skill",
+      "webfetch",
+      "websearch",
+      "codesearch",
+      "todoread",
+      "todowrite",
+      "doom_loop"
+    ].map((permission) => [permission, "allow"])));
+  },
   pickAuthMethod: () => null,
   authFailure: "continue",
   isAuthenticated: async (env, config2) => Boolean(env.OPENCODE_API_KEY) || hasStoredOpenCodeAuth(env) || await canListOpenCodeModels(env, config2.cli),
@@ -60755,10 +60777,14 @@ import { realpathSync as realpathSync6 } from "node:fs";
 import { relative as relative3, resolve as resolve12, sep as sep2 } from "node:path";
 var TurnResources = class {
   owners = /* @__PURE__ */ new Map();
-  claim(resource, owner2) {
+  blocker(resource, owner2) {
     for (const [key3, current2] of this.owners) {
-      if (overlaps(key3, resource) && !sameOwner(current2, owner2)) return false;
+      if (overlaps(key3, resource) && !sameOwner(current2, owner2)) return current2;
     }
+    return void 0;
+  }
+  claim(resource, owner2) {
+    if (this.blocker(resource, owner2)) return false;
     this.owners.set(resource, owner2);
     return true;
   }
@@ -64739,6 +64765,7 @@ function routineRequestOwnerKey(owner2) {
 var ALL_DAYS = [0, 1, 2, 3, 4, 5, 6];
 var CATCH_UP_MS = 12 * 60 * 6e4;
 var WAKE_HORIZON_MS = 60 * 6e4;
+var ROUTINE_DEFERRAL_NOTICE_MS = 30 * 6e4;
 var MAX_DATE_MS = 864e13;
 var LOCAL_DAY_MS = 24 * 60 * 6e4;
 var INTERVAL_RESTRICTION_SEARCH_MS = 9 * LOCAL_DAY_MS;
@@ -65713,7 +65740,20 @@ var RoutineManager = class {
           }
         }
         const state = this.targetState(run3);
-        if (state === "busy") continue;
+        if (state === "busy") {
+          if (run3.deferredAt == null) {
+            run3.deferredAt = now;
+            this.save();
+            this.emitRun(run3);
+          }
+          if (run3.deferredNoticeAt == null && now - run3.deferredAt >= ROUTINE_DEFERRAL_NOTICE_MS) {
+            run3.deferredNoticeAt = now;
+            this.save();
+            this.emitRun(run3);
+            this.options.onRunDeferred?.(cloneRun(run3));
+          }
+          continue;
+        }
         if (state === "missing") {
           this.failRun(run3, this.missingTargetMessage(run3.target));
           continue;
@@ -81627,9 +81667,33 @@ function releaseTurnResources(owner2) {
     teamComputerTurns.delete(owner2.threadId);
   }
 }
-function bindTurnComputer(owner2, resource, exclusive = false) {
-  if (exclusive && !claimTurnResource(owner2, resource)) {
-    throw Object.assign(new Error("another thread is using this computer \u2014 wait for it to finish"), { status: 409, code: "computer_busy" });
+async function bindTurnComputer(owner2, resource, exclusive = false) {
+  const active = () => activeInternalGenerationByThread.get(owner2.threadId) === owner2.generation && turnResourceOwners.get(owner2.threadId)?.generation === owner2.generation;
+  let waitingMessage;
+  const deadline = Date.now() + GROUP_GOAL_WAIT_MAX_MS;
+  try {
+    while (true) {
+      if (!active()) throw new DirectTurnSetupCancelled("Computer wait cancelled");
+      if (!exclusive || claimTurnResource(owner2, resource)) break;
+      if (!waitingMessage) {
+        const blocker = turnResources.blocker(resource, owner2);
+        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;
+        waitingMessage = store.appendMessage(owner2.threadId, {
+          role: "bot",
+          kind: "activity",
+          tool: { name: `Waiting for computer${holder ? ` \u2014 ${holder} is using it` : ""}; will continue automatically` },
+          ...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.");
+      await new Promise((resolve16) => setTimeout(resolve16, 100));
+    }
+  } finally {
+    if (waitingMessage) store.patchMessage(owner2.threadId, waitingMessage.id, {
+      tool: { name: active() && turnResources.owns(resource, owner2) ? "Computer available \u2014 continuing" : "Computer wait ended", ok: true }
+    });
   }
   turnResourceOwners.set(owner2.threadId, owner2);
   turnComputerResources.set(owner2.threadId, { owner: owner2, resource });
@@ -83426,10 +83490,10 @@ var watchdog = new TurnWatchdog({
         groupSpeakers.delete(turn.threadId);
         store.patchGroup(group.id, { busyBotId: null, unread: true });
       }
+      releaseTurnResources(stalledResourceOwner);
       const currentBot = store.bot(turn.botId);
       if (currentBot?.busy) {
         stopScreenPoller(currentBot.id, turn.threadId);
-        releaseTurnResources(stalledResourceOwner);
         if (activeVpsThreads.get(currentBot.id) === turn.threadId) activeVpsThreads.delete(currentBot.id);
         if (store.taskByThread(currentBot.id, turn.threadId)) store.setTaskActivity(currentBot.id, turn.threadId, "idle");
         else store.setActivity(currentBot.id, "idle");
@@ -83611,11 +83675,11 @@ async function attachTeamBox(computer, botId, owner2, canMount, remoteAgent) {
   const ownerId = teamComputerOwner(computer.id);
   if (boxLifecycleBusyBots.has(ownerId)) throw new Error("The team computer is being changed; wait for it to finish");
   if (computerControl.snapshot(ownerId).held) throw new Error("Release human control of the team computer before starting another turn");
-  bindTurnComputer(owner2, `computer:box-bot:${ownerId}`, true);
+  await bindTurnComputer(owner2, `computer:box-bot:${ownerId}`, true);
   teamComputerTurns.set(owner2.threadId, { owner: owner2, computerId: computer.id, botId, remoteAgent });
   let machine = await findBox(cfg, ownerId);
   if (!machine) throw new Error("The team's Box computer is missing; explicitly create or retry it from the Team map");
-  bindTurnComputer(owner2, `computer:box:${machine.id}`, true);
+  await bindTurnComputer(owner2, `computer:box:${machine.id}`, true);
   const action = boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null });
   if (action === "wake") machine = await readyBox(cfg, ownerId);
   if (!machine || boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null }) !== "attach") {
@@ -85013,7 +85077,7 @@ async function startTurn(botId, text8, opts) {
           if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(localVmTarget.key)) return false;
         }
         try {
-          bindTurnComputer(resourceOwner, `computer:vm:${localVmTarget.key}`, true);
+          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 \u2014 wait for setup to finish");
           }
@@ -85058,7 +85122,7 @@ async function startTurn(botId, text8, opts) {
         }
         const cua = readCuaConnection();
         if (!cua) throw new Error("CUA Driver is not ready for this computer \u2014 check permissions and restart OpenMausBot");
-        bindTurnComputer(resourceOwner, "computer:host");
+        await bindTurnComputer(resourceOwner, "computer:host");
         integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId));
         computerKind = "local";
       }
@@ -85067,7 +85131,7 @@ async function startTurn(botId, text8, opts) {
         if (unsupported && wants2 === "cloud") throw new Error(unsupported);
         if (unsupported && wants2 === void 0) autoVpsProblem = unsupported;
         if (!unsupported) {
-          bindTurnComputer(resourceOwner, `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`, true);
+          await bindTurnComputer(resourceOwner, `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`, true);
           activeVpsThreads.set(bot.id, threadId);
           let remote;
           remote = vpsStartsForTurn({ wants: wants2, autoStartVps: bot.autoStartVps, automationSource: opts?.automationSource }) ? await vpsComputerAction("provision", cfg, bot.id) : await inspectVpsForAuto(cfg, bot.id);
@@ -85097,7 +85161,7 @@ async function startTurn(botId, text8, opts) {
         computerKind = "box";
       }
       if (!teamComputer && mountsCloudComputer && (wants2 === "cloud" || wants2 === void 0) && cloudBackend === "box" && boxConfigured(cfg)) {
-        if (wants2 === "cloud") bindTurnComputer(resourceOwner, `computer:box-bot:${bot.id}`, true);
+        if (wants2 === "cloud") await bindTurnComputer(resourceOwner, `computer:box-bot:${bot.id}`, true);
         if (!mountsCloudComputer && wants2 === "cloud") {
           throw new Error("this model engine cannot use computer tools \u2014 choose Claude, an ACP engine, or the Computer engine");
         }
@@ -85133,7 +85197,7 @@ async function startTurn(botId, text8, opts) {
           });
         }
         if (b3 && lifecycle === "attach") {
-          bindTurnComputer(resourceOwner, `computer:box:${b3.id}`, instance.driverKind === "boxAgent");
+          await bindTurnComputer(resourceOwner, `computer:box:${b3.id}`, instance.driverKind === "boxAgent");
           previewCapture = () => screenshotBox(cfg, bot.id, b3.id);
           if (mountsCloudComputer) {
             integrations.computer = {
@@ -85161,7 +85225,7 @@ async function startTurn(botId, text8, opts) {
       })) {
         const cua = readCuaConnection();
         if (cua) {
-          bindTurnComputer(resourceOwner, "computer:host");
+          await bindTurnComputer(resourceOwner, "computer:host");
           integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId));
           computerKind = "local";
         }
@@ -85415,6 +85479,7 @@ function routineRunCard(run3) {
     status: run3.status
   };
   if (run3.goalStatus) card.goalStatus = run3.goalStatus;
+  if (run3.deferredAt != null && run3.status === "queued") card.deferredAt = run3.deferredAt;
   if (run3.threadId) card.executionThreadId = run3.threadId;
   if (summary) card.summary = summary;
   if (error51) card.error = error51;
@@ -85422,7 +85487,7 @@ function routineRunCard(run3) {
 }
 function routineRunFallbackText(card) {
   const goalState = card.goalStatus === "needs-input" ? "needs your input" : card.goalStatus === "blocked" ? "was blocked" : card.goalStatus === "limit-reached" ? "reached its limit" : card.goalStatus === "stopped" ? "was stopped" : card.goalStatus === "failed" ? "failed" : void 0;
-  const state = goalState ?? (card.status === "waiting" ? "needs your attention" : card.status === "completed" ? "completed" : card.status === "failed" ? "failed" : card.status === "cancelled" ? "was cancelled" : card.status === "missed" ? "was missed" : card.status);
+  const state = goalState ?? (card.status === "waiting" ? "needs your attention" : card.status === "completed" ? "completed" : card.status === "failed" ? "failed" : card.status === "cancelled" ? "was cancelled" : card.status === "missed" ? "was missed" : card.status === "queued" && card.deferredAt != null ? "deferred: target busy" : card.status);
   return `Routine \u201C${card.routineName}\u201D ${state}`;
 }
 function syncRoutineRunToSource(run3) {
@@ -85585,6 +85650,14 @@ routines = new RoutineManager({
     const detail = run3.error ? `${run3.routineName}: ${run3.error}` : run3.routineName;
     const notificationBot = routineSourceOwner(run3)?.bot ?? bot;
     notify(buildNotification("routine-failed", notificationBot, routineSourceThread(run3) ?? run3.threadId ?? bot.threadId, detail));
+  },
+  onRunDeferred: (run3) => {
+    const bot = store.bot(run3.botId);
+    if (!bot) return;
+    const minutes = run3.deferredAt != null && run3.deferredNoticeAt != null ? Math.max(1, Math.round((run3.deferredNoticeAt - run3.deferredAt) / 6e4)) : null;
+    const detail = `${redactSecretsInText(run3.routineName)}: target busy${minutes != null ? ` for ${minutes} minutes` : ""}`;
+    const notificationBot = routineSourceOwner(run3)?.bot ?? bot;
+    notify(buildNotification("routine-deferred", notificationBot, routineSourceThread(run3) ?? bot.threadId, detail));
   }
 });
 var recoveredRoutineGoalRuns = new Map(
@@ -86424,7 +86497,7 @@ async function runGroupMemberTurn(groupId, threadId, botId, hop, spoken = /* @__
         throw new Error("this model engine cannot use the Local VM");
       }
       const target = { ...localVmTargetForBot(readyBot.id) };
-      bindTurnComputer(resourceOwner, `computer:vm:${target.key}`, true);
+      await bindTurnComputer(resourceOwner, `computer:vm:${target.key}`, true);
       if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(target.key)) {
         throw new Error("this Local VM is being started, stopped, or replaced");
       }
@@ -86775,6 +86848,7 @@ ${e.text}`;
     return true;
   } catch (error51) {
     if (providerDispatched) throw error51;
+    if (error51 instanceof DirectTurnSetupCancelled) return false;
     const isSpendCap = typeof error51 === "object" && error51 !== null && error51.code === "spend_cap";
     const isVariantError = typeof error51 === "object" && error51 !== null && error51.code === "unsupported_model_variant";
     if (!roomSpeaker && !isSpendCap && !isVariantError) throw error51;

package/dist-server/openmausbot.js

@@ -20054,7 +20054,7 @@ function createAcpDriver(support11) {
           return { turnId };
         }
         const resolvedModel = support11.resolveTurnModel?.(turn.model, env);
-        support11.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model });
+        support11.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
         const cliTurn = resolvedModel !== void 0 && resolvedModel !== turn.model ? { ...turn, model: resolvedModel } : turn;
         const mcpServers = acpMcpServers(turn);
         let launch;
@@ -36256,6 +36256,28 @@ var init_opencode_go = __esm({
       modelVariants: true,
       resolveTurnModel: (model, env) => model ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model, env), env) : model,
       transformEnv: stripForeignProviderKeys,
+      applyTurnEnv: (env, { fullAuto }) => {
+        if (!fullAuto) return;
+        env.OPENCODE_PERMISSION = JSON.stringify(Object.fromEntries([
+          "*",
+          "external_directory",
+          "read",
+          "edit",
+          "bash",
+          "glob",
+          "grep",
+          "list",
+          "task",
+          "lsp",
+          "skill",
+          "webfetch",
+          "websearch",
+          "codesearch",
+          "todoread",
+          "todowrite",
+          "doom_loop"
+        ].map((permission) => [permission, "allow"])));
+      },
       pickAuthMethod: () => null,
       authFailure: "continue",
       isAuthenticated: async (env, config2) => Boolean(env.OPENCODE_API_KEY) || hasStoredOpenCodeAuth(env) || await canListOpenCodeModels(env, config2.cli),

package/dist-server/pair-cli.js

@@ -20054,7 +20054,7 @@ function createAcpDriver(support11) {
           return { turnId };
         }
         const resolvedModel = support11.resolveTurnModel?.(turn.model, env);
-        support11.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model });
+        support11.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
         const cliTurn = resolvedModel !== void 0 && resolvedModel !== turn.model ? { ...turn, model: resolvedModel } : turn;
         const mcpServers = acpMcpServers(turn);
         let launch;
@@ -36256,6 +36256,28 @@ var init_opencode_go = __esm({
       modelVariants: true,
       resolveTurnModel: (model, env) => model ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model, env), env) : model,
       transformEnv: stripForeignProviderKeys,
+      applyTurnEnv: (env, { fullAuto }) => {
+        if (!fullAuto) return;
+        env.OPENCODE_PERMISSION = JSON.stringify(Object.fromEntries([
+          "*",
+          "external_directory",
+          "read",
+          "edit",
+          "bash",
+          "glob",
+          "grep",
+          "list",
+          "task",
+          "lsp",
+          "skill",
+          "webfetch",
+          "websearch",
+          "codesearch",
+          "todoread",
+          "todowrite",
+          "doom_loop"
+        ].map((permission) => [permission, "allow"])));
+      },
       pickAuthMethod: () => null,
       authFailure: "continue",
       isAuthenticated: async (env, config2) => Boolean(env.OPENCODE_API_KEY) || hasStoredOpenCodeAuth(env) || await canListOpenCodeModels(env, config2.cli),

package/dist-server/server/drivers/acp/core.js

@@ -327,7 +327,7 @@ export function createAcpDriver(support) {
                     return { turnId };
                 }
                 const resolvedModel = support.resolveTurnModel?.(turn.model, env);
-                support.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model });
+                support.applyTurnEnv?.(env, { model: resolvedModel, requestedModel: turn.model, fullAuto: turnConfig.fullAuto === true });
                 const cliTurn = resolvedModel !== undefined && resolvedModel !== turn.model
                     ? { ...turn, model: resolvedModel }
                     : turn;

package/dist-server/server/drivers/acp/opencode-go.js

@@ -340,6 +340,19 @@ const support = (loadCatalog) => ({
         ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model, env), env)
         : model,
     transformEnv: stripForeignProviderKeys,
+    applyTurnEnv: (env, { fullAuto }) => {
+        if (!fullAuto)
+            return;
+        // Scope native permissions to this child, not the user's OpenCode config.
+        // A wildcard alone leaves OpenCode's more-specific external-directory and
+        // read rules in place. Replace the built-in rules as well, including path
+        // maps, so Full means the same thing inside the provider and in OMB.
+        env.OPENCODE_PERMISSION = JSON.stringify(Object.fromEntries([
+            "*", "external_directory", "read", "edit", "bash", "glob", "grep",
+            "list", "task", "lsp", "skill", "webfetch", "websearch", "codesearch",
+            "todoread", "todowrite", "doom_loop",
+        ].map((permission) => [permission, "allow"])));
+    },
     pickAuthMethod: () => null,
     authFailure: "continue",
     isAuthenticated: async (env, config) => (Boolean(env.OPENCODE_API_KEY)

package/dist-server/server/index.js

@@ -616,9 +616,39 @@ function releaseTurnResources(owner) {
         teamComputerTurns.delete(owner.threadId);
     }
 }
-function bindTurnComputer(owner, resource, exclusive = false) {
-    if (exclusive && !claimTurnResource(owner, resource)) {
-        throw Object.assign(new Error("another thread is using this computer — wait for it to finish"), { status: 409, code: "computer_busy" });
+async function bindTurnComputer(owner, resource, exclusive = false) {
+    const active = () => activeInternalGenerationByThread.get(owner.threadId) === owner.generation &&
+        turnResourceOwners.get(owner.threadId)?.generation === owner.generation;
+    let waitingMessage;
+    const deadline = Date.now() + GROUP_GOAL_WAIT_MAX_MS;
+    try {
+        while (true) {
+            if (!active())
+                throw new DirectTurnSetupCancelled("Computer wait cancelled");
+            if (!exclusive || claimTurnResource(owner, resource))
+                break;
+            if (!waitingMessage) {
+                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;
+                waitingMessage = store.appendMessage(owner.threadId, {
+                    role: "bot", kind: "activity",
+                    tool: { name: `Waiting for computer${holder ? ` — ${holder} is using it` : ""}; will continue automatically` },
+                    ...(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.");
+            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 },
+            });
     }
     turnResourceOwners.set(owner.threadId, owner);
     turnComputerResources.set(owner.threadId, { owner, resource });
@@ -2943,10 +2973,12 @@ const watchdog = new TurnWatchdog({
                 groupSpeakers.delete(turn.threadId);
                 store.patchGroup(group.id, { busyBotId: null, unread: true });
             }
+            // A cleared UI busy flag must not strand this finished generation's
+            // computer claim. The generation checks above protect replacements.
+            releaseTurnResources(stalledResourceOwner);
             const currentBot = store.bot(turn.botId);
             if (currentBot?.busy) {
                 stopScreenPoller(currentBot.id, turn.threadId);
-                releaseTurnResources(stalledResourceOwner);
                 if (activeVpsThreads.get(currentBot.id) === turn.threadId)
                     activeVpsThreads.delete(currentBot.id);
                 if (store.taskByThread(currentBot.id, turn.threadId))
@@ -3223,12 +3255,12 @@ async function attachTeamBox(computer, botId, owner, canMount, remoteAgent) {
         throw new Error("The team computer is being changed; wait for it to finish");
     if (computerControl.snapshot(ownerId).held)
         throw new Error("Release human control of the team computer before starting another turn");
-    bindTurnComputer(owner, `computer:box-bot:${ownerId}`, true);
+    await bindTurnComputer(owner, `computer:box-bot:${ownerId}`, true);
     teamComputerTurns.set(owner.threadId, { owner, computerId: computer.id, botId, remoteAgent });
     let machine = await box.findBox(cfg, ownerId);
     if (!machine)
         throw new Error("The team's Box computer is missing; explicitly create or retry it from the Team map");
-    bindTurnComputer(owner, `computer:box:${machine.id}`, true);
+    await bindTurnComputer(owner, `computer:box:${machine.id}`, true);
     const action = box.boxTurnLifecycleAction({ explicitCloud: true, canMount: true, state: typeof machine.state === "string" ? machine.state : null });
     if (action === "wake")
         machine = await box.readyBox(cfg, ownerId);
@@ -5209,7 +5241,7 @@ async function startTurn(botId, text, opts) {
                         return false;
                 }
                 try {
-                    bindTurnComputer(resourceOwner, `computer:vm:${localVmTarget.key}`, true);
+                    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");
                     }
@@ -5268,7 +5300,7 @@ async function startTurn(botId, text, opts) {
                 const cua = readCuaConnection();
                 if (!cua)
                     throw new Error("CUA Driver is not ready for this computer — check permissions and restart OpenMausBot");
-                bindTurnComputer(resourceOwner, "computer:host");
+                await bindTurnComputer(resourceOwner, "computer:host");
                 integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId));
                 computerKind = "local";
             }
@@ -5284,7 +5316,7 @@ async function startTurn(botId, text, opts) {
                 if (!unsupported) {
                     // The remote lifecycle and container are shared by this bot. Keep
                     // its explicit computer turns serialized; ordinary threads still run.
-                    bindTurnComputer(resourceOwner, `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`, true);
+                    await bindTurnComputer(resourceOwner, `computer:vps:${vpsSshAlias(cfg)}:${bot.id}`, true);
                     activeVpsThreads.set(bot.id, threadId);
                     let remote;
                     remote = vps.vpsStartsForTurn({ wants, autoStartVps: bot.autoStartVps, automationSource: opts?.automationSource })
@@ -5322,7 +5354,7 @@ async function startTurn(botId, text, opts) {
                 // Explicit cloud turns can provision/wake the same bot's Box. Claim
                 // before any network await so setup itself cannot race another turn.
                 if (wants === "cloud")
-                    bindTurnComputer(resourceOwner, `computer:box-bot:${bot.id}`, true);
+                    await bindTurnComputer(resourceOwner, `computer:box-bot:${bot.id}`, true);
                 if (!mountsCloudComputer && wants === "cloud") {
                     throw new Error("this model engine cannot use computer tools — choose Claude, an ACP engine, or the Computer engine");
                 }
@@ -5366,7 +5398,7 @@ async function startTurn(botId, text, opts) {
                     });
                 }
                 if (b && lifecycle === "attach") {
-                    bindTurnComputer(resourceOwner, `computer:box:${b.id}`, instance.driverKind === "boxAgent");
+                    await bindTurnComputer(resourceOwner, `computer:box:${b.id}`, instance.driverKind === "boxAgent");
                     previewCapture = () => box.screenshotBox(cfg, bot.id, b.id);
                     if (mountsCloudComputer) {
                         integrations.computer = {
@@ -5407,7 +5439,7 @@ async function startTurn(botId, text, opts) {
                 })) {
                 const cua = readCuaConnection();
                 if (cua) {
-                    bindTurnComputer(resourceOwner, "computer:host");
+                    await bindTurnComputer(resourceOwner, "computer:host");
                     integrations.localComputer = gatedLocalComputer(cua, controlIntegration(bot.id, threadId, dispatchClaimId));
                     computerKind = "local";
                 }
@@ -5771,6 +5803,8 @@ function routineRunCard(run) {
     };
     if (run.goalStatus)
         card.goalStatus = run.goalStatus;
+    if (run.deferredAt != null && run.status === "queued")
+        card.deferredAt = run.deferredAt;
     if (run.threadId)
         card.executionThreadId = run.threadId;
     if (summary)
@@ -5801,7 +5835,9 @@ function routineRunFallbackText(card) {
                     ? "was cancelled"
                     : card.status === "missed"
                         ? "was missed"
-                        : card.status);
+                        : card.status === "queued" && card.deferredAt != null
+                            ? "deferred: target busy"
+                            : card.status);
     return `Routine “${card.routineName}” ${state}`;
 }
 /** Upsert one durable lifecycle card per run. Replaying the same transition,
@@ -6005,6 +6041,17 @@ routines = new RoutineManager({
         const notificationBot = routineSourceOwner(run)?.bot ?? bot;
         notify(buildNotification("routine-failed", notificationBot, routineSourceThread(run) ?? run.threadId ?? bot.threadId, detail));
     },
+    onRunDeferred: (run) => {
+        const bot = store.bot(run.botId);
+        if (!bot)
+            return;
+        const minutes = run.deferredAt != null && run.deferredNoticeAt != null
+            ? Math.max(1, Math.round((run.deferredNoticeAt - run.deferredAt) / 60_000))
+            : null;
+        const detail = `${redactSecretsInText(run.routineName)}: target busy${minutes != null ? ` for ${minutes} minutes` : ""}`;
+        const notificationBot = routineSourceOwner(run)?.bot ?? bot;
+        notify(buildNotification("routine-deferred", notificationBot, routineSourceThread(run) ?? bot.threadId, detail));
+    },
 });
 // The scheduler receipt and room transcript live in separate durable stores.
 // If the process exited between those two writes, prefer the correlated
@@ -7009,7 +7056,7 @@ setupRetry = 0) {
             }
             // A distinct identity fences cleanup even in shared mode on the same room thread.
             const target = { ...localVmTargetForBot(readyBot.id) };
-            bindTurnComputer(resourceOwner, `computer:vm:${target.key}`, true);
+            await bindTurnComputer(resourceOwner, `computer:vm:${target.key}`, true);
             if (localVmImageBusy || localVmModeChangeBusy || localVmLifecycleBusy.has(target.key)) {
                 throw new Error("this Local VM is being started, stopped, or replaced");
             }
@@ -7449,6 +7496,8 @@ setupRetry = 0) {
     catch (error) {
         if (providerDispatched)
             throw error;
+        if (error instanceof DirectTurnSetupCancelled)
+            return false;
         const isSpendCap = typeof error === "object" && error !== null && error.code === "spend_cap";
         const isVariantError = typeof error === "object" && error !== null && error.code === "unsupported_model_variant";
         if (!roomSpeaker && !isSpendCap && !isVariantError)

package/dist-server/server/notify.js

@@ -10,6 +10,9 @@
 // bot is not working, and the fix is usually a setting only a person can
 // change, so a retry cannot clear it. A routine failure already buzzed;
 // this makes an interactive turn behave the same way.
+// A routine parked behind a busy target earns one notice after half an
+// hour: from outside the schedule looks broken, and only a person can
+// decide whether the busy work or the routine matters more.
 //
 // Delivery is a separate concern. The harness emits a frame; whoever is
 // listening decides what to do with it — desktop and paired-phone local
@@ -53,9 +56,11 @@ export function buildNotification(kind, bot, threadId, detail, extra) {
                 ? `${who} needs your hands`
                 : kind === "routine-failed"
                     ? `${who}'s routine failed`
-                    : kind === "turn-failed"
-                        ? `${who} couldn't start`
-                        : `${who} finished`;
+                    : kind === "routine-deferred"
+                        ? `${who}'s routine is waiting`
+                        : kind === "turn-failed"
+                            ? `${who} couldn't start`
+                            : `${who} finished`;
     // A "finished" with nothing to say is not worth a notification — the
     // badge in the sidebar already carries that much.
     if (kind === "done" && !body)

package/dist-server/server/routines.js

@@ -22,6 +22,9 @@ const ALL_DAYS = [0, 1, 2, 3, 4, 5, 6];
 const CATCH_UP_MS = 12 * 60 * 60_000;
 /** How long before a due routine the computer is asked to stay awake. */
 const WAKE_HORIZON_MS = 60 * 60_000;
+/** How long a run may sit deferred behind a busy target before the user
+ * hears about it once. Surfacing only; dispatch semantics stay unchanged. */
+export const ROUTINE_DEFERRAL_NOTICE_MS = 30 * 60_000;
 const MAX_DATE_MS = 8_640_000_000_000_000;
 const LOCAL_DAY_MS = 24 * 60 * 60_000;
 const INTERVAL_RESTRICTION_SEARCH_MS = 9 * LOCAL_DAY_MS;
@@ -1168,8 +1171,23 @@ export class RoutineManager {
                     }
                 }
                 const state = this.targetState(run);
-                if (state === "busy")
+                if (state === "busy") {
+                    // A queued run behind a busy target is deferred, not silent. Stamp
+                    // the wait once so receipts and cards can say how long it has been
+                    // held; the run still dispatches the moment the target frees.
+                    if (run.deferredAt == null) {
+                        run.deferredAt = now;
+                        this.save();
+                        this.emitRun(run);
+                    }
+                    if (run.deferredNoticeAt == null && now - run.deferredAt >= ROUTINE_DEFERRAL_NOTICE_MS) {
+                        run.deferredNoticeAt = now;
+                        this.save();
+                        this.emitRun(run);
+                        this.options.onRunDeferred?.(cloneRun(run));
+                    }
                     continue;
+                }
                 if (state === "missing") {
                     this.failRun(run, this.missingTargetMessage(run.target));
                     continue;

package/dist-server/server/turn-resources.js

@@ -6,11 +6,16 @@ import { relative, resolve, sep } from "node:path";
  * are not a sandbox for arbitrary shell commands. */
 export class TurnResources {
     owners = new Map();
-    claim(resource, owner) {
+    blocker(resource, owner) {
         for (const [key, current] of this.owners) {
             if (overlaps(key, resource) && !sameOwner(current, owner))
-                return false;
+                return current;
         }
+        return undefined;
+    }
+    claim(resource, owner) {
+        if (this.blocker(resource, owner))
+            return false;
         this.owners.set(resource, owner);
         return true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openmausbot",
-  "version": "0.1.81",
+  "version": "0.1.82",
   "description": "Run the OpenMausBot server anywhere and pair your devices to it",
   "license": "Apache-2.0",
   "type": "module",