openmausbot 0.1.86 → 0.1.87

package/dist-server/server/team-setup-requests.js

@@ -7,6 +7,7 @@ import { redactSecretsInText } from "./redact.js";
 const section = (value) => value?.trim() || "";
 const teamName = z.string().trim().min(1).max(60).refine(fitsOnOneLine).refine((value) => redactSecretsInText(value) === value, "Team names cannot contain credentials");
 const fieldsSchema = z.object({
+    chiefOfStaff: z.boolean().optional(),
     name: z.string().optional(), title: z.string().optional(), description: z.string().optional(), soul: z.string().optional(),
     section: z.string().trim().max(60).refine(fitsOnOneLine).refine((value) => redactSecretsInText(value) === value, "Team names cannot contain credentials").optional(),
     modelSelection: z.object({ instanceId: z.string().trim().min(1), model: z.string().trim().min(1), effort: z.string().optional() }).strict().optional(),
@@ -44,7 +45,7 @@ export class TeamSetupRequestService {
         return chief;
     }
     fields(input, current) {
-        const { section: targetSection, modelSelection, ...profile } = input;
+        const { section: targetSection, modelSelection, chiefOfStaff, ...profile } = input;
         const safe = Object.fromEntries(Object.entries(profile).map(([key, value]) => [key, redactSecretsInText(value)]));
         const parsed = parseBotProfilePatch(safe, true);
         if (!parsed.ok)
@@ -52,6 +53,8 @@ export class TeamSetupRequestService {
         const result = { ...parsed.patch };
         if (targetSection !== undefined)
             result.section = targetSection;
+        if (chiefOfStaff !== undefined)
+            result.chiefOfStaff = chiefOfStaff;
         if (modelSelection) {
             const selection = modelSelection;
             const error = this.options.validateModel(selection, current);
@@ -108,7 +111,7 @@ export class TeamSetupRequestService {
                 throw new TeamSetupError("The destination team is outside this Chief's authorized scope", 403);
             if (!request.newTeams.includes(section(destination)) && !existingTeams.has(section(destination)))
                 throw new TeamSetupError("The destination team no longer exists", 409);
-            const next = { id: operation.botId, name: fields.name ?? target.name, section: section(destination), chiefOfStaff: target?.chiefOfStaff, hidden: false };
+            const next = { id: operation.botId, name: fields.name ?? target.name, section: section(destination), chiefOfStaff: fields.chiefOfStaff ?? target?.chiefOfStaff, hidden: false };
             const at = projected.findIndex((bot) => bot.id === operation.botId);
             if (at < 0)
                 projected.push(next);
@@ -125,7 +128,7 @@ export class TeamSetupRequestService {
             if (projected.some((bot) => bot.id !== candidate.id && !bot.hidden && bot.section === candidate.section && bot.name.trim().toLowerCase() === candidate.name.trim().toLowerCase()))
                 throw new TeamSetupError(`@${candidate.name} already exists in that team`, 409);
             if (candidate.chiefOfStaff && projected.some((bot) => bot.id !== candidate.id && bot.chiefOfStaff && bot.section === candidate.section))
-                throw new TeamSetupError("That move would put two Chiefs in one team", 409);
+                throw new TeamSetupError("Each team can have one Chief. Include the current Chief's demotion in this plan.", 409);
         }
         if (request.deletion) {
             const target = this.options.store.bot(request.deletion.botId);
@@ -195,12 +198,20 @@ export class TeamSetupRequestService {
         const lines = [`Why: ${request.reason}`];
         if (request.deletion)
             lines.push(`Delete @${request.deletion.name} (${request.deletion.botId}).`, "Permanently removes this bot, all its conversations, memory, instructions, skills, and any computer owned only by it. Generated project files and shared team computers remain. Active work or an unavailable provider can block deletion safely.");
-        if (request.newTeams.length)
-            lines.push(`Create teams: ${request.newTeams.map((name) => JSON.stringify(name)).join(", ")}.`, `Authorize @${chief.name} to coordinate and propose setup changes in these new teams.`);
+        if (request.newTeams.length) {
+            lines.push(`Create teams: ${request.newTeams.map((name) => JSON.stringify(name)).join(", ")}.`);
+            if (!request.operations.some(op => op.botId === chief.id && op.fields.chiefOfStaff === false)) {
+                lines.push(`Authorize @${chief.name} to coordinate and propose setup changes in these new teams.`);
+            }
+        }
         for (const operation of request.operations) {
             const current = this.options.store.bot(operation.botId);
             lines.push(`\n${operation.action === "create" ? "Create" : "Update"} @${operation.fields.name ?? current?.name} (${operation.action === "create" ? "new bot" : operation.botId})`);
             for (const [key, value] of Object.entries(operation.fields)) {
+                if (key === "chiefOfStaff") {
+                    lines.push(`Chief of Staff: ${current?.chiefOfStaff ? "Yes" : "No"} → ${value ? "Yes" : "No"}.${value ? " May coordinate and configure bots in this team." : " Additional managed-team access is removed."}`);
+                    continue;
+                }
                 const before = current ? (key === "section" ? current.section || "General" : current[key]) : undefined;
                 lines.push(`${key === "modelSelection" ? "Default engine/model" : key}: ${current ? `${JSON.stringify(before ?? "")} → ` : ""}${key === "section" ? JSON.stringify(value || "General") : JSON.stringify(value)}`);
             }

package/dist-server/server/thread-events.js

@@ -133,6 +133,10 @@ const stringOrMissing = (value) => value === undefined || typeof value === "stri
 const stringOrNullOrMissing = (value) => value === undefined || value === null || typeof value === "string";
 const numberOrNullOrMissing = (value) => value === undefined || value === null || typeof value === "number";
 const stringsOrMissing = (value) => value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string"));
+/** A computer holder as the wait events carry it: a name, and the holding
+ * thread's title when one was known. */
+const computerHolderOrMissing = (value) => value === undefined ||
+    (isRecord(value) && typeof value.name === "string" && stringOrMissing(value.task));
 /** A replayed structured ask. Only the shape the card actually reads is
  * required; the rest is optional and simply absent on an older event. */
 const askQuestionsOrMissing = (value) => value === undefined ||
@@ -175,6 +179,15 @@ function isRuntimeEvent(value) {
                 stringsOrMissing(value.denials) &&
                 (value.usage === undefined ||
                     (isRecord(value.usage) && typeof value.usage.input === "number" && typeof value.usage.output === "number")));
+        case "turn.wait_started":
+            return typeof value.resource === "string" && computerHolderOrMissing(value.holder);
+        case "turn.wait_ended":
+            return (typeof value.resource === "string" &&
+                computerHolderOrMissing(value.holder) &&
+                typeof value.waitedMs === "number" &&
+                Number.isFinite(value.waitedMs) &&
+                value.waitedMs >= 0 &&
+                (value.outcome === "acquired" || value.outcome === "gave_up" || value.outcome === "stopped"));
         case "item.started":
             return (value.itemType === "tool" || value.itemType === "reasoning") && stringOrMissing(value.title);
         case "item.updated":
@@ -188,7 +201,10 @@ function isRuntimeEvent(value) {
                 typeof value.tool === "string" &&
                 typeof value.summary === "string" &&
                 stringsOrMissing(value.choices) &&
-                askQuestionsOrMissing(value.questions));
+                askQuestionsOrMissing(value.questions) &&
+                // Required fields only: events recorded before origin exists replay
+                // unchanged, and a value other than the two documented marks is not.
+                (value.origin === undefined || value.origin === "tool" || value.origin === "output"));
         case "request.resolved":
             return ((value.behavior === "allow" || value.behavior === "deny" || value.behavior === "answer") &&
                 (value.source === "user" ||

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

@@ -1,4 +1,6 @@
 import { peerName } from "./peer-roster.js";
+// All three use createOpenAIChatRuntime and get history via SendTurnInput.transcript.
+export const NATIVELY_REPLAYING_DRIVER_KINDS = ["grok", "openai-compat", "minimax"];
 /** Does this engine need the thread replayed to it? True when a DIFFERENT
  * instance ran the last turn here — a cursor of our own is not enough,
  * because it only proves we once had a session covering some prefix of the

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

@@ -23,10 +23,10 @@ export class TurnWatchdog {
         this.timer = null;
         this.turns.clear();
     }
-    /** A turn was dispatched on this thread. */
+    /** A turn was admitted on this thread. */
     watch(threadId, botId) {
         const at = this.now();
-        this.turns.set(threadId, { threadId, botId, startedAt: at, lastEventAt: at, waitingOnHuman: false });
+        this.turns.set(threadId, { threadId, botId, startedAt: at, lastEventAt: at, waitingOnHuman: false, waitingOnComputer: false });
     }
     /** Any provider event for the thread proves the turn is alive. */
     touch(threadId) {
@@ -43,6 +43,15 @@ export class TurnWatchdog {
         turn.waitingOnHuman = waiting;
         turn.lastEventAt = this.now();
     }
+    /** Shared-computer waits have their own bounded deadline. Waiting for
+     * another turn to release the computer is not a silent provider stall. */
+    setWaitingOnComputer(threadId, waiting) {
+        const turn = this.turns.get(threadId);
+        if (!turn)
+            return;
+        turn.waitingOnComputer = waiting;
+        turn.lastEventAt = this.now();
+    }
     /** The turn settled normally — stop watching it. */
     settle(threadId) {
         this.turns.delete(threadId);
@@ -54,7 +63,7 @@ export class TurnWatchdog {
     sweep() {
         const at = this.now();
         for (const turn of this.turns.values()) {
-            if (turn.waitingOnHuman)
+            if (turn.waitingOnHuman || turn.waitingOnComputer)
                 continue;
             if (at - turn.lastEventAt < this.opts.stallMs)
                 continue;

package/dist-server/server/usage-ledger.js

@@ -18,6 +18,14 @@ const DAY_MS = 24 * 60 * 60_000;
 const writeQueues = new Map();
 const clean = (value) => typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
 const finiteOrNull = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : null;
+const promptBytesOf = (value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    return typeof record.stable === "number" && typeof record.volatile === "number"
+        ? { stable: clean(record.stable), volatile: clean(record.volatile) }
+        : null;
+};
 function monthKey(at) {
     return `${at.getUTCFullYear()}-${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
 }
@@ -34,12 +42,15 @@ export function usageRowKey(row) {
 /** Append one settled turn. Fire-and-forget (see the module comment): the
  * returned promise never rejects, and says whether the row reached disk. */
 export function appendUsage(dataDir, row) {
+    const { promptBytes: rawPromptBytes, ...rest } = row;
+    const promptBytes = promptBytesOf(rawPromptBytes);
     const record = {
-        ...row,
+        ...rest,
         at: row.at ?? new Date().toISOString(),
         input: clean(row.input),
         output: clean(row.output),
         ...(typeof row.cachedInput === "number" ? { cachedInput: clean(row.cachedInput) } : {}),
+        ...(promptBytes ? { promptBytes } : {}),
         costUsd: finiteOrNull(row.costUsd),
     };
     // A cost is labelled with where it came from; an unpriced row carries no label.

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

@@ -6,7 +6,8 @@ import { spawn } from "node:child_process";
 import { createConnection, createServer } from "node:net";
 import { BASE_IMAGE, CUA_DRIVER_VERSION, CUA_SOCKET, IMAGE as CUA_IMAGE, cuaExecArgs, dockerSecurityIsHardened, imageLabelsMatch, managedImageDockerfile, wholeScreenshot, BASE_IMAGE_DIGEST, BASE_IMAGE_LABEL, DRIVER_LABEL, IMAGE_LAYER_LABEL, IMAGE_LAYER_VERSION, MANAGED_LABEL, } from "./container-computer.js";
 import { DATA_DIR, isValidSshAlias, vpsSshAlias } from "./config.js";
-import { augmentedPath, resolveCliSpawn } from "./env-path.js";
+import { augmentedPath } from "./env-path.js";
+import { killCliTree, spawnCli } from "./procs.js";
 import { prepareVpsSsh } from "./vps-ssh.js";
 import { loadEnvironmentId } from "./environment.js";
 import { SPAWNED_PROXIES } from "./proxy-paths.js";
@@ -28,7 +29,9 @@ function vpsEnvironmentId() {
 // SIGTERM must give ssh + docker time to tear down the remote exec before the
 // SIGKILL escalation; 1s was routinely too short over a WAN round-trip, and an
 // orphaned remote exec keeps the driver socket busy for the next command.
-const COMMAND_TIMEOUT_KILL_GRACE_MS = 5_000;
+const COMMAND_TIMEOUT_TERM_GRACE_MS = 5_000;
+// killCliTree also waits up to one second for the forced group exit.
+const COMMAND_TIMEOUT_KILL_GRACE_MS = COMMAND_TIMEOUT_TERM_GRACE_MS + 1_000;
 const CONTAINER_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_.-]+$/;
 const CONTAINER_ID = /^[a-f0-9]{12,64}$/i;
 const FULL_CONTAINER_ID = /^[a-f0-9]{64}$/i;
@@ -63,20 +66,32 @@ function snapshotVpsConfig(cfg) {
 export function vpsLifecycleBusy() {
     return lifecycleLocks.size > 0;
 }
-// A held lock means a lifecycle mutation (worst case: a 10-minute image
-// build) is running. Waiting it out would wedge Sleep and the screenshot
-// poll behind it, so acquisition fails fast instead.
+// Sleep, remove and preview requests must not queue behind a potentially
+// 10-minute image build. Turn preparation may instead wait through a normal
+// preview, whose bounded duration is accounted for below.
 const LOCK_ACQUIRE_TIMEOUT_MS = 5_000;
 // The panel polls status every 4-6s and the screen poller re-checks it before
 // every frame; each full status is several docker-over-SSH processes. Same
 // pattern as container-computer's screenshotStatusCache, and the same TTL.
 const STATUS_CACHE_TTL_MS = 10_000;
 const statusCache = new Map();
+const pendingStatuses = new Map();
+const pendingProvisions = new Map();
 const SCREENSHOT_BUDGET_MS = 45_000;
 const SCREENSHOT_CLEANUP_BUDGET_MS = 10_000;
+// Turn preparation may wait for a normal preview to finish; destructive
+// actions retain the short acquisition limit. Overlapping provisions share
+// one operation below, so they never queue behind their own image build.
+const PREPARATION_LOCK_TIMEOUT_MS = SCREENSHOT_BUDGET_MS + LOCK_ACQUIRE_TIMEOUT_MS;
 const pendingScreenshots = new Map();
 const viewerConnections = new Map();
 const desktopTunnels = new Map();
+function invalidateVpsStatus(key) {
+    statusCache.delete(key);
+    // Detach old polls as well: an inspection begun before a mutation must
+    // neither be joined nor republish its old result after that mutation.
+    pendingStatuses.delete(key);
+}
 /** Whether a turn may prepare or start the VPS container rather than only
  * reuse a running one. Explicit Cloud always may; Auto only when the person
  * switched on Start VPS automatically — except for unattended runs. A
@@ -216,11 +231,10 @@ function tailCollector() {
 }
 export function defaultRunner(args, options = {}) {
     return new Promise((resolve, reject) => {
-        const command = resolveCliSpawn("docker", args);
         // docker's SSH transport runs the first `ssh` on PATH: the app's shim,
         // which shares one connection across every command of this VPS.
         const ssh = prepareVpsSsh(DATA_DIR, augmentedPath());
-        const child = spawn(command.command, command.args, {
+        const child = spawnCli("docker", args, {
             shell: false,
             env: { ...process.env, PATH: ssh.path },
             stdio: ["pipe", "pipe", "pipe"],
@@ -228,31 +242,33 @@ export function defaultRunner(args, options = {}) {
         const stdout = tailCollector();
         const stderr = tailCollector();
         let settled = false;
-        let timedOut = false;
-        let killTimer;
+        let failure = null;
         let timeout;
         const settle = (finish) => {
             if (settled)
                 return;
             settled = true;
             clearTimeout(timeout);
-            if (killTimer)
-                clearTimeout(killTimer);
             finish();
         };
-        timeout = setTimeout(() => {
-            if (settled)
+        const fail = (error) => {
+            if (settled || failure)
                 return;
-            timedOut = true;
-            killTimer = setTimeout(() => {
-                if (settled)
-                    return;
-                child.kill("SIGKILL");
-                settle(() => reject(new Error("Docker-over-SSH command timed out")));
-            }, COMMAND_TIMEOUT_KILL_GRACE_MS);
-            killTimer.unref?.();
-            child.kill("SIGTERM");
-        }, options.timeoutMs ?? 120_000);
+            failure = error;
+            clearTimeout(timeout);
+            // Docker launches ssh, which can retain these pipes after Docker exits.
+            // Only this command's private process group is ours to stop; persistent
+            // SSH masters detach from it and may serve other commands. Hold callers'
+            // lifecycle ownership until the bounded tree cleanup has completed.
+            const cleaned = () => {
+                child.stdin.destroy();
+                child.stdout.destroy();
+                child.stderr.destroy();
+                settle(() => reject(error));
+            };
+            void killCliTree(child, COMMAND_TIMEOUT_TERM_GRACE_MS).then(cleaned, cleaned);
+        };
+        timeout = setTimeout(() => fail(new Error("Docker-over-SSH command timed out")), options.timeoutMs ?? 120_000);
         timeout.unref?.();
         child.stdout.setEncoding("utf8");
         child.stderr.setEncoding("utf8");
@@ -263,18 +279,14 @@ export function defaultRunner(args, options = {}) {
             stderr.push(chunk);
         });
         child.stdin.on("error", (error) => {
-            if (timedOut)
-                return;
-            settle(() => reject(new Error(`Docker-over-SSH stdin failed: ${error.message}`)));
+            fail(new Error(`Docker-over-SSH stdin failed: ${error.message}`));
         });
         child.on("error", (error) => {
-            settle(() => reject(new Error(`Docker-over-SSH could not start: ${error.message}`)));
+            fail(new Error(`Docker-over-SSH could not start: ${error.message}`));
         });
         child.on("close", (code, signal) => {
-            if (timedOut) {
-                settle(() => reject(new Error("Docker-over-SSH command timed out")));
+            if (failure)
                 return;
-            }
             settle(() => {
                 if (code === 0)
                     return resolve({ stdout: stdout.text(), stderr: stderr.text() });
@@ -286,7 +298,7 @@ export function defaultRunner(args, options = {}) {
             child.stdin.end(options.input);
         }
         catch (error) {
-            settle(() => reject(new Error(`Docker-over-SSH stdin failed: ${error instanceof Error ? error.message : String(error)}`)));
+            fail(new Error(`Docker-over-SSH stdin failed: ${error instanceof Error ? error.message : String(error)}`));
         }
     });
 }
@@ -531,15 +543,30 @@ export async function vpsComputerStatus(cfg, botId, runner = defaultRunner) {
     if (cacheable) {
         // A capture already checks this exact target. Let it finish instead of
         // opening another six SSH connections while its readiness check is cold.
-        await pendingScreenshots.get(key)?.catch(() => { });
+        const capture = pendingScreenshots.get(key);
+        if (capture)
+            await capture.catch(() => { });
         const cached = statusCache.get(key);
         if (cached && cached.expiresAt > Date.now())
             return cached.status;
+        const pending = pendingStatuses.get(key);
+        if (pending)
+            return pending;
     }
-    const status = await computeVpsComputerStatus(cfg, botId, runner);
+    const inspection = computeVpsComputerStatus(cfg, botId, runner);
     if (cacheable)
-        statusCache.set(key, { status, expiresAt: Date.now() + STATUS_CACHE_TTL_MS });
-    return status;
+        pendingStatuses.set(key, inspection);
+    try {
+        const status = await inspection;
+        if (cacheable && pendingStatuses.get(key) === inspection && !lifecycleLocks.has(key)) {
+            statusCache.set(key, { status, expiresAt: Date.now() + STATUS_CACHE_TTL_MS });
+        }
+        return status;
+    }
+    finally {
+        if (cacheable && pendingStatuses.get(key) === inspection)
+            pendingStatuses.delete(key);
+    }
 }
 const VPS_INVENTORY_LIMIT = 256;
 const VPS_INVENTORY_STATES = new Set([
@@ -761,14 +788,32 @@ async function prepareVpsImage(alias, runner) {
  * Backoff doubles 0.5s→4s because each poll is a real SSH connection, and
  * between polls only ONE cheap exec (`cua-driver status`) asks whether the
  * driver answers yet — the full multi-invocation status runs again only when
- * that predicate flips, and once more at the deadline, so the returned state
- * is always a complete inspection. */
+ * that predicate flips. Every command, including the diagnostic tail, is
+ * clamped to the readiness phase's deadline and transport cleanup allowance. */
 async function waitForVpsReady(cfg, botId, runner, budgetMs = 60_000) {
     const alias = vpsSshAlias(cfg);
     const deadline = Date.now() + budgetMs;
-    let status = await computeVpsComputerStatus(cfg, botId, runner);
+    let budgetExpired = false;
+    const boundedRunner = async (args, options = {}) => {
+        // Include transport termination in the readiness phase's budget; a
+        // final failed probe or diagnostic tail must not keep its lock past it.
+        const remaining = deadline - Date.now() - COMMAND_TIMEOUT_KILL_GRACE_MS;
+        if (remaining <= 0) {
+            budgetExpired = true;
+            throw new Error("VPS desktop readiness timed out");
+        }
+        try {
+            return await runner(args, { ...options, timeoutMs: Math.min(options.timeoutMs ?? 120_000, remaining) });
+        }
+        catch (error) {
+            if (Date.now() >= deadline - COMMAND_TIMEOUT_KILL_GRACE_MS)
+                budgetExpired = true;
+            throw error;
+        }
+    };
+    let status = await computeVpsComputerStatus(cfg, botId, boundedRunner);
     let delayMs = 500;
-    while (!status.ready && alias && Date.now() < deadline) {
+    while (!status.ready && alias && !budgetExpired && Date.now() < deadline) {
         if (!status.daemonUp ||
             !status.image ||
             !status.imageMatches ||
@@ -785,14 +830,24 @@ async function waitForVpsReady(cfg, botId, runner, budgetMs = 60_000) {
         });
         delayMs = Math.min(delayMs * 2, 4_000);
         const container = status.container_id ?? status.container_name;
-        const driverAnswers = await runner(vpsDockerArgs(alias, cuaExecArgs(["status", "--socket", CUA_SOCKET], { container })), { timeoutMs: 10_000 }).then(() => true, () => false);
+        const driverAnswers = await boundedRunner(vpsDockerArgs(alias, cuaExecArgs(["status", "--socket", CUA_SOCKET], { container })), { timeoutMs: 10_000 }).then(() => true, () => false);
+        if (budgetExpired)
+            break;
         if (!driverAnswers && Date.now() < deadline)
             continue;
-        status = await computeVpsComputerStatus(cfg, botId, runner);
+        status = await computeVpsComputerStatus(cfg, botId, boundedRunner);
     }
+    if (budgetExpired)
+        return {
+            ...status,
+            ready: false,
+            desktopReady: false,
+            desktop_error: "VPS desktop readiness timed out",
+            problem: "The VPS desktop did not become ready in time — retry when the connection recovers",
+        };
     return status;
 }
-async function withVpsLifecycleLock(key, operation) {
+async function withVpsLifecycleLock(key, operation, acquireTimeoutMs = LOCK_ACQUIRE_TIMEOUT_MS) {
     const previous = lifecycleLocks.get(key);
     let release;
     const current = new Promise((resolve) => {
@@ -804,7 +859,7 @@ async function withVpsLifecycleLock(key, operation) {
         const acquired = await Promise.race([
             previous.then(() => true),
             new Promise((resolve) => {
-                acquireTimer = setTimeout(() => resolve(false), LOCK_ACQUIRE_TIMEOUT_MS);
+                acquireTimer = setTimeout(() => resolve(false), acquireTimeoutMs);
                 acquireTimer.unref?.();
             }),
         ]);
@@ -849,6 +904,7 @@ export async function removeManagedVpsComputer(cfg, owners, containerName, confi
     }
     const key = `${alias}:${containerName}`;
     return withVpsLifecycleLock(key, async () => {
+        invalidateVpsStatus(key);
         const scan = await scanManagedVpsComputers(cfg, owners, runner);
         const inventory = scan.inventory;
         if (!inventory.available) {
@@ -874,13 +930,14 @@ export async function removeManagedVpsComputer(cfg, owners, containerName, confi
             await runner(vpsDockerArgs(alias, ["rm", "-f", containerId]), { timeoutMs: 2 * 60_000 });
         }
         catch (error) {
+            invalidateVpsStatus(key);
             const detail = (error instanceof Error ? error.message : String(error))
                 .replace(/[\r\n\t]+/g, " ")
                 .trim()
                 .slice(0, 200);
             throw Object.assign(new Error(`The VPS refused to remove this computer${detail ? `: ${detail}` : ""}`), { status: 502 });
         }
-        statusCache.delete(key);
+        invalidateVpsStatus(key);
         viewerConnections.delete(key);
         if (instance.ownerBotId)
             stopDesktopTunnel(instance.ownerBotId);
@@ -893,14 +950,19 @@ export async function vpsComputerAction(action, cfg, botId, runner = defaultRunn
     if (!alias)
         throw Object.assign(new Error("VPS is not configured — add an SSH config alias in App Settings → Connections"), { status: 409 });
     const key = `${alias}:${vpsContainerName(botId)}`;
+    const pending = action === "provision" ? pendingProvisions.get(key) : undefined;
+    if (pending)
+        return pending;
     const operation = async () => {
         // A mutation invalidates every cached poll answer, before and after: the
         // panel must never keep showing the pre-action world for a TTL.
-        statusCache.delete(key);
+        invalidateVpsStatus(key);
         try {
             const before = await computeVpsComputerStatus(cfg, botId, runner);
             if (!before.daemonUp)
                 throw Object.assign(new Error(before.problem ?? "Docker over SSH is not reachable"), { status: 409 });
+            if (action === "provision" && before.ready)
+                return before;
             // A real lifecycle change invalidates the remote endpoint. Provision
             // is also the turn-start idempotency path, so leave an already-running
             // viewer alone when no start/replacement will occur.
@@ -946,7 +1008,7 @@ export async function vpsComputerAction(action, cfg, botId, runner = defaultRunn
                     throw Object.assign(new Error("The VPS container name is occupied by a container OpenMausBot did not create — remove it on the VPS yourself"), { status: 409 });
                 }
                 await run(["rm", "-f", containerRef]);
-                return computeVpsComputerStatus(cfg, botId, runner);
+                return await computeVpsComputerStatus(cfg, botId, runner);
             }
             else {
                 if (before.container !== "running")
@@ -954,13 +1016,22 @@ export async function vpsComputerAction(action, cfg, botId, runner = defaultRunn
                 assertUsableContainer(before);
                 await run(["stop", containerRef]);
             }
-            return action === "stop" ? computeVpsComputerStatus(cfg, botId, runner) : waitForVpsReady(cfg, botId, runner);
+            return await (action === "stop" ? computeVpsComputerStatus(cfg, botId, runner) : waitForVpsReady(cfg, botId, runner));
         }
         finally {
-            statusCache.delete(key);
+            invalidateVpsStatus(key);
         }
     };
-    return withVpsLifecycleLock(key, operation);
+    const preparation = withVpsLifecycleLock(key, operation, action === "provision" ? PREPARATION_LOCK_TIMEOUT_MS : LOCK_ACQUIRE_TIMEOUT_MS);
+    if (action === "provision")
+        pendingProvisions.set(key, preparation);
+    try {
+        return await preparation;
+    }
+    finally {
+        if (pendingProvisions.get(key) === preparation)
+            pendingProvisions.delete(key);
+    }
 }
 /** Auto is intentionally read-only: it can attach only to an existing ready
  * container. It recomputes rather than reading the poll cache — routing a
@@ -976,7 +1047,7 @@ export async function inspectVpsForAuto(cfg, botId, runner = defaultRunner) {
     cfg = snapshotVpsConfig(cfg);
     const key = vpsLockKey(cfg, botId);
     return key
-        ? withVpsLifecycleLock(key, () => computeVpsComputerStatus(cfg, botId, runner))
+        ? withVpsLifecycleLock(key, () => computeVpsComputerStatus(cfg, botId, runner), PREPARATION_LOCK_TIMEOUT_MS)
         : computeVpsComputerStatus(cfg, botId, runner);
 }
 /** Open a temporary noVNC connection through the configured SSH alias. The
@@ -1116,9 +1187,26 @@ export async function vpsComputerScreenshot(cfg, botId, runner = defaultRunner)
         // poller runs every few seconds, and re-verifying the whole container
         // between frames multiplied every frame's SSH cost.
         const cached = cacheable ? statusCache.get(key) : undefined;
+        const pendingStatus = cacheable ? pendingStatuses.get(key) : undefined;
+        // A poll which started first already owns the inspection. Sharing its
+        // result must not extend this preview's own deadline; the poll remains
+        // independently owned if it is still checking when this preview expires.
+        let statusTimer;
         const status = cached && cached.expiresAt > Date.now()
             ? cached.status
-            : await computeVpsComputerStatus(cfg, botId, boundedRunner);
+            : pendingStatus
+                ? await Promise.race([
+                    pendingStatus,
+                    new Promise((_resolve, reject) => {
+                        statusTimer = setTimeout(() => {
+                            invalidateVpsStatus(key);
+                            reject(timeoutError());
+                        }, Math.max(0, workDeadline - Date.now()));
+                        statusTimer.unref?.();
+                    }),
+                ]).finally(() => { if (statusTimer)
+                    clearTimeout(statusTimer); })
+                : await computeVpsComputerStatus(cfg, botId, boundedRunner);
         // Status converts transport errors into displayable state. A deadline is
         // still a timeout, not evidence that this container became incompatible.
         if (budgetExpired) {

package/dist-server/server/vps-container-mcp.js

@@ -5,6 +5,9 @@
 // mcp-bridge.ts, shared with the Local VM entry point.
 import { runMcpBridge } from "./mcp-bridge.js";
 import { vpsContainerMcpArgs, vpsDockerArgs } from "./vps-computer.js";
+import { DATA_DIR } from "./config.js";
+import { augmentedPath } from "./env-path.js";
+import { prepareVpsSsh } from "./vps-ssh.js";
 const [alias, containerName] = process.argv.slice(2);
 const sshAlias = alias ?? "";
 let args;
@@ -19,9 +22,13 @@ catch {
 // through `ps`, and the token guards a loopback endpoint.
 const controlUrl = process.env.OMB_CONTROL_URL ?? "";
 const controlToken = process.env.OMB_CONTROL_TOKEN ?? "";
+const ssh = prepareVpsSsh(DATA_DIR, augmentedPath());
 runMcpBridge({
     command: "docker",
     args,
+    // Keep tool calls and the watchdog on the same bounded, shared transport
+    // as startup and previews; otherwise only the panel gets the SSH defaults.
+    env: { ...process.env, PATH: ssh.path },
     label: "VPS Cua Driver",
     // The probe checks the TRANSPORT (SSH + daemon), deliberately not the
     // driver: a busy desktop mid-tool-call must never look dead, while an