openmausbot 0.1.92 → 0.1.94

package/dist-server/permission-proxy.js

@@ -94,7 +94,70 @@ function questionAnswersById(message, questions) {
   return only && flat ? { [only.id]: flat } : {};
 }
 
+// shared/tool-scope.ts
+var SERVER_NAME = /^[a-z][a-z0-9_-]{0,31}$/;
+var CONTROL_CHARACTER = /[\x00-\x1f\x7f]/;
+var MAX_SELECTORS = 256;
+var MAX_SELECTOR_LENGTH = 1024;
+function validName(name) {
+  return typeof name === "string" && name.trim().length > 0 && name.length <= MAX_SELECTOR_LENGTH && !CONTROL_CHARACTER.test(name) && !name.includes("*");
+}
+function selectorIdentity(selector) {
+  if (selector.length > MAX_SELECTOR_LENGTH || CONTROL_CHARACTER.test(selector)) return;
+  if (selector.startsWith("native:")) {
+    const name = selector.slice(7);
+    if (name === "*" || validName(name)) return { kind: "native", name };
+  } else if (selector.startsWith("mcp:")) {
+    const separator = selector.indexOf(":", 4);
+    if (separator < 0) return;
+    const server = selector.slice(4, separator);
+    const name = selector.slice(separator + 1);
+    if (SERVER_NAME.test(server) && (name === "*" || validName(name))) {
+      return { kind: "mcp", server, name };
+    }
+  }
+}
+function parseToolScope(value) {
+  if (value === void 0) return { ok: true, scope: void 0 };
+  const invalid = { ok: false, error: "Tool selection must contain only valid allow and deny lists." };
+  if (!value || typeof value !== "object" || Array.isArray(value)) return invalid;
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) return invalid;
+  const scope = {};
+  for (const key of Reflect.ownKeys(value)) {
+    if (key !== "allow" && key !== "deny") return invalid;
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor)) return invalid;
+    const list = descriptor.value;
+    if (!Array.isArray(list) || list.length > MAX_SELECTORS) return invalid;
+    if (!Array.from(list).every((entry) => typeof entry === "string" && selectorIdentity(entry))) return invalid;
+    scope[key] = [...new Set(list)];
+  }
+  return { ok: true, scope };
+}
+function matches(selector, tool) {
+  const selected = selectorIdentity(selector);
+  return selected?.kind === tool.kind && (selected.kind !== "mcp" || tool.kind === "mcp" && selected.server === tool.server) && (selected.name === "*" || selected.name === tool.name);
+}
+function permits(scope, tool) {
+  if (!validName(tool.name) || tool.kind === "mcp" && !SERVER_NAME.test(tool.server)) return false;
+  return (scope?.allow === void 0 || scope.allow.some((selector) => matches(selector, tool))) && !scope?.deny?.some((selector) => matches(selector, tool));
+}
+function allowsTool(scope, tool) {
+  const parsed = parseToolScope(scope);
+  return parsed.ok && permits(parsed.scope, tool);
+}
+
 // server/permission-proxy.ts
+var selection = parseToolScope(process.env.OMB_PERMISSION_TOOL_SCOPE === void 0 ? void 0 : (() => {
+  try {
+    return JSON.parse(process.env.OMB_PERMISSION_TOOL_SCOPE);
+  } catch {
+    return null;
+  }
+})());
+if (!selection.ok) throw new Error(selection.error);
+var allowQuestion = allowsTool(selection.scope, { kind: "mcp", server: "ogb", name: "ask_user" });
 var socketPath = process.argv[2] ?? "";
 var waiting = /* @__PURE__ */ new Map();
 var conn = connect(socketPath);
@@ -203,11 +266,12 @@ async function handle(msg) {
       }
     });
   }
-  if (msg.method === "tools/list") return send({ jsonrpc: "2.0", id: msg.id, result: { tools: TOOLS } });
+  if (msg.method === "tools/list") return send({ jsonrpc: "2.0", id: msg.id, result: { tools: TOOLS.filter((tool) => tool.name === "approve" || allowQuestion) } });
   if (msg.method === "tools/call") {
     const name = msg.params?.name;
     const args = msg.params?.arguments ?? {};
     const reply = (text3) => send({ jsonrpc: "2.0", id: msg.id, result: { content: [{ type: "text", text: text3 }] } });
+    if (name === "ask_user" && !allowQuestion) return reply("OpenMausBot: this question tool is excluded by the bot's tool selection.");
     if (name === "approve" && args.tool_name === ASK_USER_QUESTION) {
       return reply(await answerNativeQuestions(args.input));
     }

package/dist-server/proxy-paths.js

@@ -17,6 +17,7 @@ var SPAWNED_PROXIES = {
   dweb: resolveProxy("drivers/dweb-proxy"),
   connectors: resolveProxy("connector-proxy"),
   mcpGate: resolveProxy("mcp-gate"),
+  mcpRemote: resolveProxy("mcp-remote-proxy"),
   phone: resolveProxy("drivers/phone-proxy"),
   hook: resolveProxy("hooks/omb-hook"),
   // Loaded by the external `pi` process via `-e`, not by this server — but

package/dist-server/server/auto-approve.js

@@ -25,7 +25,7 @@ export async function deliverFullAccessApproval(adapter, threadId, requestId, tu
 }
 /** Full access is the person's explicit grant to this receiving bot, including
  * delegated work. It never inherits the sender's mode or elevates another bot
- * — with the one exception below (delegationInheritsFullAccess), applied
+ * — with the one exception below (delegatedApprovalMode), applied
  * where a Chief's delegated thread is created rather than here.
  * Custom is a provider-config choice rather than an app Full-access grant, so
  * peer-started Custom turns use Auto. Provider support and grant confirmation
@@ -35,16 +35,38 @@ export function approvalModeForOrigin(mode, origin) {
         return "auto";
     return mode;
 }
-/** Whether work a bot hands to a teammate runs with Full access. Only a Chief
- * of Staff passes access on, and only the Full access the person gave it for
- * the conversation it is delegating from: the Chief exists to get the team's
- * work done without the person answering every card, and a teammate stopping
- * that work to ask defeats the grant. The recipient's engine has to implement
- * Full, or the work keeps the recipient's own level. A bot never elevates
- * itself this way. */
-export function delegationInheritsFullAccess(input) {
-    return input.senderIsChief && input.senderHasFullAccess && !input.sameBot
-        && supportsApprovalMode(input.recipientDriverKind, "full");
+/** Levels by how much runs without asking. Custom is a provider config of
+ * its own and is never compared. */
+const LEVEL_RANK = { ask: 0, edits: 1, auto: 2, full: 3 };
+/** The level work a bot hands to a teammate starts at, or null to keep the
+ * teammate's own. A Chief of Staff's level flows down: the person set it on
+ * the Chief so the team's work runs that way, and switching every thread the
+ * Chief opens with a teammate back off "Ask for approval" was the friction
+ * people reported. Only a Chief passes its level on, only the level of the
+ * conversation it delegates from, and only upward: a teammate already on a
+ * higher level keeps it, and one on Custom keeps its own config. The level
+ * is capped at what the teammate's engine implements (Full or Auto-accept
+ * edits are not everywhere), stepping down to the next level it has. A bot
+ * never raises itself this way. */
+export function delegatedApprovalMode(input) {
+    if (!input.senderIsChief || input.sameBot)
+        return null;
+    // A Chief's Custom config is its own; for a teammate it reads as Approve
+    // for me, as for any peer-started Custom turn (approvalModeForOrigin).
+    const sender = LEVEL_RANK[approvalModeForOrigin(input.senderMode, { peerInitiated: true })] ?? 0;
+    const own = LEVEL_RANK[input.recipientMode];
+    if (own === undefined)
+        return null;
+    for (const mode of ["full", "auto", "edits"]) {
+        const rank = LEVEL_RANK[mode];
+        if (rank > sender)
+            continue;
+        if (rank <= own)
+            return null;
+        if (supportsApprovalMode(input.recipientDriverKind, mode))
+            return mode;
+    }
+    return null;
 }
 // Tools that ask a PERSON something. A question exists so that a human
 // decides; any mode answering one on their behalf defeats the only reason

package/dist-server/server/boat.js

@@ -923,9 +923,9 @@ export async function verifyToken(token) {
         return { ok: false, message: "Couldn't reach boat.dev to check that token — check your connection and retry." };
     }
 }
-/** A rejected Cloud Pro relay token: nothing the person pasted, so nothing
- * for them to fix in Settings. */
-const INCLUDED_BOAT_UNAVAILABLE = "Cloud Pro's included cloud computers aren't available right now. Try again later.";
+/** A rejected Cloud relay token: nothing the person pasted, so nothing
+ * for them to fix in Settings. Plan-neutral: every Cloud plan includes them. */
+const INCLUDED_BOAT_UNAVAILABLE = "The cloud computers included with your Cloud plan aren't available right now. Try again later.";
 /** Turn a provider refusal into something a person can act on. The
  * provider's own message is better than anything we can invent — it knows
  * the plan, the limit and the link — so prefer it and only fall back to

package/dist-server/server/browser-live.js

@@ -10,6 +10,9 @@ const HEARTBEAT_MS = 10_000;
 // The native press resolver supplies the virtual key codes and Enter/Tab text
 // that its raw input_keyboard relay omits. Keep unknown keys literal.
 const DISCRETE_KEYS = new Set(["Backspace", "Enter", "Tab", "Escape", "Delete", "ArrowUp", "ArrowDown", "ArrowLeft", "ArrowRight", "Home", "End", "PageUp", "PageDown"]);
+// The panel has no take-control button: interacting takes control, and an
+// interrupted action is recovered from the panel's menu.
+const RESTART_NEEDED = "A browser action was interrupted. Choose Restart browser… in the browser menu before continuing.";
 export class BrowserLiveError extends Error {
     status;
     constructor(message, status = 400) { super(message); this.name = "BrowserLiveError"; this.status = status; }
@@ -569,22 +572,24 @@ export class BrowserLive {
             try {
                 const taking = this.runtime.take(viewer.session, viewer.id);
                 this.control(viewer.session);
-                await taking;
+                // waited: the bot's own action finished first, so input the person
+                // aimed at the page before the grant may no longer fit it.
+                const waited = await taking;
                 if (!this.current(viewer)) {
                     this.close(viewer);
                     throw new BrowserLiveError("This browser view closed.", 409);
                 }
-                return { ok: true };
+                return { ok: true, waited: waited === true };
             }
             catch {
-                throw new BrowserLiveError("Another browser view or bot action is using this browser. Try again shortly.", 409);
+                throw this.refusal(viewer, "Another browser view or bot action is using this browser. Try again shortly.");
             }
             finally {
                 this.control(viewer.session);
             }
         }
         if (!this.runtime.canControl(viewer.session, viewer.id))
-            throw new BrowserLiveError("Take control of this browser before interacting.", 409);
+            throw this.refusal(viewer, "Browser control changed. Try again.");
         if (viewer.pendingActions >= 32)
             throw new BrowserLiveError("Too many browser actions are pending. Try again shortly.", 429);
         viewer.pendingActions += 1;
@@ -600,13 +605,17 @@ export class BrowserLive {
             return { ok: true };
         }
         catch (error) {
-            throw error instanceof BrowserLiveError ? error : new BrowserLiveError("Browser control changed. Take control again to continue.", 409);
+            throw error instanceof BrowserLiveError ? error : this.refusal(viewer, "Browser control changed. Try again.");
         }
         finally {
             viewer.pendingActions -= 1;
             this.control(viewer.session);
         }
     }
+    /** Why this viewer cannot act now: an interrupted browser needs a restart. */
+    refusal(viewer, otherwise) {
+        return new BrowserLiveError(this.runtime.interrupted(viewer.session) ? RESTART_NEEDED : otherwise, 409);
+    }
     closeForSession(session) { for (const viewer of this.viewers.values())
         if (viewer.session === session)
             this.close(viewer); }

package/dist-server/server/browser-runtime.js

@@ -364,6 +364,8 @@ export class BrowserRuntime {
         };
         return method === "tools/call" ? this.withAgentAction(session, invoke) : invoke();
     }
+    /** Resolves true when the grant had to wait for the bot's own browser
+     * action to finish: the page may have changed since the person aimed. */
     async take(session, owner) {
         if (!owner)
             throw new Error("Browser control requires an owner.");
@@ -374,6 +376,7 @@ export class BrowserRuntime {
             throw new Error("Another person controls this browser.");
         gate.owner = owner; // synchronous: no new agent work slips in while draining.
         gate.ready = false;
+        const waited = gate.agents > 0;
         await new Promise((resolve, reject) => {
             const finish = (error) => {
                 clearTimeout(timer);
@@ -398,12 +401,15 @@ export class BrowserRuntime {
             gate.changed.add(check);
             check();
         });
+        return waited;
     }
     canControl(session, owner) {
         const gate = this.gates.get(session);
         return Boolean(owner && gate?.owner === owner && gate.ready && !gate.releasing && !gate.closing && !gate.uncertain && gate.agents === 0);
     }
     heldBy(session) { return this.gates.get(session)?.owner ?? null; }
+    /** An interrupted action left the browser's state unknown; only a restart clears it. */
+    interrupted(session) { return this.gates.get(session)?.uncertain === true; }
     /** A disconnected viewer may leave a physical key/button pressed. Never
      * let an agent inherit that input state; explicit restart clears it. */
     abandonHumanInput(session, owner) {

package/dist-server/server/channel-queue.js

@@ -17,8 +17,11 @@ export function restoreChannelMessages() {
         const entry = queues.get(row.threadId) ?? { groupId: row.ownerId, items: [] };
         if (entry.groupId !== row.ownerId)
             throw new Error("queued task belongs to another channel");
+        // a channel line is only ever stamped "api"; "call" belongs to 1:1 rows
+        const { via, ...payload } = row.payload;
         entry.items.push({
-            ...row.payload,
+            ...payload,
+            ...(via === "api" ? { via } : {}),
             id: row.id,
             mode: row.payload.mode ?? "chat",
             // rows queued before timestamps were kept read as queued at restore

package/dist-server/server/cli.js

@@ -812,7 +812,7 @@ export async function runBrowser(options, io = defaultIo()) {
             io.error("on Linux, install Chrome's system libraries with `sudo openmausbot browser install --with-deps`, then retry `openmausbot browser install` as the user running serve");
         return 1;
     }
-    io.log("browser installed for this user and data directory; run serve as the same user, then enable it under Settings → Experimental and per bot");
+    io.log("browser installed for this user and data directory; run serve as the same user, then enable it under Settings → Computers and per bot");
     if (process.platform === "linux" && options.withDeps)
         io.log("if serve runs as another user, run `openmausbot browser install` from that user's login shell too");
     return 0;
@@ -834,8 +834,13 @@ export function serverEntry(here = HERE) {
 }
 /** Everything `--tunnel` needs before the server starts, or the one reason
  * it cannot have it. Fails closed: no silent fallback to a local-only server. */
-async function planTunnel(options, log) {
+async function planTunnel(options, log, recovery) {
     let access = null;
+    let account = null;
+    const fail = (error) => {
+        account?.service.dispose();
+        return { error };
+    };
     const credential = fleetCredential();
     if (credential) {
         // A fleet-started container: the credential is the whole identity.
@@ -848,36 +853,41 @@ async function planTunnel(options, log) {
         }
     }
     else {
-        const account = createTunnelAccount({ dataDir: options.dataDir, version: serverVersion() });
+        account = createTunnelAccount({ dataDir: options.dataDir, version: serverVersion(), recovery });
         if (account.credentials.status === "unavailable")
-            return { error: `${account.credentials.file} exists but could not be read; fix or remove it` };
+            return fail(`${account.credentials.file} exists but could not be read; fix or remove it`);
         if (!describeTunnelAccount(account.credentials.read()).email) {
-            return { error: "no account on this machine yet: run `openmausbot login` first, then `openmausbot serve --tunnel`" };
+            return fail("no account on this machine yet: run `openmausbot login` first, then `openmausbot serve --tunnel`");
         }
         // A fresh connector token when the control plane answers; the saved one otherwise.
         try {
             const state = await account.service.retry();
-            if (state.message && !tunnelAccess(account.credentials.read()))
-                log(`tunnel: ${state.message}`);
+            const saved = tunnelAccess(account.credentials.read()) !== null;
+            // Said even when a saved address exists: an expired sign-in means this
+            // machine can no longer repair that address on its own.
+            if (state.status === "signed-out")
+                log(`tunnel: the sign-in on this machine expired; run \`openmausbot login\` to renew it${saved ? " (serving the saved address until then)" : ""}`);
+            else if (state.message)
+                log(`tunnel: ${state.message}${saved ? " Serving the saved address for now." : ""}`);
         }
         catch (error) {
             log(`tunnel: control plane not reachable right now (${message(error)}); using the saved address`);
         }
         access = tunnelAccess(account.credentials.read());
         if (!access)
-            return { error: "this machine has no public address; run `openmausbot login` again" };
+            return fail("this machine has no public address; run `openmausbot login` again");
     }
     let binary;
     try {
         binary = await ensureCloudflared({ dataDir: options.dataDir, log });
     }
     catch (error) {
-        return { error: `--tunnel: ${message(error)}` };
+        return fail(`--tunnel: ${message(error)}`);
     }
     const guardian = guardianEntry();
     if (!guardian)
-        return { error: "--tunnel: the connector guardian is missing from this install" };
-    return { access, binary, guardian, origin: createTunnelOrigin() };
+        return fail("--tunnel: the connector guardian is missing from this install");
+    return { access, binary, guardian, origin: createTunnelOrigin(), account };
 }
 export async function runServe(options, log = console.log) {
     const { browserEngineStatus, describeBrowserEngine } = await import("./browser-engine.js");
@@ -896,8 +906,11 @@ export async function runServe(options, log = console.log) {
         tailscale = probe.status;
     }
     let plan = null;
+    // The tunnel this process serves, once it runs; the account service's
+    // background recovery reads it (see TunnelRecovery).
+    const serving = { tunnel: null };
     if (options.tunnel) {
-        const planned = await planTunnel(options, log);
+        const planned = await planTunnel(options, log, { running: () => serving.tunnel });
         if ("error" in planned) {
             console.error(planned.error);
             return 1;
@@ -991,6 +1004,7 @@ export async function runServe(options, log = console.log) {
     catch (error) {
         if ((tailscaleServing || (startupCancelled && tailscaleAttempted)) && tailscale)
             await tailscaleServeOff(tailscale).catch(() => undefined);
+        plan?.account?.service.dispose();
         if (plan)
             cleanupTunnelOrigin(plan.origin);
         if (error instanceof SetupCancelled) {
@@ -1015,6 +1029,8 @@ export async function runServe(options, log = console.log) {
     let stopping = null;
     const stop = () => {
         stopping ??= (async () => {
+            serving.tunnel = null;
+            plan?.account?.service.dispose();
             // The gateway and the edge stop accepting before the server they forward to goes away.
             if (tunnel)
                 await tunnel.stop().catch(() => undefined);
@@ -1083,6 +1099,10 @@ export async function runServe(options, log = console.log) {
                 onState: (state) => log(describeTunnelState(state, plan.access.endpoint)),
             });
             tunnel.started.catch((error) => log(`tunnel: ${message(error)}`));
+            // From here on the endpoint is checked every 15 minutes; one reclaimed
+            // while this machine was offline is re-created behind the same address.
+            serving.tunnel = tunnel;
+            void plan.account?.service.restore().catch(() => undefined);
         }
         log("");
         log(`OpenMausBot is running on http://127.0.0.1:${options.port}${publicUrl ? `, reachable at ${publicUrl}` : ""}`);

package/dist-server/server/cloud-move-http.js

@@ -1,11 +1,17 @@
 import { z } from "zod";
-import { backupsBytes, beginUpload, CLOUD_MOVE_MAX_BYTES, CLOUD_MOVE_MAX_PART_BYTES, CLOUD_MOVE_PART_BYTES, completedUpload, discardNextPreviousCloud, discardUpload, forgetMoveRestore, freeVolumeBytes, isEmptyWorkspace, moveSpaceNeeded, noteMoveRestore, prepareNextPreviousCloud, previousCloud, previousCloudArchiveBytes, removeMoveFiles, stagePreviousCloud, tidyCloudMoveStorage, uploadStatus, validUploadDeclaration, workspaceContents, workspaceMoveSize, writeUploadPart, } from "./cloud-move.js";
+import { backupsBytes, beginUpload, CLOUD_MOVE_MAX_BYTES, CLOUD_MOVE_MAX_PART_BYTES, CLOUD_MOVE_PART_BYTES, completedUpload, discardNextPreviousCloud, discardUpload, enabledRoutineCount, forgetMoveRestore, freeVolumeBytes, isEmptyWorkspace, moveSpaceNeeded, noteMoveRestore, prepareNextPreviousCloud, previousCloud, previousCloudArchiveBytes, removeMoveFiles, stagePreviousCloud, tidyCloudMoveStorage, totalVolumeBytes, uploadStatus, validUploadDeclaration, workspaceContents, workspaceMoveSize, writeUploadPart, } from "./cloud-move.js";
 import { commitPendingWorkspaceRestore, createWorkspaceBackup, stageWorkspaceBackup } from "./workspace-backup.js";
 export const CLOUD_MOVE_PREFIX = "/api/cloud-move";
 const failure = (message, status) => Object.assign(new Error(message), { status });
 const HELD_CACHE_MS = 30_000;
 export function createCloudMoveRoutes(options) {
     const freeBytes = options.freeBytes ?? freeVolumeBytes;
+    const volumeBytes = (path) => { try {
+        return (options.volumeBytes ?? totalVolumeBytes)(path);
+    }
+    catch {
+        return null;
+    } };
     // A move's restore that startup has installed keeps no safety copy or
     // staged files; an abandoned upload goes after a day.
     if (options.cloudHome) {
@@ -113,7 +119,7 @@ export function createCloudMoveRoutes(options) {
             if (!auth.scopes.includes("admin"))
                 throw failure("Only the owner can move a workspace.", 403);
             if (method === "GET" && path === `${CLOUD_MOVE_PREFIX}/estimate`) {
-                json(res, 200, { ...workspaceContents(options.dataDir), ...workspaceMoveSize(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES });
+                json(res, 200, { ...workspaceContents(options.dataDir), ...workspaceMoveSize(options.dataDir), routines: enabledRoutineCount(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES });
                 return true;
             }
             if (!options.cloudHome)
@@ -126,7 +132,7 @@ export function createCloudMoveRoutes(options) {
                 if (!held || held.at + HELD_CACHE_MS < Date.now())
                     held = { at: Date.now(), bytes: backupsBytes(options.dataDir) };
                 json(res, 200, {
-                    contents, empty: isEmptyWorkspace(contents), freeBytes: freeBytes(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES,
+                    contents, empty: isEmptyWorkspace(contents), freeBytes: freeBytes(options.dataDir), volumeBytes: volumeBytes(options.dataDir), maxBytes: CLOUD_MOVE_MAX_BYTES,
                     partBytes: CLOUD_MOVE_PART_BYTES, upload: uploadStatus(options.dataDir), previous: previousCloud(options.dataDir), job,
                     // What backups and the previous Cloud hold on the volume.
                     heldBytes: held.bytes,

package/dist-server/server/cloud-move.js

@@ -96,6 +96,24 @@ export function freeVolumeBytes(path) {
     const free = disk.bavail * disk.bsize;
     return free > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(free);
 }
+/** The whole volume, so the app can tell how far a disk that grows may still grow. */
+export function totalVolumeBytes(path) {
+    const disk = statfsSync(path, { bigint: true });
+    const total = disk.blocks * disk.bsize;
+    return total > BigInt(Number.MAX_SAFE_INTEGER) ? Number.MAX_SAFE_INTEGER : Number(total);
+}
+/** Routines switched on in this workspace. A move brings them paused, so the
+ * app says how many to turn on there. */
+export function enabledRoutineCount(dataDir) {
+    try {
+        const value = JSON.parse(readFileSync(join(dataDir, "routines.json"), "utf8"));
+        const routines = value && typeof value === "object" ? value.routines : undefined;
+        return Array.isArray(routines) ? routines.filter((routine) => routine && typeof routine === "object" && routine.enabled !== false).length : 0;
+    }
+    catch {
+        return 0;
+    }
+}
 /** Peak extra space a move of `upload` bytes needs: the upload, its decrypted
  * copy and its staged files exist together while it is checked; the restore
  * then installs from the staged copy. Replacing a workspace first backs it up

package/dist-server/server/cloud-owner.js

@@ -29,7 +29,7 @@
 import { lstatSync, readFileSync } from "node:fs";
 import { z } from "zod";
 import { writeFileAtomic } from "./atomic.js";
-export const CLOUD_PERSONAL_REFUSAL = "Cloud Pro is personal: only your own devices can connect.";
+export const CLOUD_PERSONAL_REFUSAL = "OMB Cloud is personal: only your own devices can connect.";
 const KEY = /^p_[\w-]{22}$/;
 const keys = z.array(z.string().regex(KEY)).max(100_000);
 const recordFile = z.object({

package/dist-server/server/computer-control.js

@@ -71,6 +71,12 @@ export class ComputerControl {
         });
         return { snapshot: this.changed(botId), owned: true, acquired: true };
     }
+    /** Whether this workspace lease is the one holding the wheel right now.
+     * Read-only: unlike `acquireLease`, a free computer is not taken. */
+    ownsLease(botId, controlLeaseId) {
+        const entry = this.entries.get(botId);
+        return entry?.heldSinceMs != null && entry.controlLeaseId === controlLeaseId;
+    }
     /** The person hands the wheel back. Also settles any open help request —
      * the waiting bot resumes from this one state change. */
     release(botId) {

package/dist-server/server/computer-wait.js

@@ -2,11 +2,11 @@
 //
 // The chip used to read "Waiting for computer — X / Y is using it; will
 // continue automatically", which people read as an error about a machine
-// they could not see. It is a queue position: this turn is behind one named
-// turn on one desktop, and it starts on its own when that turn ends. Say
-// that, name the holder as a bot running a thread, and keep the same words
-// on every surface (chat chip, room chip, the gate's refusal) so a person
-// who has read it once recognises it everywhere.
+// they could not see. It is a queue position: this turn sits behind a named
+// turn on one desktop — and every turn queued ahead of it — and starts on
+// its own when they finish. Say that, name the holder as a bot running a
+// thread, and keep the same words on every surface (chat chip, room chip,
+// the gate's refusal) so a person who has read it once recognises it everywhere.
 /** Whole minutes, or seconds under one minute, singular at exactly one. */
 const minutes = (ms) => {
     const value = ms >= 60_000 ? Math.round(ms / 60_000) : Math.round(ms / 1000);
@@ -19,11 +19,30 @@ export function computerWaitDuration(ms) {
     return ms < 1_000 ? "under a second" : minutes(ms);
 }
 const holderPhrase = (holder) => holder.task ? `${holder.name} is running ${holder.task}` : `${holder.name} is using it`;
-/** The chip a turn shows while it is queued behind another turn's desktop. */
-export function computerWaitingText(holder) {
+const ordinal = (position) => {
+    const mod100 = position % 100;
+    const mod10 = position % 10;
+    const suffix = mod100 >= 11 && mod100 <= 13 ? "th" : mod10 === 1 ? "st" : mod10 === 2 ? "nd" : mod10 === 3 ? "rd" : "th";
+    return `${position}${suffix}`;
+};
+/** The chip a turn shows while it is queued behind another turn's desktop:
+ * its stable queue position, the holder, and — only once waits here have
+ * history — about how long they have been taking. */
+export function computerWaitingText(holder, queue) {
+    const position = queue?.position && queue.position > 0 ? queue.position : undefined;
+    const place = position ? ` — ${ordinal(position)} in queue` : "";
+    const estimate = queue?.estimateMs !== undefined ? `; recent waits here have taken ${computerWaitDuration(queue.estimateMs)}` : "";
+    // Behind more than the holder, that turn ending is not this turn's start:
+    // the released seat goes to the front waiter first, so this turn starts
+    // only once every turn ahead of it has finished (#1652).
+    const starts = position && position > 1
+        ? "Starts automatically when the turns ahead finish"
+        : holder
+            ? "Starts automatically when that finishes"
+            : "Starts automatically when it is free";
     if (!holder)
-        return "Waiting for its turn on this computer. Starts automatically when it is free.";
-    return `Waiting for its turn on this computer — ${holderPhrase(holder)}. Starts automatically when that finishes.`;
+        return `Waiting for its turn on this computer${place}. ${starts}${estimate}.`;
+    return `Waiting for its turn on this computer${place} — ${holderPhrase(holder)}. ${starts}${estimate}.`;
 }
 /** The resolution appended once the wait landed and this turn holds the
  * desktop: how long it waited, and who held it. The waiting chip stays as
@@ -38,9 +57,10 @@ export function computerStoppedWaitingText(holder, waitedMs) {
     const who = holder ? ` — ${holderPhrase(holder)}` : "";
     return `Stopped waiting for the computer after ${computerWaitDuration(waitedMs)}${who}.`;
 }
-/** The error after the wait ceiling: still names who holds it, and says
- * what a person can do — stop that turn, or move this one. */
-export function computerStillBusyText(holder, ceilingMs) {
+/** The resolution appended when the wait ceiling parks the turn (#1651):
+ * still names who holds it, but the work is not lost — the turn settled and
+ * resumes on its own when the desktop frees, so nobody has to fix it. */
+export function computerParkedText(holder, ceilingMs) {
     const who = holder ? ` — ${holderPhrase(holder).replace(" is running ", " is still running ").replace(" is using it", " is still using it")}` : "";
-    return `Computer is still busy after ${minutes(ceilingMs)}${who}. Stop that turn, or run this on another computer.`;
+    return `Computer still busy after ${minutes(ceilingMs)}${who}. Parked — it continues automatically when the computer is free.`;
 }