openmausbot 0.1.67 → 0.1.69

package/dist-server/server/avatar-image.js

@@ -1,4 +1,6 @@
 import { z } from "zod";
+import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
+import { decodeGeneratedImage } from "./generated-image.js";
 export const AVATAR_DIRECTION_MAX_CHARS = 400;
 export const AVATAR_IMAGE_TIMEOUT_MS = 120_000;
 const MAX_UPSTREAM_RESPONSE_BYTES = 15 * 1024 * 1024;
@@ -6,8 +8,34 @@ export const avatarGenerationRequestSchema = z.object({
     prompt: z.string().trim().max(AVATAR_DIRECTION_MAX_CHARS).default(""),
 });
 const generatedImageResponseSchema = z.object({
-    data: z.array(z.object({ b64_json: z.string().min(1) })).min(1),
+    data: z.array(z.object({ b64_json: z.string().min(1).optional(), url: z.string().optional() })).min(1),
 });
+/** Public settings describe availability without returning provider secrets. */
+export function avatarImageStatus(cfg) {
+    const provider = cfg.imageGen?.provider ?? "openai";
+    const openaiConfigured = Boolean(cfg.imageGen?.key?.trim());
+    const xaiConfigured = Boolean(cfg.xai?.key?.trim());
+    const customKeyConfigured = Boolean(cfg.imageGen?.customApiKey?.trim());
+    const customModel = cfg.imageGen?.customModel?.trim() ?? "";
+    let customUrl = "";
+    try {
+        if (cfg.imageGen?.customUrl?.trim())
+            customUrl = normalizeImageGenerationUrl(cfg.imageGen.customUrl);
+    }
+    catch {
+        // A manually edited invalid URL must not become an outbound request.
+    }
+    return {
+        provider,
+        configured: provider === "openai" ? openaiConfigured : provider === "xai" ? xaiConfigured : Boolean(customUrl && customModel),
+        model: provider === "openai" ? "gpt-image-2" : provider === "xai" ? "grok-imagine-image-2.0" : customModel,
+        customUrl,
+        customModel,
+        openaiConfigured,
+        xaiConfigured,
+        customKeyConfigured,
+    };
+}
 /** Copy the mutable avatar fields before an asynchronous generation starts. */
 export function snapshotAvatarGenerationState(bot) {
     return { avatarUrl: bot.avatarUrl, avatarCrop: bot.avatarCrop };
@@ -53,7 +81,14 @@ async function boundedResponseText(response) {
     let received = 0;
     try {
         for (;;) {
-            const { done, value } = await reader.read();
+            let chunk;
+            try {
+                chunk = await reader.read();
+            }
+            catch {
+                throw Object.assign(new Error("Could not read the generated avatar response"), { status: 502 });
+            }
+            const { done, value } = chunk;
             if (done)
                 break;
             received += value.byteLength;
@@ -70,31 +105,45 @@ async function boundedResponseText(response) {
         reader.releaseLock();
     }
 }
-export async function generateAvatarImage(apiKey, bot, direction, fetchImpl = fetch, timeoutMs = AVATAR_IMAGE_TIMEOUT_MS) {
-    if (!apiKey.trim())
-        throw Object.assign(new Error("Add an OpenAI image API key first"), { status: 409 });
+export async function generateAvatarImage(cfg, bot, direction, fetchImpl = fetch, timeoutMs = AVATAR_IMAGE_TIMEOUT_MS) {
+    const settings = avatarImageStatus(cfg);
+    const { provider, model } = settings;
+    if (!settings.configured) {
+        const message = provider === "openai" ? "Add an OpenAI image API key first"
+            : provider === "xai" ? "Add an xAI API key first"
+                : "Set a valid custom image API URL and model first";
+        throw Object.assign(new Error(message), { status: 409 });
+    }
+    const apiKey = (provider === "openai" ? cfg.imageGen?.key
+        : provider === "xai" ? cfg.xai?.key : cfg.imageGen?.customApiKey)?.trim();
+    const providerName = provider === "openai" ? "OpenAI" : provider === "xai" ? "xAI" : "Custom";
+    const url = provider === "openai" ? "https://api.openai.com/v1/images/generations"
+        : provider === "xai" ? "https://api.x.ai/v1/images/generations"
+            : `${settings.customUrl}/images/generations`;
+    const headers = { "content-type": "application/json" };
+    if (apiKey)
+        headers.authorization = `Bearer ${apiKey}`;
+    const body = {
+        model,
+        prompt: avatarGenerationPrompt(bot, direction),
+        ...(provider === "openai" ? { size: "1024x1024", quality: "low", output_format: "webp" }
+            : provider === "xai" ? { response_format: "b64_json", aspect_ratio: "1:1" }
+                : { response_format: "b64_json", size: "1024x1024", n: 1 }),
+    };
     const timeoutSignal = AbortSignal.timeout(timeoutMs);
     let response;
     try {
-        response = await fetchImpl("https://api.openai.com/v1/images/generations", {
+        response = await fetchImpl(url, {
             method: "POST",
-            headers: {
-                authorization: `Bearer ${apiKey.trim()}`,
-                "content-type": "application/json",
-            },
-            body: JSON.stringify({
-                model: "gpt-image-2",
-                prompt: avatarGenerationPrompt(bot, direction),
-                size: "1024x1024",
-                quality: "low",
-                output_format: "webp",
-            }),
+            headers,
+            body: JSON.stringify(body),
+            redirect: "error",
             signal: timeoutSignal,
         });
     }
     catch (error) {
         const timedOut = timeoutSignal.aborted || (error instanceof Error && error.name === "TimeoutError");
-        throw Object.assign(new Error(timedOut ? "Avatar generation timed out" : "Could not reach OpenAI image generation"), { status: 502 });
+        throw Object.assign(new Error(timedOut ? "Avatar generation timed out" : `Could not reach ${providerName} image generation`), { status: 502 });
     }
     let text;
     try {
@@ -110,15 +159,9 @@ export async function generateAvatarImage(apiKey, bot, direction, fetchImpl = fe
         throw error;
     }
     if (!response.ok) {
-        let message = `OpenAI image generation failed (HTTP ${response.status})`;
-        try {
-            const parsed = z.object({ error: z.object({ message: z.string() }) }).safeParse(JSON.parse(text));
-            if (parsed.success)
-                message = parsed.data.error.message.slice(0, 500);
-        }
-        catch {
-            // Keep the bounded status-only message for malformed upstream errors.
-        }
+        // Upstream errors can repeat authorization headers, signed URLs, or other
+        // secrets. Return only the provider and HTTP status, never its raw body.
+        const message = `${providerName} image generation failed (HTTP ${response.status})`;
         throw Object.assign(new Error(message), { status: response.status === 401 ? 401 : 502 });
     }
     let parsedJson;
@@ -126,19 +169,28 @@ export async function generateAvatarImage(apiKey, bot, direction, fetchImpl = fe
         parsedJson = JSON.parse(text);
     }
     catch {
-        throw Object.assign(new Error("OpenAI returned an invalid image response"), { status: 502 });
+        throw Object.assign(new Error(`${providerName} returned an invalid image response`), { status: 502 });
     }
     const parsed = generatedImageResponseSchema.safeParse(parsedJson);
     if (!parsed.success) {
-        throw Object.assign(new Error("OpenAI returned no generated image"), { status: 502 });
+        throw Object.assign(new Error(`${providerName} returned no generated image`), { status: 502 });
     }
     const encoded = parsed.data.data[0].b64_json;
+    if (!encoded) {
+        // Do not fetch arbitrary URLs returned by a provider. Compatible gateways
+        // must support the requested inline base64 response format.
+        throw Object.assign(new Error(`${providerName} image generation must return base64 image data (b64_json)`), { status: 502 });
+    }
     if (!/^[A-Za-z0-9+/]+={0,2}$/.test(encoded) || encoded.length % 4 !== 0) {
-        throw Object.assign(new Error("OpenAI returned invalid image data"), { status: 502 });
+        throw Object.assign(new Error(`${providerName} returned invalid image data`), { status: 502 });
     }
-    const bytes = Buffer.from(encoded, "base64");
-    if (bytes.byteLength === 0) {
-        throw Object.assign(new Error("OpenAI returned an empty image"), { status: 502 });
+    try {
+        const image = decodeGeneratedImage(encoded);
+        if (image.mime === "image/gif")
+            throw new Error("unsupported avatar format");
+        return { bytes: image.bytes, mime: image.mime };
+    }
+    catch {
+        throw Object.assign(new Error(`${providerName} returned invalid or oversized image data; expected PNG, JPEG, or WebP`), { status: 502 });
     }
-    return { bytes, mime: "image/webp" };
 }

package/dist-server/server/bot-package.js

@@ -27,6 +27,52 @@ const key = requiredText(64).regex(/^[a-z0-9][a-z0-9_-]*$/, {
     message: "may only contain lowercase letters, numbers, - and _",
 });
 const MAX_DATE_MS = 8_640_000_000_000_000;
+const CLOCK_TIME = /^([01]\d|2[0-3]):[0-5]\d$/;
+const intervalWeekdays = z.array(z.number().int().min(0).max(6)).min(1).max(7).refine((weekdays) => new Set(weekdays).size === weekdays.length, "must contain unique weekdays");
+const intervalWindow = z.object({
+    start: z.string().regex(CLOCK_TIME, { message: "must use HH:MM" }),
+    end: z.string().regex(CLOCK_TIME, { message: "must use HH:MM" }),
+}).strict().refine(({ start, end }) => start < end, {
+    message: "must end later on the same day",
+});
+const packageRoutineScheduleSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("once"), at: z.number().int() }),
+    z.object({
+        type: z.literal("daily"),
+        time: requiredText(5).regex(CLOCK_TIME, { message: "must use HH:MM" }),
+        weekdays: z.array(z.number().int().min(0).max(6)).min(1).max(7),
+    }),
+    z.object({
+        type: z.literal("interval"),
+        everyMinutes: z.number().int().min(5).max(1_440),
+        anchorAt: z.number().int().nonnegative().max(MAX_DATE_MS),
+        weekdays: intervalWeekdays.optional(),
+        window: intervalWindow.optional(),
+        endsAt: z.number().int().nonnegative().max(MAX_DATE_MS).optional(),
+    }),
+]).superRefine((schedule, context) => {
+    if (schedule.type !== "interval")
+        return;
+    if (schedule.window) {
+        const [startHour, startMinute] = schedule.window.start.split(":").map(Number);
+        const [endHour, endMinute] = schedule.window.end.split(":").map(Number);
+        const windowMinutes = endHour * 60 + endMinute - (startHour * 60 + startMinute);
+        if (windowMinutes < schedule.everyMinutes) {
+            context.addIssue({
+                code: "custom",
+                message: "must be at least as long as the interval cadence",
+                path: ["window"],
+            });
+        }
+    }
+    if (schedule.endsAt !== undefined && schedule.endsAt < schedule.anchorAt) {
+        context.addIssue({
+            code: "custom",
+            message: "must not be before the interval anchor",
+            path: ["endsAt"],
+        });
+    }
+});
 const packageSchema = z.object({
     format: z.literal(BOT_PACKAGE_FORMAT, { error: "This is not an OpenMaus package" }),
     version: z.literal(BOT_PACKAGE_VERSION, { error: "Package version is not supported" }),
@@ -86,19 +132,7 @@ const packageSchema = z.object({
             agent: key,
             prompt: requiredText(20_000),
             runOn: z.enum(["maus", "cloud"]),
-            schedule: z.discriminatedUnion("type", [
-                z.object({ type: z.literal("once"), at: z.number().int() }),
-                z.object({
-                    type: z.literal("daily"),
-                    time: requiredText(5).regex(/^([01]\d|2[0-3]):[0-5]\d$/, { message: "must use HH:MM" }),
-                    weekdays: z.array(z.number().int().min(0).max(6)).min(1).max(7),
-                }),
-                z.object({
-                    type: z.literal("interval"),
-                    everyMinutes: z.number().int().min(5).max(1_440),
-                    anchorAt: z.number().int().nonnegative().max(MAX_DATE_MS),
-                }),
-            ]),
+            schedule: packageRoutineScheduleSchema,
             durationMinutes: z.number().int().min(5).max(240),
             timeoutMinutes: z.number().int().min(5).max(240).optional(),
             enabledAfterInstall: z.literal(false),
@@ -200,6 +234,18 @@ export function parseBotPackage(value) {
     return parsed.data;
 }
 const list = (values) => values.map((value) => `- ${value}`).join("\n");
+const WEEKDAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"];
+function intervalScheduleText(schedule) {
+    const restrictions = [
+        schedule.weekdays?.length
+            ? `on ${schedule.weekdays.map((day) => WEEKDAY_NAMES[day]).join(", ")}`
+            : null,
+        schedule.window ? `during ${schedule.window.start}–${schedule.window.end}` : null,
+        schedule.endsAt !== undefined ? `until ${new Date(schedule.endsAt).toISOString()}` : null,
+    ].filter((part) => part !== null);
+    const cadence = `every ${schedule.everyMinutes} minutes from ${new Date(schedule.anchorAt).toISOString()}`;
+    return restrictions.length ? `${cadence}; ${restrictions.join("; ")}` : cadence;
+}
 /** Render the public artifact. The frontmatter enables deterministic imports;
  * the body is deliberately complete enough for any Chief-of-Staff agent to
  * run without OpenMausBot or another proprietary parser. */
@@ -226,7 +272,7 @@ export function renderBotPackageMarkdown(document) {
         `**Schedule:** ${routine.schedule.type === "daily"
             ? `${routine.schedule.time} on weekdays ${routine.schedule.weekdays.join(", ")}`
             : routine.schedule.type === "interval"
-                ? `every ${routine.schedule.everyMinutes} minutes from ${new Date(routine.schedule.anchorAt).toISOString()}`
+                ? intervalScheduleText(routine.schedule)
                 : `once at ${routine.schedule.at}`}  `,
         `**Run limit:** ${routine.timeoutMinutes === undefined ? "none" : `${routine.timeoutMinutes} minutes`}  `,
         "**Initial state:** paused — the user must enable it",

package/dist-server/server/brand.js

@@ -10,6 +10,7 @@ import { DATA_DIR } from "./config.js";
 import { entitled } from "./enterprise.js";
 const HEX_COLOUR = /^#[0-9a-fA-F]{6}$/;
 const MAX_LOGO_CHARS = 300_000;
+const MAX_FAVICON_CHARS = 120_000;
 export const brandSchema = z
     .object({
     /** Product name shown in the window title, onboarding and settings. */
@@ -26,6 +27,12 @@ export const brandSchema = z
         .optional(),
     /** Where "get help" points for this deployment. */
     supportUrl: z.string().url().startsWith("https://", "supportUrl must be an https:// URL").optional(),
+    /** Tab and home-screen icon: an inline data:image/... URI (PNG or SVG, small) or an https:// URL. */
+    favicon: z
+        .string()
+        .max(MAX_FAVICON_CHARS, `favicon must be under ${MAX_FAVICON_CHARS} characters (a 64px PNG or a small SVG)`)
+        .refine((v) => v.startsWith("data:image/") || v.startsWith("https://"), "favicon must be a data:image/... URI or an https:// URL")
+        .optional(),
 })
     .strict();
 export const DEFAULT_BRAND = { name: "OpenMausBot" };

package/dist-server/server/cli.js

@@ -32,12 +32,13 @@ import qrcode from "qrcode-terminal";
 import { parseAllowList } from "./account-signin.js";
 import { writeFileAtomic } from "./atomic.js";
 import { ensureCaddy, normalizeDomainOption, startCaddy } from "./caddy.js";
+import { runServiceCommand } from "./service-cli.js";
 import { explainTailscaleFailure, tailscaleServe, tailscaleServeOff, tailscaleStatus } from "./tailscale.js";
 import { defaultSetupIo, SetupCancelled } from "./cli-prompts.js";
 import { normalizePhoneOrigin, phonePairingInstructions, runPhoneSetup } from "./cli-phone-setup.js";
 import { cleanupTunnelOrigin, createTunnelAccount, createTunnelOrigin, describeTunnelAccount, describeTunnelState, ensureCloudflared, FLEET_CREDENTIAL_ENV, fleetAccess, fleetCredential, guardianEntry, startTunnel, tunnelAccess, } from "./tunnel.js";
 const HERE = dirname(fileURLToPath(import.meta.url));
-const COMMANDS = ["setup", "start", "serve", "pair", "sessions", "status", "login", "logout", "access", "browser", "help", "--help", "-h"];
+const COMMANDS = ["setup", "start", "serve", "pair", "sessions", "status", "login", "logout", "access", "service", "browser", "help", "--help", "-h"];
 export function parseArgs(argv, env = process.env) {
     const implicitStart = !argv.length || (argv[0].startsWith("--") && argv[0] !== "--help");
     const [command = "start", ...rest] = implicitStart ? ["start", ...argv] : argv;
@@ -105,6 +106,8 @@ export function parseArgs(argv, env = process.env) {
             }
             else if (options.command === "access" && arg === "--chat-only")
                 options.chatOnly = true;
+            else if (options.command === "service" && !options.serviceAction && (arg === "install" || arg === "uninstall"))
+                options.serviceAction = arg;
             else if (options.command === "browser" && (arg === "install" || arg === "status"))
                 options.browserAction = arg;
             else if (options.command === "browser" && arg === "--with-deps")
@@ -124,6 +127,8 @@ export function parseArgs(argv, env = process.env) {
         return { error: "choose one of --tailscale (your tailnet) and --tunnel (a public address)" };
     if (options.command === "access" && !options.accessAction)
         return { error: "access needs one of: list, add EMAIL [--chat-only], remove EMAIL" };
+    if (options.command === "service" && !options.serviceAction)
+        return { error: "service needs one of: install [the same options as serve], uninstall" };
     if (options.domain && (options.tailscale || options.tunnel || options.publicUrl))
         return { error: "--domain already gives the server its address; drop --tailscale, --tunnel and --public-url" };
     if (options.local && (options.tailscale || options.tunnel || options.publicUrl))
@@ -145,6 +150,7 @@ export const USAGE = `openmausbot — your team of AI bots, ready in a few steps
   openmausbot login [--email you@example.com]
   openmausbot logout
   openmausbot access list | add EMAIL [--chat-only] | remove EMAIL
+  openmausbot service install [--domain HOST | --tunnel | --tailscale] [--port N] [--data-dir DIR] | uninstall
   openmausbot browser install [--with-deps] | status
 
 setup   choose AI access and optional phone access; keep existing bots and chats
@@ -159,6 +165,10 @@ logout  releases that address and signs out
 access  who may sign in with an emailed code at /pair: an address or
         @domain; --chat-only gives chat and approvals without settings.
         Takes effect at once, no restart.
+service keep the server running across reboots: writes a systemd unit
+        (Linux) or a launchd agent (macOS) for the same serve options and
+        prints the commands that install it. Install the package
+        permanently first (npm install -g openmausbot).
 browser install: the bots' browser engine (agent-browser, pinned) into the
         data dir, and Chrome for Testing into the user's browser cache.
         --with-deps also installs
@@ -1013,6 +1023,18 @@ export async function main(argv = process.argv.slice(2)) {
             return runLogin(options);
         case "access":
             return runAccess(options);
+        case "service":
+            return runServiceCommand({
+                action: options.serviceAction ?? "install",
+                dataDir: options.dataDir,
+                port: options.port,
+                domain: options.domain,
+                tunnel: options.tunnel,
+                tailscale: options.tailscale,
+                label: options.label,
+                script: process.argv[1] ?? "",
+                node: process.execPath,
+            }, { log: (line) => console.log(line), error: (line) => console.error(line) });
         case "logout":
             return runLogout(options);
         case "browser":

package/dist-server/server/config.js

@@ -5,6 +5,7 @@ import { readFileSync, mkdirSync, existsSync, renameSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { z } from "zod";
+import { normalizeImageGenerationUrl } from "../shared/image-generation.js";
 import { writeFileAtomic } from "./atomic.js";
 import { EFFORT_LEVELS } from "./contracts.js";
 import { parseStoredMcpServer } from "./mcp-registry.js";
@@ -16,6 +17,8 @@ const BROWSER_PROFILE_ID = /^[a-z0-9_-]{1,40}$/;
 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;
+export const DEFAULT_MAX_CONCURRENT_BOT_THREADS = 3;
+export const MAX_CONCURRENT_BOT_THREADS = 10;
 export const DEFAULT_LOCAL_VM_MODE = "shared";
 export const DEFAULT_LOCAL_VM_MAX_INSTANCES = 2;
 export const MIN_LOCAL_VM_MAX_INSTANCES = 1;
@@ -245,14 +248,31 @@ const appConfigSchema = z.object({
      * engine: "elevenlabs" (default; needs a key) or "system" (the Mac's
      * built-in voices, no key). */
     tts: z.object({ key: optionalText, voice: optionalText, provider: z.enum(["elevenlabs", "system"]).optional() }).optional(),
-    /** OpenAI key used only by the in-process avatar image generator. */
-    imageGen: z.object({ key: optionalText }).optional(),
+    /** Avatar provider credentials stay separate; choosing a router never reuses a cloud key. */
+    imageGen: z.object({
+        provider: z.enum(["openai", "xai", "custom"]).optional(),
+        key: optionalText,
+        customApiKey: optionalText,
+        customUrl: z.string().trim().max(2048).transform((value, ctx) => {
+            if (!value)
+                return "";
+            try {
+                return normalizeImageGenerationUrl(value);
+            }
+            catch (error) {
+                ctx.addIssue({ code: "custom", message: error.message });
+                return z.NEVER;
+            }
+        }).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(),
     /** UI language override (BCP-47, lowercase). Empty/absent = follow the
      * system language. Unknown tags degrade to English in the renderer. */
     language: optionalText,
     rooms: roomConfigSchema.optional(),
+    threads: z.object({ maxConcurrentPerBot: z.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS) }).strict().optional(),
     localVm: localVmConfigSchema.optional(),
     features: featureConfigSchema.optional(),
     browserProfiles: browserProfilesSchema.optional(),
@@ -349,6 +369,9 @@ export function vpsSshAlias(cfg) {
 export function roomTurnTimeoutMinutes(cfg) {
     return cfg.rooms?.turnTimeoutMinutes ?? DEFAULT_ROOM_TURN_TIMEOUT_MINUTES;
 }
+export function maxConcurrentBotThreads(cfg) {
+    return cfg.threads?.maxConcurrentPerBot ?? DEFAULT_MAX_CONCURRENT_BOT_THREADS;
+}
 export function localVmMode(cfg) {
     return cfg.localVm?.mode ?? DEFAULT_LOCAL_VM_MODE;
 }
@@ -427,6 +450,8 @@ export function loadConfig() {
     cfg.imageGen = { ...cfg.imageGen };
     if (process.env.OMB_OPENAI_IMAGE_KEY !== undefined)
         cfg.imageGen.key = process.env.OMB_OPENAI_IMAGE_KEY;
+    if (process.env.OMB_CUSTOM_IMAGE_KEY !== undefined)
+        cfg.imageGen.customApiKey = process.env.OMB_CUSTOM_IMAGE_KEY;
     // The sign-in allow-list: env is how a headless box or a container is
     // bootstrapped before anyone can reach Settings.
     const splitEmails = (value) => value.split(/[,\s]+/).map((entry) => entry.trim().toLowerCase()).filter(Boolean);
@@ -455,6 +480,7 @@ export function syncCredentialEnv(patch) {
         [patch.opencodeGo?.apiKey, "OPENCODE_API_KEY"],
         [patch.tts?.key, "OMB_TTS_KEY"],
         [patch.imageGen?.key, "OMB_OPENAI_IMAGE_KEY"],
+        [patch.imageGen?.customApiKey, "OMB_CUSTOM_IMAGE_KEY"],
     ];
     for (const [value, name] of secrets) {
         if (value === undefined)
@@ -493,6 +519,7 @@ export const WORKSPACE_CREDENTIAL_ENV = [
     "OPENCODE_API_KEY",
     "OMB_TTS_KEY",
     "OMB_OPENAI_IMAGE_KEY",
+    "OMB_CUSTOM_IMAGE_KEY",
     "COMPOSIO_API_KEY",
     "OMB_COMPOSIO_BROKER_TOKEN",
     // Harness-private filesystem hints are not credentials themselves, but
@@ -544,7 +571,7 @@ export function saveConfig(patch, options = {}) {
     const storedProfiles = storedBrowserProfilesSchema.safeParse(disk.browserProfiles);
     if (storedProfiles.success)
         disk.browserProfiles = storedProfiles.data;
-    for (const key of ["xai", "openaiCompat", "composio", "box", "opencodeGo", "tts", "imageGen", "profile", "rooms", "localVm", "features"]) {
+    for (const key of ["xai", "openaiCompat", "composio", "box", "opencodeGo", "tts", "imageGen", "profile", "rooms", "threads", "localVm", "features"]) {
         const section = checkedPatch[key];
         if (!section)
             continue;

package/dist-server/server/delegations.js

@@ -251,7 +251,10 @@ export function queueDelegation(bus, from, item, maxDepth, sourceThreadId = from
  * of the target turn is delegated to `runTarget` so delegations.ts
  * stays free of harness-level concerns (commsDepth is the only thing
  * the caller needs). */
-export function drainDelegations(bus, approvalBus, threadId, runTarget) {
+export function drainDelegations(bus, approvalBus, threadId, runTarget, 
+/** Terminal failures before dispatch also need to wake the source. A
+ * launched peer reports through its provider-turn finalizer instead. */
+onSettled) {
     if (drainingThreads.has(threadId)) {
         queuedRedrains.add(threadId);
         return;
@@ -263,6 +266,10 @@ export function drainDelegations(bus, approvalBus, threadId, runTarget) {
     drainingThreads.add(threadId);
     void (async () => {
         for (const item of snapshot) {
+            // Stop/deletion may remove queued work while another item awaits a
+            // person's approval. A stale snapshot is never authority to launch it.
+            if (!pendingDelegations.get(threadId)?.some((candidate) => candidate.id === item.id))
+                continue;
             // A shared channel's thread is not owned by any single bot, so each
             // queued item carries its own source bot identity.
             const from = bus.store.botByThread(threadId) ??
@@ -307,8 +314,19 @@ export function drainDelegations(bus, approvalBus, threadId, runTarget) {
             finally {
                 // A requeued item (busy target, retries left) stays for the drain
                 // that the target's own settling turn will trigger.
+                const stillQueued = pendingDelegations.get(threadId)?.some((candidate) => candidate.id === item.id);
                 if (outcome !== "requeued")
                     acknowledgeDelegation(threadId, item.id);
+                if (outcome === "settled" && stillQueued) {
+                    const receipt = findDelegationReceipt(item.id);
+                    try {
+                        if (receipt)
+                            onSettled?.(receipt);
+                    }
+                    catch (error) {
+                        console.error("delegation settled but its source could not be resumed", error);
+                    }
+                }
             }
         }
     })().finally(() => {
@@ -321,7 +339,7 @@ export function drainDelegations(bus, approvalBus, threadId, runTarget) {
         const snapshotIds = new Set(snapshot.map((item) => item.id));
         const hasNewItems = pendingDelegations.get(threadId)?.some((item) => !snapshotIds.has(item.id)) ?? false;
         if (redrainRequested || hasNewItems) {
-            drainDelegations(bus, approvalBus, threadId, runTarget);
+            drainDelegations(bus, approvalBus, threadId, runTarget, onSettled);
         }
     });
 }
@@ -368,6 +386,19 @@ export function discardDelegations(bus, threadId) {
 async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarget) {
     let sender = from;
     let target = bus.store.bot(item.toBotId);
+    // Retained approval authorizes the message, not a deleted conversation or
+    // revoked room membership. Check every retry before writing to its source.
+    if (!sourceThreadBelongsToBot(bus.store, sender.id, sourceThreadId)) {
+        recordDelegationReceipt({
+            id: item.id,
+            sourceThreadId,
+            toBotId: item.toBotId,
+            toBotName: target?.name ?? item.toBotId,
+            status: "dropped",
+            result: "the source conversation no longer belongs to the delegating bot",
+        });
+        return "settled";
+    }
     if (!target) {
         recordDelegationReceipt({
             id: item.id,
@@ -422,6 +453,23 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     }
     if (sender.approvePeerComms && !item.approvalAlreadyGranted) {
         const verdict = await requestPeerApproval(approvalBus, sender, target, item.message, "delegate_bot", sourceThreadId);
+        if (!pendingDelegations.get(sourceThreadId)?.some((candidate) => candidate.id === item.id))
+            return "settled";
+        // Approval may have waited for minutes. Revalidate before even reporting
+        // a denial, which otherwise recreates a deleted source transcript.
+        const current = bus.store.bot(item.toBotId);
+        const currentSender = bus.store.bot(from.id);
+        if (!current || !currentSender || !sourceThreadBelongsToBot(bus.store, currentSender.id, sourceThreadId)) {
+            recordDelegationReceipt({
+                id: item.id,
+                sourceThreadId,
+                toBotId: item.toBotId,
+                toBotName: target.name,
+                status: "dropped",
+                result: "the peer or source conversation no longer exists",
+            });
+            return "settled";
+        }
         if (verdict !== "allow") {
             recordDelegationReceipt({
                 id: item.id,
@@ -438,14 +486,11 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
             });
             return "settled";
         }
-        // The approval could have been sitting for up to 15 minutes. Everything
-        // checked above is a stale snapshot now: re-read both bots and re-check
-        // busy, or an allow can start a second turn on a bot that is mid-turn —
-        // and mirror a "Messaged @X" chip for an exchange that never happens.
-        const current = bus.store.bot(item.toBotId);
-        const currentSender = bus.store.bot(from.id);
-        if (!current || !currentSender || !sourceThreadBelongsToBot(bus.store, currentSender.id, sourceThreadId))
-            return "settled";
+        // A busy-target retry must not ask for the very same approval again.
+        item.approvalAlreadyGranted = true;
+        savePending();
+        // Recheck peer access and busy state too: an approval must not start a
+        // second turn or mirror an exchange that cannot actually happen.
         if (dropIfUnreachable(bus, currentSender, current, sourceThreadId, item)) {
             return "settled";
         }
@@ -490,7 +535,7 @@ async function processOne(bus, approvalBus, from, sourceThreadId, item, runTarge
     const reasonLine = item.reason ? `\n\n[Reason: ${item.reason}]` : "";
     const prefixed = `[Delegated by @${sender.name}, another bot in this OpenMausBot workspace. Do the work and reply directly.]\n\n${item.message}${reasonLine}`;
     await runTarget(item.toBotId, prefixed, item.depth + 1, sourceThreadId, channel, item.id, sender.id);
-    return "settled";
+    return "dispatched";
 }
 /** The source thread may be a bot's own task or a shared group where the
  * bot is a member. This is the same check the API gate uses for group turns. */