openmausbot 0.1.79 → 0.1.81

package/dist-server/openmausbot.js

@@ -17569,6 +17569,9 @@ var init_image_generation = __esm({
 });
 
 // server/contracts.ts
+function isModelVariant(value) {
+  return typeof value === "string" && value.length > 0 && value.length <= 256 && value.trim() === value && !new RegExp("\\p{Cc}", "u").test(value);
+}
 var EFFORT_LEVELS, eventCounter, newEventId, newId;
 var init_contracts = __esm({
   "server/contracts.ts"() {
@@ -17584,21 +17587,31 @@ var init_contracts = __esm({
 function isHarnessOwnedMcpEnvName(name) {
   return name === "ELECTRON_RUN_AS_NODE" || name.startsWith("OMB_") || name.startsWith("OGB_");
 }
-var MAX_ARGS, storedEntrySchema, mutationEntrySchema;
+var MAX_ARGS, stdioEntrySchema, stdioMutationSchema, remoteEntrySchema, remoteMutationSchema;
 var init_mcp_registry = __esm({
   "server/mcp-registry.ts"() {
     "use strict";
     init_zod();
     MAX_ARGS = 64;
-    storedEntrySchema = external_exports.object({
+    stdioEntrySchema = external_exports.object({
       command: external_exports.string().trim().min(1).max(1024),
       args: external_exports.array(external_exports.string().max(4096)).max(MAX_ARGS).optional(),
       env: external_exports.record(external_exports.string(), external_exports.string().max(16384)).optional(),
       enabled: external_exports.boolean().optional()
     }).strict();
-    mutationEntrySchema = storedEntrySchema.extend({
+    stdioMutationSchema = stdioEntrySchema.extend({
       env: external_exports.record(external_exports.string(), external_exports.union([external_exports.string().max(16384), external_exports.literal(true)])).optional()
     });
+    remoteEntrySchema = external_exports.object({
+      /** Streamable HTTP unless the entry says the older SSE transport. */
+      type: external_exports.enum(["http", "sse"]).optional(),
+      url: external_exports.string().trim().min(1).max(2048),
+      headers: external_exports.record(external_exports.string(), external_exports.string().max(16384)).optional(),
+      enabled: external_exports.boolean().optional()
+    }).strict();
+    remoteMutationSchema = remoteEntrySchema.extend({
+      headers: external_exports.record(external_exports.string(), external_exports.union([external_exports.string().max(16384), external_exports.literal(true)])).optional()
+    });
   }
 });
 
@@ -17775,6 +17788,7 @@ function loadConfig() {
   if (process.env.OPENCODE_API_KEY !== void 0) cfg.opencodeGo.apiKey = process.env.OPENCODE_API_KEY;
   cfg.tts = { ...cfg.tts };
   if (process.env.OMB_TTS_KEY !== void 0) cfg.tts.key = process.env.OMB_TTS_KEY;
+  if (process.env.OMB_FISH_AUDIO_API_KEY !== void 0) cfg.tts.fishKey = process.env.OMB_FISH_AUDIO_API_KEY;
   cfg.imageGen = { ...cfg.imageGen };
   if (process.env.OMB_OPENAI_IMAGE_KEY !== void 0) cfg.imageGen.key = process.env.OMB_OPENAI_IMAGE_KEY;
   if (process.env.OMB_CUSTOM_IMAGE_KEY !== void 0) cfg.imageGen.customApiKey = process.env.OMB_CUSTOM_IMAGE_KEY;
@@ -17923,7 +17937,7 @@ function instanceConfigs(cfg) {
   }
   return map3;
 }
-var optionalText, SSH_ALIAS, LEGACY_BROWSER_PROFILE_ID, BROWSER_PROFILE_ID, MIN_ROOM_TURN_TIMEOUT_MINUTES, MAX_ROOM_TURN_TIMEOUT_MINUTES, MAX_CONCURRENT_BOT_THREADS, MIN_LOCAL_VM_MAX_INSTANCES, MAX_LOCAL_VM_MAX_INSTANCES, vpsConfigSchema, roomConfigSchema, localVmConfigSchema, browserProfileSchema, legacyBrowserProfileSchema, legacyBrowserProfilesSchema, storedBrowserProfilesSchema, browserProfilesSchema, featureConfigSchema, onboardingConfigSchema, instanceConfigSchema, instanceConfigMapSchema, defaultModelSelectionSchema, appConfigSchema, storedAppConfigSchema, appConfigPatchSchema, jsonObjectSchema, DATA_DIR, LEGACY_DATA_DIR, EVENTS_DIR, NATIVE_DIR, WORKSPACE_CREDENTIAL_ENV, PROVIDER_CREDENTIAL_ENV;
+var optionalText, SSH_ALIAS, LEGACY_BROWSER_PROFILE_ID, BROWSER_PROFILE_ID, MIN_ROOM_TURN_TIMEOUT_MINUTES, MAX_ROOM_TURN_TIMEOUT_MINUTES, MAX_CONCURRENT_BOT_THREADS, MIN_THREAD_EVENT_LOG_BYTES, MAX_THREAD_EVENT_LOG_BYTES, MIN_LOCAL_VM_MAX_INSTANCES, MAX_LOCAL_VM_MAX_INSTANCES, vpsConfigSchema, roomConfigSchema, localVmConfigSchema, browserProfileSchema, legacyBrowserProfileSchema, legacyBrowserProfilesSchema, storedBrowserProfilesSchema, browserProfilesSchema, featureConfigSchema, onboardingConfigSchema, instanceConfigSchema, instanceConfigMapSchema, defaultModelSelectionSchema, appConfigSchema, storedAppConfigSchema, appConfigPatchSchema, jsonObjectSchema, DATA_DIR, LEGACY_DATA_DIR, EVENTS_DIR, NATIVE_DIR, WORKSPACE_CREDENTIAL_ENV, PROVIDER_CREDENTIAL_ENV;
 var init_config = __esm({
   "server/config.ts"() {
     "use strict";
@@ -17940,6 +17954,8 @@ var init_config = __esm({
     MIN_ROOM_TURN_TIMEOUT_MINUTES = 1;
     MAX_ROOM_TURN_TIMEOUT_MINUTES = 1440;
     MAX_CONCURRENT_BOT_THREADS = 10;
+    MIN_THREAD_EVENT_LOG_BYTES = 256 * 1024;
+    MAX_THREAD_EVENT_LOG_BYTES = 4 * 1024 * 1024 * 1024;
     MIN_LOCAL_VM_MAX_INSTANCES = 1;
     MAX_LOCAL_VM_MAX_INSTANCES = 4;
     vpsConfigSchema = external_exports.object({
@@ -17999,7 +18015,11 @@ var init_config = __esm({
       /** Opt-in computer sharing (a desktop lending folders, a terminal or
        * computer control to a workspace). Off until explicitly enabled; there is
        * no Settings toggle — see sharedComputersEnabled. */
-      sharedComputers: external_exports.boolean().optional()
+      sharedComputers: external_exports.boolean().optional(),
+      /** Claude bots also load the MCP servers and connectors from this
+       * machine's own Claude Code setup (Plugins → MCP servers switch). Off by
+       * default: each extra tool costs tokens on every model call. */
+      claudeUserMcp: external_exports.boolean().optional()
     });
     onboardingConfigSchema = external_exports.object({
       /** ISO timestamp of finishing (or skipping to the end of) the welcome flow. */
@@ -18021,8 +18041,12 @@ var init_config = __esm({
     defaultModelSelectionSchema = external_exports.object({
       instanceId: external_exports.string().trim().min(1),
       model: external_exports.string().trim().min(1),
-      effort: external_exports.enum(EFFORT_LEVELS).optional()
-    });
+      effort: external_exports.enum(EFFORT_LEVELS).optional(),
+      variant: external_exports.string().refine(isModelVariant, "invalid model variant").optional()
+    }).refine(
+      (selection) => selection.variant === void 0 || selection.effort === void 0,
+      "choose either a model variant or an effort level"
+    );
     appConfigSchema = external_exports.object({
       /** Verified by the dedicated domain endpoint, never a generic config patch. */
       customDomain: external_exports.string().optional(),
@@ -18071,13 +18095,16 @@ var init_config = __esm({
       /** Optional OpenCode key; persisted write-only and passed only to its child. */
       opencodeGo: external_exports.object({ apiKey: optionalText }).optional(),
       /** Voice settings and the selected voice id. `provider` picks the
-       * engine: "elevenlabs" (default; needs a key), "system" (the Mac's
-       * built-in voices, no key), or "chatterbox" (a local OpenAI-compatible
-       * Chatterbox server; `baseUrl` and `model` are settings, not secrets). */
+       * engine: "elevenlabs" (default; needs `key`), "fish" (needs its own
+       * `fishKey`), "system" (the Mac's built-in voices, no 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. */
       tts: external_exports.object({
         key: optionalText,
+        fishKey: optionalText,
         voice: optionalText,
-        provider: external_exports.enum(["elevenlabs", "system", "chatterbox"]).optional(),
+        provider: external_exports.enum(["elevenlabs", "fish", "system", "chatterbox"]).optional(),
         baseUrl: external_exports.string().trim().max(2048).refine((value) => !value || /^https?:\/\//i.test(value), "the Chatterbox server address must start with http:// or https://").optional(),
         model: optionalText
       }).optional(),
@@ -18106,7 +18133,12 @@ var init_config = __esm({
        * system language. Unknown tags degrade to English in the renderer. */
       language: optionalText,
       rooms: roomConfigSchema.optional(),
-      threads: external_exports.object({ maxConcurrentPerBot: external_exports.number().int().min(1).max(MAX_CONCURRENT_BOT_THREADS) }).strict().optional(),
+      threads: external_exports.object({
+        maxConcurrentPerBot: external_exports.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: external_exports.number().int().min(MIN_THREAD_EVENT_LOG_BYTES).max(MAX_THREAD_EVENT_LOG_BYTES).optional()
+      }).strict().optional(),
       localVm: localVmConfigSchema.optional(),
       features: featureConfigSchema.optional(),
       onboarding: onboardingConfigSchema.optional(),
@@ -18136,6 +18168,7 @@ var init_config = __esm({
       "BOX_TOKEN",
       "OPENCODE_API_KEY",
       "OMB_TTS_KEY",
+      "OMB_FISH_AUDIO_API_KEY",
       "OMB_OPENAI_IMAGE_KEY",
       "OMB_CUSTOM_IMAGE_KEY",
       "COMPOSIO_API_KEY",
@@ -19049,7 +19082,7 @@ var init_registry = __esm({
         this.npmPresent = options.npmAvailable ?? npmAvailable;
         this.driversByKind = new Map(drivers.map((d) => [d.driverKind, d]));
       }
-      async load(configs) {
+      async load(configs, decorate) {
         for (const [instanceId, entry] of Object.entries(configs)) {
           await this.dispose(instanceId);
           const driver = this.driversByKind.get(entry.driver);
@@ -19078,7 +19111,7 @@ var init_registry = __esm({
               enabled: entry.enabled ?? true,
               config: config2
             });
-            this.byId.set(instanceId, { instanceId, live });
+            this.byId.set(instanceId, { instanceId, live: decorate ? decorate(live) : live });
           } catch (e) {
             this.byId.set(instanceId, {
               instanceId,
@@ -19212,6 +19245,7 @@ var init_registry = __esm({
                 browserMcp: inst.adapter.capabilities.browserMcp === true,
                 images: inst.adapter.capabilities.images === true,
                 effortLevels: inst.adapter.capabilities.effortLevels,
+                modelVariants: inst.adapter.capabilities.modelVariants === true,
                 queueing: inst.adapter.capabilities.queueing === true,
                 localComputerMcp: inst.adapter.capabilities.localComputerMcp === true,
                 approvalReview: inst.reviewPermission !== void 0
@@ -19600,6 +19634,8 @@ var init_redact = __esm({
     REDACTION_MARKER = /^«redacted \d+ chars»$/;
     mask = (value) => REDACTION_MARKER.test(value) ? value : `\xABredacted ${value.length} chars\xBB`;
     KEY_PREFIXES = [
+      /\bom[dg]_[A-Za-z0-9_-]{43}(?![A-Za-z0-9_-])/g,
+      // desktop device and model-only credentials
       /\bsk-(?:ant-|proj-|live-|test-)?[A-Za-z0-9_-]{16,}/g,
       // anthropic / openai / stripe
       /\bxai-[A-Za-z0-9_-]{20,}/g,
@@ -19632,16 +19668,84 @@ var init_redact = __esm({
   }
 });
 
+// server/thread-log-rotation.ts
+import { closeSync as closeSync4, fstatSync, openSync as openSync4, readSync as readSync2, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync3, writeSync } from "node:fs";
+function currentThreadLogCap() {
+  try {
+    return capProvider();
+  } catch {
+    return null;
+  }
+}
+function capThreadLog(file2, maxBytes) {
+  if (typeof maxBytes !== "number" || !Number.isFinite(maxBytes) || maxBytes <= 0) return;
+  let size;
+  try {
+    size = statSync3(file2).size;
+  } catch {
+    return;
+  }
+  if (size <= maxBytes) return;
+  trimToTail(file2, Math.max(1, Math.floor(maxBytes / 2)));
+}
+function trimToTail(file2, keepBytes) {
+  const staging = `${file2}.trim`;
+  try {
+    const source = openSync4(file2, "r");
+    try {
+      const size = fstatSync(source).size;
+      const start = Math.max(0, size - keepBytes);
+      const window = Buffer.allocUnsafe(size - start);
+      let filled = 0;
+      while (filled < window.length) {
+        const count = readSync2(source, window, filled, window.length - filled, start + filled);
+        if (count === 0) return;
+        filled += count;
+      }
+      const firstNewline = window.indexOf(10);
+      if (firstNewline === -1 || firstNewline + 1 >= window.length) return;
+      const target = openSync4(staging, "w", 384);
+      try {
+        let written = firstNewline + 1;
+        while (written < window.length) {
+          const count = writeSync(target, window, written, window.length - written);
+          if (count === 0) throw new Error(`no progress writing ${staging}`);
+          written += count;
+        }
+      } finally {
+        closeSync4(target);
+      }
+    } finally {
+      closeSync4(source);
+    }
+    renameSync5(staging, file2);
+  } catch {
+    try {
+      rmSync4(staging, { force: true });
+    } catch {
+    }
+  }
+}
+var capProvider;
+var init_thread_log_rotation = __esm({
+  "server/thread-log-rotation.ts"() {
+    "use strict";
+    capProvider = () => null;
+  }
+});
+
 // server/drivers/native.ts
 import { appendFileSync as appendFileSync3 } from "node:fs";
 import { join as join12 } from "node:path";
 function appendNative(threadId, entry) {
+  const file2 = join12(NATIVE_DIR, `${threadId}.ndjson`);
   try {
     appendFileSync3(
-      join12(NATIVE_DIR, `${threadId}.ndjson`),
+      file2,
       JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry, msg: redactSecrets(entry.msg) }) + "\n",
       { mode: 384 }
     );
+    capThreadLog(file2, currentThreadLogCap());
   } catch {
   }
 }
@@ -19650,6 +19754,7 @@ var init_native = __esm({
     "use strict";
     init_config();
     init_redact();
+    init_thread_log_rotation();
   }
 });
 
@@ -19725,6 +19830,29 @@ import { basename as basename3, dirname as dirname5, isAbsolute, relative, resol
 function skipSubscriptionAuthForLocalInject(model) {
   return Boolean(decodeInjectId(model));
 }
+function acpVariantOption(result) {
+  const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find(
+    (entry) => entry?.type === "select" && typeof entry.id === "string" && (entry.id === "effort" || entry.category === "thought_level")
+  );
+  if (!option) return;
+  const options = [];
+  const seen = /* @__PURE__ */ new Set();
+  const collect = (entries) => {
+    if (!Array.isArray(entries)) return;
+    for (const entry of entries) {
+      if (typeof entry?.value === "string" && !seen.has(entry.value)) {
+        seen.add(entry.value);
+        options.push({ id: entry.value, label: typeof entry.name === "string" ? entry.name : entry.value });
+      } else if (Array.isArray(entry?.options)) collect(entry.options);
+    }
+  };
+  collect(option.options);
+  return {
+    configId: option.id,
+    options,
+    ...typeof option.currentValue === "string" ? { currentValue: option.currentValue } : {}
+  };
+}
 async function readAcpImageBlocks(images) {
   return Promise.all(images.map(async (image) => ({
     type: "image",
@@ -19900,6 +20028,10 @@ function createAcpDriver(support11) {
         }
         for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
           if (servers.some((existing) => existing.name === name)) continue;
+          if ("url" in server) {
+            servers.push({ type: server.type, name, url: server.url, headers: acpEnv(server.headers) });
+            continue;
+          }
           servers.push({ name, command: server.command, args: server.args, env: acpEnv(server.env) });
         }
         return servers;
@@ -19948,6 +20080,37 @@ function createAcpDriver(support11) {
         const asks = /* @__PURE__ */ new Map();
         let nextId = 1;
         let sessionId = null;
+        let sessionConfigResult = null;
+        const modelOf = (result) => {
+          const option = (Array.isArray(result?.configOptions) ? result.configOptions : []).find(
+            (entry) => entry?.id === (support11.selectModel?.configId ?? "model")
+          );
+          return typeof option?.currentValue === "string" ? option.currentValue : null;
+        };
+        const receiveModelVariants = (result) => {
+          sessionConfigResult = result;
+          if (!support11.modelVariants) return;
+          const nativeModel = modelOf(result) ?? cliTurn.model;
+          if (!nativeModel) return;
+          const option = acpVariantOption(result);
+          emit({
+            ...base2(threadId, turnId),
+            type: "session.model-variants",
+            model: nativeModel === cliTurn.model ? turn.model ?? nativeModel : nativeModel,
+            variants: {
+              options: option?.options ?? [],
+              ...option?.currentValue !== void 0 ? { currentValue: option.currentValue } : {}
+            }
+          });
+        };
+        const requestedVariantOption = () => {
+          if (!support11.modelVariants) throw new Error(`${support11.displayName} does not support model variants`);
+          const option = acpVariantOption(sessionConfigResult);
+          if (!option || !option.options.some((entry) => entry.id === turn.variant)) {
+            throw new Error(`${support11.displayName} does not advertise variant ${turn.variant} for this model`);
+          }
+          return option;
+        };
         let interruptTimer = null;
         const rpcPending = /* @__PURE__ */ new Map();
         const send = (obj) => {
@@ -19957,7 +20120,7 @@ function createAcpDriver(support11) {
           }
           appendNative(threadId, { dir: "out", source: SOURCE, msg: nativeLogMessage(obj) });
         };
-        const request = (method, params, timeoutMs) => new Promise((resolve12, reject) => {
+        const request = (method, params, timeoutMs, receive) => new Promise((resolve12, reject) => {
           const id = nextId++;
           let timer = null;
           if (timeoutMs) {
@@ -19967,7 +20130,16 @@ function createAcpDriver(support11) {
             }, timeoutMs);
             timer.unref?.();
           }
-          rpcPending.set(id, { resolve: resolve12, reject, timer });
+          rpcPending.set(id, {
+            // Consume configuration in wire order: an update following this
+            // response may arrive before the awaiting continuation resumes.
+            resolve: (result) => {
+              receive?.(result);
+              resolve12(result);
+            },
+            reject,
+            timer
+          });
           send({ jsonrpc: "2.0", id, method, params });
         });
         const stop = () => killCliTree(child);
@@ -20150,7 +20322,12 @@ function createAcpDriver(support11) {
         const handleNotification = (msg) => {
           if (msg.method !== "session/update") return;
           const p = msg.params ?? {};
-          if (!state.promptSent || p._meta?.isReplay === true) return;
+          if (p._meta?.isReplay === true) return;
+          if (support11.modelVariants && p.update?.sessionUpdate === "config_option_update") {
+            if (!state.settled && sessionId && p.sessionId === sessionId) receiveModelVariants(p.update);
+            return;
+          }
+          if (!state.promptSent) return;
           const u4 = p.update ?? {};
           switch (u4.sessionUpdate) {
             case "agent_message_chunk": {
@@ -20307,6 +20484,7 @@ function createAcpDriver(support11) {
                 `${support11.displayName} is configured for image attachments, but this installed runtime does not advertise ACP image input. Update the ${support11.displayName} CLI or send the message without an image.`
               );
             }
+            const sessionServers = mcpServers.filter((server) => !("type" in server) || init?.agentCapabilities?.mcpCapabilities?.[server.type] === true);
             const cursor3 = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
             if (!cursor3) sessionAllows.delete(threadId);
             let sessionResult = null;
@@ -20314,16 +20492,23 @@ function createAcpDriver(support11) {
               try {
                 sessionResult = await request(
                   support11.resumeMethod === "resume" ? "session/resume" : "session/load",
-                  { sessionId: cursor3, cwd, mcpServers },
-                  LOAD_SESSION_TIMEOUT
+                  { sessionId: cursor3, cwd, mcpServers: sessionServers },
+                  LOAD_SESSION_TIMEOUT,
+                  (result2) => {
+                    if (result2) {
+                      sessionId = cursor3;
+                      receiveModelVariants(result2);
+                    }
+                  }
                 );
-                if (sessionResult) sessionId = cursor3;
               } catch {
               }
             }
             if (!sessionId) {
-              sessionResult = await request("session/new", { cwd, mcpServers }, NEW_SESSION_TIMEOUT);
-              sessionId = typeof sessionResult?.sessionId === "string" ? sessionResult.sessionId : null;
+              sessionResult = await request("session/new", { cwd, mcpServers: sessionServers }, NEW_SESSION_TIMEOUT, (result2) => {
+                sessionId = typeof result2?.sessionId === "string" ? result2.sessionId : null;
+                receiveModelVariants(result2);
+              });
               if (!sessionId) throw new Error("session/new returned no sessionId");
             }
             let selectedModel = null;
@@ -20341,16 +20526,15 @@ function createAcpDriver(support11) {
             try {
               if (support11.selectModel) {
                 const { configId } = support11.selectModel;
-                const currentOf = (r2) => (Array.isArray(r2?.configOptions) ? r2.configOptions : []).find((o) => o?.id === configId)?.currentValue ?? null;
-                selectedModel = currentOf(sessionResult);
+                selectedModel = modelOf(sessionConfigResult);
                 if (cliTurn.model && cliTurn.model !== selectedModel) {
-                  selectedModel = currentOf(
-                    await request(
-                      "session/set_config_option",
-                      { sessionId, configId, value: cliTurn.model },
-                      INIT_TIMEOUT
-                    )
+                  sessionResult = await request(
+                    "session/set_config_option",
+                    { sessionId, configId, value: cliTurn.model },
+                    INIT_TIMEOUT,
+                    receiveModelVariants
                   );
+                  selectedModel = modelOf(sessionConfigResult);
                   if (selectedModel !== cliTurn.model) {
                     throw new Error(
                       `${DRIVER_KIND8} did not switch to ${cliTurn.model} (still ${selectedModel ?? "unknown"})`
@@ -20368,16 +20552,34 @@ function createAcpDriver(support11) {
                 });
                 if (!selectedModel && cliTurn.model) selectedModel = cliTurn.model;
               }
+              if (turn.variant !== void 0) {
+                const option = requestedVariantOption();
+                await request(
+                  "session/set_config_option",
+                  { sessionId, configId: option.configId, value: turn.variant },
+                  SESSION_CONFIG_TIMEOUT,
+                  receiveModelVariants
+                );
+                if (requestedVariantOption().currentValue !== turn.variant) {
+                  throw new Error(`${support11.displayName} did not apply variant ${turn.variant}`);
+                }
+              }
             } catch (error51) {
               emitSessionStarted();
               throw error51;
             }
             emitSessionStarted();
-            state.promptSent = true;
             const text4 = support11.buildPromptText ? support11.buildPromptText(turn) : turn.system ? `${turn.system}
 
 ${turn.text}` : turn.text;
             const imageBlocks = support11.images === true && runtimeAcceptsImages ? await readAcpImageBlocks(images) : [];
+            if (support11.modelVariants && cliTurn.model && modelOf(sessionConfigResult) !== cliTurn.model) {
+              throw new Error(`${support11.displayName} changed model before the prompt`);
+            }
+            if (turn.variant !== void 0 && requestedVariantOption().currentValue !== turn.variant) {
+              throw new Error(`${support11.displayName} changed variant before the prompt`);
+            }
+            state.promptSent = true;
             const result = await request("session/prompt", {
               sessionId,
               prompt: [{ type: "text", text: text4 }, ...imageBlocks]
@@ -20456,6 +20658,7 @@ ${turn.text}` : turn.text;
             images: support11.images !== false,
             nativeImageInput: support11.images === true,
             effortLevels: support11.effortLevels,
+            modelVariants: support11.modelVariants === true,
             // OpenMausBot supplies a per-bot approvalMode on every harness
             // turn, which safely overrides a legacy instance fullAuto value.
             // Direct adapter calls that omit it still fail closed in sendTurn.
@@ -22513,7 +22716,7 @@ var init_ask_question = __esm({
 
 // server/drivers/claude.ts
 import { createHash as createHash5, randomBytes as randomBytes2 } from "node:crypto";
-import { chmodSync as chmodSync4, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync4, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
+import { chmodSync as chmodSync4, mkdtempSync as mkdtempSync2, readFileSync as readFileSync7, rmSync as rmSync5, unlinkSync as unlinkSync3, writeFileSync as writeFileSync5 } from "node:fs";
 import { createServer as createNetServer } from "node:net";
 import { homedir as homedir9, tmpdir as tmpdir3 } from "node:os";
 import { join as join18, dirname as dirname9, isAbsolute as isAbsolute4, normalize } from "node:path";
@@ -22577,6 +22780,13 @@ function claudeEnvironment(model, source = process.env, configDir, instanceEnvir
 function inheritsUserConfig(env) {
   return env.OMB_CLAUDE_INHERIT_USER_CONFIG === "1";
 }
+function claudeInheritWarning(env) {
+  if (!inheritsUserConfig(env)) return void 0;
+  return {
+    title: "Bots inherit this machine's Claude Code setup",
+    message: "OMB_CLAUDE_INHERIT_USER_CONFIG=1 is set on the OpenMausBot process, so every Claude bot also loads this computer's own MCP servers, connectors, skills, hooks and personal CLAUDE.md on every turn \u2014 often thousands of extra tokens per model call, and tools nobody gave the bot. Unless a bot genuinely needs a server from your user-scope Claude config, remove the variable and restart; add the server under Settings \u2192 MCP servers or the bot project's .mcp.json instead."
+  };
+}
 function readClaudeAuthSettings(env, instanceEnvironment = {}) {
   if (CLAUDE_ACCOUNT_ENV_KEYS.some((key) => instanceEnvironment[key])) return {};
   try {
@@ -22637,21 +22847,17 @@ function claudeCliUpdate(version2, cli) {
   if (!parsed || versionAtLeast(parsed, CLAUDE_CONTEXT_CONTROL_MIN_VERSION)) return void 0;
   const floor = CLAUDE_CONTEXT_CONTROL_MIN_VERSION.join(".");
   const missing = Object.keys(CLAUDE_FLAG_FLOORS).filter((flag) => !claudeCliSupports(parsed, flag));
+  const effects = [
+    ...missing.includes("--autocompact") ? ["no compaction window picked by OpenMausBot"] : [],
+    ...missing.includes("--setting-sources") ? ["bots still see this machine's own Claude Code setup"] : [],
+    ...missing.includes("--system-prompt-snapshot") ? ["coordinated resumed turns cannot refresh stale system prompts"] : []
+  ];
   return {
     title: "Update Claude Code for context controls",
-    message: `Claude Code ${parsed.join(".")} predates ${floor}, so bots run without ${missing.join(", ")}: no compaction window picked by OpenMausBot` + (missing.includes("--setting-sources") ? ", and bots still see this machine's own Claude Code setup" : "") + ". Update it, then refresh Engines.",
+    message: `Claude Code ${parsed.join(".")} predates ${floor}, so bots run without ${missing.join(", ")}: ${effects.join("; ")}. Update it, then refresh Engines.`,
     command: cli === "claude" ? "claude update" : `${cli} update`
   };
 }
-function claudeCliHelpSupportsFlag(help, flag) {
-  if (!help) return false;
-  const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`^\\s*${escaped}\\b`, "m").test(help);
-}
-function claudeAutoCompactSupported(version2, help) {
-  if (help !== null) return claudeCliHelpSupportsFlag(help, "--autocompact");
-  return claudeCliSupports(version2, "--autocompact");
-}
 async function resolveClaudeTurnModel(model, env) {
   if (!model || decodeInjectId(model) || STATIC_CLAUDE_MODELS.options.some((option) => option.id === model)) {
     return model;
@@ -22699,7 +22905,7 @@ function readClaudeModelCatalog(env = process.env) {
 function removePrivateTempDir(filePath) {
   if (!filePath) return true;
   try {
-    rmSync4(dirname9(filePath), { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
+    rmSync5(dirname9(filePath), { recursive: true, force: true, maxRetries: 3, retryDelay: 50 });
     return true;
   } catch {
     return false;
@@ -22914,6 +23120,7 @@ function decodeConfig2(raw) {
   return {
     cli: typeof o.cli === "string" ? o.cli : "claude",
     ...configDir ? { configDir } : {},
+    ...o.managed === true ? { managed: true } : {},
     permissionMode: mode ?? "acceptEdits",
     ...tools !== void 0 ? { tools } : {},
     ...disallowedTools !== void 0 ? { disallowedTools } : {}
@@ -23003,9 +23210,12 @@ var init_claude = __esm({
     CLAUDE_FLAG_FLOORS = {
       "--strict-mcp-config": [1, 0, 60],
       "--setting-sources": [1, 0, 122],
-      "--autocompact": [2, 1, 122]
+      "--autocompact": [2, 1, 122],
+      // 2.1.267 is the first CLI that accepts it; below that the recorded prompt
+      // simply is not refreshed, which is the pre-existing behaviour.
+      "--system-prompt-snapshot": [2, 1, 267]
     };
-    CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--autocompact"];
+    CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--system-prompt-snapshot"];
     DRIVER_KIND2 = "claudeAgent";
     STATIC_CLAUDE_MODELS = {
       default: "claude-sonnet-5",
@@ -23044,10 +23254,14 @@ var init_claude = __esm({
       defaultConfig: () => decodeConfig2({}),
       async create(input) {
         const { instanceId, config: config2 } = input;
-        const environment = (model) => claudeEnvironment(model, { ...process.env, ...input.environment }, config2.configDir, input.environment);
+        const environment = (model) => claudeEnvironment(config2.managed ? void 0 : model, { ...process.env, ...input.environment }, config2.configDir, input.environment);
         const catalogEnv = environment();
+        if (inheritsUserConfig(catalogEnv)) {
+          console.error(`claude (${instanceId}): OMB_CLAUDE_INHERIT_USER_CONFIG=1 \u2014 bots inherit this machine's Claude Code MCP servers, skills, hooks and CLAUDE.md on every turn; remove it unless a bot needs a user-scope server`);
+        }
         let models2 = STATIC_CLAUDE_MODELS;
         const refreshModels = async () => {
+          if (config2.managed) return;
           try {
             const resolved = await mergeLocalInject(readClaudeModelCatalog(catalogEnv), catalogEnv);
             if (resolved.options.length) models2 = resolved;
@@ -23056,8 +23270,15 @@ var init_claude = __esm({
         };
         await refreshModels();
         let cliVersion = null;
-        let cliHelp = null;
-        let cliHelpVersion = null;
+        let cliVersionChecked = false;
+        const readCliVersion = (env) => new Promise((resolve12) => {
+          execCli(
+            config2.cli,
+            ["--version"],
+            { timeout: 8e3, env },
+            (err, stdout2) => resolve12(err ? null : stdout2.trim() || null)
+          );
+        });
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const sessions = /* @__PURE__ */ new Map();
@@ -23124,6 +23345,9 @@ var init_claude = __esm({
         });
         const retryState = /* @__PURE__ */ new Map();
         const sendTurn = async (turn, logicalTurnId) => {
+          if (config2.managed && (!turn.model || turn.model.includes("::") || !config2.configDir || !input.environment.ANTHROPIC_API_KEY || !input.environment.ANTHROPIC_BASE_URL)) {
+            throw new Error("Company model access is unavailable. Reconnect your organization; personal billing will not be used.");
+          }
           const { threadId, botId } = turn;
           const relaunch = logicalTurnId !== void 0;
           if (active.has(threadId) && !relaunch) throw new Error("a turn is already running on this thread");
@@ -23160,17 +23384,27 @@ var init_claude = __esm({
             args.push("--disallowedTools", config2.disallowedTools.join(","));
           }
           const turnEnvironment = environment();
+          if (turn.refreshSystemPrompt && !cliVersionChecked) {
+            const version2 = await readCliVersion(turnEnvironment);
+            if (version2) {
+              cliVersion = parseClaudeCliVersion(version2);
+              cliVersionChecked = true;
+            }
+          }
           const isolated = !inheritsUserConfig(turnEnvironment);
           if (isolated) {
-            if (claudeCliSupports(cliVersion, "--strict-mcp-config")) args.push("--strict-mcp-config");
+            if (!turn.mcpFromUserConfig && claudeCliSupports(cliVersion, "--strict-mcp-config")) args.push("--strict-mcp-config");
             if (claudeCliSupports(cliVersion, "--setting-sources")) args.push("--setting-sources", "project");
           }
           const compactWindow = autoCompactWindow(turnEnvironment);
-          if (compactWindow && claudeAutoCompactSupported(cliVersion, cliHelp)) {
+          if (compactWindow && claudeCliSupports(cliVersion, "--autocompact")) {
             args.push("--autocompact", compactWindow);
           }
-          const turnModel = await resolveClaudeTurnModel(turn.model, turnEnvironment);
-          const injected = applyClaudeInject({ ...turnEnvironment }, turnModel);
+          if (turn.refreshSystemPrompt && cliVersionChecked && claudeCliSupports(cliVersion, "--system-prompt-snapshot")) {
+            args.push("--system-prompt-snapshot", "off");
+          }
+          const turnModel = config2.managed ? turn.model : await resolveClaudeTurnModel(turn.model, turnEnvironment);
+          const injected = config2.managed ? { model: turnModel ?? null, injected: false } : applyClaudeInject({ ...turnEnvironment }, turnModel);
           if (injected.model) args.push("--model", injected.model);
           if (turn.effort) args.push("--effort", turn.effort);
           let systemPromptPath = null;
@@ -23289,7 +23523,7 @@ var init_claude = __esm({
               retryState.delete(threadId);
               if (mcpConfigPath) {
                 try {
-                  rmSync4(dirname9(mcpConfigPath), { recursive: true, force: true });
+                  rmSync5(dirname9(mcpConfigPath), { recursive: true, force: true });
                 } catch {
                 }
               }
@@ -23297,7 +23531,7 @@ var init_claude = __esm({
             }
             if (mcpConfigPath) {
               try {
-                rmSync4(dirname9(mcpConfigPath), { recursive: true, force: true });
+                rmSync5(dirname9(mcpConfigPath), { recursive: true, force: true });
               } catch {
               }
             }
@@ -23309,7 +23543,7 @@ var init_claude = __esm({
             broker = void 0;
             if (mcpConfigPath) {
               try {
-                rmSync4(dirname9(mcpConfigPath), { recursive: true, force: true });
+                rmSync5(dirname9(mcpConfigPath), { recursive: true, force: true });
               } catch {
               }
               mcpConfigPath = null;
@@ -23424,7 +23658,7 @@ var init_claude = __esm({
             session.broker?.pause();
             if (session.mcpConfigPath) {
               try {
-                rmSync4(dirname9(session.mcpConfigPath), { recursive: true, force: true });
+                rmSync5(dirname9(session.mcpConfigPath), { recursive: true, force: true });
               } catch {
               }
               session.mcpConfigPath = null;
@@ -23506,7 +23740,10 @@ var init_claude = __esm({
                     type: "thread.token-usage.updated",
                     input: (msg.usage.input_tokens || 0) + (msg.usage.cache_read_input_tokens || 0),
                     output: msg.usage.output_tokens || 0,
-                    ...typeof msg.usage.cache_read_input_tokens === "number" ? { cachedInput: msg.usage.cache_read_input_tokens } : {}
+                    ...typeof msg.usage.cache_read_input_tokens === "number" ? { cachedInput: msg.usage.cache_read_input_tokens } : {},
+                    // one assistant message = one model call, and its prompt is
+                    // everything in the window: fresh text, cache reads and writes
+                    contextTokens: (msg.usage.input_tokens || 0) + (msg.usage.cache_read_input_tokens || 0) + (msg.usage.cache_creation_input_tokens || 0)
                   });
                 }
                 break;
@@ -23575,7 +23812,7 @@ var init_claude = __esm({
                 failedBroker?.close();
                 if (session.mcpConfigPath) {
                   try {
-                    rmSync4(dirname9(session.mcpConfigPath), { recursive: true, force: true });
+                    rmSync5(dirname9(session.mcpConfigPath), { recursive: true, force: true });
                   } catch {
                   }
                   session.mcpConfigPath = null;
@@ -23653,7 +23890,7 @@ var init_claude = __esm({
                 session.broker = void 0;
                 if (session.mcpConfigPath) {
                   try {
-                    rmSync4(dirname9(session.mcpConfigPath), { recursive: true, force: true });
+                    rmSync5(dirname9(session.mcpConfigPath), { recursive: true, force: true });
                   } catch {
                   }
                   session.mcpConfigPath = null;
@@ -23704,7 +23941,7 @@ var init_claude = __esm({
             session.broker?.close();
             if (session.mcpConfigPath) {
               try {
-                rmSync4(dirname9(session.mcpConfigPath), { recursive: true, force: true });
+                rmSync5(dirname9(session.mcpConfigPath), { recursive: true, force: true });
               } catch {
               }
             }
@@ -23739,38 +23976,14 @@ var init_claude = __esm({
         } });
         const snapshot = async () => {
           const env = environment();
-          const version2 = await new Promise((resolve12) => {
-            execCli(
-              config2.cli,
-              ["--version"],
-              { timeout: 8e3, env },
-              (err, stdout2) => resolve12(err ? null : stdout2.trim())
-            );
-          });
+          const version2 = await readCliVersion(env);
           if (!version2) return { state: "unavailable", reason: `\`${config2.cli}\` CLI not found` };
           cliVersion = parseClaudeCliVersion(version2);
-          if (version2 !== cliHelpVersion) {
-            cliHelp = await new Promise((resolve12) => {
-              execCli(
-                config2.cli,
-                ["--help"],
-                { timeout: 8e3, env },
-                (err, stdout2) => resolve12(err ? null : stdout2)
-              );
-            });
-            cliHelpVersion = version2;
-          }
-          const features = cliHelp !== null ? { autocompact: claudeCliHelpSupportsFlag(cliHelp, "--autocompact") } : void 0;
+          cliVersionChecked = true;
           const auth = await claudeAuthStatus(config2.cli, env);
           const update = claudeCliUpdate(version2, config2.cli);
-          return {
-            state: "available",
-            version: version2,
-            ...auth,
-            ...update ? { update } : {},
-            ...features ? { features } : {},
-            billing: "subscription"
-          };
+          const warning = claudeInheritWarning(env);
+          return { state: "available", version: version2, ...auth, ...update ? { update } : {}, ...warning ? { warning } : {}, billing: "subscription" };
         };
         const generateReview = (prompt, signal) => new Promise((resolve12, reject) => {
           const child = spawnCli(
@@ -24709,6 +24922,9 @@ var init_codex_identity = __esm({
 // server/drivers/codex.ts
 import { existsSync as existsSync10 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
+function missingNativeCodexThread(error51, cursor3) {
+  return error51 instanceof CodexRpcError && error51.code === -32600 && error51.message === `no rollout found for thread id ${cursor3}`;
+}
 function codexPredatesAstra(version2) {
   const value = version2.trim();
   const match = /\bcodex-cli\s+v?(\d+)\.(\d+)\.(\d+)(?:[-+][0-9a-z.-]+)?(?![\d.])\b/i.exec(value) ?? /^v?(\d+)\.(\d+)\.(\d+)(?:[-+][0-9a-z.-]+)?$/i.exec(value);
@@ -24743,9 +24959,48 @@ function decodeConfig3(raw) {
   const o = raw ?? {};
   return {
     cli: typeof o.cli === "string" ? o.cli : "codex",
-    fullAuto: o.fullAuto === true
+    fullAuto: o.fullAuto === true,
+    ...o.managed && typeof o.managed === "object" ? { managed: decodeManagedCodex(o.managed) } : {}
   };
 }
+function decodeManagedCodex(raw) {
+  const value = raw;
+  if (typeof value.url !== "string" || !Array.isArray(value.models) || !value.models.length || value.models.some((model) => typeof model !== "string" || !/^[\w][\w./+-]*$/.test(model))) {
+    throw new Error("Invalid Company Codex configuration.");
+  }
+  const url2 = new URL(value.url);
+  const loopback = url2.hostname === "localhost" || url2.hostname === "[::1]" || /^127(?:\.\d{1,3}){3}$/.test(url2.hostname);
+  if (url2.username || url2.password || url2.search || url2.hash || url2.protocol !== "https:" && !(url2.protocol === "http:" && loopback)) throw new Error("Invalid Company Codex endpoint.");
+  return { url: url2.href.replace(/\/$/, ""), models: value.models };
+}
+function managedCodexArgs(config2) {
+  return [
+    "-c",
+    'model_provider="openmaus_company"',
+    "-c",
+    'model_providers.openmaus_company.name="Company"',
+    "-c",
+    `model_providers.openmaus_company.base_url=${JSON.stringify(config2.url)}`,
+    "-c",
+    'model_providers.openmaus_company.env_key="OPENMAUSBOT_COMPANY_API_KEY"',
+    "-c",
+    'model_providers.openmaus_company.wire_api="responses"',
+    "-c",
+    "model_providers.openmaus_company.requires_openai_auth=false",
+    "-c",
+    'cli_auth_credentials_store="ephemeral"',
+    "-c",
+    "shell_environment_policy.ignore_default_excludes=false"
+  ];
+}
+function noteSkippedSseServer(name) {
+  if (skippedSseServers.has(name)) return;
+  skippedSseServers.add(name);
+  console.error(`codex: MCP server ${JSON.stringify(name)} uses the SSE transport, which codex does not speak \u2014 it is available to Claude bots only`);
+}
+function tomlInlineTable(entries) {
+  return `{ ${Object.entries(entries).map(([key, value]) => `${JSON.stringify(key)} = ${JSON.stringify(value)}`).join(", ")} }`;
+}
 function grantedPermissions(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return {};
   return Object.fromEntries(
@@ -24945,23 +25200,43 @@ function codexNativeIncomingLogMessage(message2, sensitiveResponseIds) {
   return message2;
 }
 function mountMcpServer(appServerArgs, env, name, server, preApproved = true) {
-  Object.assign(env, server.env);
   const prefix = `mcp_servers.${name}`;
-  appServerArgs.push(
-    "-c",
-    `${prefix}.command=${JSON.stringify(server.command)}`,
-    "-c",
-    `${prefix}.args=${JSON.stringify(server.args)}`,
-    // Values stay in the child environment; argv contains names only so
-    // credentials never appear in process listings or diagnostics.
-    "-c",
-    `${prefix}.env_vars=${JSON.stringify(Object.keys(server.env))}`
-  );
+  if ("url" in server) {
+    appServerArgs.push("-c", `${prefix}.url=${JSON.stringify(server.url)}`);
+    const stem = `OMB_MCP_HEADER_${name.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+    const variables = {};
+    Object.entries(server.headers).forEach(([header, value], index) => {
+      const bearer = header.toLowerCase() === "authorization" ? /^Bearer\s+(\S+)$/i.exec(value) : null;
+      if (bearer) {
+        env[`${stem}_BEARER`] = bearer[1];
+        appServerArgs.push("-c", `${prefix}.bearer_token_env_var=${JSON.stringify(`${stem}_BEARER`)}`);
+        return;
+      }
+      const variable = `${stem}_${index}`;
+      env[variable] = value;
+      variables[header] = variable;
+    });
+    if (Object.keys(variables).length) {
+      appServerArgs.push("-c", `${prefix}.env_http_headers=${tomlInlineTable(variables)}`);
+    }
+  } else {
+    Object.assign(env, server.env);
+    appServerArgs.push(
+      "-c",
+      `${prefix}.command=${JSON.stringify(server.command)}`,
+      "-c",
+      `${prefix}.args=${JSON.stringify(server.args)}`,
+      // Values stay in the child environment; argv contains names only so
+      // credentials never appear in process listings or diagnostics.
+      "-c",
+      `${prefix}.env_vars=${JSON.stringify(Object.keys(server.env))}`
+    );
+  }
   if (preApproved) {
     appServerArgs.push("-c", `${prefix}.default_tools_approval_mode="auto"`);
   }
 }
-var DRIVER_KIND3, ASTRA_MODEL_ID, ASTRA_MIN_CODEX_VERSION, QUESTION_TIMEOUT_NOTE2, DENY_TIMEOUT_NOTE2, plainRecord, containsControlCharacter, CodexDriver;
+var DRIVER_KIND3, ASTRA_MODEL_ID, ASTRA_MIN_CODEX_VERSION, CodexRpcError, QUESTION_TIMEOUT_NOTE2, DENY_TIMEOUT_NOTE2, skippedSseServers, plainRecord, containsControlCharacter, CodexDriver;
 var init_codex = __esm({
   "server/drivers/codex.ts"() {
     "use strict";
@@ -24978,12 +25253,21 @@ var init_codex = __esm({
     init_codex_instructions();
     init_codex_device_auth();
     init_codex_identity();
+    init_resume_recovery();
     init_codex_catalog();
     DRIVER_KIND3 = "codex";
     ASTRA_MODEL_ID = "gpt-6-astra";
     ASTRA_MIN_CODEX_VERSION = [0, 153, 1];
+    CodexRpcError = class extends Error {
+      code;
+      constructor(error51) {
+        super(error51.message ?? JSON.stringify(error51));
+        this.code = error51.code;
+      }
+    };
     QUESTION_TIMEOUT_NOTE2 = "No answer was given \u2014 use your best judgment.";
     DENY_TIMEOUT_NOTE2 = "OpenMausBot: nobody answered this permission request in time. Skip this action and finish what you can without it.";
+    skippedSseServers = /* @__PURE__ */ new Set();
     plainRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : null;
     containsControlCharacter = (value) => {
       for (const character of value) {
@@ -25022,8 +25306,9 @@ var init_codex = __esm({
           return env;
         };
         const catalogEnv = childEnv();
-        let models2 = STATIC_CODEX_MODELS;
+        let models2 = config2.managed ? { default: config2.managed.models[0], options: config2.managed.models.map((id) => ({ id, label: id })) } : STATIC_CODEX_MODELS;
         const refreshModels = async () => {
+          if (config2.managed) return;
           try {
             const resolved = await readCodexModelCatalog(catalogEnv, fetch, config2.cli);
             if (resolved.options.length) models2 = resolved;
@@ -25049,11 +25334,28 @@ var init_codex = __esm({
           createdAt: (/* @__PURE__ */ new Date()).toISOString()
         });
         const sendTurn = async (turn) => {
+          if (config2.managed) {
+            if (!turn.model) {
+              throw new Error("Company model access is unavailable: no model is selected. Reconnect your organization; personal billing will not be used.");
+            }
+            if (!config2.managed.models.includes(turn.model)) {
+              throw new Error("Company model access is unavailable: " + turn.model + " is not approved for your organization. Reconnect your organization; personal billing will not be used.");
+            }
+            if (!input.environment.OPENMAUSBOT_COMPANY_API_KEY) {
+              throw new Error("Company model access is unavailable: OPENMAUSBOT_COMPANY_API_KEY is missing. Reconnect your organization; personal billing will not be used.");
+            }
+            if (!input.environment.CODEX_HOME) {
+              throw new Error("Company model access is unavailable: CODEX_HOME is missing. Reconnect your organization; personal billing will not be used.");
+            }
+          }
           let stopRequested = false;
+          let promptSubmitted = false;
+          let recoveredMissingSession = false;
           const stopSignal = new AbortController();
           const { threadId } = turn;
           const approvalMode = turn.approvalMode ?? (config2.fullAuto ? "full" : "ask");
           for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
+            if ("url" in server) continue;
             const reserved = Object.keys(server.env).find(isHarnessOwnedMcpEnvName);
             if (reserved) {
               throw new Error(`Custom MCP server \u201C${name}\u201D cannot set reserved environment variable \u201C${reserved}\u201D`);
@@ -25065,7 +25367,7 @@ var init_codex = __esm({
           const retryScale = Number(process.env.FAKE_CODEX_RETRY_SCALE ?? "1");
           const launchAttempt = async (attempt) => {
             const env = childEnv();
-            const appServerArgs = ["app-server", ...codexLocalProviderArgs(env, turn.model)];
+            const appServerArgs = ["app-server", ...config2.managed ? managedCodexArgs(config2.managed) : codexLocalProviderArgs(env, turn.model)];
             if (turn.integrations?.composio) {
               mountMcpServer(appServerArgs, env, "openmausbot_connectors", turn.integrations.composio);
             }
@@ -25079,6 +25381,10 @@ var init_codex = __esm({
               mountMcpServer(appServerArgs, env, "browser", turn.integrations.browser);
             }
             for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
+              if ("url" in server && server.type === "sse") {
+                noteSkippedSseServer(name);
+                continue;
+              }
               mountMcpServer(appServerArgs, env, name, server, false);
             }
             if (turn.integrations?.phone) {
@@ -25111,9 +25417,12 @@ var init_codex = __esm({
               lastError: "",
               lastText: "",
               sawStreamDelta: false,
-              // codex reports token usage as a running THREAD total; the harness
-              // wants this turn's figure, so the last report is banked on settle
-              usage: void 0
+              // codex reports token usage as a running total for this app-server
+              // process. The harness wants this turn's figure: the total minus
+              // whatever the process already carried before turn/start (a resumed
+              // thread may restore earlier usage), banked on settle.
+              usage: void 0,
+              usageBaseline: void 0
             };
             const asks = /* @__PURE__ */ new Map();
             let nextId = 1;
@@ -25140,6 +25449,12 @@ var init_codex = __esm({
               rpcPending.set(id, {
                 resolve: (v) => {
                   clearTimeout(timer);
+                  if (method === "thread/start" || method === "thread/resume") {
+                    const returnedId = v?.thread?.id;
+                    const requestedId = method === "thread/resume" && params && typeof params === "object" && "threadId" in params ? params.threadId : null;
+                    if (typeof returnedId === "string" && returnedId) codexThreadId = returnedId;
+                    else if (typeof requestedId === "string" && requestedId) codexThreadId = requestedId;
+                  }
                   if (method === "turn/start") {
                     if (typeof v?.turn?.id !== "string" || !v.turn.id) {
                       reject(new Error("Codex did not return a native turn id"));
@@ -25214,6 +25529,18 @@ var init_codex = __esm({
                 }
                 return;
               }
+              if (isQuestion && (!Array.isArray(params.questions) || params.questions.length !== 1)) {
+                const bundled = Array.isArray(params.questions) && params.questions.length > 1;
+                send({
+                  jsonrpc: "2.0",
+                  id: msg.id,
+                  error: {
+                    code: -32602,
+                    message: bundled ? `ask supports one question per call; this request bundled ${params.questions.length}. Split it into separate asks, one question each.` : Array.isArray(params.questions) ? "ask supports one question per call; this request sent none." : "ask supports one question per call; params.questions must be an array with exactly one question."
+                  }
+                });
+                return;
+              }
               const mcpTool = isLegacyMcpPermission ? String(params.message ?? "").match(/tool "([^"]+)"/)?.[1] : void 0;
               const tool = mcpAppApproval ? mcpAppApproval.tool : isLegacyMcpPermission ? mcpTool ?? "mcp" : isAdditionalPermission ? "permissions" : method === "item/fileChange/requestApproval" || method === "applyPatchApproval" ? "edit" : isQuestion ? "ask_user" : "shell";
               const permissionResult = (allow) => isMcpPermission ? allow ? mcpAppApproval?.allowResult ?? { action: "accept", content: {} } : { action: "decline" } : isAdditionalPermission ? { permissions: allow ? grantedPermissions(params.permissions) : {}, scope: "turn" } : { decision: allow ? legacy ? "approved" : "accept" : legacy ? "denied" : "decline" };
@@ -25268,6 +25595,11 @@ var init_codex = __esm({
               const connectionError = msg.method === "error" && !("threadId" in p) && !("turnId" in p);
               if (!connectionError) {
                 if (!codexThreadId || p.threadId !== codexThreadId) return;
+                if (!codexTurnId && msg.method === "thread/tokenUsage/updated" && p.tokenUsage?.total) {
+                  const t2 = p.tokenUsage.total;
+                  state.usageBaseline = { input: t2.inputTokens ?? 0, output: t2.outputTokens ?? 0, cachedInput: t2.cachedInputTokens ?? 0 };
+                  return;
+                }
                 if (!codexTurnId) {
                   if (startingNativeTurn) {
                     if (earlyNotifications.length >= 1024) {
@@ -25351,22 +25683,35 @@ var init_codex = __esm({
                   break;
                 }
                 case "thread/tokenUsage/updated": {
-                  const turnUsage = p.tokenUsage?.last ?? p.tokenUsage?.total;
-                  if (turnUsage) {
+                  const t2 = p.tokenUsage?.total;
+                  const last = p.tokenUsage?.last;
+                  const shape = (u4) => ({
+                    input: u4.inputTokens ?? 0,
+                    output: u4.outputTokens ?? 0,
+                    cachedInput: u4.cachedInputTokens ?? 0
+                  });
+                  if (t2) {
+                    const b = state.usageBaseline ?? { input: 0, output: 0, cachedInput: 0 };
+                    const now = shape(t2);
                     state.usage = {
-                      input: turnUsage.inputTokens ?? 0,
-                      output: turnUsage.outputTokens ?? 0,
-                      ...typeof turnUsage.cachedInputTokens === "number" ? { cachedInput: turnUsage.cachedInputTokens } : {}
+                      input: Math.max(0, now.input - b.input),
+                      output: Math.max(0, now.output - b.output),
+                      ...typeof t2.cachedInputTokens === "number" ? { cachedInput: Math.max(0, now.cachedInput - b.cachedInput) } : {}
                     };
+                  } else if (last) {
+                    state.usage = { input: last.inputTokens ?? 0, output: last.outputTokens ?? 0, ...typeof last.cachedInputTokens === "number" ? { cachedInput: last.cachedInputTokens } : {} };
                   }
-                  const t2 = p.tokenUsage?.total;
                   if (t2) {
+                    const window = p.tokenUsage?.modelContextWindow;
                     emit({
                       ...base2(threadId, turnId),
                       type: "thread.token-usage.updated",
                       input: t2.inputTokens ?? 0,
                       output: t2.outputTokens ?? 0,
-                      ...typeof t2.cachedInputTokens === "number" ? { cachedInput: t2.cachedInputTokens } : {}
+                      ...typeof t2.cachedInputTokens === "number" ? { cachedInput: t2.cachedInputTokens } : {},
+                      // the last call's prompt is what fills the window
+                      ...last && typeof last.inputTokens === "number" ? { contextTokens: last.inputTokens } : {},
+                      ...typeof window === "number" && window > 0 ? { contextWindow: window } : {}
                     });
                   }
                   break;
@@ -25420,7 +25765,7 @@ var init_codex = __esm({
                   const pend = rpcPending.get(msg.id);
                   if (pend) {
                     rpcPending.delete(msg.id);
-                    if (msg.error) pend.reject(new Error(msg.error.message ?? JSON.stringify(msg.error)));
+                    if (msg.error) pend.reject(new CodexRpcError(msg.error));
                     else pend.resolve(msg.result);
                   }
                 } else if (msg.id !== void 0 && msg.method) {
@@ -25451,7 +25796,7 @@ var init_codex = __esm({
               }
               const recentStderr = stderrSinceOutput.trim();
               const hadStreamedOutput = codexTurnId !== null || state.sawStreamDelta;
-              const verdict = classifyError({ exitCode: code, stderr: recentStderr || stderr });
+              const verdict = signal !== null ? { transient: false, reason: "interrupted" } : classifyError({ exitCode: code, stderr: recentStderr });
               if (!stopRequested && codexTurnId === null && earlyNotifications.length === 0 && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1) {
                 const delayMs = computeBackoff(attempt);
                 attempt++;
@@ -25518,30 +25863,39 @@ var init_codex = __esm({
               autoAcceptPermissions = approvalMode === "full";
               const cursor3 = typeof turn.resumeCursor === "string" ? turn.resumeCursor : null;
               let startedModel = null;
+              let resumedNativeThread = false;
+              let promptText = turn.text;
               if (cursor3) {
+                const resumeThread = () => request("thread/resume", {
+                  threadId: cursor3,
+                  developerInstructions,
+                  ...approvalParams.thread
+                });
                 try {
-                  const resumed = await request("thread/resume", {
-                    threadId: cursor3,
-                    developerInstructions,
-                    ...approvalParams.thread
-                  });
-                  codexThreadId = resumed?.thread?.id ?? cursor3;
-                } catch (error51) {
-                  if (approvalParams.fallback && permissionProfileUnsupported(error51)) {
+                  let resumed;
+                  try {
+                    resumed = await resumeThread();
+                  } catch (error51) {
+                    if (!approvalParams.fallback || !permissionProfileUnsupported(error51)) throw error51;
                     approvalParams = approvalParams.fallback;
-                    const resumed = await request("thread/resume", {
-                      threadId: cursor3,
-                      developerInstructions,
-                      ...approvalParams.thread
-                    });
-                    codexThreadId = resumed?.thread?.id ?? cursor3;
-                  } else {
-                    throw error51;
+                    resumed = await resumeThread();
                   }
+                  codexThreadId = resumed?.thread?.id ?? cursor3;
+                  resumedNativeThread = true;
+                } catch (error51) {
+                  const failure = classifyResumeFailure({
+                    attempted: true,
+                    rejected: error51 instanceof CodexRpcError,
+                    promptSubmitted,
+                    producedOutput: state.sawStreamDelta
+                  });
+                  if (!config2.managed || recoveredMissingSession || stopRequested || state.settled || !turn.recoveryText?.trim() || !missingNativeCodexThread(error51, cursor3) || !mayReplay(failure)) throw error51;
+                  recoveredMissingSession = true;
+                  promptText = recoveryPromptFor({ recoveryText: turn.recoveryText, currentText: turn.text, failure }).text;
                 }
               }
               if (!codexThreadId) {
-                const selection = decodeCodexSelection(turn.model);
+                const selection = config2.managed ? { model: turn.model, modelProvider: "openmaus_company" } : decodeCodexSelection(turn.model);
                 const startThread = () => request("thread/start", {
                   developerInstructions,
                   cwd: turn.cwd ?? homedir13(),
@@ -25562,14 +25916,14 @@ var init_codex = __esm({
                 startedModel = started?.model ?? null;
               }
               if (!codexThreadId) throw new Error("Codex did not return a native thread id");
-              await syncCodexInstructions(threadId, codexThreadId, developerInstructions, Boolean(cursor3), request);
+              await syncCodexInstructions(threadId, codexThreadId, developerInstructions, resumedNativeThread, request);
               emit({ ...base2(threadId, turnId), type: "session.started", sessionId: codexThreadId, model: startedModel ?? turn.model ?? null });
-              const promptText = turn.text;
               const turnInput = [
                 ...promptText ? [{ type: "text", text: promptText }] : [],
                 ...(turn.images ?? []).map((image) => ({ type: "localImage", path: image.path }))
               ];
               const startTurn = () => {
+                promptSubmitted = true;
                 startingNativeTurn = true;
                 return request("turn/start", {
                   threadId: codexThreadId,
@@ -25599,7 +25953,7 @@ var init_codex = __esm({
               const message2 = e instanceof Error ? e.message : String(e);
               const needsAuth = /(?:\b401\b|unauthorized|missing bearer|authentication required)/i.test(message2);
               const verdict = classifyError(failure);
-              if (!state.settled && !abandoned && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
+              if (!state.settled && !abandoned && !recoveredMissingSession && !stopRequested && !needsAuth && verdict.transient && attempt < RETRY_MAX_ATTEMPTS - 1 && state.sawStreamDelta === false) {
                 const delayMs = computeBackoff(attempt);
                 attempt++;
                 emit({
@@ -25649,6 +26003,7 @@ var init_codex = __esm({
             );
           });
           if (!version2) return { state: "unavailable", reason: `\`${config2.cli}\` CLI not found` };
+          if (config2.managed) return { state: "available", version: version2, authenticated: Boolean(input.environment.OPENMAUSBOT_COMPANY_API_KEY && input.environment.CODEX_HOME), billing: "metered" };
           const authenticated = await new Promise((resolve12) => {
             execCli(
               config2.cli,
@@ -33457,7 +33812,9 @@ async function mountChatTools(integrations, signal) {
   const servers = [];
   if (integrations?.agents) servers.push(["agents", integrations.agents]);
   if (integrations?.composio) servers.push(["composio", integrations.composio]);
-  servers.push(...Object.entries(integrations?.custom ?? {}));
+  for (const [name, server] of Object.entries(integrations?.custom ?? {})) {
+    if ("command" in server) servers.push([name, server]);
+  }
   if (servers.length > 32) throw new Error("MCP server count exceeds the 32-server limit");
   const clients = [];
   let closed = false;
@@ -35682,12 +36039,14 @@ function parseOpenCodeModelsOutput(stdout2) {
     const name = typeof record3.name === "string" && record3.name.trim() ? record3.name.trim() : labelForModel(model);
     const limit = record3.limit && typeof record3.limit === "object" && !Array.isArray(record3.limit) ? record3.limit : {};
     const contextWindow = typeof limit.context === "number" && Number.isFinite(limit.context) && limit.context > 0 ? Math.floor(limit.context) : void 0;
+    const variants = record3.variants && typeof record3.variants === "object" && !Array.isArray(record3.variants) ? Object.entries(record3.variants).filter(([, settings2]) => settings2 && typeof settings2 === "object" && !Array.isArray(settings2) && settings2.disabled !== true).map(([id]) => ({ id, label: labelForModel(id) })) : void 0;
     seen.add(slug);
     options.push({
       id: slug,
       label: `${providerLabel(provider)} \xB7 ${name}`,
       ...localModelRecord(record3) ? { custom: true, loaded: true } : {},
-      ...contextWindow ? { contextWindow } : {}
+      ...contextWindow ? { contextWindow } : {},
+      ...variants ? { variants } : {}
     });
   };
   for (const line of stdout2.split(/\r?\n/u)) {
@@ -35894,6 +36253,7 @@ var init_opencode_go = __esm({
       spawnArgs: () => ["acp"],
       credentialEnv: ["OPENCODE_API_KEY"],
       selectModel: { configId: "model" },
+      modelVariants: true,
       resolveTurnModel: (model, env) => model ? ensureOpenCodeInjectModel(normalizeLegacyOpenCodeModel(model, env), env) : model,
       transformEnv: stripForeignProviderKeys,
       pickAuthMethod: () => null,
@@ -43486,7 +43846,7 @@ var init_openai_compat = __esm({
 });
 
 // server/drivers/pi.ts
-import { chmodSync as chmodSync6, existsSync as existsSync17, mkdirSync as mkdirSync15, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, rmSync as rmSync5, writeFileSync as writeFileSync12 } from "node:fs";
+import { chmodSync as chmodSync6, existsSync as existsSync17, mkdirSync as mkdirSync15, mkdtempSync as mkdtempSync3, readFileSync as readFileSync17, rmSync as rmSync6, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir21, tmpdir as tmpdir4 } from "node:os";
 import { join as join30 } from "node:path";
 function readPiPromptImages(turn) {
@@ -43822,7 +44182,7 @@ var init_pi = __esm({
               writeFileSync12(join30(mcpTempDir, "mcp.json"), JSON.stringify({ mcpServers }), { mode: 384 });
             } catch (err) {
               try {
-                rmSync5(mcpTempDir, { recursive: true, force: true });
+                rmSync6(mcpTempDir, { recursive: true, force: true });
               } catch {
               }
               throw err;
@@ -43843,7 +44203,7 @@ var init_pi = __esm({
             } catch (err) {
               if (mcpTempDir) {
                 try {
-                  rmSync5(mcpTempDir, { recursive: true, force: true });
+                  rmSync6(mcpTempDir, { recursive: true, force: true });
                 } catch {
                 }
               }
@@ -43900,7 +44260,7 @@ var init_pi = __esm({
             }
             if (mcpTempDir) {
               try {
-                rmSync5(mcpTempDir, { recursive: true, force: true });
+                rmSync6(mcpTempDir, { recursive: true, force: true });
               } catch {
               }
             }
@@ -44913,7 +45273,7 @@ __export(browser_engine_exports, {
 });
 import { spawn as spawn8 } from "node:child_process";
 import { createHash as createHash8, randomBytes as randomBytes3, randomUUID as randomUUID11 } from "node:crypto";
-import { chmodSync as chmodSync7, constants as constants2, copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync16, readFileSync as readFileSync20, readdirSync as readdirSync3, renameSync as renameSync5, rmSync as rmSync6, statSync as statSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync as chmodSync7, constants as constants2, copyFileSync, existsSync as existsSync18, mkdirSync as mkdirSync16, readFileSync as readFileSync20, readdirSync as readdirSync3, renameSync as renameSync6, rmSync as rmSync7, statSync as statSync4, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "node:fs";
 import { homedir as homedir23, tmpdir as tmpdir5 } from "node:os";
 import { delimiter as delimiter6, dirname as dirname11, join as join35, resolve as resolve10 } from "node:path";
 function browserRestoreKey(session) {
@@ -45031,7 +45391,7 @@ async function prepareBrowserSessionState(binaryPath, session, options = {}) {
       const candidates = [".json.enc", ".json"].flatMap((suffix) => {
         const path3 = join35(directory, `${session}-${session}${suffix}`);
         try {
-          const stat4 = statSync3(path3);
+          const stat4 = statSync4(path3);
           if (!stat4.isFile()) throw new Error("Saved browser state is not a file.");
           return [{ path: path3, suffix, modified: stat4.mtimeMs }];
         } catch (error51) {
@@ -45126,7 +45486,7 @@ async function installAgentBrowserBinary(options = {}) {
   const staging = `${destination}.${randomBytes3(6).toString("hex")}.part`;
   writeFileSync13(staging, body, { mode: 493 });
   if (platform !== "win32") chmodSync7(staging, 493);
-  renameSync5(staging, destination);
+  renameSync6(staging, destination);
   return destination;
 }
 function ensureChrome(binaryPath, options = {}) {
@@ -45243,7 +45603,7 @@ function agentBrowserFrame(input) {
       } catch {
         fail(new Error("the browser reported a picture it did not write"));
       } finally {
-        rmSync6(file2, { force: true });
+        rmSync7(file2, { force: true });
       }
     };
     child.on("error", (error51) => done(error51 instanceof Error ? error51 : new Error(String(error51))));
@@ -45262,7 +45622,7 @@ function describeBrowserEngine(status) {
 }
 function agentBrowserBinaryExists(dataDir = DATA_DIR) {
   try {
-    return statSync3(pinnedBinaryPath(dataDir)).isFile();
+    return statSync4(pinnedBinaryPath(dataDir)).isFile();
   } catch {
     return false;
   }
@@ -45325,7 +45685,7 @@ var init_browser_engine = __esm({
 // server/cli.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
 import { spawn as spawn9 } from "node:child_process";
-import { closeSync as closeSync4, existsSync as existsSync19, mkdirSync as mkdirSync17, openSync as openSync4, readFileSync as readFileSync21 } from "node:fs";
+import { closeSync as closeSync5, existsSync as existsSync19, mkdirSync as mkdirSync17, openSync as openSync5, readFileSync as readFileSync21 } from "node:fs";
 import { homedir as homedir24 } from "node:os";
 import { dirname as dirname12, join as join36, resolve as resolve11 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
@@ -48288,7 +48648,7 @@ async function runPhoneSetup(options, io, deps) {
     const device = await io.choose("Use OpenMausBot on your phone?", [
       "Skip for now",
       "iPhone / iPad \u2014 native app or Safari",
-      "Android \u2014 web browser"
+      "Android \u2014 app or browser"
     ], 0);
     if (device === 0) return skip();
     const phone = device === 1 ? "ios" : "android";
@@ -48351,7 +48711,7 @@ function phonePairingInstructions(phone, input) {
     ];
   }
   return [
-    phone === "ios" ? "On iPhone or iPad, scan the QR with Camera to open Safari. If you already have the OpenMausBot iOS app, use its pairing scanner or paste the full pairing link there." : "On Android, scan the QR with Camera and open it in your web browser. This link is for the web app, not the Android native pairing scanner.",
+    phone === "ios" ? "On iPhone or iPad, scan the QR with Camera to open Safari. If you already have the OpenMausBot iOS app, use its pairing scanner or paste the full pairing link there." : "On Android, open the OpenMausBot app and scan the QR with its pairing scanner. The QR is an app link, so Camera will not open it in a browser.",
     `Or open ${origin}/pair on your phone and enter the code.`,
     "Choose Connect on the phone. Scanning a QR does not mean the phone is paired.",
     "The code works once and expires after five minutes. This phone receives client access: chat and approvals, not settings or pairing administration."
@@ -48642,7 +49002,11 @@ function parseArgs(argv, env = process.env) {
         options.domain = domain2;
       } else if (arg === "--tunnel") options.tunnel = true;
       else if (arg === "--client") options.client = true;
-      else if (arg === "--no-pair") options.pair = false;
+      else if (arg === "--phone") {
+        const kind = value().toLowerCase();
+        if (kind !== "ios" && kind !== "android") return { error: "--phone takes ios or android" };
+        options.phone = kind;
+      } else if (arg === "--no-pair") options.pair = false;
       else if (arg === "--no-open") options.open = false;
       else if (arg === "--local") options.local = true;
       else if (arg === "--json") options.json = true;
@@ -48702,7 +49066,8 @@ var USAGE = `openmausbot \u2014 your team of AI bots, ready in a few steps
   openmausbot start [the same options as serve]
   openmausbot serve [--port 8799] [--data-dir DIR] [--label NAME]
                     [--public-url https://host] [--tailscale | --tunnel | --domain HOST] [--no-pair]
-  openmausbot pair  [--label NAME] [--client] [--public-url https://host]
+  openmausbot pair  [--label NAME] [--client] [--phone ios|android]
+                    [--public-url https://host]
   openmausbot sessions [revoke ID]
   openmausbot status
   openmausbot login [--email you@example.com]
@@ -48877,22 +49242,46 @@ async function showPhonePairing(options, origin, log) {
     return false;
   }
   for (const line of phonePairingInstructions(options.phone ?? "ios", { origin, ready })) log(line);
-  log(await mintPairing(options.port, { client: true, label: options.label ?? (options.phone === "android" ? "Android" : "iPhone / iPad"), publicUrl: origin }));
+  log(await mintPairing(options.port, { client: true, label: options.label ?? (options.phone === "android" ? "Android" : "iPhone / iPad"), publicUrl: origin, phone: options.phone }));
   log("Waiting for you to connect on the phone. Keep this terminal and the code private.");
   return true;
 }
 function pairingBlock(input) {
   const lines = [`pairing code:  ${input.code}`, `expires:       ${new Date(input.expiresAt).toLocaleTimeString()} (single use)`];
-  if (input.url) {
-    lines.push(`open or scan:  ${input.url}`);
-    lines.push("");
-    lines.push(qrToString(input.url));
-  } else {
+  if (!input.url && !input.inviteUrl) {
     lines.push(`open:          /pair on the address you use for this server, and type the code`);
     if (input.hint) lines.push(`               (${input.hint})`);
+    return lines.join("\n");
+  }
+  const scanInvite = input.phone === "android" && !!input.inviteUrl;
+  if (input.url) lines.push(scanInvite ? `web browser:   ${input.url}` : `open or scan:  ${input.url}`);
+  if (input.inviteUrl) lines.push(`phone app:     ${input.inviteUrl}`);
+  const target = scanInvite ? input.inviteUrl : input.url;
+  if (target) {
+    lines.push("");
+    lines.push(qrToString(target));
+    lines.push("");
+    if (scanInvite) {
+      lines.push(`Scan that in the OpenMausBot app. For a browser instead, open the web`);
+      lines.push(`address above and type the code.`);
+    } else if (input.phone === "android") {
+      lines.push(`That QR opens the web app. The Android app needs the phone-app link,`);
+      lines.push(`which this server cannot build without a public address: set`);
+      lines.push(`OMB_PUBLIC_URL, or open the web address above and type the code.`);
+    } else if (input.inviteUrl) {
+      lines.push(`Scan that with Camera for the browser, or paste the phone-app link`);
+      lines.push(`above into the OpenMausBot app.`);
+    }
   }
   return lines.join("\n");
 }
+function originOf(link) {
+  try {
+    return new URL(link).origin;
+  } catch {
+    return null;
+  }
+}
 function qrToString(text4) {
   let out = "";
   import_qrcode_terminal.default.generate(text4, { small: true }, (rendered) => {
@@ -48907,7 +49296,9 @@ async function mintPairing(port, options) {
   const { status, body } = await api(port, "/api/auth/pairing", { method: "POST", body: JSON.stringify(request) });
   if (status !== 200) throw new Error(`server refused to mint a pairing code: ${typeof body?.error === "string" ? body.error : status}`);
   const url2 = options.publicUrl ? `${options.publicUrl}/pair#code=${body.code}` : typeof body.url === "string" ? body.url : null;
-  return pairingBlock({ code: body.code, url: url2, expiresAt: body.expiresAt, hint: typeof body.hint === "string" ? body.hint : null });
+  const address = options.publicUrl ?? (typeof body.url === "string" ? originOf(body.url) : null);
+  const invite = typeof body.credential === "string" && address ? `openmausbot://pair?address=${encodeURIComponent(address)}&token=${encodeURIComponent(body.credential)}${typeof body.serverName === "string" ? `&name=${encodeURIComponent(body.serverName)}` : ""}` : typeof body.inviteUrl === "string" ? body.inviteUrl : null;
+  return pairingBlock({ code: body.code, url: url2, inviteUrl: invite, expiresAt: body.expiresAt, hint: typeof body.hint === "string" ? body.hint : null, phone: options.phone });
 }
 async function runPair(options) {
   if (!await serverUp(options.port)) {
@@ -48935,7 +49326,7 @@ async function runPair(options) {
     }
     const ui = defaultSetupIo();
     try {
-      const selected = await ui.choose("Which phone are you connecting?", ["iPhone / iPad \u2014 app or Safari", "Android \u2014 web browser", "Cancel"], 0);
+      const selected = await ui.choose("Which phone are you connecting?", ["iPhone / iPad \u2014 app or Safari", "Android \u2014 app or browser", "Cancel"], 0);
       if (selected === 2) return 0;
       launch = { ...launch, phone: selected === 0 ? "ios" : "android" };
       return await showPhonePairing(launch, origin, ui.log) ? 0 : 1;
@@ -48945,7 +49336,7 @@ async function runPair(options) {
       return 130;
     }
   }
-  console.log(await mintPairing(options.port, { label: options.label, client: options.client, publicUrl: options.publicUrl }));
+  console.log(await mintPairing(options.port, { label: options.label, client: options.client, publicUrl: options.publicUrl, phone: options.phone }));
   if (options.client) console.log("(client scope: chat and approvals only; cannot change settings or pair others)");
   return 0;
 }
@@ -49269,7 +49660,7 @@ async function runServe(options, log = console.log) {
       const logsDir = join36(options.dataDir, "logs");
       mkdirSync17(logsDir, { recursive: true, mode: 448 });
       logPath = join36(logsDir, `server-${Date.now()}-${process.pid}.log`);
-      logFd = openSync4(logPath, "wx", 384);
+      logFd = openSync5(logPath, "wx", 384);
       log("\nStarting your workspace\u2026");
     }
     if (tailscale) {
@@ -49293,7 +49684,7 @@ async function runServe(options, log = console.log) {
     }
     throw error51;
   } finally {
-    if (logFd !== void 0) closeSync4(logFd);
+    if (logFd !== void 0) closeSync5(logFd);
     process.removeListener("SIGINT", cancelStartup);
     process.removeListener("SIGTERM", cancelStartup);
   }