openmausbot 0.1.91 → 0.1.93

package/dist-server/server/config.js

@@ -19,6 +19,9 @@ const optionalText = z.string().optional();
 const SSH_ALIAS = /^[A-Za-z0-9][A-Za-z0-9_.-]{0,127}$/;
 const LEGACY_BROWSER_PROFILE_ID = /^[A-Za-z0-9_-]{1,40}$/;
 const BROWSER_PROFILE_ID = /^[a-z0-9_-]{1,40}$/;
+/** Fish Audio speech models (`tts.fishModel`). `s2.1-pro-free` is Fish's
+ * free developer tier; an unset model means `s2.1-pro`. */
+export const FISH_TTS_MODELS = ["s2.1-pro", "s2.1-pro-free"];
 export const DEFAULT_ROOM_TURN_TIMEOUT_MINUTES = 5;
 export const MIN_ROOM_TURN_TIMEOUT_MINUTES = 1;
 export const MAX_ROOM_TURN_TIMEOUT_MINUTES = 1_440;
@@ -36,6 +39,11 @@ export const DEFAULT_LOCAL_VM_MODE = "shared";
 export const DEFAULT_LOCAL_VM_MAX_INSTANCES = 2;
 export const MIN_LOCAL_VM_MAX_INSTANCES = 1;
 export const MAX_LOCAL_VM_MAX_INSTANCES = 8;
+/** Idle window before a Local VM's disposable container is recycled. The
+ * default keeps the historical 8-hour window for existing configs. */
+export const DEFAULT_LOCAL_VM_IDLE_TIMEOUT_MINUTES = 480;
+export const MIN_LOCAL_VM_IDLE_TIMEOUT_MINUTES = 5;
+export const MAX_LOCAL_VM_IDLE_TIMEOUT_MINUTES = 1_440;
 export function isValidSshAlias(value) {
     return typeof value === "string" && SSH_ALIAS.test(value);
 }
@@ -112,6 +120,12 @@ const localVmConfigSchema = z.object({
         .min(MIN_LOCAL_VM_MAX_INSTANCES)
         .max(MAX_LOCAL_VM_MAX_INSTANCES)
         .optional(),
+    idleTimeoutMinutes: z
+        .number()
+        .int()
+        .min(MIN_LOCAL_VM_IDLE_TIMEOUT_MINUTES)
+        .max(MAX_LOCAL_VM_IDLE_TIMEOUT_MINUTES)
+        .optional(),
 });
 /** A named, shareable browser session ("Work", "Client A"). The id names a
  * durable Electron partition; user-controlled characters never reach it. */
@@ -302,6 +316,10 @@ const onboardingConfigSchema = z.object({
     version: z.number().int().min(0).max(1000).optional(),
     reelSeen: z.boolean().optional(),
     hintsSeen: z.array(z.string().trim().min(1).max(60)).max(100).optional(),
+    /** OMB Cloud home only: when a bot's turn first finished on this machine
+     * (cloud-home.ts firstCloudTurnPatch). Written by the server, read by the
+     * Cloud's setup checklist. */
+    firstTurnAt: z.string().trim().max(40).optional(),
 }).strict();
 const instanceConfigSchema = z.object({
     driver: z.string().min(1),
@@ -314,6 +332,7 @@ const instanceConfigSchema = z.object({
     ]).optional(),
     environment: z.record(z.string(), z.string()).optional(),
     enabled: z.boolean().optional(),
+    access: z.enum(["subscription", "custom", "api"]).optional(),
     config: z.json().optional(),
 });
 const instanceConfigMapSchema = z.record(z.string(), instanceConfigSchema);
@@ -369,11 +388,17 @@ const appConfigSchema = z.object({
         phone: z.enum(["ios", "android"]).optional(),
     }).optional(),
     mistral: z.object({ key: optionalText }).optional(),
+    cerebras: z.object({ key: optionalText }).optional(),
     xai: z.object({ key: optionalText, url: optionalText }).optional(),
     /** Anthropic API key for Claude Code billed per token, handed only to
      * Claude instances; `url` only for a proxy or a test double. Never a
      * personal-login OAuth token. */
-    anthropic: z.object({ key: optionalText, url: optionalText }).optional(),
+    anthropic: z.object({ key: optionalText, url: optionalText, everyClaudeBot: z.boolean().optional() }).optional(),
+    /** OpenAI's own API key, for the `openai` instance only. Codex keeps its
+     * own ChatGPT or API login and never reads this. */
+    openai: z.object({ key: optionalText }).optional(),
+    /** OpenRouter key, for the `openrouter` instance only. */
+    openrouter: z.object({ key: optionalText }).optional(),
     /** Monthly spend limit for the whole workspace, against the cost engines
      * report to the usage ledger. Enforced only with the `budgets` entitlement. */
     budgets: z
@@ -412,8 +437,8 @@ const appConfigSchema = z.object({
     opencodeGo: z.object({ apiKey: optionalText }).optional(),
     /** Voice settings and the selected voice id. `provider` picks the
      * engine: "elevenlabs" (default; needs `key`), "fish" (needs its own
-     * `fishKey`), "system" (the Mac's built-in voices, no key), or
-     * "xai" (Grok TTS, reusing `xai.key`), or
+     * `fishKey`; `fishModel` picks its speech model), "system" (the Mac's
+     * built-in voices, no key), "xai" (Grok TTS, reusing `xai.key`), or
      * "chatterbox" (a local OpenAI-compatible Chatterbox server; `baseUrl`
      * and `model` are settings, not secrets). Cloud keys stay separate so
      * switching providers never overwrites or misuses the other key. */
@@ -429,6 +454,7 @@ const appConfigSchema = z.object({
             .refine((value) => !value || /^https?:\/\//i.test(value), "the Chatterbox server address must start with http:// or https://")
             .optional(),
         model: optionalText,
+        fishModel: z.enum(FISH_TTS_MODELS).optional(),
     }).optional(),
     /** The decision model (server/decider): a fast classifier that picks
      * things for bots, starting with who answers a room message. `key` is
@@ -638,6 +664,9 @@ export function localVmMode(cfg) {
 export function localVmMaxInstances(cfg) {
     return cfg.localVm?.maxInstances ?? DEFAULT_LOCAL_VM_MAX_INSTANCES;
 }
+export function localVmIdleTimeoutMinutes(cfg) {
+    return cfg.localVm?.idleTimeoutMinutes ?? DEFAULT_LOCAL_VM_IDLE_TIMEOUT_MINUTES;
+}
 /** On by default; only an explicit `false` (the Settings toggle, or a legacy
  * `skillRecorder: false` carried over at startup) switches it off. */
 export function skillAuthoringEnabled(cfg) {
@@ -856,6 +885,9 @@ export function loadConfig() {
     cfg.mistral = { ...cfg.mistral };
     if (process.env.MISTRAL_API_KEY !== undefined)
         cfg.mistral.key = process.env.MISTRAL_API_KEY;
+    cfg.cerebras = { ...cfg.cerebras };
+    if (process.env.CEREBRAS_API_KEY !== undefined)
+        cfg.cerebras.key = process.env.CEREBRAS_API_KEY;
     cfg.xai = { ...cfg.xai };
     if (process.env.XAI_API_KEY !== undefined)
         cfg.xai.key = process.env.XAI_API_KEY;
@@ -867,6 +899,12 @@ export function loadConfig() {
         cfg.anthropic.key = process.env.OMB_ANTHROPIC_API_KEY;
     if (process.env.OMB_ANTHROPIC_API_URL !== undefined)
         cfg.anthropic.url = process.env.OMB_ANTHROPIC_API_URL;
+    cfg.openai = { ...cfg.openai };
+    if (process.env.OMB_OPENAI_API_KEY !== undefined)
+        cfg.openai.key = process.env.OMB_OPENAI_API_KEY;
+    cfg.openrouter = { ...cfg.openrouter };
+    if (process.env.OMB_OPENROUTER_API_KEY !== undefined)
+        cfg.openrouter.key = process.env.OMB_OPENROUTER_API_KEY;
     cfg.openaiCompat = { ...cfg.openaiCompat };
     if (process.env.OPENAI_COMPAT_API_KEY !== undefined)
         cfg.openaiCompat.key = process.env.OPENAI_COMPAT_API_KEY;
@@ -927,8 +965,11 @@ export function syncCredentialEnv(patch) {
     const secrets = [
         [patch.xai?.key, "XAI_API_KEY"],
         [patch.mistral?.key, "MISTRAL_API_KEY"],
+        [patch.cerebras?.key, "CEREBRAS_API_KEY"],
         [patch.anthropic?.key, "OMB_ANTHROPIC_API_KEY"],
         [patch.openaiCompat?.key, "OPENAI_COMPAT_API_KEY"],
+        [patch.openai?.key, "OMB_OPENAI_API_KEY"],
+        [patch.openrouter?.key, "OMB_OPENROUTER_API_KEY"],
         [patch.composio?.apiKey, "COMPOSIO_API_KEY"],
         [patch.box?.token, "BOX_TOKEN"],
         [patch.opencodeGo?.apiKey, "OPENCODE_API_KEY"],
@@ -971,12 +1012,15 @@ export function syncCredentialEnv(patch) {
 export const WORKSPACE_CREDENTIAL_ENV = [
     "XAI_API_KEY",
     "MISTRAL_API_KEY",
+    "CEREBRAS_API_KEY",
     "OMB_ANTHROPIC_API_KEY",
     "OMB_ANTHROPIC_API_URL",
     "OMB_HOSTED_MODEL_TOKEN",
     "OMB_HOSTED_MODELS",
     "OPENAI_COMPAT_API_KEY",
     "OPENAI_COMPAT_URL",
+    "OMB_OPENAI_API_KEY",
+    "OMB_OPENROUTER_API_KEY",
     "BOX_TOKEN",
     "OPENCODE_API_KEY",
     "OMB_TTS_KEY",
@@ -1041,6 +1085,7 @@ export const PROVIDER_CREDENTIAL_ENV = [
     "OPENCODE_API_KEY",
     "XAI_API_KEY",
     "MISTRAL_API_KEY",
+    "CEREBRAS_API_KEY",
     "CURSOR_API_KEY",
     "CURSOR_AUTH_TOKEN",
 ];
@@ -1073,7 +1118,7 @@ export function saveConfig(patch, options = {}) {
     const storedProfiles = storedBrowserProfilesSchema.safeParse(disk.browserProfiles);
     if (storedProfiles.success)
         disk.browserProfiles = storedProfiles.data;
-    for (const key of ["xai", "anthropic", "mistral", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "cloudOverflow", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
+    for (const key of ["xai", "anthropic", "mistral", "cerebras", "openai", "openrouter", "openaiCompat", "composio", "box", "opencodeGo", "tts", "decider", "imageGen", "profile", "rooms", "threads", "context", "memory", "localVm", "features", "cloudOverflow", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;
@@ -1259,29 +1304,102 @@ export function persistableInstanceConfigs(cfg) {
     }
     return map;
 }
+/** Claude Code variables that choose where a turn goes and how it signs in.
+ * An instance that sets any of them (a router, a gateway, a cloud platform)
+ * owns that routing and credential pair outright. */
+const CLAUDE_ROUTING_ENV = [
+    "ANTHROPIC_BASE_URL",
+    "ANTHROPIC_AUTH_TOKEN",
+    "ANTHROPIC_API_KEY",
+    "ANTHROPIC_CUSTOM_HEADERS",
+    "CLAUDE_CODE_USE_BEDROCK",
+    "CLAUDE_CODE_USE_VERTEX",
+    "CLAUDE_CODE_USE_FOUNDRY",
+];
+/** Whether a Claude instance brings its own endpoint or credential. The
+ * workspace Anthropic key must never reach it: the key would be sent as
+ * x-api-key to that instance's host (a third-party router), or would
+ * silently re-route its turns to the workspace URL. */
+export function claudeInstanceOwnsRouting(environment) {
+    return CLAUDE_ROUTING_ENV.some((key) => typeof environment?.[key] === "string" && environment[key] !== "");
+}
+const sameUrl = (a, b) => a.trim().replace(/\/+$/u, "") === b.trim().replace(/\/+$/u, "");
+/** Whether an instance brings its own endpoint or credential, so the
+ * workspace key for its driver must never reach it: that key would be sent
+ * to the instance's own host (a third-party router or proxy). The same rule
+ * as a Claude router instance, for the API-key engines. An instance on the
+ * workspace's own endpoint with nothing of its own still gets the key. */
+export function instanceOwnsRouting(cfg, entry, routingDefaults) {
+    const config = typeof entry.config === "object" && entry.config !== null && !Array.isArray(entry.config)
+        ? entry.config
+        : {};
+    const own = (value) => typeof value === "string" && value.trim() !== "";
+    const ownUrl = (...workspace) => own(config.url)
+        && !workspace.some((url) => url !== undefined && sameUrl(config.url, url));
+    const compatKeyEnv = routingDefaults?.apiKeyEnv ?? "OPENAI_COMPAT_API_KEY";
+    switch (entry.driver) {
+        case "claudeAgent":
+            return claudeInstanceOwnsRouting(entry.environment);
+        case "openai-compat":
+            return own(config.key) || own(entry.environment?.OPENAI_COMPAT_API_KEY)
+                || own(entry.environment?.[compatKeyEnv])
+                || (own(config.apiKeyEnv) && config.apiKeyEnv !== compatKeyEnv)
+                || ownUrl(routingDefaults?.url || cfg.openaiCompat?.url || process.env.OPENAI_COMPAT_URL || "https://openrouter.ai/api/v1");
+        case "mistral":
+            return own(entry.environment?.MISTRAL_API_KEY) || ownUrl("https://api.mistral.ai/v1");
+        case "cerebras":
+            return own(entry.environment?.CEREBRAS_API_KEY) || ownUrl("https://api.cerebras.ai/v1");
+        case "grok":
+            return own(entry.environment?.XAI_API_KEY) || (own(config.apiKeyEnv) && config.apiKeyEnv !== "XAI_API_KEY")
+                || ownUrl("https://api.x.ai/v1", cfg.xai?.url);
+        default:
+            return false;
+    }
+}
 /** The credential env instanceConfigs() injects for one driver at runtime.
  * Each secret goes only to the driver that actually reads it: the API-key
  * Grok driver reads XAI_API_KEY, the Computer driver reads BOX_TOKEN, and
  * OpenCode reads OPENCODE_API_KEY. Every other engine brings its own
  * login, so handing it a key it never uses would only put that key in the
  * environment of an unrelated child process. */
-function injectedEnvironment(cfg, driver) {
+function injectedEnvironment(cfg, instanceId, driver) {
     const environment = new Map();
     if (driver === "mistral" && cfg.mistral?.key)
         environment.set("MISTRAL_API_KEY", cfg.mistral.key);
+    if (driver === "cerebras" && cfg.cerebras?.key)
+        environment.set("CEREBRAS_API_KEY", cfg.cerebras.key);
     if (driver === "grok" && cfg.xai?.key)
         environment.set("XAI_API_KEY", cfg.xai.key);
     // The workspace Anthropic key reaches Claude Code as the variable it
     // reads, carried in the instance environment so the driver can tell a
     // deliberate workspace key from one riding along in the parent's env.
-    if (driver === "claudeAgent" && cfg.anthropic?.key)
+    // By default it runs only the `claudeApi` instance, so signed-in Claude
+    // bots stay on their plan; `everyClaudeBot` (the pre-split behaviour, and
+    // what a hosted workspace seeded with only a key relies on) runs every
+    // other Claude instance on it too.
+    const anthropicHere = driver === "claudeAgent" && Boolean(cfg.anthropic?.key)
+        && (cfg.anthropic?.everyClaudeBot === false ? instanceId === CLAUDE_API_INSTANCE : instanceId !== CLAUDE_API_INSTANCE);
+    if (anthropicHere)
         environment.set("ANTHROPIC_API_KEY", cfg.anthropic.key);
-    if (driver === "claudeAgent" && cfg.anthropic?.key && cfg.anthropic.url)
+    if (anthropicHere && cfg.anthropic.url)
         environment.set("ANTHROPIC_BASE_URL", cfg.anthropic.url);
-    if (driver === "openai-compat" && cfg.openaiCompat?.key)
-        environment.set("OPENAI_COMPAT_API_KEY", cfg.openaiCompat.key);
-    if (driver === "openai-compat" && cfg.openaiCompat?.url)
-        environment.set("OPENAI_COMPAT_URL", cfg.openaiCompat.url);
+    // OpenAI and OpenRouter have their own instances and keys; the workspace
+    // OpenAI-compatible key and URL belong to every other openai-compat
+    // instance ("Other" in Settings).
+    if (driver === "openai-compat" && instanceId === OPENAI_API_INSTANCE) {
+        if (cfg.openai?.key)
+            environment.set("OMB_OPENAI_API_KEY", cfg.openai.key);
+    }
+    else if (driver === "openai-compat" && instanceId === OPENROUTER_API_INSTANCE) {
+        if (cfg.openrouter?.key)
+            environment.set("OMB_OPENROUTER_API_KEY", cfg.openrouter.key);
+    }
+    else {
+        if (driver === "openai-compat" && cfg.openaiCompat?.key)
+            environment.set("OPENAI_COMPAT_API_KEY", cfg.openaiCompat.key);
+        if (driver === "openai-compat" && cfg.openaiCompat?.url)
+            environment.set("OPENAI_COMPAT_URL", cfg.openaiCompat.url);
+    }
     // driverKind "boxAgent" and env BOX_TOKEN keep their historical names.
     // Only the person's own token: without one the driver itself falls back
     // to Cloud Pro's included token, which never enters an environment map.
@@ -1291,6 +1409,28 @@ function injectedEnvironment(cfg, driver) {
         environment.set("OPENCODE_API_KEY", cfg.opencodeGo.apiKey);
     return environment;
 }
+/** One instance per pasted provider key, each running only on its own key.
+ * They sit in the picker's "API keys" group and stay hidden until their key
+ * is saved (unavailable without one). */
+export const OPENAI_API_INSTANCE = "openai";
+export const OPENROUTER_API_INSTANCE = "openrouter";
+export const XAI_API_INSTANCE = "xaiApi";
+export const CLAUDE_API_INSTANCE = "claudeApi";
+const API_KEY_FLEET = {
+    [OPENAI_API_INSTANCE]: {
+        driver: "openai-compat", displayName: "OpenAI", access: "api", icon: { kind: "preset", preset: "openai" },
+        config: { url: "https://api.openai.com/v1", apiKeyEnv: "OMB_OPENAI_API_KEY", catalog: "openai" },
+    },
+    [CLAUDE_API_INSTANCE]: {
+        driver: "claudeAgent", displayName: "Claude (API key)", access: "api", icon: { kind: "preset", preset: "anthropic" },
+        config: { requireApiKey: true },
+    },
+    [XAI_API_INSTANCE]: { driver: "grok", displayName: "xAI", access: "api", icon: { kind: "preset", preset: "xai" } },
+    [OPENROUTER_API_INSTANCE]: {
+        driver: "openai-compat", displayName: "OpenRouter", access: "api", icon: { kind: "preset", preset: "openrouter" },
+        config: { url: "https://openrouter.ai/api/v1", apiKeyEnv: "OMB_OPENROUTER_API_KEY" },
+    },
+};
 // Default fleet: one instance per built-in driver (upstream
 // defaultInstanceIdForDriver — instanceId defaults to the driver kind).
 // Config-file keys are injected as per-instance environment so drivers
@@ -1318,11 +1458,14 @@ export function instanceConfigs(cfg) {
         cursor: { driver: "cursorAgent" },
         claude: { driver: "claudeAgent" },
         codex: { driver: "codex" },
+        chatgpt: { driver: "codex", displayName: "ChatGPT plan", config: { authMode: "chatgpt-plan" } },
         antigravity: { driver: "antigravityAgent" },
         opencodeGo: { driver: "opencodeGo" },
         computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
+        cerebras: { driver: "cerebras" },
+        ...API_KEY_FLEET,
         qwen: { driver: "qwenAgent" },
         hermes: { driver: "hermesAgent" },
         pi: { driver: "piAgent" },
@@ -1336,9 +1479,12 @@ export function instanceConfigs(cfg) {
     // never see. Custom-only engines stay in CUSTOM_ONLY so a one-off test map
     // is not expanded, matching the claude/grok/codex product-fleet probe.
     const PRODUCT_FLEET_ADDITIONS = {
+        chatgpt: { driver: "codex", displayName: "ChatGPT plan", config: { authMode: "chatgpt-plan" } },
         cursor: { driver: "cursorAgent" },
         openaiCompat: { driver: "openai-compat" },
         mistral: { driver: "mistral" },
+        cerebras: { driver: "cerebras" },
+        ...API_KEY_FLEET,
         ...CUSTOM_ONLY,
     };
     const configured = cfg.instances && Object.keys(cfg.instances).length ? cfg.instances : null;
@@ -1352,6 +1498,22 @@ export function instanceConfigs(cfg) {
                 map[id] = { ...entry };
         }
     }
+    // A saved `instances` map (any engine edit persists the whole fleet) keeps
+    // these entries without their built-in routing. Re-apply it on every load
+    // so the OpenAI and OpenRouter instances can never fall back to the shared
+    // OpenAI-compatible key and URL; saved fields still win.
+    for (const [id, builtIn] of Object.entries(API_KEY_FLEET)) {
+        const saved = map[id];
+        if (!saved || saved.driver !== builtIn.driver)
+            continue;
+        const savedConfig = typeof saved.config === "object" && saved.config !== null && !Array.isArray(saved.config) ? saved.config : {};
+        map[id] = { ...builtIn, ...saved, config: { ...builtIn.config, ...savedConfig } };
+    }
+    if (map.chatgpt?.driver === "codex" && !map.chatgpt.config?.cli) {
+        const cli = map.codex?.config?.cli;
+        if (typeof cli === "string" && cli)
+            map.chatgpt = { ...map.chatgpt, config: { ...map.chatgpt.config, cli } };
+    }
     for (const [id, sourceEntry] of Object.entries(map)) {
         // instanceConfigs() builds a transient runtime map. Never mutate the
         // caller's persisted entries while injecting workspace defaults: doing so
@@ -1359,14 +1521,25 @@ export function instanceConfigs(cfg) {
         const entry = { ...sourceEntry };
         map[id] = entry;
         const environment = { ...entry.environment };
-        for (const [key, value] of injectedEnvironment(cfg, entry.driver))
-            environment[key] = value;
+        // Main's rule: an instance that brought its own key or host gets no
+        // workspace credential. Built-in per-provider routing is a default,
+        // not an override, but saved custom routing on those IDs still owns its
+        // credential rather than receiving the workspace's provider key.
+        const builtIn = API_KEY_FLEET[id];
+        const routingDefaults = builtIn?.driver === entry.driver
+            ? builtIn.config
+            : undefined;
+        const ownsRouting = instanceOwnsRouting(cfg, entry, routingDefaults);
+        if (!ownsRouting) {
+            for (const [key, value] of injectedEnvironment(cfg, id, entry.driver))
+                environment[key] = value;
+        }
         entry.environment = environment;
         // The driver URL is configuration, not a credential. Environment is
         // intentionally not consulted by ProviderRegistry when it decodes a
         // driver's config, so carry the workspace default into the transient
         // instance map while preserving a per-instance override.
-        if (entry.driver === "openai-compat" && cfg.openaiCompat) {
+        if (entry.driver === "openai-compat" && cfg.openaiCompat && id !== OPENAI_API_INSTANCE && id !== OPENROUTER_API_INSTANCE) {
             const defaults = {};
             if (cfg.openaiCompat.url)
                 defaults.url = cfg.openaiCompat.url;

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

@@ -82,7 +82,7 @@ export function poolLocalVmTarget(seat) {
         label: `pool-${seat}`,
     };
 }
-/** Only provisioning creates this durable directory; idle removal keeps it. */
+/** Only provisioning creates this durable directory; idle shutdown keeps it. */
 export function localVmWorkspaceExists(target) {
     try {
         return lstatSync(target.workspaceDir, { throwIfNoEntry: false })?.isDirectory() === true;
@@ -269,6 +269,7 @@ function emptyStatus(platform, target) {
         desktopReady: false,
         desktop_error: null,
         create_supported: true,
+        resumable: false,
         ready: false,
         problem: "Install a supported container runtime first",
         image_ref: IMAGE,
@@ -283,21 +284,8 @@ function emptyStatus(platform, target) {
         viewer_url: target.viewerPort ? `http://127.0.0.1:${target.viewerPort}/vnc.html` : "",
     };
 }
-/** Whether a turn may recreate this Local VM itself instead of failing.
- *
- * True for exactly one state: the container is gone, and a plain `run` is all
- * that is needed to bring it back. That is what `LocalVmIdleTimer` leaves
- * behind — it removes an unused Local VM rather than pausing it — so a turn
- * arriving after an idle period should not have to send the person to App
- * Settings for a container the app itself deleted.
- *
- * Every other problem in `statusProblem` stays the person's call and returns
- * false here: no runtime, daemon down, image never prepared, `create_supported`
- * false, and any existing container — stale image, unmanaged, unsafe network,
- * security or persistence. A stopped container is excluded deliberately, since
- * `statusProblem` says this desktop image cannot safely resume and asks for a
- * recreate rather than a start.
- */
+/** Recreate a missing desktop when its image and runtime are already prepared.
+ * This also recovers desktops deleted by older versions' idle cleanup. */
 export function localVmRecreatableOnDemand(status) {
     return Boolean(status.runtime)
         && status.daemonUp
@@ -305,12 +293,28 @@ export function localVmRecreatableOnDemand(status) {
         && status.container === "missing"
         && status.create_supported;
 }
+/** Start only an existing, compatible desktop with the managed safety boundary.
+ * Fails closed on fields left "unknown" by a partial inspect, which
+ * `statusProblem` alone would let through. */
+export function localVmResumable(status) {
+    return Boolean(status.runtime) && status.daemonUp && status.image && status.container === "stopped"
+        && existingContainerProblem(status) === null
+        && status.network === "loopback" && status.security === "hardened" && status.persistence === "durable";
+}
+/** What a turn may do on its own to bring this Local VM up, if anything. */
+export function localVmWakeAction(status) {
+    if (localVmRecreatableOnDemand(status))
+        return "run";
+    if (localVmResumable(status))
+        return "start";
+    return null;
+}
 /** Whether Auto may attach this Local VM without a person choosing it: the
- * desktop is ready, or its image is prepared and the container can simply be
- * recreated after idling away. Anything else — no runtime, daemon down, image
+ * desktop is ready, a compatible stopped desktop can be started, or its image
+ * is prepared and a missing container can be recreated. Anything else — no runtime, daemon down, image
  * never prepared, an unmanaged or unsafe container — stays the person's call. */
 export function autoLocalVmAttachable(status) {
-    return status.ready === true || localVmRecreatableOnDemand(status);
+    return status.ready === true || localVmWakeAction(status) !== null;
 }
 function statusProblem(status) {
     if (!status.runtime)
@@ -324,6 +328,19 @@ function statusProblem(status) {
     }
     if (status.container === "missing")
         return "Create the Local VM";
+    const existing = existingContainerProblem(status);
+    if (existing)
+        return existing;
+    if (status.container === "stopped")
+        return "The Local VM is stopped; start it to continue";
+    if (status.desktop_error)
+        return `The Local VM desktop failed to start: ${status.desktop_error}`;
+    if (!status.desktopReady)
+        return "The Local VM started, but Cua Driver is not ready yet";
+    return null;
+}
+/** Problems with an existing container that only a recreate fixes. */
+function existingContainerProblem(status) {
     if (!status.imageMatches)
         return "The existing Local VM uses an older desktop or Cua Driver; recreate it";
     if (!status.managed)
@@ -334,12 +351,6 @@ function statusProblem(status) {
         return "The existing Local VM is missing safety limits; recreate it";
     if (status.persistence === "unsafe")
         return "The existing Local VM is missing its durable folder; recreate it";
-    if (status.container === "stopped")
-        return "This desktop image cannot safely resume; recreate the Local VM";
-    if (status.desktop_error)
-        return `The Local VM desktop failed to start: ${status.desktop_error}`;
-    if (!status.desktopReady)
-        return "The Local VM started, but Cua Driver is not ready yet";
     return null;
 }
 /** Shared with the BYO-VPS backend (vps-computer.ts): both containers are
@@ -408,7 +419,7 @@ export function cuaExecArgs(args, options = {}) {
         ...args,
     ];
 }
-export async function containerComputerStatus(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET) {
+export async function containerComputerStatus(runner = sh, platform = process.platform, target = SHARED_LOCAL_VM_TARGET, options = {}) {
     const status = emptyStatus(platform, target);
     const runtimeStatus = await containerRuntimeStatus(runner, platform);
     status.available = runtimeStatus.available;
@@ -457,6 +468,7 @@ export async function containerComputerStatus(runner = sh, platform = process.pl
             const inspected = JSON.parse(stdout);
             const detail = inspected[0];
             status.container = detail?.State?.Running ? "running" : "stopped";
+            status.stopped_at = status.container === "stopped" ? detail?.State?.FinishedAt ?? null : null;
             status.network = dockerPortsAreLocal(detail?.HostConfig?.PortBindings) ? "loopback" : "unsafe";
             status.viewer_port = dockerViewerPort(detail?.NetworkSettings?.Ports, target.viewerPort);
             status.imageMatches =
@@ -475,7 +487,8 @@ export async function containerComputerStatus(runner = sh, platform = process.pl
     catch {
         // No container with this name.
     }
-    const canProbe = status.container === "running" &&
+    const canProbe = options.probeDesktop !== false &&
+        status.container === "running" &&
         status.imageMatches &&
         status.managed &&
         status.network === "loopback" &&
@@ -529,6 +542,7 @@ export async function containerComputerStatus(runner = sh, platform = process.pl
     }
     status.problem = statusProblem(status);
     status.ready = status.problem === null;
+    status.resumable = localVmResumable(status);
     return status;
 }
 function loopback(address) {
@@ -596,8 +610,8 @@ function appleWorkspaceMountIsSafe(mounts, platform, expectedWorkspace) {
  * runtime-specific capability exception is Podman's Firefox sandbox chroot.
  * Callers also differ on restart policy — the VPS
  * container must survive a reboot nobody is watching ("unless-stopped"),
- * while the Local VM must NOT auto-resume: its desktop leaves a stale X lock
- * on stop, so a restarted container is a broken one. */
+ * while Local VM starts remain controlled by OMB's idle policy and turn
+ * lifecycle rather than a daemon restart policy. */
 export function dockerSecurityIsHardened(config, options = {}) {
     if (!config)
         return false;
@@ -726,10 +740,8 @@ export async function containerComputerAction(action, runner = sh, platform = pr
     if (action === "run" && !before.create_supported) {
         throw Object.assign(new Error(before.problem ?? "This runtime cannot create a per-bot Local VM"), { status: 409 });
     }
-    if (action === "start") {
-        throw Object.assign(new Error("This desktop image cannot safely resume; remove and recreate the Local VM"), {
-            status: 409,
-        });
+    if (action === "start" && !localVmResumable(before)) {
+        throw Object.assign(new Error(before.problem ?? "The Local VM is not stopped"), { status: 409 });
     }
     if (action === "stop" && before.container !== "running") {
         throw Object.assign(new Error("The Local VM is not running"), { status: 409 });
@@ -942,7 +954,7 @@ export function setupCommands(runtime, platform = process.platform, target = SHA
         run: runtime === "container" && target.key !== SHARED_LOCAL_VM_TARGET.key
             ? null
             : command(containerRunArgs(runtime, "CHANGE_ME", target)),
-        start: null,
+        start: command(["start", target.containerName]),
         stop: command(["stop", target.containerName]),
         remove: command(["rm", runtime === "container" ? "--force" : "-f", target.containerName]),
         view: target.viewerPort ? `http://127.0.0.1:${target.viewerPort}/vnc.html` : "",

package/dist-server/server/desktop-viewer-targets.js

@@ -0,0 +1,26 @@
+import { desktopViewerUrl } from "./routes/desktop-viewer.js";
+export const viewerTargetId = (target) => `local/${target.key.replace(":", "-")}`;
+/** Native owner windows keep the existing direct viewer and cookie isolation. */
+export function localVmViewerStatus(status, auth) {
+    return auth.kind === "loopback" ? status : {
+        ...status,
+        viewer_url: status.viewer_url ? desktopViewerUrl(viewerTargetId({ key: status.target_key })) : "",
+    };
+}
+export function localDesktopTarget(target, deps) {
+    return {
+        key: target.key,
+        async resolve() {
+            const status = await deps.status(target);
+            if (!status.managed || !status.imageMatches || status.network !== "loopback" || status.container !== "running"
+                || !status.viewer_url) {
+                throw Object.assign(new Error("Local VM unavailable"), { status: 409 });
+            }
+            return {
+                port: status.viewer_port ?? 0,
+                password: new URLSearchParams(new URL(status.viewer_url).hash.slice(1)).get("password"),
+                touch: () => deps.touch(target),
+            };
+        },
+    };
+}

package/dist-server/server/digest.js

@@ -1,3 +1,4 @@
+import { toolIdentity } from "../shared/tool-name.js";
 /** Evidence is observed, not inferred from a provider's brand. In particular,
  * OpenAI-compatible and Grok turns now expose structured tool activity too. */
 export function coverageForDriver(_driverKind, fullResults = false, observedTools = false) {
@@ -20,13 +21,19 @@ export function buildTurnDigest(input) {
     for (const m of input.activities) {
         if (m.kind !== "activity" || !m.tool?.itemId || m.turnId !== input.turnId)
             continue;
-        const entry = byName.get(m.tool.name) ?? { name: fitBytes(m.tool.name, 160), count: 0, failed: 0 };
+        // by identity, not by the chip's title: a command-titled chip would
+        // otherwise be its own bucket and carry the unredacted command line into
+        // a row that is FTS-indexed and replayed into rebuilt context
+        const identity = toolIdentity(m.tool.name);
+        const entry = byName.get(identity) ?? { name: fitBytes(identity, 160), count: 0, failed: 0 };
         entry.count += 1;
         if (m.tool.ok === false)
             entry.failed += 1;
+        // the driver's summary is the bounded, redacted one-line command; the
+        // title is neither, so a shell bucket says what it ran only through this
         if (entry.sample === undefined && m.tool.summary)
             entry.sample = fitBytes(m.tool.summary.replace(/\s+/g, " "), 300);
-        byName.set(m.tool.name, entry);
+        byName.set(identity, entry);
     }
     // busiest first; ties keep first-seen order (Map preserves insertion)
     const ranked = [...byName.values()].sort((a, b) => b.count - a.count);
@@ -78,6 +85,9 @@ function firstSentence(reply) {
 export function renderDigest(d) {
     const parts = ["[digest]"];
     if (d.tools.length) {
+        // every entry ends at "×N" or "(N failed)": the phones split the tools
+        // part on exactly that (ios DigestSummary, android TurnDigest), so a
+        // shell bucket's sample stays in the stored digest, not in this line
         const tools = d.tools.map((t) => `${t.name} ×${t.count}${t.failed ? ` (${t.failed} failed)` : ""}`).join(", ");
         parts.push(`tools: ${tools}${d.toolsDropped ? ` +${d.toolsDropped} more` : ""}${d.hookCoverage === "preview" ? " (from tool previews)" : ""}`);
     }