openmausbot 0.1.85 → 0.1.87

package/dist-server/server/config.js

@@ -7,6 +7,7 @@ import { join } from "node:path";
 import { z } from "zod";
 import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
+import { newBotDefaultsSchema } from "./new-bot-defaults.js";
 import { EFFORT_LEVELS } from "../shared/wire.js";
 import { isModelVariant } from "./contracts.js";
 import { PROVIDER_ICON_PRESETS, providerIconError } from "../shared/provider-icon.js";
@@ -289,11 +290,36 @@ const instanceConfigSchema = z.object({
 });
 const instanceConfigMapSchema = z.record(z.string(), instanceConfigSchema);
 const defaultModelSelectionSchema = z.object({
-    instanceId: z.string().trim().min(1),
-    model: z.string().trim().min(1),
+    instanceId: z.string().trim().min(1).max(200),
+    model: z.string().trim().min(1).max(500),
     effort: z.enum(EFFORT_LEVELS).optional(),
     variant: z.string().refine(isModelVariant, "invalid model variant").optional(),
 }).refine((selection) => selection.variant === undefined || selection.effort === undefined, "choose either a model variant or an effort level");
+const threadsConfigSchema = z.object({
+    maxConcurrentPerBot: z.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS),
+    /** Cap each per-thread events/ and native/ NDJSON log at this many
+     * bytes; absent (the default) keeps today's unbounded growth (#1280). */
+    eventLogMaxBytes: z.number().int().min(MIN_THREAD_EVENT_LOG_BYTES).max(MAX_THREAD_EVENT_LOG_BYTES).optional(),
+    /** Days a closed or archived thread's event logs survive (#1280).
+     * Absent keeps them forever. */
+    eventLogRetentionDays: z.number().int().min(1).max(3650).optional(),
+}).strict();
+/** Workspace-wide defaults every new bot starts with (Store.createBot). */
+const newBotsConfigSchema = z.object({
+    /** Effort for a new bot whose model selection names none. */
+    effort: z.enum(EFFORT_LEVELS).optional(),
+}).strict();
+/** PATCH newBots: null clears a default back to absent (no level is sent). */
+const newBotsPatchSchema = z.object({
+    effort: newBotsConfigSchema.shape.effort.nullable(),
+}).strict();
+/** PATCH threads: every knob is independently patchable, and null clears an
+ * event-log knob back to its absent (off) default. */
+const threadsPatchSchema = threadsConfigSchema.extend({
+    maxConcurrentPerBot: threadsConfigSchema.shape.maxConcurrentPerBot.optional(),
+    eventLogMaxBytes: threadsConfigSchema.shape.eventLogMaxBytes.nullable(),
+    eventLogRetentionDays: threadsConfigSchema.shape.eventLogRetentionDays.nullable(),
+});
 const appConfigSchema = z.object({
     /** Verified by the dedicated domain endpoint, never a generic config patch. */
     customDomain: z.string().optional(),
@@ -301,12 +327,15 @@ const appConfigSchema = z.object({
      * addresses or `@domain` entries; admins get every scope, members chat only. */
     signIn: z.object({ admins: z.array(z.string().max(320)).max(500).optional(), members: z.array(z.string().max(320)).max(5000).optional() }).optional(),
     defaultModelSelection: defaultModelSelectionSchema.optional(),
+    newBotDefaults: newBotDefaultsSchema.optional(),
+    newBots: newBotsConfigSchema.optional(),
     /** CLI-only launch preferences. Never enable remote access implicitly. */
     cliStartup: z.object({
         access: z.enum(["local", "tunnel", "tailscale", "public-url"]),
         publicUrl: z.string().url().optional(),
         phone: z.enum(["ios", "android"]).optional(),
     }).optional(),
+    mistral: 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
@@ -384,8 +413,8 @@ const appConfigSchema = z.object({
         }).optional(),
         customModel: z.string().trim().max(200).refine((value) => !["\r", "\n", "\0"].some((character) => value.includes(character)), "Use a model ID without control characters").optional(),
     }).optional(),
-    /** Non-secret profile details shown in the sidebar. */
-    profile: z.object({ name: optionalText, email: optionalText }).optional(),
+    /** Non-secret profile details; aboutMe is shared with every bot. */
+    profile: z.object({ name: optionalText, email: optionalText, aboutMe: z.string().max(24_000).optional() }).optional(),
     /** UI language override (BCP-47, lowercase). Empty/absent = follow the
      * system language. Unknown tags degrade to English in the renderer. */
     language: optionalText,
@@ -395,15 +424,10 @@ const appConfigSchema = z.object({
         compactAt: z.number().positive().max(10_000_000).optional(),
         autoCompact: z.boolean().optional(),
     }).optional(),
-    threads: z.object({
-        maxConcurrentPerBot: z.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS),
-        /** Cap each per-thread events/ and native/ NDJSON log at this many
-         * bytes; absent (the default) keeps today's unbounded growth (#1280). */
-        eventLogMaxBytes: z.number().int().min(MIN_THREAD_EVENT_LOG_BYTES).max(MAX_THREAD_EVENT_LOG_BYTES).optional(),
-        /** Days a closed or archived thread's event logs survive (#1280).
-         * Absent keeps them forever. */
-        eventLogRetentionDays: z.number().int().min(1).max(3650).optional(),
-    }).strict().optional(),
+    threads: threadsConfigSchema.optional(),
+    /** The authorization decision log (server/decision-log.ts): days of month
+     * files kept, at least; OMB_DECISION_RETENTION_DAYS wins when set. */
+    decisions: z.object({ retentionDays: z.number().int().min(1).max(3650).optional() }).strict().optional(),
     localVm: localVmConfigSchema.optional(),
     features: featureConfigSchema.optional(),
     onboarding: onboardingConfigSchema.optional(),
@@ -420,7 +444,8 @@ const appConfigSchema = z.object({
 const storedAppConfigSchema = appConfigSchema.extend({
     browserProfiles: storedBrowserProfilesSchema.optional(),
 });
-const appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true });
+const appConfigPatchSchema = appConfigSchema.omit({ instances: true, mcpServers: true, cliStartup: true, customDomain: true })
+    .extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() });
 const jsonObjectSchema = z.record(z.string(), z.json());
 /** Resolve a canonical profile record to its exact durable Electron
  * partition identity. Callers must never substitute the display/API id. */
@@ -520,6 +545,8 @@ export function roomHandoffLimits(cfg) {
         hardCapMs: (cfg.rooms?.handoffHardCapMinutes ?? DEFAULT_ROOM_HANDOFF_HARD_CAP_MINUTES) * 60_000,
     };
 }
+/** Accepts a full config or a parsed patch: the concurrency limit may be
+ * read from either, and a patch may legitimately omit it. */
 export function maxConcurrentBotThreads(cfg) {
     return cfg.threads?.maxConcurrentPerBot ?? DEFAULT_MAX_CONCURRENT_BOT_THREADS;
 }
@@ -671,6 +698,9 @@ export function loadConfig() {
     // Anything that saves a credential mid-session must keep process.env in
     // step (syncCredentialEnv below), or the value injected at boot would
     // shadow the save until the next launch.
+    cfg.mistral = { ...cfg.mistral };
+    if (process.env.MISTRAL_API_KEY !== undefined)
+        cfg.mistral.key = process.env.MISTRAL_API_KEY;
     cfg.xai = { ...cfg.xai };
     if (process.env.XAI_API_KEY !== undefined)
         cfg.xai.key = process.env.XAI_API_KEY;
@@ -732,6 +762,7 @@ export function loadConfig() {
 export function syncCredentialEnv(patch) {
     const secrets = [
         [patch.xai?.key, "XAI_API_KEY"],
+        [patch.mistral?.key, "MISTRAL_API_KEY"],
         [patch.anthropic?.key, "OMB_ANTHROPIC_API_KEY"],
         [patch.openaiCompat?.key, "OPENAI_COMPAT_API_KEY"],
         [patch.composio?.apiKey, "COMPOSIO_API_KEY"],
@@ -774,8 +805,11 @@ export function syncCredentialEnv(patch) {
  * child these are someone else's keys riding along in `...process.env`. */
 export const WORKSPACE_CREDENTIAL_ENV = [
     "XAI_API_KEY",
+    "MISTRAL_API_KEY",
     "OMB_ANTHROPIC_API_KEY",
     "OMB_ANTHROPIC_API_URL",
+    "OMB_HOSTED_MODEL_TOKEN",
+    "OMB_HOSTED_MODELS",
     "OPENAI_COMPAT_API_KEY",
     "OPENAI_COMPAT_URL",
     "BOX_TOKEN",
@@ -792,10 +826,32 @@ export const WORKSPACE_CREDENTIAL_ENV = [
     "OMB_BROWSER_CONNECTION",
     "OMB_USER_DATA",
 ];
-/** Drop every workspace credential from a child-process env (in place). */
+/** Secrets of whoever operates this server, not of the workspace: the license
+ * key, a fleet container's installation credential, and everything a hosting
+ * control plane injects under `OMB_CLOUD_` (the readiness token, the bootstrap
+ * document and its gateway token). Only this process reads them. The prefix
+ * ends in an underscore on purpose: `OMB_CLOUDFLARED_PATH` is not one of them.
+ * What an engine is meant to receive arrives under another name through its
+ * instance environment (the hosted model token as ANTHROPIC_API_KEY or
+ * OPENMAUSBOT_COMPANY_API_KEY), so nothing here is ever an engine's input. */
+export const CONTROL_PLANE_ENV = ["OMB_LICENSE_KEY", "OMB_INSTALLATION_CREDENTIAL"];
+export const CONTROL_PLANE_ENV_PREFIX = "OMB_CLOUD_";
+/** Drop every control-plane secret from a child-process env (in place). No
+ * driver allowlist re-admits these. Names compare case-insensitively because
+ * Windows environments do. */
+export function stripControlPlaneEnv(env) {
+    for (const key of Object.keys(env)) {
+        const name = key.toUpperCase();
+        if (name.startsWith(CONTROL_PLANE_ENV_PREFIX) || CONTROL_PLANE_ENV.includes(name))
+            delete env[key];
+    }
+}
+/** Drop every workspace credential, and every control-plane secret, from a
+ * child-process env (in place). */
 export function stripWorkspaceCredentialEnv(env) {
     for (const key of WORKSPACE_CREDENTIAL_ENV)
         delete env[key];
+    stripControlPlaneEnv(env);
 }
 /** Env names a provider CLI might read as its own billing identity. A spawned
  * engine keeps only what its driver explicitly allows: a foreign key riding
@@ -812,9 +868,18 @@ export const PROVIDER_CREDENTIAL_ENV = [
     "OPENAI_API_KEY",
     "OPENCODE_API_KEY",
     "XAI_API_KEY",
+    "MISTRAL_API_KEY",
     "CURSOR_API_KEY",
     "CURSOR_AUTH_TOKEN",
 ];
+const configSaveListeners = new Set();
+/** Told, synchronously, what each saveConfig wrote: the file before and
+ * after. The admin activity log (server/admin-activity.ts) records the
+ * change for whoever's request made it. A listener must not throw. */
+export function onConfigSaved(listener) {
+    configSaveListeners.add(listener);
+    return () => { configSaveListeners.delete(listener); };
+}
 /** Merge a partial config into ~/.openmausbot/config.json (secrets never
  * echoed back — callers report configured-or-not booleans only). */
 export function saveConfig(patch, options = {}) {
@@ -828,20 +893,33 @@ export function saveConfig(patch, options = {}) {
     catch {
         /* first write */
     }
-    const checkedPatch = appConfigSchema.partial().parse(patch);
+    const checkedPatch = appConfigSchema.partial().extend({ threads: threadsPatchSchema.optional(), newBots: newBotsPatchSchema.optional() }).parse(patch);
+    const before = configSaveListeners.size ? structuredClone(disk) : disk;
     // A write is the durable migration point. Preserve every other raw key in
     // config.json, but never write #567's mixed-case or duplicate profile ids
     // back after we have successfully recognized the legacy list.
     const storedProfiles = storedBrowserProfilesSchema.safeParse(disk.browserProfiles);
     if (storedProfiles.success)
         disk.browserProfiles = storedProfiles.data;
-    for (const key of ["xai", "anthropic", "openaiCompat", "composio", "box", "opencodeGo", "tts", "imageGen", "profile", "rooms", "threads", "context", "localVm", "features", "budgets", "billing", "onboarding", "browserEngine"]) {
+    for (const key of ["xai", "anthropic", "mistral", "openaiCompat", "composio", "box", "opencodeGo", "tts", "imageGen", "profile", "rooms", "threads", "context", "localVm", "features", "budgets", "billing", "decisions", "onboarding", "browserEngine", "newBots"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;
         const current = jsonObjectSchema.safeParse(disk[key]);
         const merged = current.success ? { ...current.data } : {};
+        // parseStoredConfig requires threads.maxConcurrentPerBot, so creating
+        // the section with only an event-log knob must still persist a valid
+        // concurrency default.
+        if (key === "threads" && !current.success)
+            merged.maxConcurrentPerBot = DEFAULT_MAX_CONCURRENT_BOT_THREADS;
         Object.assign(merged, section);
+        // null is the patch's explicit "remove this key" marker (the threads
+        // event-log knobs and newBots.effort use it); a key the patch omits
+        // keeps its value.
+        for (const [sectionKey, sectionValue] of Object.entries(section)) {
+            if (sectionValue === null)
+                delete merged[sectionKey];
+        }
         disk[key] = merged;
     }
     if (checkedPatch.vps !== undefined)
@@ -857,6 +935,24 @@ export function saveConfig(patch, options = {}) {
     // an effort level omitted from the new selection.
     if (checkedPatch.defaultModelSelection !== undefined) {
         disk.defaultModelSelection = checkedPatch.defaultModelSelection;
+        if (disk.newBotDefaults) {
+            const previousDefaults = newBotDefaultsSchema.parse(disk.newBotDefaults);
+            disk.newBotDefaults = newBotDefaultsSchema.parse({
+                ...previousDefaults,
+                profile: { ...previousDefaults.profile, modelSelection: checkedPatch.defaultModelSelection },
+            });
+        }
+    }
+    // Replace the complete template so clearing a field, file or routine
+    // cannot revive an old value through the general section merge above.
+    if (checkedPatch.newBotDefaults !== undefined) {
+        disk.newBotDefaults = checkedPatch.newBotDefaults;
+        if (checkedPatch.newBotDefaults.profile.modelSelection) {
+            disk.defaultModelSelection = checkedPatch.newBotDefaults.profile.modelSelection;
+        }
+        else {
+            delete disk.defaultModelSelection;
+        }
     }
     if (checkedPatch.cliStartup !== undefined)
         disk.cliStartup = checkedPatch.cliStartup;
@@ -880,6 +976,14 @@ export function saveConfig(patch, options = {}) {
         if (routingConflict)
             throw Object.assign(new Error(routingConflict), { status: 409 });
         disk.browserProfiles = nextProfiles;
+        if (disk.newBotDefaults) {
+            const defaults = newBotDefaultsSchema.parse(disk.newBotDefaults);
+            const profileId = defaults.profile.browserProfile;
+            if (profileId && profileId !== "guest" && !nextProfiles.some(profile => profile.id === profileId)) {
+                delete defaults.profile.browserProfile;
+                disk.newBotDefaults = defaults;
+            }
+        }
     }
     if (checkedPatch.instances) {
         const currentInstances = jsonObjectSchema.safeParse(disk.instances);
@@ -920,6 +1024,14 @@ export function saveConfig(patch, options = {}) {
     }
     mkdirSync(DATA_DIR, { recursive: true });
     writeFileAtomic(p, JSON.stringify(disk, null, 2), { mode: 0o600 });
+    for (const listener of configSaveListeners) {
+        try {
+            listener(before, disk);
+        }
+        catch (error) {
+            console.warn(`config: a save listener failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }
 /** Set one instance's `config.cli` ("" clears the override back to the
  * driver default). Creating the instance entry is fine — a config-less
@@ -980,6 +1092,8 @@ export function persistableInstanceConfigs(cfg) {
  * environment of an unrelated child process. */
 function injectedEnvironment(cfg, driver) {
     const environment = new Map();
+    if (driver === "mistral" && cfg.mistral?.key)
+        environment.set("MISTRAL_API_KEY", cfg.mistral.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
@@ -1030,6 +1144,7 @@ export function instanceConfigs(cfg) {
         opencodeGo: { driver: "opencodeGo" },
         computer: { driver: "boxAgent" },
         openaiCompat: { driver: "openai-compat" },
+        mistral: { driver: "mistral" },
         qwen: { driver: "qwenAgent" },
         hermes: { driver: "hermesAgent" },
         pi: { driver: "piAgent" },
@@ -1045,6 +1160,7 @@ export function instanceConfigs(cfg) {
     const PRODUCT_FLEET_ADDITIONS = {
         cursor: { driver: "cursorAgent" },
         openaiCompat: { driver: "openai-compat" },
+        mistral: { driver: "mistral" },
         ...CUSTOM_ONLY,
     };
     const configured = cfg.instances && Object.keys(cfg.instances).length ? cfg.instances : null;

package/dist-server/server/connector-verdict.js

@@ -0,0 +1,141 @@
+// The harness-side verdict for connected-app tool calls (issue #1736, part
+// of the per-bot Composio tool grants umbrella #1734).
+//
+// Every Composio tool call crosses POST /api/internal/connectors/mcp: the
+// provider CLIs talk to the stdio bridge, and the bridge forwards each
+// JSON-RPC frame there. So the grants verdict lives on the harness side,
+// where the loopback token already names the bot and the decision log is
+// native — the bridge never sees a key it could have to enforce with.
+//
+// Three shapes reach this module:
+//
+//   * a direct per-toolkit call — params.name is the tool itself, e.g.
+//     GMAIL_SEND_EMAIL;
+//   * the executor meta-tool — COMPOSIO_MULTI_EXECUTE_TOOL, whose
+//     arguments name one or many target tools;
+//   * everything else — connection cards, discovery, notifications —
+//     which passes through untouched (advertisement filtering is slice 3).
+//
+// Unrecognized argument shapes are denied by default: a call whose target
+// tools cannot be read is a call whose tools cannot be checked, and the
+// grants promise — "this bot may call exactly these tools" — must hold
+// even against a model that garbles the protocol.
+import { CONNECTOR_TOOL_NAME_PATTERN } from "../shared/wire.js";
+/** The executor meta-tool: the only meta-tool whose arguments name target
+ * tools. Discovery and connection meta-tools keep their existing flows. */
+export const COMPOSIO_MULTI_EXECUTE_TOOL = "COMPOSIO_MULTI_EXECUTE_TOOL";
+/** The service a Composio tool name belongs to: the upper-snake prefix
+ * before the first underscore, lowercased (GMAIL_SEND_EMAIL to gmail). A
+ * name with no underscore names no service, so no grant can cover it. */
+export function serviceSlugFor(tool) {
+    const underscore = tool.indexOf("_");
+    if (underscore <= 0)
+        return null;
+    return tool.slice(0, underscore).toLowerCase();
+}
+/** Classify one relayed JSON-RPC frame. Anything that is not a tools/call,
+ * or is a discovery/connection/platform meta-tool, passes through. */
+export function connectorCallFromFrame(payload) {
+    if (!payload || typeof payload !== "object" || Array.isArray(payload))
+        return { kind: "passthrough" };
+    const frame = payload;
+    if (frame.method !== "tools/call")
+        return { kind: "passthrough" };
+    const params = frame.params;
+    if (!params || typeof params !== "object" || Array.isArray(params)) {
+        return { kind: "unrecognized", invoked: "tools/call", reason: "the call carried no params object" };
+    }
+    const name = params.name;
+    if (typeof name !== "string" || !name) {
+        return { kind: "unrecognized", invoked: "tools/call", reason: "the call named no tool" };
+    }
+    if (name === COMPOSIO_MULTI_EXECUTE_TOOL) {
+        return multiExecuteCall(name, params.arguments);
+    }
+    // Platform meta-tools (search, schemas, remote workbench) are not
+    // connected-app tools; grants are keyed by service slug, and slice 3
+    // owns what the model is even shown.
+    if (name.startsWith("COMPOSIO_"))
+        return { kind: "passthrough" };
+    // Per-service connection cards keep their card flow in any spelling.
+    if (name.endsWith("_MANAGE_CONNECTIONS") || name.endsWith("_WAIT_FOR_CONNECTIONS")) {
+        return { kind: "passthrough" };
+    }
+    if (!CONNECTOR_TOOL_NAME_PATTERN.test(name)) {
+        return { kind: "unrecognized", invoked: name, reason: "the tool name is not a Composio tool name" };
+    }
+    return { kind: "tools", invoked: name, names: [name] };
+}
+/** Read the target tools out of COMPOSIO_MULTI_EXECUTE_TOOL arguments:
+ * the upstream schema is a 1-50 item tools array of { tool_slug,
+ * arguments }; a legacy single { tool_slug } object is accepted too.
+ * Anything else cannot be checked, so it is denied. */
+function multiExecuteCall(invoked, args) {
+    if (!args || typeof args !== "object" || Array.isArray(args)) {
+        return { kind: "unrecognized", invoked, reason: "the arguments were not an object" };
+    }
+    const tools = args.tools;
+    const singleSlug = args.tool_slug;
+    if (Array.isArray(tools)) {
+        if (tools.length === 0) {
+            return { kind: "unrecognized", invoked, reason: "the tools list was empty" };
+        }
+        const names = [];
+        for (const item of tools) {
+            const slug = item && typeof item === "object" && !Array.isArray(item)
+                ? item.tool_slug
+                : undefined;
+            if (typeof slug !== "string" || !slug) {
+                return { kind: "unrecognized", invoked, reason: "an entry in the tools list named no tool_slug" };
+            }
+            names.push(slug);
+        }
+        return { kind: "tools", invoked, names };
+    }
+    if (typeof singleSlug === "string" && singleSlug) {
+        return { kind: "tools", invoked, names: [singleSlug] };
+    }
+    return { kind: "unrecognized", invoked, reason: "the arguments named no tools to execute" };
+}
+/** Judge distinct target names against a bot's grants. grants undefined
+ * is the legacy all-tools bot and passes everything; an explicit record —
+ * including the empty one — allows only what it names. */
+export function evaluateConnectorTools(names, grants) {
+    if (grants === undefined) {
+        return { allowed: true, legacy: true, denials: [], rule: "composio" };
+    }
+    const denials = [];
+    let rule = "";
+    for (const tool of new Set(names)) {
+        const service = serviceSlugFor(tool);
+        const grant = service === null ? undefined : grants[service];
+        if (grant && (grant.tools === "*" || grant.tools.includes(tool))) {
+            if (!rule)
+                rule = "connectorTools." + service;
+            continue;
+        }
+        denials.push({ tool, service, onGrantedService: Boolean(grant) });
+    }
+    return { allowed: denials.length === 0, legacy: false, denials, rule };
+}
+/** Safe to hand straight to the model: names the refused tool and says who
+ * can change it. It never lists what the bot could have called instead —
+ * a refusal that enumerates adjacent grants teaches the model to probe. */
+export function connectorRefusalText(denials) {
+    const named = denials.map((denial) => '"' + denial.tool + '"').join(", ");
+    const one = denials.length === 1;
+    return [
+        named + " " + (one ? "is" : "are") + " not granted to this bot.",
+        "This call was not performed.",
+        "Ask the person to grant " + (one ? "it" : "these tools") + " in OpenMausBot if they want " + (one ? "it" : "them") + " run.",
+    ].join(" ");
+}
+/** The unrecognized-shape refusal: names the meta-tool and what could not
+ * be read, and still points at the person rather than at any tool list. */
+export function connectorUnrecognizedText(invoked, reason) {
+    return [
+        "A " + invoked + " call arrived in a shape OpenMausBot could not read (" + reason + "), so it was not performed.",
+        "Send a well-formed call that names the tools to execute.",
+        "Ask the person to grant any tool this bot needs.",
+    ].join(" ");
+}

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

@@ -310,7 +310,7 @@ function statusProblem(status) {
     if (status.security === "unsafe")
         return "The existing Local VM is missing safety limits; recreate it";
     if (status.persistence === "unsafe")
-        return "The existing Local VM is missing its durable workspace; recreate it";
+        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)