openmausbot 0.1.91 → 0.1.92

package/dist-server/server/store.js

@@ -442,6 +442,10 @@ export function roomResponders(text, members, defaultResponder) {
     }
     return [];
 }
+/** A hidden routine execution is not a conversation the person can open. */
+function taskCountsAsBotUnread(task) {
+    return Boolean(task.unread) && !task.routineRunId;
+}
 export class Store {
     bots = [];
     groups = [];
@@ -721,6 +725,13 @@ export class Store {
                     task.unread = task === active && b.unread;
                     botsMigrated = true;
                 }
+                // Older builds left a failed hidden run unread, which kept the bot
+                // dot on after every visible chat was read. Clear it before the
+                // recompute below so the saved roster heals.
+                if (task.routineRunId && task.unread) {
+                    task.unread = false;
+                    botsMigrated = true;
+                }
                 if (task === active) {
                     if (task.rewound === undefined && b.rewound !== undefined) {
                         task.rewound = b.rewound;
@@ -742,7 +753,7 @@ export class Store {
                 task.turnStartedAt = undefined;
             }
             this.mirrorActiveTask(b, active);
-            b.unread = b.tasks.some((task) => task.unread);
+            b.unread = b.tasks.some(taskCountsAsBotUnread);
         }
         if (botsMigrated)
             this.saveBots();
@@ -819,13 +830,20 @@ export class Store {
         if (groupsDirty)
             this.saveGroups();
     }
+    /** Resolve the identity of a historical pair row, including a sender
+     * recreated with the same unique name. */
+    openerIdentity(openedBy) {
+        if (this.bot(openedBy.botId))
+            return openedBy.botId;
+        const named = this.bots.filter((bot) => bot.name === openedBy.name);
+        return named.length === 1 ? named[0].id : openedBy.botId;
+    }
     /** At most one live pair row per (recipient, sender identity). Servers
      * before identity-stable matching minted a second live pair row for a
      * deleted-and-recreated sender while the predecessor's row dangled live
-     * forever; collapse those on load by keeping the row the resolver favors
-     * (first in the task list — the newest, actively used one) and demoting
-     * the rest to closed plain threads. History is kept, never deleted, and
-     * a demoted row is never re-adopted: adoption skips closed rows. Runs on
+     * forever; collapse those on load by keeping the first row in the task
+     * list (the newest, actively used one) and demoting
+     * the rest to closed plain threads. History is kept, never deleted. Runs on
      * every load and touches nothing in a store that already holds the
      * invariant. */
     repairDuplicatePairConversations() {
@@ -840,8 +858,7 @@ export class Store {
                 pairs.set(identity, [...(pairs.get(identity) ?? []), task]);
             }
             for (const rows of pairs.values()) {
-                // rows are in task-list order, the same order the resolver's
-                // find() favors: the first is the one it keeps using.
+                // Rows are in task-list order; keep the newest.
                 for (const duplicate of rows.slice(1)) {
                     const by = duplicate.openedBy;
                     const identity = this.openerIdentity(by);
@@ -856,8 +873,7 @@ export class Store {
                 }
             }
         };
-        // Pair rows only ever live on bots: the resolver requires a bot
-        // recipient, and group tasks carry no peer stamps.
+        // Historical pair rows lived only on bots; group tasks have no peer stamps.
         for (const bot of this.bots)
             sweep(bot.tasks, () => { botsDirty = true; });
         if (botsDirty)
@@ -1796,7 +1812,7 @@ export class Store {
                     Object.assign(task, { [key]: structuredClone(patch[key]) });
                 }
             }
-            bot.unread = bot.tasks.some((candidate) => candidate.unread);
+            bot.unread = bot.tasks.some(taskCountsAsBotUnread);
         }
         this.saveBots();
         this.emit({ type: "bot", botId: id });
@@ -2146,11 +2162,34 @@ export class Store {
      * current folder — unless the task already has a session (a thread from
      * before folders existed), which pins to the default so the folder can't
      * move under it. Returns the pinned value: a path, or null for default. */
+    /** Forget where a conversation works: its next turn pins it again
+     * (pinTaskCwd). For a Cloud home's conversation a revoked session opened,
+     * whose next turn must work in its own folder (server/cloud-owner.ts). */
+    unpinTaskCwd(threadId) {
+        const bot = this.botByThread(threadId);
+        const task = bot ? this.taskByThread(bot.id, threadId) : undefined;
+        if (!bot || !task || task.cwd === undefined)
+            return false;
+        delete task.cwd;
+        this.saveBots();
+        this.emit({ type: "bot", botId: bot.id });
+        return true;
+    }
     pinTaskCwd(botId, threadId, fallbackCwd, opts = {}) {
         const bot = this.bot(botId);
         const task = bot ? this.taskByThread(botId, threadId) : undefined;
         if (!bot || !task)
             return null;
+        // Its own folder, never the bot's project folder (a Cloud home's guest
+        // conversation), pinned when it first runs. A conversation that already
+        // ran elsewhere keeps its pin: it was not opened that way, and moving it
+        // would lose its work and its session.
+        if (opts.privateOnly && task.cwd === undefined) {
+            task.cwd = fallbackCwd ?? null;
+            this.saveBots();
+            this.emit({ type: "bot", botId });
+            return task.cwd;
+        }
         if (opts.none) {
             if (task.cwd !== null) {
                 task.cwd = null;
@@ -2318,9 +2357,13 @@ export class Store {
             task.title = patch.title.trim().slice(0, 80) || UNTITLED_THREAD;
         if (Object.prototype.hasOwnProperty.call(patch, "pinned") && task.pinned !== true)
             delete task.pinned;
+        // Still hidden: attention belongs on the source conversation. A same-call
+        // clear of routineRunId (no-source promotion) may keep unread.
+        if (task.routineRunId)
+            task.unread = false;
         if (bot.threadId === threadId)
             this.mirrorActiveTask(bot, task);
-        bot.unread = bot.tasks.some((candidate) => candidate.unread);
+        bot.unread = bot.tasks.some(taskCountsAsBotUnread);
         this.saveBots();
         this.emit({ type: "bot", botId });
         return task;
@@ -2399,8 +2442,10 @@ export class Store {
         bot.pinnedMessageId = task.pinnedMessageId;
     }
     /** A fresh context on the same bot: new thread, new session, same
-     * persona/tools/computer. Becomes the active task. */
-    createTask(botId, title, activate = true, projectId, openedBy, approvalMode) {
+     * persona/tools/computer. Becomes the active task. It runs on the bot's
+     * default model unless the caller hands it one (a thread opened from
+     * another of this bot's threads keeps that thread's model). */
+    createTask(botId, title, activate = true, projectId, openedBy, approvalMode, modelSelection) {
         const bot = this.bot(botId);
         if (!bot)
             return null;
@@ -2415,7 +2460,7 @@ export class Store {
             ...(projectId ? { projectId } : {}),
             ...(openedBy ? { openedBy: structuredClone(openedBy) } : {}),
             resumeCursors: {},
-            modelSelection: structuredClone(bot.modelSelection),
+            modelSelection: structuredClone(modelSelection ?? bot.modelSelection),
             approvalMode: approvalMode ?? approvalModeFor(bot),
             autoApprove: approvalMode ? false : Boolean(bot.autoApprove),
             alwaysAllow: approvalMode ? [] : [...(bot.alwaysAllow ?? [])],
@@ -2463,112 +2508,6 @@ export class Store {
         this.emit({ type: "bot", botId });
         return task;
     }
-    /** Where a bot-to-bot send outside a room lands: the PAIR CONVERSATION
-     * for (sender, recipient) — the recipient's task stamped `openedBy` this
-     * sender with kind "pair".
-     *
-     * Its scope is global for those two bots: deliberately not per source
-     * thread and not per assignment, so a teammate you work with all day is
-     * one readable row in the recipient's sidebar that remembers what was
-     * asked last time, instead of one row per message. Nothing about the
-     * caller's current turn takes part in choosing it — no dispatch
-     * generation, no request key — and never the recipient's selected
-     * thread, which belongs to the person.
-     *
-     * Two things bend that rule, both deliberately:
-     *
-     *   adoption — a recipient still carrying threads this sender opened
-     *   before pair conversations existed (one per assignment, each titled
-     *   with a sliced brief) has its most recently active one stamped as the
-     *   pair conversation instead of gaining yet another row, so the sprawl
-     *   stops on upgrade day. Nothing is deleted or closed. A start_thread
-     *   handoff is left alone: the sender named that job itself and tracks
-     *   it by its own delegation id.
-     *
-     *   concurrency — a second assignment arriving while the pair
-     *   conversation is still working (`working`, which the caller answers
-     *   from live turn state) gets its own work thread, so two jobs never
-     *   interleave in one transcript. `label` names that thread; the caller
-     *   closes it once its result has been reported. A pair conversation
-     *   never auto-closes. */
-    /** The identity a peer-opened row belongs to: its opener's id while that
-     * bot lives, else the one live bot the stamp's name still points at —
-     * what a deleted-and-recreated same-name bot inherits — else the dead id
-     * itself. A name two live bots share resolves to nobody's twin:
-     * ambiguous means unmatched, never a wrong merge. */
-    openerIdentity(openedBy) {
-        if (this.bot(openedBy.botId))
-            return openedBy.botId;
-        const named = this.bots.filter((bot) => bot.name === openedBy.name);
-        return named.length === 1 ? named[0].id : openedBy.botId;
-    }
-    resolvePairConversation(sender, recipientId, options) {
-        if (!this.bot(recipientId))
-            return null;
-        const title = `@${sender.name}`;
-        const opener = (kind, at = Date.now()) => ({ botId: sender.id, name: sender.name, kind, at });
-        // Identity-stable: the sender's own rows, plus ones a deleted
-        // predecessor opened when the stamp's name still points at exactly
-        // this bot — a same-name recreation inherits the conversation instead
-        // of minting a twin while the old row dangles live. A name two live
-        // bots share matches nobody's inheritance: refusing the fallback can
-        // cost a new row, never merge two bots' histories.
-        const fromSender = this.tasks(recipientId).filter((task) => task.openedBy && this.openerIdentity(task.openedBy) === sender.id);
-        let pair = fromSender.find((task) => task.openedBy?.kind === "pair");
-        if (!pair) {
-            const lastActivity = (task) => this.messagesTail(task.threadId, 1).messages.at(-1)?.at ?? task.openedBy?.at ?? task.createdAt;
-            const adopted = fromSender
-                .filter((task) => !task.openedBy?.kind && !task.openedBy?.delegationId && !task.closedBy)
-                .sort((a, b) => lastActivity(b) - lastActivity(a))[0];
-            if (adopted) {
-                // Keep the hour it was really opened: list_threads and the sidebar
-                // order by it, and adoption is not a new conversation.
-                this.setTaskOpenedBy(recipientId, adopted.threadId, opener("pair", adopted.openedBy?.at ?? adopted.createdAt));
-                // The title changes only when nobody typed it. The rule: rename it
-                // when it still equals what createTask made of the assignment that
-                // opened the thread — and that assignment is still the thread's
-                // first message, "@Recipient <brief>" — so the comparison is
-                // threadTitleFrom(that brief). Anything else is a name a person
-                // chose, and a thread with no request to read (its handoff never
-                // ran) cannot be checked, so both keep the title they have.
-                if (adopted.title === this.openingRequestTitle(recipientId, adopted.threadId)) {
-                    this.renameTask(recipientId, adopted.threadId, title);
-                }
-                pair = adopted;
-            }
-        }
-        if (pair && !options.working(pair.threadId)) {
-            // A conversation the sender closed after reading a result is picked
-            // back up, never replaced: closing is only the sidebar's idle state.
-            if (pair.closedBy)
-                this.setTaskClosedBy(recipientId, pair.threadId, null);
-            // An inherited row carries the predecessor's id; rebind it to the
-            // live bot so the name fallback is needed only once — a namesake
-            // appearing later cannot claim the row. The hour it was opened
-            // stays: inheritance is not a new conversation.
-            const inherited = pair.openedBy;
-            if (inherited && inherited.botId !== sender.id) {
-                this.setTaskOpenedBy(recipientId, pair.threadId, { ...inherited, botId: sender.id, name: sender.name });
-            }
-            return { task: pair, created: false };
-        }
-        // The brief is never a title. An 80-character slice of an assignment
-        // is the row nobody can read, and a durable conversation outlives the
-        // one brief that opened it.
-        const task = this.createTask(recipientId, pair ? `${title} · ${options.label || "parallel work"}` : title, false, undefined, opener(pair ? "work" : "pair"));
-        return task ? { task, created: true } : null;
-    }
-    /** The title a peer-opened thread was born with: what createTask made of
-     * the request that opened it, which is still the first message in it,
-     * addressed "@Recipient <brief>". null when there is no such message to
-     * read — an unrun handoff proves nothing about who named the row. */
-    openingRequestTitle(recipientId, threadId) {
-        const first = this.messagesFor(threadId)[0]?.text?.trim();
-        if (!first)
-            return null;
-        const addressed = `@${this.bot(recipientId)?.name ?? ""} `;
-        return threadTitleFrom(first.startsWith(addressed) ? first.slice(addressed.length) : first);
-    }
     switchTask(botId, threadId) {
         const bot = this.bot(botId);
         const task = bot?.tasks?.find((t) => t.threadId === threadId);
@@ -2598,7 +2537,8 @@ export class Store {
     /** Swap a machine-made first-message title for a generated one, once.
      * Equality against the snippet is the whole contract: a rename by the
      * person, by pair adoption, or by an earlier generated title each break
-     * it, so this never overwrites a name anyone chose. */
+     * it, so this never overwrites a name anyone chose. Regenerate title passes
+     * the title it started from, so a rename made while it ran stands. */
     retitleTask(botId, threadId, machineTitle, title) {
         const task = this.taskByThread(botId, threadId);
         if (!task || task.title !== machineTitle)
@@ -2620,7 +2560,7 @@ export class Store {
             this.mirrorActiveTask(bot, visible);
         }
         this.deleteThreadRecord(threadId);
-        bot.unread = bot.tasks.some((task) => task.unread);
+        bot.unread = bot.tasks.some(taskCountsAsBotUnread);
         this.refreshBotActivity(bot);
         this.saveBots();
         this.emit({ type: "bot", botId });

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

@@ -215,6 +215,8 @@ function isRuntimeEvent(value) {
                     value.source === "peer"));
         case "thread.token-usage.updated":
             return typeof value.input === "number" && typeof value.output === "number";
+        case "runtime.notice":
+            return typeof value.message === "string";
         case "runtime.error":
             return typeof value.message === "string" &&
                 (value.setup === undefined || typeof value.setup === "boolean") &&

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

@@ -35,6 +35,39 @@ export class ThreadStarters {
     get(threadId) {
         return this.starters.get(threadId);
     }
+    /** The threads opened for one person, newest first, at most `limit`. */
+    threadsOf(person, limit) {
+        const threads = [];
+        for (const [threadId, starter] of [...this.starters].reverse()) {
+            if (starter !== person)
+                continue;
+            threads.push(threadId);
+            if (threads.length >= limit)
+                break;
+        }
+        return threads;
+    }
+    /** Everyone a thread here was opened for. */
+    people() {
+        return new Set(this.starters.values());
+    }
+    /** Name `to` for every thread whose person `move` accepts: a one-time
+     * migration (server/cloud-owner.ts), not an ordinary record. The threads
+     * that changed. */
+    reassign(move, to) {
+        if (!KEY.test(to))
+            return [];
+        const moved = [];
+        for (const [threadId, person] of this.starters) {
+            if (person === to || !move(person))
+                continue;
+            this.starters.set(threadId, to);
+            moved.push(threadId);
+        }
+        if (moved.length)
+            writeFileAtomic(this.file, JSON.stringify(Object.fromEntries(this.starters)) + "\n", { mode: 0o600 });
+        return moved;
+    }
     /** Record once; a thread keeps the person it was first opened for. */
     set(threadId, person) {
         if (!person || !KEY.test(person) || !THREAD.test(threadId) || this.starters.has(threadId))

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

@@ -0,0 +1,46 @@
+// What a generated thread title is asked from.
+//
+// A fresh thread is named from its first message. "Regenerate title" (#1858)
+// names it again from the conversation as it is now: the newest user and bot
+// lines, never tool output, cards or screen frames, and bounded so the
+// one-shot stays as cheap as the first-message one.
+import { redactSecretsInText } from "./redact.js";
+/** The most text either kind of title one-shot ever sees. */
+export const TITLE_INPUT_MAX_CHARS = 1_500;
+const EXCERPT_MAX_MESSAGES = 12;
+const EXCERPT_LINE_MAX_CHARS = 300;
+const ATTACHMENT_TAG = /<attached-(?:image|file)\b[^>]*\/>/g;
+export function threadTitlePrompt(text, source = "first-message") {
+    return [
+        source === "conversation"
+            ? "Name the conversation below by what it is about now."
+            : "Name the conversation that begins with the message below.",
+        "Reply with only a short title: 3 to 6 words, plain text, no quotes, no trailing period.",
+        source === "conversation" ? "Conversation:" : "Message:",
+        text.trim().slice(0, TITLE_INPUT_MAX_CHARS),
+    ].join("\n");
+}
+/** The newest user and bot text lines, oldest first, one per line and each
+ * clipped, until the next line would pass the input cap. Attachment markup
+ * and secrets are scrubbed before anything leaves this machine. Empty when
+ * the thread has nothing a title could be drawn from. */
+export function titleConversationExcerpt(messages) {
+    const lines = [];
+    let length = 0;
+    for (let index = messages.length - 1; index >= 0 && lines.length < EXCERPT_MAX_MESSAGES; index--) {
+        const message = messages[index];
+        // peer asides and still-queued lines are not the conversation yet
+        if (message.kind !== "text" || !message.text || message.aside || message.queued)
+            continue;
+        const text = redactSecretsInText(message.text.replace(ATTACHMENT_TAG, " ")).replace(/\s+/g, " ").trim();
+        if (!text)
+            continue;
+        const clipped = text.length > EXCERPT_LINE_MAX_CHARS ? `${text.slice(0, EXCERPT_LINE_MAX_CHARS - 1)}…` : text;
+        const line = `${message.role === "user" ? "User" : "Bot"}: ${clipped}`;
+        if (length + line.length + 1 > TITLE_INPUT_MAX_CHARS)
+            break;
+        lines.push(line);
+        length += line.length + 1;
+    }
+    return lines.reverse().join("\n");
+}

package/dist-server/server/tts/fish.js

@@ -1,7 +1,6 @@
-// Fish Audio text to speech. The API key stays on the harness: the renderer
-// receives only voice metadata and synthesized audio bytes.
 const API = (process.env.OMB_FISH_AUDIO_API || "https://api.fish.audio").replace(/\/+$/, "");
-const MODEL = "s2.1-pro";
+/** Used when no model is saved, so existing setups keep their behavior. */
+export const DEFAULT_FISH_MODEL = "s2.1-pro";
 const MAX_ERROR_LENGTH = 240;
 const PAGE_SIZE = 100;
 const MAX_OWNED_PAGES = 100;
@@ -124,7 +123,7 @@ export async function listVoices(key) {
     });
     return [...new Map(voices.map((voice) => [voice.id, voice])).values()];
 }
-export async function synthesize(text, voiceId, key) {
+export async function synthesize(text, voiceId, key, model = DEFAULT_FISH_MODEL) {
     let res;
     try {
         res = await fetch(`${API}/v1/tts`, {
@@ -133,7 +132,7 @@ export async function synthesize(text, voiceId, key) {
                 authorization: `Bearer ${key}`,
                 "content-type": "application/json",
                 accept: "audio/mpeg",
-                model: MODEL,
+                model,
             },
             body: JSON.stringify({
                 text,

package/dist-server/server/tts/index.js

@@ -69,8 +69,9 @@ export function voiceReady(cfg, voiceId) {
 }
 /** What the settings panel needs. Never includes the key — same write-only
  * rule as every other credential. baseUrl and model are Chatterbox
- * settings, not credentials, so they come back in full. `included` says the
- * voice is Cloud Pro's, not a saved key. */
+ * settings, not credentials, so they come back in full; `fishModel` is the
+ * Fish Audio speech model, resolved to its default when unset. `included`
+ * says the voice is Cloud Pro's, not a saved key. */
 export function describeVoice(cfg) {
     const provider = voiceProvider(cfg);
     const included = provider === "elevenlabs" && elevenLabs(cfg)?.included === true;
@@ -81,6 +82,7 @@ export function describeVoice(cfg) {
         provider,
         baseUrl: provider === "chatterbox" ? (cfg.tts?.baseUrl ?? "") : "",
         model: provider === "chatterbox" ? (cfg.tts?.model ?? "") : "",
+        ...(provider === "fish" ? { fishModel: cfg.tts?.fishModel ?? fish.DEFAULT_FISH_MODEL } : {}),
         ...(included ? { included: true } : {}),
     };
 }
@@ -147,7 +149,7 @@ export function speak(cfg, text, voiceId, run) {
         const voice = voiceId || cfg.tts?.voice;
         if (!voice)
             throw new NoVoiceConfigured("voice");
-        return fish.synthesize(text, voice, key);
+        return fish.synthesize(text, voice, key, cfg.tts?.fishModel);
     }
     const credential = elevenLabs(cfg);
     if (!credential)

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

@@ -85,6 +85,8 @@ const SCREENSHOT_CLEANUP_BUDGET_MS = 10_000;
 const PREPARATION_LOCK_TIMEOUT_MS = SCREENSHOT_BUDGET_MS + LOCK_ACQUIRE_TIMEOUT_MS;
 const pendingScreenshots = new Map();
 const viewerConnections = new Map();
+const REMOTE_VIEWER_GRACE_MS = 30_000;
+const NATIVE_VIEWER_LIFETIME_MS = 8 * 60 * 60_000;
 const desktopTunnels = new Map();
 function invalidateVpsStatus(key) {
     statusCache.delete(key);
@@ -198,12 +200,53 @@ function stopDesktopTunnel(botId) {
     return true;
 }
 export function closeVpsDesktopTunnel(botId) {
+    const tunnel = desktopTunnels.get(botId);
+    // Remote tabs still hold the tunnel; drop only the native claim and let
+    // the last tab's release start the grace period.
+    if (tunnel?.viewers) {
+        tunnel.localViewer = false;
+        clearTimeout(tunnel.expiry);
+        return { closed: false };
+    }
     return { closed: stopDesktopTunnel(botId) };
 }
 export function closeAllVpsDesktopTunnels() {
     for (const botId of desktopTunnels.keys())
         stopDesktopTunnel(botId);
 }
+/** Resolve only a tunnel opened by the authenticated join route. Multiple
+ * remote tabs share it; the final tab releases it unless a native viewer owns it. */
+export function vpsDesktopConnection(botId) {
+    const tunnel = desktopTunnels.get(botId);
+    if (!tunnel || tunnel.child.exitCode !== null || tunnel.child.killed)
+        return;
+    const url = new URL(tunnel.joinUrl);
+    return {
+        port: Number(url.port),
+        password: new URLSearchParams(url.hash.slice(1)).get("password"),
+        live: () => desktopTunnels.get(botId) === tunnel && tunnel.child.exitCode === null && !tunnel.child.killed,
+        retain: () => {
+            tunnel.viewers++;
+            if (!tunnel.localViewer)
+                clearTimeout(tunnel.expiry);
+            let released = false;
+            return () => {
+                if (released)
+                    return;
+                released = true;
+                tunnel.viewers--;
+                if (!tunnel.viewers && !tunnel.localViewer && desktopTunnels.get(botId) === tunnel) {
+                    // A short grace period lets a reload/reconnect reuse the tunnel.
+                    tunnel.expiry = setTimeout(() => {
+                        if (desktopTunnels.get(botId) === tunnel)
+                            stopDesktopTunnel(botId);
+                    }, REMOTE_VIEWER_GRACE_MS);
+                    tunnel.expiry.unref();
+                }
+            };
+        },
+    };
+}
 const STREAM_CAP_CHARS = 16 * 1024 * 1024;
 /** Keeps the LAST 16MB of a stream without rebuilding one giant string per
  * chunk (a 10-minute `docker build` stream made that rebuild quadratic).
@@ -317,7 +360,7 @@ function emptyStatus(botId, alias) {
         desktopReady: false,
         desktop_error: null,
         ready: false,
-        problem: alias ? "Docker over SSH is not reachable" : "Configure a VPS SSH alias in App Settings → Connections",
+        problem: alias ? "Docker over SSH is not reachable" : "Configure a VPS SSH alias in Settings → API keys",
         image_ref: VPS_IMAGE,
         base_image_ref: BASE_IMAGE,
         driver_version: CUA_DRIVER_VERSION,
@@ -335,6 +378,9 @@ function isMissingObjectMessage(message) {
     return /no such (object|image|container)/i.test(message);
 }
 function transportFailure(message) {
+    if (/timed out/i.test(message)) {
+        return "Docker over SSH failed while checking the VPS: the connection timed out. Check that the VPS is online, SSH is reachable from this computer, and Docker is running on the VPS, then retry. No computer was reset.";
+    }
     return `Docker over SSH failed while checking the VPS: ${message.trim().slice(0, 200) || "unknown transport error"}`;
 }
 function privateDockerIpv4(value) {
@@ -371,7 +417,7 @@ function hasNoPublishedPorts(config, networks) {
 }
 function statusProblem(status) {
     if (!status.configured)
-        return "Configure a VPS SSH alias in App Settings → Connections";
+        return "Configure a VPS SSH alias in Settings → API keys";
     if (!status.daemonUp)
         return "Docker over SSH could not reach the VPS; check the SSH alias and Docker on the VPS";
     if (!status.image)
@@ -412,9 +458,23 @@ async function computeVpsComputerStatus(cfg, botId, runner) {
         return status;
     viewerConnections.delete(`${alias}:${status.container_name}`);
     const run = (args, timeoutMs = 10_000, input) => runner(vpsDockerArgs(alias, args), { timeoutMs, input });
+    // Only repeat read-only Docker inspections, never an exec or lifecycle
+    // mutation whose outcome is unknown after a lost connection. Awaiting the
+    // runner also lets its owned SSH process finish cleanup before retrying.
+    const inspect = async (args) => {
+        try {
+            return await run(args);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!/timed out|connection reset by peer|broken pipe/i.test(message))
+                throw error;
+            return run(args);
+        }
+    };
     let inspectedImageId = null;
     try {
-        const inspected = JSON.parse((await run(["image", "inspect", VPS_IMAGE])).stdout);
+        const inspected = JSON.parse((await inspect(["image", "inspect", VPS_IMAGE])).stdout);
         status.daemonUp = true;
         const image = inspected[0];
         const labels = image?.Config?.Labels ?? image?.config?.Labels ?? image?.config?.labels;
@@ -434,7 +494,7 @@ async function computeVpsComputerStatus(cfg, botId, runner) {
         status.image = false;
     }
     try {
-        const inspected = JSON.parse((await run(["inspect", status.container_name])).stdout);
+        const inspected = JSON.parse((await inspect(["inspect", status.container_name])).stdout);
         const detail = inspected[0];
         const labels = detail?.Config?.Labels;
         const containerId = detail?.Id ?? detail?.id;
@@ -897,7 +957,7 @@ export async function removeManagedVpsComputer(cfg, owners, containerName, confi
     cfg = snapshotVpsConfig(cfg);
     const alias = vpsSshAlias(cfg);
     if (!alias) {
-        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in Connections"), { status: 409 });
+        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in Settings → API keys"), { status: 409 });
     }
     if (!MANAGED_VPS_CONTAINER_NAME.test(containerName)) {
         throw Object.assign(new Error("invalid managed VPS computer name"), { status: 400 });
@@ -948,7 +1008,7 @@ export async function vpsComputerAction(action, cfg, botId, runner = defaultRunn
     cfg = snapshotVpsConfig(cfg);
     const alias = vpsSshAlias(cfg);
     if (!alias)
-        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in App Settings → Connections"), { status: 409 });
+        throw Object.assign(new Error("VPS is not configured — add an SSH config alias in Settings → API keys"), { status: 409 });
     const key = `${alias}:${vpsContainerName(botId)}`;
     const pending = action === "provision" ? pendingProvisions.get(key) : undefined;
     if (pending)
@@ -1054,13 +1114,20 @@ export async function inspectVpsForAuto(cfg, botId, runner = defaultRunner) {
  * returned URL is loopback-only and contains the per-container password in
  * its fragment (never sent in HTTP). Closing the app viewer calls the paired
  * close endpoint, and process shutdown closes every remaining child. */
-export async function vpsComputerJoin(cfg, botId, runner = defaultRunner) {
+export async function vpsComputerJoin(cfg, botId, runner = defaultRunner, remoteViewer = false) {
     cfg = snapshotVpsConfig(cfg);
     const alias = vpsSshAlias(cfg);
     if (!alias)
         throw Object.assign(new Error("VPS is not configured"), { status: 409 });
     const existing = desktopTunnels.get(botId);
     if (existing && existing.child.exitCode === null && !existing.child.killed) {
+        if (!remoteViewer)
+            existing.localViewer = true;
+        if (!existing.viewers || existing.localViewer) {
+            clearTimeout(existing.expiry);
+            existing.expiry = setTimeout(() => stopDesktopTunnel(botId), existing.localViewer ? NATIVE_VIEWER_LIFETIME_MS : REMOTE_VIEWER_GRACE_MS);
+            existing.expiry.unref();
+        }
         return { joinUrl: existing.joinUrl, state: "running" };
     }
     stopDesktopTunnel(botId);
@@ -1114,11 +1181,11 @@ export async function vpsComputerJoin(cfg, botId, runner = defaultRunner) {
         throw Object.assign(new Error(`Could not open the VPS live desktop: ${detail}`), { status: 502 });
     }
     const joinUrl = `http://127.0.0.1:${localPort}/vnc.html#autoconnect=true&resize=scale&password=${encodeURIComponent(connection.password)}`;
-    // Viewer-close is the normal cleanup. This unref'd ceiling is a backstop
-    // for a renderer crash or an old browser client that cannot signal close.
-    const expiry = setTimeout(() => stopDesktopTunnel(botId), 8 * 60 * 60_000);
+    // Remote tabs retain the tunnel when their WebSocket opens. Reclaim an
+    // abandoned join promptly; native windows retain the existing close/ceiling.
+    const expiry = setTimeout(() => stopDesktopTunnel(botId), remoteViewer ? REMOTE_VIEWER_GRACE_MS : NATIVE_VIEWER_LIFETIME_MS);
     expiry.unref?.();
-    desktopTunnels.set(botId, { child, joinUrl, expiry });
+    desktopTunnels.set(botId, { child, joinUrl, expiry, viewers: 0, localViewer: !remoteViewer });
     return { joinUrl, state: "running" };
 }
 export function vpsContainerMcpArgs(alias, containerName) {
@@ -1142,7 +1209,7 @@ export function vpsDriverError(driverKind, computerMcp) {
         return "The Computer engine runs its agent on Boat and cannot use a self-hosted VPS — choose Claude or an ACP engine";
     }
     if (!computerMcp) {
-        return "This model engine cannot mount a self-hosted VPS computer — choose Claude or an ACP engine";
+        return "This model cannot mount a self-hosted VPS computer — choose Claude or an ACP model provider";
     }
     return null;
 }