openmausbot 0.1.69 → 0.1.71

package/dist-server/pair-cli.js

@@ -1181,7 +1181,7 @@ var init_dist = __esm({
     MODIFIER_RE = new RegExp("\\p{M}+", "gu");
     NO_TRUNCATION = { limit: Infinity, ellipsis: "" };
     getStringTruncatedWidth = (input, truncationOptions = {}, widthOptions = {}) => {
-      const LIMIT = truncationOptions.limit ?? Infinity;
+      const LIMIT2 = truncationOptions.limit ?? Infinity;
       const ELLIPSIS = truncationOptions.ellipsis ?? "";
       const ELLIPSIS_WIDTH = truncationOptions?.ellipsisWidth ?? (ELLIPSIS ? getStringTruncatedWidth(ELLIPSIS, NO_TRUNCATION, widthOptions).width : 0);
       const ANSI_WIDTH = 0;
@@ -1205,7 +1205,7 @@ var init_dist = __esm({
       let lengthExtra = 0;
       let truncationEnabled = false;
       let truncationIndex = length;
-      let truncationLimit = Math.max(0, LIMIT - ELLIPSIS_WIDTH);
+      let truncationLimit = Math.max(0, LIMIT2 - ELLIPSIS_WIDTH);
       let unmatchedStart = 0;
       let unmatchedEnd = 0;
       let width = 0;
@@ -1226,7 +1226,7 @@ var init_dist = __esm({
             if (width + widthExtra > truncationLimit) {
               truncationIndex = Math.min(truncationIndex, Math.max(unmatchedStart, indexPrev) + lengthExtra);
             }
-            if (width + widthExtra > LIMIT) {
+            if (width + widthExtra > LIMIT2) {
               truncationEnabled = true;
               break outer;
             }
@@ -1247,7 +1247,7 @@ var init_dist = __esm({
             if (width + widthExtra > truncationLimit) {
               truncationIndex = Math.min(truncationIndex, index + Math.floor((truncationLimit - width) / BLOCK_WIDTH));
             }
-            if (width + widthExtra > LIMIT) {
+            if (width + widthExtra > LIMIT2) {
               truncationEnabled = true;
               break outer;
             }
@@ -1264,7 +1264,7 @@ var init_dist = __esm({
         width: truncationEnabled ? truncationLimit : width,
         index: truncationEnabled ? truncationIndex : length,
         truncated: truncationEnabled,
-        ellipsed: truncationEnabled && LIMIT >= ELLIPSIS_WIDTH
+        ellipsed: truncationEnabled && LIMIT2 >= ELLIPSIS_WIDTH
       };
     };
     dist_default = getStringTruncatedWidth;
@@ -17964,8 +17964,9 @@ var init_config = __esm({
       });
     });
     featureConfigSchema = external_exports.object({
-      /** Experimental desktop workflow recorder. Hidden unless explicitly enabled. */
-      skillRecorder: external_exports.boolean().optional(),
+      /** Bots may draft skills (skill_manage, /learn) for your review. Off unless
+       * explicitly enabled. */
+      skillAuthoring: external_exports.boolean().optional(),
       /** Show each tool run in the transcript. Off unless explicitly enabled. */
       showToolCalls: external_exports.boolean().optional(),
       /** Experimental built-in browser. Off until explicitly enabled; each bot
@@ -18475,6 +18476,11 @@ function windowsKnownDirs() {
     join7(home, "go", "bin")
   ];
 }
+function registerPathDir(dir) {
+  if (registeredDirs.includes(dir)) return;
+  registeredDirs.unshift(dir);
+  resetPathCache();
+}
 function resetPathCache() {
   cached2 = null;
   probed = false;
@@ -18482,6 +18488,7 @@ function resetPathCache() {
 function augmentedPath() {
   if (cached2 === null) {
     cached2 = mergePaths([
+      ...registeredDirs.filter((d) => existsSync5(d)),
       ...process.env.OMB_EXTRA_PATH ? process.env.OMB_EXTRA_PATH.split(delimiter3) : [],
       ...process.env.PATH ? process.env.PATH.split(delimiter3) : [],
       // Keep the last successful login-shell result while a rescan starts a
@@ -18646,13 +18653,14 @@ function resolveCliSpawn(cli, args) {
   }
   return resolveWord(cli, args);
 }
-var cached2, probed, loginShellPath;
+var cached2, probed, loginShellPath, registeredDirs;
 var init_env_path = __esm({
   "server/env-path.ts"() {
     "use strict";
     cached2 = null;
     probed = false;
     loginShellPath = null;
+    registeredDirs = [];
   }
 });
 
@@ -18766,7 +18774,124 @@ var init_procs = __esm({
   }
 });
 
+// server/engine-install.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync6 } from "node:fs";
+import { join as join9 } from "node:path";
+import { stripVTControlCharacters as stripVTControlCharacters3 } from "node:util";
+function enginesPrefix(baseDir = DATA_DIR) {
+  return join9(baseDir, "tools", "npm");
+}
+function enginesBinDir(baseDir = DATA_DIR, platform = process.platform) {
+  return platform === "win32" ? enginesPrefix(baseDir) : join9(enginesPrefix(baseDir), "bin");
+}
+function npmPackageOf(install) {
+  const line = install?.command?.linux ?? install?.command?.darwin ?? install?.command?.win32;
+  const match = line ? /^npm install -g ((?:@[\w.-]+\/)?[\w.-]+)$/.exec(line.trim()) : null;
+  return match ? match[1] : null;
+}
+function npmAvailable() {
+  return findCliCandidates("npm").length > 0;
+}
+function serverInstallFor(install, npmPresent = npmAvailable()) {
+  if (!install || install.managed) return null;
+  const pkg = npmPackageOf(install);
+  return pkg && npmPresent ? { package: pkg } : null;
+}
+function installNpmEngine(pkg, options = {}) {
+  const key = `${options.baseDir ?? DATA_DIR} ${pkg}`;
+  const existing = running.get(key);
+  if (existing) return existing;
+  const run3 = installOnce(pkg, options).finally(() => running.delete(key));
+  running.set(key, run3);
+  return run3;
+}
+async function installOnce(pkg, options) {
+  const prefix = enginesPrefix(options.baseDir);
+  mkdirSync6(prefix, { recursive: true });
+  const env = {
+    ...options.env ?? process.env,
+    PATH: options.path ?? augmentedPath(),
+    NO_COLOR: "1",
+    npm_config_update_notifier: "false",
+    npm_config_fund: "false",
+    npm_config_audit: "false"
+  };
+  stripWorkspaceCredentialEnv(env);
+  const args = ["install", "-g", "--prefix", prefix, "--loglevel=error", `--allow-scripts=${pkg}`, `${pkg}@latest`];
+  const result = await runNpm(args, env, prefix, options.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  if (result.code !== 0) {
+    throw new Error(`npm could not install ${pkg} on this server.${tail(result.output)}`);
+  }
+  registerPathDir(enginesBinDir(options.baseDir));
+  resetPathCache();
+  if (options.cli) {
+    const binDir = enginesBinDir(options.baseDir);
+    if (!findCliCandidates(options.cli).some((path3) => path3.startsWith(binDir))) {
+      throw new Error(`${pkg} installed, but it did not provide a \`${options.cli}\` command. Check the package name in this engine's install descriptor.`);
+    }
+  }
+}
+function tail(output) {
+  const clean = stripVTControlCharacters3(output).trim();
+  if (!clean) return "";
+  const lines = clean.split(/\r?\n/).filter((line) => line.trim()).slice(-6);
+  return `
+${lines.join("\n").slice(-600)}`;
+}
+function runNpm(args, env, cwd, timeoutMs) {
+  return new Promise((resolveRun, rejectRun) => {
+    let child;
+    try {
+      child = spawnCli("npm", args, { env, cwd, stdio: ["pipe", "pipe", "pipe"] });
+    } catch {
+      rejectRun(new Error("npm could not start on this server. Install Node.js with npm for the user running OpenMausBot, then try again."));
+      return;
+    }
+    child.stdin.end();
+    let output = "";
+    const receive = (chunk) => {
+      if (output.length < MAX_OUTPUT) output += chunk.toString("utf8").slice(0, MAX_OUTPUT - output.length);
+    };
+    child.stdout.on("data", receive);
+    child.stderr.on("data", receive);
+    let timedOut = false;
+    const timer = setTimeout(() => {
+      timedOut = true;
+      void killCliTree(child);
+    }, timeoutMs);
+    timer.unref();
+    child.once("error", (error51) => {
+      clearTimeout(timer);
+      rejectRun(new Error(error51.code === "ENOENT" ? "npm is not installed on this server. Install Node.js with npm for the user running OpenMausBot, then try again." : "npm could not start on this server. Check that Node.js is installed for the user running OpenMausBot."));
+    });
+    child.once("close", (code) => {
+      clearTimeout(timer);
+      if (timedOut) {
+        rejectRun(new Error("The install took too long and was stopped. Check the server's network connection and try again."));
+        return;
+      }
+      resolveRun({ code, output });
+    });
+  });
+}
+var MAX_OUTPUT, DEFAULT_TIMEOUT_MS, running;
+var init_engine_install = __esm({
+  "server/engine-install.ts"() {
+    "use strict";
+    init_config();
+    init_env_path();
+    init_procs();
+    MAX_OUTPUT = 64 * 1024;
+    DEFAULT_TIMEOUT_MS = 10 * 6e4;
+    running = /* @__PURE__ */ new Map();
+  }
+});
+
 // server/harness/registry.ts
+function withServerInstall(install, npmPresent) {
+  const server = install ? serverInstallFor(install, npmPresent) : null;
+  return server ? { ...install, server } : install;
+}
 function cliDefaultOf(driver) {
   if (!driver) return void 0;
   try {
@@ -18785,13 +18910,21 @@ var init_registry = __esm({
   "server/harness/registry.ts"() {
     "use strict";
     init_env_path();
+    init_engine_install();
     ProviderRegistry = class {
       byId = /* @__PURE__ */ new Map();
       /** decoded per-instance `cli` overrides, for describe() — drivers spawn
        * from their own config; this map only reports what was configured */
       cliByInstance = /* @__PURE__ */ new Map();
       driversByKind;
-      constructor(drivers) {
+      /** Where Settings-driven npm installs go; the data directory by default. */
+      enginesBaseDir;
+      /** Whether npm is on this machine; injectable because the PATH scan also
+       * looks in standard install locations, which tests cannot empty. */
+      npmPresent;
+      constructor(drivers, options = {}) {
+        this.enginesBaseDir = options.enginesBaseDir;
+        this.npmPresent = options.npmAvailable ?? npmAvailable;
         this.driversByKind = new Map(drivers.map((d) => [d.driverKind, d]));
       }
       async load(configs) {
@@ -18866,10 +18999,20 @@ var init_registry = __esm({
         await instance.refreshModels?.();
         return true;
       }
+      /** A driver's own installer (a managed download) first; otherwise the
+       * app's npm prefix, when the driver's install one-liner is an npm package
+       * and npm is on PATH. False means Settings has nothing to offer here. */
       async installRuntime(instanceId) {
-        const instance = this.get(instanceId);
-        if (!instance?.installRuntime) return false;
-        await instance.installRuntime();
+        const entry = this.byId.get(instanceId);
+        if (!entry) return false;
+        if (entry.live?.installRuntime) {
+          await entry.live.installRuntime();
+          return true;
+        }
+        const driver = this.driversByKind.get(entry.shadow?.driverKind ?? entry.live.driverKind);
+        const server = serverInstallFor(driver?.install, this.npmPresent());
+        if (!server) return false;
+        await installNpmEngine(server.package, { baseDir: this.enginesBaseDir, cli: cliDefaultOf(driver) });
         return true;
       }
       async startAuthentication(instanceId) {
@@ -18904,6 +19047,7 @@ var init_registry = __esm({
           candidatesByName.set(name, found);
           return found;
         };
+        const npmPresent = this.npmPresent();
         return Promise.all(
           this.entries().map(async (entry) => {
             const driver = this.driversByKind.get(entry.shadow?.driverKind ?? entry.live.driverKind);
@@ -18917,7 +19061,7 @@ var init_registry = __esm({
                 capabilities: { computerMcp: false, agentsMcp: false, localComputerMcp: false },
                 // an unknown driver has no driver record, hence no install path
                 access: driver?.metadata.access ?? "subscription",
-                install: driver?.install,
+                install: withServerInstall(driver?.install, npmPresent),
                 cli: entry.shadow.cli,
                 cliDefault: cliDefaultOf(driver),
                 // a shadow is exactly the "your CLI is broken, pick another"
@@ -18951,7 +19095,7 @@ var init_registry = __esm({
                 approvalReview: inst.reviewPermission !== void 0
               },
               access: driver?.metadata.access ?? "subscription",
-              install: driver?.install,
+              install: withServerInstall(driver?.install, npmPresent),
               authentication: inst.startAuthentication ? {
                 method: inst.getAuthentication && inst.completeAuthentication ? "paste-code" : inst.getAuthentication ? "device-code" : "browser",
                 // a link and a callback URL (managed engines)
@@ -18986,7 +19130,7 @@ var init_registry = __esm({
 // server/drivers/local-inject.ts
 import { readFileSync as readFileSync5 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
-import { join as join9 } from "node:path";
+import { join as join10 } from "node:path";
 function contextWindowsFromPs(extra) {
   const out = /* @__PURE__ */ new Map();
   const rec = extra && typeof extra === "object" ? extra : null;
@@ -19071,7 +19215,7 @@ function firstUnslothToken(row) {
 function readUnslothKey(env) {
   const home = env.HOME || env.USERPROFILE || homedir6();
   try {
-    const raw = JSON.parse(readFileSync5(join9(home, ".unsloth", "studio", "auth", "agent_api_key.json"), "utf8"));
+    const raw = JSON.parse(readFileSync5(join10(home, ".unsloth", "studio", "auth", "agent_api_key.json"), "utf8"));
     if (raw.servers && typeof raw.servers === "object") {
       const servers = raw.servers;
       for (const url2 of ["http://127.0.0.1:8888", "http://localhost:8888"]) {
@@ -19130,12 +19274,12 @@ function loadedIdsFromPayloads(_host, catalog, extra) {
   };
   if (extra && typeof extra === "object") {
     const rec = extra;
-    const running = Array.isArray(rec.models) ? rec.models : Array.isArray(rec.data) ? rec.data : [];
-    const hasLoadedFlags = running.some(
+    const running2 = Array.isArray(rec.models) ? rec.models : Array.isArray(rec.data) ? rec.data : [];
+    const hasLoadedFlags = running2.some(
       (row) => row && typeof row === "object" && ("loaded" in row || "state" in row)
     );
     if (!hasLoadedFlags && typeof rec.default_model === "string") add(rec.default_model);
-    for (const row of running) {
+    for (const row of running2) {
       if (typeof row === "string") {
         if (!hasLoadedFlags) add(row);
         continue;
@@ -19272,12 +19416,12 @@ var init_local_inject = __esm({
 });
 
 // server/proxy-paths.ts
-import { existsSync as existsSync6 } from "node:fs";
-import { dirname as dirname4, join as join10 } from "node:path";
+import { existsSync as existsSync7 } from "node:fs";
+import { dirname as dirname4, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function resolveProxy(relative2) {
-  const source = join10(SERVER_ROOT, `${relative2}.ts`);
-  return existsSync6(source) ? source : join10(SERVER_ROOT, `${relative2}.js`);
+  const source = join11(SERVER_ROOT, `${relative2}.ts`);
+  return existsSync7(source) ? source : join11(SERVER_ROOT, `${relative2}.js`);
 }
 var SERVER_ROOT, SPAWNED_PROXIES;
 var init_proxy_paths = __esm({
@@ -19294,6 +19438,7 @@ var init_proxy_paths = __esm({
       agents: resolveProxy("drivers/agents-proxy"),
       dweb: resolveProxy("drivers/dweb-proxy"),
       connectors: resolveProxy("connector-proxy"),
+      mcpGate: resolveProxy("mcp-gate"),
       phone: resolveProxy("drivers/phone-proxy"),
       // Loaded by the external `pi` process via `-e`, not by this server — but
       // resolved through the same single source of truth so the packaged layout
@@ -19305,7 +19450,7 @@ var init_proxy_paths = __esm({
 
 // server/container-computer.ts
 import { execFile as execFile4 } from "node:child_process";
-import { join as join11, resolve as resolve3 } from "node:path";
+import { join as join12, resolve as resolve3 } from "node:path";
 import { promisify } from "node:util";
 function computerProxyEnv(computer) {
   return {
@@ -19329,7 +19474,7 @@ var init_container_computer = __esm({
     IMAGE_REPOSITORY = "localhost/openmausbot/cua-local-vm";
     IMAGE_LAYER_VERSION = "5";
     IMAGE = `${IMAGE_REPOSITORY}:driver-${CUA_DRIVER_VERSION}-v${IMAGE_LAYER_VERSION}`;
-    VM_WORKSPACE_DIR = join11(DATA_DIR, "vm-home");
+    VM_WORKSPACE_DIR = join12(DATA_DIR, "vm-home");
     MEMORY_BYTES = 4 * 1024 * 1024 * 1024;
     SHM_BYTES = 512 * 1024 * 1024;
     containerMcpPath = SPAWNED_PROXIES.containerMcp;
@@ -19363,6 +19508,9 @@ ${close}`);
   for (const re of KEY_PREFIXES) out = out.replace(re, (m) => mask(m));
   out = out.replace(BEARER, (_m, lead, tok) => `${lead}${mask(tok)}`);
   out = out.replace(KEY_VALUE, (_m, key, sep, quote, value) => `${key}${sep}${quote}${mask(value)}${quote}`);
+  out = out.replace(KEY_SUFFIX_ASSIGNMENT, (_m, key, sep, quote, value) => `${key}${sep}${quote}${mask(value)}${quote}`);
+  out = out.replace(SECRET_FLAG, (_m, flag, quote, value) => `${flag}${quote}${mask(value)}${quote}`);
+  out = out.replace(URL_USERINFO, (_m, lead, secret, at) => `${lead}${mask(secret)}${at}`);
   return out;
 }
 function redactSecrets(input, depth = 0) {
@@ -19387,7 +19535,7 @@ function redactSecrets(input, depth = 0) {
   }
   return out;
 }
-var SECRET_KEY_PARTS, REDACTION_MARKER, mask, KEY_PREFIXES, BEARER, PEM_BLOCK, KEY_VALUE;
+var SECRET_KEY_PARTS, REDACTION_MARKER, mask, KEY_PREFIXES, BEARER, PEM_BLOCK, KEY_VALUE, KEY_SUFFIX_ASSIGNMENT, SECRET_FLAG, URL_USERINFO;
 var init_redact = __esm({
   "server/redact.ts"() {
     "use strict";
@@ -19397,6 +19545,12 @@ var init_redact = __esm({
     KEY_PREFIXES = [
       /\bsk-(?:ant-|proj-|live-|test-)?[A-Za-z0-9_-]{16,}/g,
       // anthropic / openai / stripe
+      /\bxai-[A-Za-z0-9_-]{20,}/g,
+      // xai (grok)
+      /\bgsk_[A-Za-z0-9]{40,}/g,
+      // groq
+      /\bhf_[A-Za-z0-9]{30,}/g,
+      // hugging face
       /\b(?:ghp|gho|ghu|ghs|ghr)_[A-Za-z0-9]{20,}/g,
       // github classic
       /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
@@ -19415,16 +19569,19 @@ var init_redact = __esm({
     BEARER = /(\bBearer\s+)([A-Za-z0-9._~+/=-]{12,})/g;
     PEM_BLOCK = /(-----BEGIN [A-Z ]*PRIVATE KEY-----)([\s\S]*?)(-----END [A-Z ]*PRIVATE KEY-----)/g;
     KEY_VALUE = /\b((?:[A-Za-z0-9_-]*_)?(?:api[_-]?key|apikey|secret|token|password|passwd|authorization|auth[_-]?token|access[_-]?key|private[_-]?key)s?)(["']?\s*[=:]\s*)(["']?)([A-Za-z0-9._~+/=-]{8,})\3/gi;
+    KEY_SUFFIX_ASSIGNMENT = /\b([A-Za-z][A-Za-z0-9_-]*[_-]key)s?(=)(["']?)([A-Za-z0-9._~+/=-]+)\3/gi;
+    SECRET_FLAG = /(--(?:token|password|passwd|api-key|apikey|secret|access-key|auth-token)(?:=|\s+))(["']?)(?!-)([A-Za-z0-9._~+/=-]+)\2/gi;
+    URL_USERINFO = /(\b[a-z][a-z0-9+.-]*:\/\/[^\s/:@'"]+:)([^\s/@'"«»]+)(@)/gi;
   }
 });
 
 // server/drivers/native.ts
 import { appendFileSync } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join13 } from "node:path";
 function appendNative(threadId, entry) {
   try {
     appendFileSync(
-      join12(NATIVE_DIR, `${threadId}.ndjson`),
+      join13(NATIVE_DIR, `${threadId}.ndjson`),
       JSON.stringify({ at: (/* @__PURE__ */ new Date()).toISOString(), ...entry, msg: redactSecrets(entry.msg) }) + "\n",
       { mode: 384 }
     );
@@ -19439,6 +19596,36 @@ var init_native = __esm({
   }
 });
 
+// server/tool-summary.ts
+function fieldsOf(input) {
+  if (input === null || typeof input !== "object" || Array.isArray(input)) return void 0;
+  return input;
+}
+function commandSummary(input) {
+  const command = fieldsOf(input)?.command;
+  if (typeof command !== "string") return void 0;
+  return cut(command.replace(/\s*[\r\n]+\s*/g, " "), LIMIT);
+}
+function askInputSummary(input) {
+  const fields = fieldsOf(input);
+  if (!fields) return void 0;
+  if (typeof fields.question === "string") return cut(fields.question, QUESTION_LIMIT);
+  if (typeof fields.command === "string") return cut(fields.command, LIMIT);
+  if (typeof fields.url === "string") return cut(fields.url, LIMIT);
+  const text2 = JSON.stringify(fields);
+  return text2 === "{}" ? void 0 : cut(text2, LIMIT);
+}
+var QUESTION_LIMIT, LIMIT, cut;
+var init_tool_summary = __esm({
+  "server/tool-summary.ts"() {
+    "use strict";
+    init_redact();
+    QUESTION_LIMIT = 300;
+    LIMIT = 200;
+    cut = (text2, limit) => redactSecretsInText(text2).trim().slice(0, limit);
+  }
+});
+
 // server/drivers/acp/core.ts
 import { homedir as homedir7 } from "node:os";
 import { lstat, mkdir, readFile, realpath, stat, writeFile } from "node:fs/promises";
@@ -19883,7 +20070,8 @@ function createAcpDriver(support11) {
                 type: "item.started",
                 itemType: "tool",
                 itemId: u4.toolCallId,
-                title: String(u4.rawInput?.command ?? u4.title ?? "tool").slice(0, 80)
+                title: String(u4.rawInput?.command ?? u4.title ?? "tool").slice(0, 80),
+                summary: commandSummary(u4.rawInput)
               });
               break;
             }
@@ -20193,6 +20381,7 @@ var init_core3 = __esm({
     init_env_path();
     init_approval_mode();
     init_native();
+    init_tool_summary();
     init_proxy_paths();
     COMPUTER_PROXY_PATH = SPAWNED_PROXIES.computer;
     envOr = (key, fallback) => Number(process.env[key] ?? fallback);
@@ -20210,7 +20399,7 @@ import { createHash as createHash3, randomUUID as randomUUID6 } from "node:crypt
 import { mkdir as mkdir2, mkdtemp, readFile as readFile2, rm, stat as stat2 } from "node:fs/promises";
 import { request as httpRequest } from "node:http";
 import { tmpdir as tmpdir2 } from "node:os";
-import { delimiter as delimiter4, join as join13, resolve as resolve5 } from "node:path";
+import { delimiter as delimiter4, join as join14, resolve as resolve5 } from "node:path";
 function quoteBrowserArgument(value) {
   return `'${value.replaceAll("'", `'"'"'`)}'`;
 }
@@ -20245,11 +20434,11 @@ function authorizationUrlFromLine(line) {
   }
 }
 function antigravityProfileDirectory(instanceId, baseDir = DATA_DIR) {
-  return join13(baseDir, "providers", "antigravity", createHash3("sha256").update(instanceId).digest("hex"));
+  return join14(baseDir, "providers", "antigravity", createHash3("sha256").update(instanceId).digest("hex"));
 }
 async function prepareAntigravityProfile(input) {
   const directory = resolve5(input.profileDirectory ?? antigravityProfileDirectory(input.instanceId, input.baseDir));
-  const acpDirectory = join13(directory, "antigravity-acp");
+  const acpDirectory = join14(directory, "antigravity-acp");
   await mkdir2(acpDirectory, { recursive: true, mode: 448 });
   if (process.platform !== "win32") {
     const { chmod: chmod2 } = await import("node:fs/promises");
@@ -20257,7 +20446,7 @@ async function prepareAntigravityProfile(input) {
     await chmod2(acpDirectory, 448);
   }
   writeFileAtomic(
-    join13(acpDirectory, "settings.json"),
+    join14(acpDirectory, "settings.json"),
     `${JSON.stringify({ auth: { type: "oauth-personal" } })}
 `,
     { mode: 384 }
@@ -20280,7 +20469,7 @@ async function prepareAntigravityProfile(input) {
     PYTHONUNBUFFERED: "1",
     ELECTRON_RUN_AS_NODE: "1"
   });
-  return { directory, tokenPath: join13(acpDirectory, "acp_token.json"), environment };
+  return { directory, tokenPath: join14(acpDirectory, "acp_token.json"), environment };
 }
 async function antigravityProfileAuthenticated(profile) {
   try {
@@ -20409,7 +20598,7 @@ function isValidAntigravityInitializeResult(initialized, expectedVersion) {
   return true;
 }
 async function validateAntigravityRuntime(runtime, expectedVersion) {
-  const profileDirectory = await mkdtemp(join13(tmpdir2(), "openmaus-antigravity-verify-"));
+  const profileDirectory = await mkdtemp(join14(tmpdir2(), "openmaus-antigravity-verify-"));
   let client;
   let failed = false;
   let failure;
@@ -20798,7 +20987,7 @@ import {
   writeFile as writeFile2
 } from "node:fs/promises";
 import { constants } from "node:fs";
-import { delimiter as delimiter5, dirname as dirname6, isAbsolute as isAbsolute2, join as join14, resolve as resolve6 } from "node:path";
+import { delimiter as delimiter5, dirname as dirname6, isAbsolute as isAbsolute2, join as join15, resolve as resolve6 } from "node:path";
 import { Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { createInflateRaw } from "node:zlib";
@@ -20819,7 +21008,7 @@ async function retryOnWindowsFileLock(step, options = {}) {
   }
 }
 function runtimeRoot(baseDir = DATA_DIR) {
-  return join14(baseDir, "tools", "antigravity-acp", `${process.platform}-${process.arch}`);
+  return join15(baseDir, "tools", "antigravity-acp", `${process.platform}-${process.arch}`);
 }
 function executableNames(platform = process.platform) {
   return platform === "win32" ? { executable: "agy_acp_server.exe", harness: "localharness_external.exe" } : { executable: "agy_acp_server.par", harness: "localharness_external" };
@@ -20836,10 +21025,10 @@ async function executableFile(path3, bytes) {
 }
 async function completedRelease(directory, asset) {
   try {
-    const record3 = JSON.parse(await readFile3(join14(directory, INSTALL_RECORD), "utf8"));
+    const record3 = JSON.parse(await readFile3(join15(directory, INSTALL_RECORD), "utf8"));
     if (record3.sha256 !== asset.sha256 || record3.version !== asset.version || record3.executable.name !== asset.executable.name || record3.executable.bytes !== asset.executable.bytes || record3.harness.name !== asset.harness.name || record3.harness.bytes !== asset.harness.bytes) return null;
-    const executablePath = join14(directory, asset.executable.name);
-    const harnessPath = join14(directory, asset.harness.name);
+    const executablePath = join15(directory, asset.executable.name);
+    const harnessPath = join15(directory, asset.harness.name);
     if (!await executableFile(executablePath, asset.executable.bytes)) return null;
     if (!await executableFile(harnessPath, asset.harness.bytes)) return null;
     return { executablePath, harnessPath, source: "managed", version: asset.version };
@@ -20855,7 +21044,7 @@ function pathCandidates(binary2, env) {
 async function externalRuntime(candidate, source) {
   const names = executableNames();
   const executablePath = resolve6(candidate);
-  const harnessPath = join14(dirname6(executablePath), names.harness);
+  const harnessPath = join15(dirname6(executablePath), names.harness);
   if (!await executableFile(executablePath) || !await executableFile(harnessPath)) return null;
   return { executablePath, harnessPath, source, version: null };
 }
@@ -20875,7 +21064,7 @@ async function resolveAntigravityRuntime(binaryPath, env = process.env, baseDir
   }
   const asset = resolveAntigravityReleaseAsset();
   if (asset) {
-    const managed = await completedRelease(join14(runtimeRoot(baseDir), "versions", asset.sha256), asset);
+    const managed = await completedRelease(join15(runtimeRoot(baseDir), "versions", asset.sha256), asset);
     if (managed) return managed;
   }
   const names = executableNames();
@@ -20895,25 +21084,25 @@ async function pinnedZipEntries(path3) {
   try {
     const info = await handle.stat();
     const tailBytes = Math.min(info.size, MAX_EOCD_BYTES);
-    const tail = Buffer.alloc(tailBytes);
+    const tail2 = Buffer.alloc(tailBytes);
     const tailOffset = info.size - tailBytes;
-    if ((await handle.read(tail, 0, tailBytes, tailOffset)).bytesRead !== tailBytes) {
+    if ((await handle.read(tail2, 0, tailBytes, tailOffset)).bytesRead !== tailBytes) {
       throw new Error("The verified archive was truncated.");
     }
     let eocd = -1;
-    for (let cursor4 = tail.length - 22; cursor4 >= 0; cursor4 -= 1) {
-      if (tail.readUInt32LE(cursor4) === EOCD_SIGNATURE && cursor4 + 22 + tail.readUInt16LE(cursor4 + 20) === tail.length) {
+    for (let cursor4 = tail2.length - 22; cursor4 >= 0; cursor4 -= 1) {
+      if (tail2.readUInt32LE(cursor4) === EOCD_SIGNATURE && cursor4 + 22 + tail2.readUInt16LE(cursor4 + 20) === tail2.length) {
         eocd = cursor4;
         break;
       }
     }
     if (eocd < 0) throw new Error("The verified archive has no valid ZIP directory.");
-    const disk = tail.readUInt16LE(eocd + 4);
-    const directoryDisk = tail.readUInt16LE(eocd + 6);
-    const diskEntries = tail.readUInt16LE(eocd + 8);
-    const entryCount = tail.readUInt16LE(eocd + 10);
-    const directoryBytes = tail.readUInt32LE(eocd + 12);
-    const directoryOffset = tail.readUInt32LE(eocd + 16);
+    const disk = tail2.readUInt16LE(eocd + 4);
+    const directoryDisk = tail2.readUInt16LE(eocd + 6);
+    const diskEntries = tail2.readUInt16LE(eocd + 8);
+    const entryCount = tail2.readUInt16LE(eocd + 10);
+    const directoryBytes = tail2.readUInt32LE(eocd + 12);
+    const directoryOffset = tail2.readUInt32LE(eocd + 16);
     const eocdOffset = tailOffset + eocd;
     if (disk !== 0 || directoryDisk !== 0 || diskEntries !== entryCount || entryCount !== 2 || directoryBytes === 4294967295 || directoryOffset === 4294967295 || directoryOffset + directoryBytes > eocdOffset) throw new Error("The verified archive uses an unsupported ZIP layout.");
     const directory = Buffer.alloc(directoryBytes);
@@ -20997,19 +21186,19 @@ async function extractPinnedArchive(archivePath, outputDirectory, asset) {
       start: dataOffset,
       end: dataOffset + entry.compressedBytes - 1
     });
-    const destination = createWriteStream(join14(outputDirectory, entry.name), { flags: "wx", mode: 448 });
+    const destination = createWriteStream(join15(outputDirectory, entry.name), { flags: "wx", mode: 448 });
     if (entry.compression === 8) await pipeline(source, createInflateRaw(), counter, destination);
     else await pipeline(source, counter, destination);
     if (bytes !== expectedBytes) throw new Error("An extracted file was truncated.");
   }
   if (seen.size !== 2) throw new Error("The archive is missing an expected file.");
 }
-async function installOnce(options) {
+async function installOnce2(options) {
   const asset = options.asset === void 0 ? resolveAntigravityReleaseAsset() : options.asset;
   if (!asset) throw new Error(`Google does not publish an Antigravity runtime for ${process.platform}-${process.arch}.`);
   const root = runtimeRoot(options.baseDir);
-  const versions = join14(root, "versions");
-  const destination = join14(versions, asset.sha256);
+  const versions = join15(root, "versions");
+  const destination = join15(versions, asset.sha256);
   await mkdir3(versions, { recursive: true, mode: 448 });
   const existing = await completedRelease(destination, asset);
   if (existing) {
@@ -21025,11 +21214,11 @@ async function installOnce(options) {
   } catch (error51) {
     if (error51 instanceof Error && error51.message.includes("Antigravity needs")) throw error51;
   }
-  const staging = await mkdtemp2(join14(versions, `${STAGING_PREFIX}${randomUUID7()}-`));
+  const staging = await mkdtemp2(join15(versions, `${STAGING_PREFIX}${randomUUID7()}-`));
   let failed = false;
   try {
-    const archivePath = join14(staging, "download.zip");
-    const runtimeDirectory = join14(staging, "runtime");
+    const archivePath = join15(staging, "download.zip");
+    const runtimeDirectory = join15(staging, "runtime");
     await mkdir3(runtimeDirectory, { mode: 448 });
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), DOWNLOAD_TIMEOUT_MS2);
@@ -21075,12 +21264,12 @@ async function installOnce(options) {
     }
     await extractPinnedArchive(archivePath, runtimeDirectory, asset);
     if (process.platform !== "win32") {
-      await chmod(join14(runtimeDirectory, asset.executable.name), 493);
-      await chmod(join14(runtimeDirectory, asset.harness.name), 493);
+      await chmod(join15(runtimeDirectory, asset.executable.name), 493);
+      await chmod(join15(runtimeDirectory, asset.harness.name), 493);
     }
     const candidate = {
-      executablePath: join14(runtimeDirectory, asset.executable.name),
-      harnessPath: join14(runtimeDirectory, asset.harness.name),
+      executablePath: join15(runtimeDirectory, asset.executable.name),
+      harnessPath: join15(runtimeDirectory, asset.harness.name),
       source: "managed",
       version: asset.version
     };
@@ -21091,7 +21280,7 @@ async function installOnce(options) {
       executable: asset.executable,
       harness: asset.harness
     };
-    await writeFile2(join14(runtimeDirectory, INSTALL_RECORD), `${JSON.stringify(record3)}
+    await writeFile2(join15(runtimeDirectory, INSTALL_RECORD), `${JSON.stringify(record3)}
 `, { flag: "wx", mode: 384 });
     try {
       await retryOnWindowsFileLock(() => rename(runtimeDirectory, destination));
@@ -21118,9 +21307,9 @@ function installAntigravityRuntime(options = {}) {
   const key = runtimeRoot(options.baseDir);
   const existing = installs.get(key);
   if (existing) return existing;
-  const running = installOnce(options).finally(() => installs.delete(key));
-  installs.set(key, running);
-  return running;
+  const running2 = installOnce2(options).finally(() => installs.delete(key));
+  installs.set(key, running2);
+  return running2;
 }
 function antigravityManagedInstallAvailable() {
   return resolveAntigravityReleaseAsset() !== null;
@@ -21337,7 +21526,7 @@ var init_boxagent = __esm({
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const emit = (event) => {
-          for (const l of [...listeners]) l(event);
+          for (const l of Array.from(listeners)) l(event);
         };
         const base2 = (threadId, turnId) => ({
           eventId: newEventId(),
@@ -21527,18 +21716,39 @@ var init_boxagent = __esm({
   }
 });
 
+// server/resume-recovery.ts
+function classifyResumeFailure(state) {
+  if (state.producedOutput || state.promptSubmitted) return "after-accept";
+  if (state.attempted && state.rejected) return "before-accept";
+  return "unknown";
+}
+function mayReplay(failure) {
+  return failure === "before-accept";
+}
+function recoveryPromptFor(input) {
+  if (!mayReplay(input.failure)) return { text: input.currentText, replayed: false };
+  const replay = input.recoveryText?.trim();
+  if (!replay || replay === input.currentText.trim()) return { text: input.currentText, replayed: false };
+  return { text: replay, replayed: true };
+}
+var init_resume_recovery = __esm({
+  "server/resume-recovery.ts"() {
+    "use strict";
+  }
+});
+
 // server/drivers/claude-login-auth.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
 import { realpathSync } from "node:fs";
 import { homedir as homedir8 } from "node:os";
-import { basename as basename4, dirname as dirname7, isAbsolute as isAbsolute3, join as join15, resolve as resolve7 } from "node:path";
-import { stripVTControlCharacters as stripVTControlCharacters3 } from "node:util";
+import { basename as basename4, dirname as dirname7, isAbsolute as isAbsolute3, join as join16, resolve as resolve7 } from "node:path";
+import { stripVTControlCharacters as stripVTControlCharacters4 } from "node:util";
 function canonicalPath(path3) {
   try {
     return realpathSync(path3);
   } catch {
     const parent = dirname7(path3);
-    return parent === path3 ? path3 : join15(canonicalPath(parent), basename4(path3));
+    return parent === path3 ? path3 : join16(canonicalPath(parent), basename4(path3));
   }
 }
 function claudeSignInLink(value) {
@@ -21553,7 +21763,7 @@ function claudeSignInLink(value) {
   }
 }
 function claudeLoginPrompt(output) {
-  const lines = stripVTControlCharacters3(output).split(/\r?\n/).slice(0, -1);
+  const lines = stripVTControlCharacters4(output).split(/\r?\n/).slice(0, -1);
   for (const line of lines) {
     const match = /(https:\/\/\S+)/.exec(line.trim());
     const link = match ? claudeSignInLink(match[1].replace(/[),.;]+$/, "")) : null;
@@ -21565,17 +21775,18 @@ function claudeLoginCode(value) {
   const code = value.trim();
   return /^[A-Za-z0-9_\-#.:]{8,1024}$/.test(code) ? code : null;
 }
-var MAX_OUTPUT, SIGN_IN_HOSTS, authenticatingHomes, NOT_AVAILABLE, ClaudeLoginController;
+var MAX_OUTPUT2, SIGN_IN_HOSTS, authenticatingHomes, NOT_AVAILABLE, ClaudeLoginController;
 var init_claude_login_auth = __esm({
   "server/drivers/claude-login-auth.ts"() {
     "use strict";
     init_procs();
-    MAX_OUTPUT = 32768;
+    MAX_OUTPUT2 = 32768;
     SIGN_IN_HOSTS = ["claude.com", "claude.ai", "console.anthropic.com", "platform.claude.com"];
     authenticatingHomes = /* @__PURE__ */ new Set();
     NOT_AVAILABLE = "This sign-in is no longer available. Start sign-in again.";
     ClaudeLoginController = class {
       flow = null;
+      logoutChild = null;
       disposed = false;
       options;
       constructor(options) {
@@ -21594,7 +21805,7 @@ var init_claude_login_auth = __esm({
         if (!isAbsolute3(home) || env.CLAUDE_CONFIG_DIR && !isAbsolute3(env.CLAUDE_CONFIG_DIR)) {
           throw new Error("Use an absolute HOME and CLAUDE_CONFIG_DIR path for this server's Claude provider before signing in.");
         }
-        const homeKey = canonicalPath(resolve7(env.CLAUDE_CONFIG_DIR || join15(home, ".claude")));
+        const homeKey = canonicalPath(resolve7(env.CLAUDE_CONFIG_DIR || join16(home, ".claude")));
         if (authenticatingHomes.has(homeKey)) {
           throw new Error("A Claude sign-in is already running for this server account. Finish or cancel it before starting another.");
         }
@@ -21667,43 +21878,121 @@ var init_claude_login_auth = __esm({
         if (this.flow?.status.phase === "waiting") this.finish(this.flow, "cancelled", "Claude sign-in cancelled.");
         await this.flow?.stopping;
         if (this.flow?.terminationFailed) throw new Error(this.flow.status.message);
+        if (this.logoutChild && !await this.stopChild(this.logoutChild)) {
+          throw new Error("Claude Code could not be stopped on this server. Ask the server administrator to stop the account command before trying again.");
+        }
       }
       async dispose() {
         this.disposed = true;
         await this.cancel();
         this.flow = null;
       }
+      /** Remove the sign-in Claude Code stores for this server account (its
+       * configuration directory) so a different subscription can sign in. A
+       * sign-in in progress is never pulled away underneath the browser
+       * completing it, and the CLI's own status is the verdict, as for sign-in. */
+      async signOut() {
+        if (this.disposed) throw new Error("This provider was removed. Refresh Settings before signing out.");
+        if (this.flow?.status.phase === "waiting") throw new Error("Finish or cancel the Claude sign-in in progress before signing out.");
+        await this.flow?.stopping;
+        if (this.disposed) throw new Error("This provider was removed. Refresh Settings before signing out.");
+        const env = this.options.environment();
+        const home = env.HOME || env.USERPROFILE || homedir8();
+        if (!isAbsolute3(home) || env.CLAUDE_CONFIG_DIR && !isAbsolute3(env.CLAUDE_CONFIG_DIR)) {
+          throw new Error("Use an absolute HOME and CLAUDE_CONFIG_DIR path for this server's Claude provider before signing out.");
+        }
+        const homeKey = canonicalPath(resolve7(env.CLAUDE_CONFIG_DIR || join16(home, ".claude")));
+        if (authenticatingHomes.has(homeKey)) {
+          throw new Error("A Claude sign-in is running for this server account. Finish or cancel it before signing out.");
+        }
+        authenticatingHomes.add(homeKey);
+        try {
+          await this.logout(env);
+          if (this.disposed) throw new Error("This provider was removed. Refresh Settings before signing out.");
+          const status = await this.authStatus(env);
+          if (status === "in") throw new Error("Claude Code still reports a sign-in on this server. Update Claude Code and check its auth status before trying again.");
+          if (status === "unknown") throw new Error("Claude Code could not confirm the sign-out on this server. Update Claude Code and check its auth status before trying again.");
+        } finally {
+          const child = this.logoutChild;
+          if (child && child.exitCode === null && child.signalCode === null) {
+            child.once("close", () => authenticatingHomes.delete(homeKey));
+          } else authenticatingHomes.delete(homeKey);
+        }
+      }
+      /** `claude auth logout`, bounded and non-interactive. Its output stays
+       * here; the status command afterwards decides whether it worked. */
+      logout(env) {
+        return new Promise((resolveDone, rejectDone) => {
+          if (this.disposed) {
+            rejectDone(new Error("This provider was removed. Refresh Settings before signing out."));
+            return;
+          }
+          let child;
+          try {
+            child = spawnCli(this.options.cli, ["auth", "logout"], { env: { ...env, NO_COLOR: "1" }, stdio: ["pipe", "pipe", "pipe"] });
+          } catch {
+            rejectDone(new Error("Claude Code could not start on this server. Install or update the configured Claude CLI, then try again."));
+            return;
+          }
+          this.logoutChild = child;
+          child.stdin.end();
+          child.stdout.on("data", () => {
+          });
+          child.stderr.on("data", () => {
+          });
+          const timer = setTimeout(() => {
+            void this.stopChild(child).catch(() => false).then((stopped) => {
+              if (!stopped) rejectDone(new Error("Claude Code could not be stopped on this server. Ask the server administrator to stop the account command before trying again."));
+            });
+          }, this.options.startupTimeoutMs ?? 3e4);
+          timer.unref();
+          child.once("error", (error51) => {
+            clearTimeout(timer);
+            rejectDone(new Error(error51.code === "ENOENT" ? "Claude Code is not installed on this server. Install it on the server, then try again." : "Claude Code could not start on this server. Check the configured CLI path and its executable permissions."));
+          });
+          child.once("close", () => {
+            clearTimeout(timer);
+            if (this.logoutChild === child) this.logoutChild = null;
+            resolveDone();
+          });
+        });
+      }
       signedIn(env) {
+        return this.authStatus(env).then((status) => status === "in");
+      }
+      /** `claude auth status --json`: signed in, signed out, or not answered. */
+      authStatus(env) {
         return new Promise((resolveStatus) => {
           let child;
           try {
             child = spawnCli(this.options.cli, ["auth", "status", "--json"], { env: { ...env, NO_COLOR: "1" }, stdio: ["ignore", "pipe", "pipe"] });
           } catch {
-            resolveStatus(false);
+            resolveStatus("unknown");
             return;
           }
           let stdout2 = "";
           child.stdout.on("data", (chunk) => {
-            if (stdout2.length < MAX_OUTPUT) stdout2 += chunk.toString("utf8");
+            if (stdout2.length < MAX_OUTPUT2) stdout2 += chunk.toString("utf8");
           });
           child.stderr.on("data", () => {
           });
           const timer = setTimeout(() => {
             child.kill("SIGKILL");
-            resolveStatus(false);
+            resolveStatus("unknown");
           }, 8e3);
           timer.unref();
           child.once("error", () => {
             clearTimeout(timer);
-            resolveStatus(false);
+            resolveStatus("unknown");
           });
-          child.once("close", () => {
+          child.once("close", (code) => {
             clearTimeout(timer);
             try {
               const status = JSON.parse(stdout2);
-              resolveStatus(typeof status === "object" && status !== null && Reflect.get(status, "loggedIn") === true);
+              const loggedIn = typeof status === "object" && status !== null ? Reflect.get(status, "loggedIn") : void 0;
+              resolveStatus(code === 0 && loggedIn === true ? "in" : code === 1 && loggedIn === false ? "out" : "unknown");
             } catch {
-              resolveStatus(false);
+              resolveStatus("unknown");
             }
           });
         });
@@ -21724,7 +22013,7 @@ var init_claude_login_auth = __esm({
         flow.child = child;
         const receive = (chunk) => {
           if (flow.status.phase !== "waiting") return;
-          if (flow.output.length + chunk.length > MAX_OUTPUT) {
+          if (flow.output.length + chunk.length > MAX_OUTPUT2) {
             this.finish(flow, "failed", "Claude Code returned an unexpected sign-in response. Update the server's Claude CLI and try again.");
             return;
           }
@@ -21746,7 +22035,7 @@ var init_claude_login_auth = __esm({
         child.once("close", (code) => {
           if (flow.child === child) flow.child = null;
           if (flow.status.phase !== "waiting") return;
-          const output = stripVTControlCharacters3(flow.output);
+          const output = stripVTControlCharacters4(flow.output);
           flow.output = "";
           void this.signedIn(flow.env).then((signedIn) => {
             if (flow.status.phase !== "waiting") return;
@@ -21779,7 +22068,7 @@ var init_claude_login_auth = __esm({
           else flow.completion.reject(new Error(message2 ?? "Claude sign-in did not finish."));
           flow.completion = void 0;
         }
-        flow.stopping = this.stopChild(flow).catch(() => false).then((stopped) => {
+        flow.stopping = this.stopChild(flow.child).catch(() => false).then((stopped) => {
           const release = () => authenticatingHomes.delete(flow.homeKey);
           if (stopped) {
             release();
@@ -21794,8 +22083,7 @@ var init_claude_login_auth = __esm({
         if (phase === "succeeded") void this.options.onAuthenticated?.().catch(() => {
         });
       }
-      async stopChild(flow) {
-        const child = flow.child;
+      async stopChild(child) {
         if (!child || await killCliTree(child, this.options.terminateTimeoutMs ?? 1500)) return true;
         if (process.platform !== "win32" && child.pid) {
           try {
@@ -21819,6 +22107,53 @@ var init_claude_login_auth = __esm({
   }
 });
 
+// server/mcp-trim.ts
+var DEFAULT_RESULT_BUDGET;
+var init_mcp_trim = __esm({
+  "server/mcp-trim.ts"() {
+    "use strict";
+    DEFAULT_RESULT_BUDGET = 8e3;
+  }
+});
+
+// server/mcp-gate-config.ts
+import { join as join17 } from "node:path";
+function resultBudget(env = process.env) {
+  const raw = env.OMB_MCP_RESULT_BUDGET;
+  if (raw === void 0 || raw === "") return DEFAULT_RESULT_BUDGET;
+  const parsed = Number(raw);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.floor(parsed) : DEFAULT_RESULT_BUDGET;
+}
+function spillDir(threadId) {
+  return join17(DATA_DIR, "tool-results", threadId.replace(/[^A-Za-z0-9_-]/g, "-").slice(0, 80) || "thread");
+}
+function gateServer(input) {
+  const { name, server, budget } = input;
+  if (budget <= 0) return null;
+  if (!server || typeof server !== "object" || Array.isArray(server)) return null;
+  const spec = server;
+  if (typeof spec.command !== "string" || !spec.command) return null;
+  return {
+    command: input.execPath ?? process.execPath,
+    args: [SPAWNED_PROXIES.mcpGate],
+    env: {
+      ...input.nodeEnv,
+      OMB_GATE_NAME: name,
+      OMB_GATE_UPSTREAM: JSON.stringify({ command: spec.command, args: spec.args ?? [], env: spec.env ?? {} }),
+      OMB_GATE_SPILL_DIR: spillDir(input.threadId),
+      OMB_GATE_BUDGET: String(budget)
+    }
+  };
+}
+var init_mcp_gate_config = __esm({
+  "server/mcp-gate-config.ts"() {
+    "use strict";
+    init_config();
+    init_mcp_trim();
+    init_proxy_paths();
+  }
+});
+
 // server/drivers/retry.ts
 function classifyError(err) {
   const text2 = messageOf(err);
@@ -21907,7 +22242,7 @@ import { createHash as createHash5, randomBytes as randomBytes2 } from "node:cry
 import { chmodSync as chmodSync3, mkdtempSync as mkdtempSync2, readFileSync as readFileSync6, rmSync as rmSync2, 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 join16, dirname as dirname8, isAbsolute as isAbsolute4, normalize } from "node:path";
+import { join as join18, dirname as dirname8, isAbsolute as isAbsolute4, normalize } from "node:path";
 function claudeAuthStatus(cli, env, run3 = execCli) {
   return new Promise((resolve13) => {
     run3(cli, ["auth", "status", "--json"], { timeout: 8e3, maxBuffer: 65536, env }, (_error, stdout2) => {
@@ -21933,8 +22268,8 @@ function claudeAuthStatus(cli, env, run3 = execCli) {
 }
 function resolveClaudeConfigDir(configDir, env = process.env) {
   const home = env.HOME || env.USERPROFILE || homedir9();
-  const configured = configDir?.trim() || env.CLAUDE_CONFIG_DIR?.trim() || join16(home, ".claude");
-  const expanded = configured === "~" ? home : configured.startsWith("~/") ? join16(home, configured.slice(2)) : configured;
+  const configured = configDir?.trim() || env.CLAUDE_CONFIG_DIR?.trim() || join18(home, ".claude");
+  const expanded = configured === "~" ? home : configured.startsWith("~/") ? join18(home, configured.slice(2)) : configured;
   if (!isAbsolute4(expanded) || /[\p{Cc}\p{Cf}]/u.test(expanded)) {
     throw new Error("claude: configDir must be an absolute path or start with ~/");
   }
@@ -21963,6 +22298,57 @@ function claudeEnvironment(model, source = process.env, configDir, instanceEnvir
   if (!applied.injected) delete env.ANTHROPIC_API_KEY;
   return env;
 }
+function inheritsUserConfig(env) {
+  return env.OMB_CLAUDE_INHERIT_USER_CONFIG === "1";
+}
+function projectMcpServers(cwd) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync6(join18(cwd, ".mcp.json"), "utf8"));
+  } catch {
+    return {};
+  }
+  const servers = parsed?.mcpServers;
+  if (!servers || typeof servers !== "object" || Array.isArray(servers)) return {};
+  const out = {};
+  for (const [name, server] of Object.entries(servers)) {
+    if (server && typeof server === "object" && !Array.isArray(server)) out[name] = server;
+  }
+  return out;
+}
+function autoCompactWindow(env) {
+  const raw = (env.OMB_CLAUDE_AUTOCOMPACT ?? "").trim().toLowerCase();
+  if (raw === "off") return null;
+  if (raw === "auto") return "auto";
+  const parsed = raw ? Number(raw) : DEFAULT_AUTOCOMPACT_TOKENS;
+  if (!Number.isFinite(parsed) || parsed <= 0) return String(DEFAULT_AUTOCOMPACT_TOKENS);
+  return String(Math.min(1e6, Math.max(1e5, Math.floor(parsed))));
+}
+function parseClaudeCliVersion(stdout2) {
+  const match = /(\d+)\.(\d+)\.(\d+)/.exec(stdout2 ?? "");
+  if (!match) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function versionAtLeast(installed, floor) {
+  for (let i2 = 0; i2 < 3; i2 += 1) {
+    if (installed[i2] !== floor[i2]) return installed[i2] > floor[i2];
+  }
+  return true;
+}
+function claudeCliSupports(version2, flag) {
+  return version2 === null || versionAtLeast(version2, CLAUDE_FLAG_FLOORS[flag]);
+}
+function claudeCliUpdate(version2, cli) {
+  const parsed = parseClaudeCliVersion(version2);
+  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));
+  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.",
+    command: cli === "claude" ? "claude update" : `${cli} update`
+  };
+}
 async function resolveClaudeTurnModel(model, env) {
   if (!model || decodeInjectId(model) || STATIC_CLAUDE_MODELS.options.some((option) => option.id === model)) {
     return model;
@@ -21986,7 +22372,7 @@ function extrasFromUnknown(value) {
 function readClaudeModelCatalog(env = process.env) {
   let settings2 = {};
   try {
-    settings2 = JSON.parse(readFileSync6(join16(resolveClaudeConfigDir(void 0, env), "settings.json"), "utf8"));
+    settings2 = JSON.parse(readFileSync6(join18(resolveClaudeConfigDir(void 0, env), "settings.json"), "utf8"));
   } catch {
     return STATIC_CLAUDE_MODELS;
   }
@@ -22020,12 +22406,7 @@ function systemEndedReply(kind) {
   return kind === "question" ? { behavior: "answer", message: "OpenMausBot: the turn is ending \u2014 wrap up." } : { behavior: "deny", message: "OpenMausBot: the turn ended" };
 }
 function askSummary(ask) {
-  const input = ask.input ?? {};
-  if (typeof input.question === "string") return input.question.slice(0, 300);
-  if (typeof input.command === "string") return input.command.slice(0, 200);
-  if (typeof input.url === "string") return input.url.slice(0, 200);
-  const text2 = JSON.stringify(input);
-  return text2 === "{}" ? ask.tool ?? "tool" : text2.slice(0, 200);
+  return askInputSummary(ask.input) ?? ask.tool ?? "tool";
 }
 function permissionSocketPath(threadId) {
   const prefix = threadId.replace(/[^\w-]/g, "").slice(0, 4);
@@ -22036,7 +22417,7 @@ function brokerSocketCandidates(threadId) {
   const base2 = permissionSocketPath(threadId);
   if (process.platform !== "win32") {
     const scope = createHash5("sha256").update(`${DATA_DIR}\0${process.pid}\0${threadId}`).digest("hex").slice(0, 16);
-    return [base2, join16(tmpdir3(), `omb-perm-${scope}.sock`)];
+    return [base2, join18(tmpdir3(), `omb-perm-${scope}.sock`)];
   }
   return [
     base2,
@@ -22159,7 +22540,7 @@ async function createPermissionBroker(opts) {
   }
   if (!server) throw new Error("claude: permission broker could not bind a local socket");
   const drain = () => {
-    for (const p of [...pending.values()]) {
+    for (const p of Array.from(pending.values())) {
       const { behavior, message: message2 } = systemEndedReply(p.ask.kind);
       p.finish(behavior, message2, "system");
     }
@@ -22234,6 +22615,17 @@ function firstText(content) {
   }
   return "";
 }
+function withVolatileNote(text2, volatile) {
+  const body = volatile.trim() ? `This part of your instructions changed since this session started. It replaces the earlier copy:
+
+${volatile.trim()}` : "The notes that were in your instructions when this session started have been cleared.";
+  const note = `<system-reminder>
+${body}
+</system-reminder>`;
+  return text2 ? `${note}
+
+${text2}` : note;
+}
 function claudeUserMessage(text2, images) {
   if (!images?.length) return { type: "user", message: { role: "user", content: text2 } };
   const content = images.map((image) => ({
@@ -22265,16 +22657,19 @@ function diagnosticClaudeUserMessage(message2) {
     }
   };
 }
-var CLAUDE_ACCOUNT_ENV_KEYS, DRIVER_KIND2, STATIC_CLAUDE_MODELS, CLAUDE_MODEL_ID, PROXY_PATH, PERM_PROXY_PATH, DWEB_PROXY_PATH, NODE_ENV_FLAG, DENY_TIMEOUT_NOTE, QUESTION_TIMEOUT_NOTE, DUPLICATE_ASK_ID_NOTE, ClaudeDriver;
+var CLAUDE_ACCOUNT_ENV_KEYS, DEFAULT_AUTOCOMPACT_TOKENS, CLAUDE_FLAG_FLOORS, CLAUDE_CONTEXT_CONTROL_MIN_VERSION, DRIVER_KIND2, STATIC_CLAUDE_MODELS, CLAUDE_MODEL_ID, PROXY_PATH, PERM_PROXY_PATH, DWEB_PROXY_PATH, NODE_ENV_FLAG, DENY_TIMEOUT_NOTE, QUESTION_TIMEOUT_NOTE, DUPLICATE_ASK_ID_NOTE, ClaudeDriver;
 var init_claude = __esm({
   "server/drivers/claude.ts"() {
     "use strict";
     init_config();
     init_env_path();
     init_procs();
+    init_resume_recovery();
     init_claude_login_auth();
     init_container_computer();
+    init_mcp_gate_config();
     init_contracts();
+    init_tool_summary();
     init_retry();
     init_local_inject();
     init_native();
@@ -22293,6 +22688,13 @@ var init_claude = __esm({
       "CLAUDE_CODE_USE_VERTEX",
       "CLAUDE_CODE_USE_FOUNDRY"
     ];
+    DEFAULT_AUTOCOMPACT_TOKENS = 2e5;
+    CLAUDE_FLAG_FLOORS = {
+      "--strict-mcp-config": [1, 0, 60],
+      "--setting-sources": [1, 0, 122],
+      "--autocompact": [2, 1, 122]
+    };
+    CLAUDE_CONTEXT_CONTROL_MIN_VERSION = CLAUDE_FLAG_FLOORS["--autocompact"];
     DRIVER_KIND2 = "claudeAgent";
     STATIC_CLAUDE_MODELS = {
       default: "claude-sonnet-5",
@@ -22343,6 +22745,7 @@ var init_claude = __esm({
           }
         };
         await refreshModels();
+        let cliVersion = null;
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const sessions = /* @__PURE__ */ new Map();
@@ -22393,7 +22796,7 @@ var init_claude = __esm({
           });
         };
         const emit = (event) => {
-          for (const l of [...listeners]) l(event);
+          for (const l of Array.from(listeners)) l(event);
         };
         const base2 = (threadId, turnId) => ({
           eventId: newEventId(),
@@ -22439,6 +22842,15 @@ var init_claude = __esm({
             args.push("--disallowedTools", config2.disallowedTools.join(","));
           }
           const turnEnvironment = environment();
+          const isolated = !inheritsUserConfig(turnEnvironment);
+          if (isolated) {
+            if (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 && claudeCliSupports(cliVersion, "--autocompact")) {
+            args.push("--autocompact", compactWindow);
+          }
           const turnModel = await resolveClaudeTurnModel(turn.model, turnEnvironment);
           const injected = applyClaudeInject({ ...turnEnvironment }, turnModel);
           if (injected.model) args.push("--model", injected.model);
@@ -22489,9 +22901,23 @@ var init_claude = __esm({
             };
             allowed.push("mcp__dweb");
           }
+          const botOwned = /* @__PURE__ */ new Set();
           for (const [name, server] of Object.entries(turn.integrations?.custom ?? {})) {
             if (name in mcpServers) continue;
             mcpServers[name] = { ...server };
+            botOwned.add(name);
+          }
+          if (isolated && turn.cwd) {
+            for (const [name, server] of Object.entries(projectMcpServers(turn.cwd))) {
+              if (name in mcpServers) continue;
+              mcpServers[name] = server;
+              botOwned.add(name);
+            }
+          }
+          const budget = resultBudget(turnEnvironment);
+          for (const name of botOwned) {
+            const gated = gateServer({ name, server: mcpServers[name], threadId, budget, nodeEnv: NODE_ENV_FLAG });
+            if (gated) mcpServers[name] = gated;
           }
           let broker;
           const socketPath = permissionSocketPath(threadId);
@@ -22502,7 +22928,7 @@ var init_claude = __esm({
           allowed.push("mcp__ogb");
           let mcpConfigPath = null;
           if (Object.keys(mcpServers).length) {
-            mcpConfigPath = join16(mkdtempSync2(join16(tmpdir3(), "omb-mcp-")), "mcp.json");
+            mcpConfigPath = join18(mkdtempSync2(join18(tmpdir3(), "omb-mcp-")), "mcp.json");
             args.push("--mcp-config", mcpConfigPath);
             args.push("--allowedTools", allowed.join(","));
           }
@@ -22513,7 +22939,9 @@ var init_claude = __esm({
           const keyArgs = args.filter((a2, i2) => !privateFileFlags.has(a2) && !privateFileFlags.has(args[i2 - 1] ?? ""));
           const argsKey = JSON.stringify({
             args: keyArgs,
-            system: turn.system ?? null,
+            // the volatile half is deliberately absent: it must not respawn a
+            // healthy session (see Session.volatile)
+            system: turn.systemStable ?? turn.system ?? null,
             mcpServers,
             cwd,
             model: injected.model ?? null,
@@ -22529,7 +22957,10 @@ var init_claude = __esm({
               killCliTree(live.child);
             }, turnId, broker: live.broker });
             emit({ ...base2(threadId, turnId), type: "turn.started" });
-            const written = await writeUser(live, threadId, promptMsg);
+            const volatile = turn.systemVolatile ?? "";
+            const message2 = volatile === live.volatile ? promptMsg : claudeUserMessage(withVolatileNote(turn.text, volatile), turn.images);
+            live.volatile = volatile;
+            const written = await writeUser(live, threadId, message2);
             if (!written) {
               active.delete(threadId);
               live.turn = null;
@@ -22570,7 +23001,7 @@ var init_claude = __esm({
           };
           try {
             if (turn.system) {
-              systemPromptPath = join16(mkdtempSync2(join16(tmpdir3(), "omb-system-")), "prompt.txt");
+              systemPromptPath = join18(mkdtempSync2(join18(tmpdir3(), "omb-system-")), "prompt.txt");
               writeFileSync5(systemPromptPath, turn.system, { mode: 384 });
               args.push("--append-system-prompt-file", systemPromptPath);
             }
@@ -22636,7 +23067,9 @@ var init_claude = __esm({
             mcpConfigPath,
             systemPromptPath,
             argsKey,
+            volatile: turn.systemVolatile ?? "",
             sessionId: sessionId ?? newSessionId,
+            sawInit: false,
             turn: { turnId, settled: false, sawStreamDelta: false },
             idleTimer: null,
             closing: false,
@@ -22676,6 +23109,7 @@ var init_claude = __esm({
             switch (o.type) {
               case "system":
                 if (o.subtype === "init") {
+                  session.sawInit = true;
                   if (typeof o.session_id === "string") session.sessionId = o.session_id;
                   emit({ ...base2(threadId, currentTurnId()), type: "session.started", sessionId: o.session_id, model: o.model });
                 } else if (o.subtype === "thinking_tokens") {
@@ -22712,7 +23146,14 @@ var init_claude = __esm({
                 }
                 for (const b of Array.isArray(msg.content) ? msg.content : []) {
                   if (b.type === "tool_use") {
-                    emit({ ...base2(threadId, currentTurnId()), type: "item.started", itemType: "tool", itemId: b.id, title: b.name });
+                    emit({
+                      ...base2(threadId, currentTurnId()),
+                      type: "item.started",
+                      itemType: "tool",
+                      itemId: b.id,
+                      title: b.name,
+                      summary: commandSummary(b.input)
+                    });
                   }
                 }
                 if (msg.usage) {
@@ -22835,6 +23276,56 @@ var init_claude = __esm({
                 })();
                 return;
               }
+              const resumeFailure = classifyResumeFailure({
+                attempted: Boolean(sessionId),
+                rejected: !session.sawInit,
+                promptSubmitted: session.sawInit,
+                producedOutput: session.turn.sawStreamDelta
+              });
+              if (mayReplay(resumeFailure) && !retry.cancelled) {
+                const recovery = recoveryPromptFor({
+                  recoveryText: turn.recoveryText,
+                  currentText: turn.text,
+                  failure: resumeFailure
+                });
+                session.broker?.close();
+                session.broker = void 0;
+                if (session.mcpConfigPath) {
+                  try {
+                    rmSync2(dirname8(session.mcpConfigPath), { recursive: true, force: true });
+                  } catch {
+                  }
+                  session.mcpConfigPath = null;
+                }
+                if (session.systemPromptPath) {
+                  removePrivateTempDir(session.systemPromptPath);
+                  session.systemPromptPath = null;
+                }
+                sessions.delete(threadId);
+                session.turn = null;
+                active.delete(threadId);
+                emit({
+                  ...base2(threadId, turnId),
+                  type: "turn.retrying",
+                  attempt: retry.attempt + 1,
+                  delayMs: 0,
+                  reason: "resume_rejected"
+                });
+                void (async () => {
+                  try {
+                    await sendTurn({ ...turn, resumeCursor: void 0, recoveryText: void 0, text: recovery.text });
+                  } catch (e) {
+                    retryState.delete(threadId);
+                    emit({
+                      ...base2(threadId, turnId),
+                      type: "runtime.error",
+                      message: e instanceof Error ? e.message : String(e)
+                    });
+                    emit({ ...base2(threadId, turnId), type: "turn.completed", ok: false, stopReason: "exit_before_result", cost: null });
+                  }
+                })();
+                return;
+              }
               retryState.delete(threadId);
               emit({
                 ...base2(threadId, currentTurnId()),
@@ -22887,8 +23378,10 @@ var init_claude = __esm({
             );
           });
           if (!version2) return { state: "unavailable", reason: `\`${config2.cli}\` CLI not found` };
+          cliVersion = parseClaudeCliVersion(version2);
           const auth = await claudeAuthStatus(config2.cli, env);
-          return { state: "available", version: version2, ...auth, billing: "subscription" };
+          const update = claudeCliUpdate(version2, config2.cli);
+          return { state: "available", version: version2, ...auth, ...update ? { update } : {}, billing: "subscription" };
         };
         const generateReview = (prompt, signal) => new Promise((resolve13, reject) => {
           const child = spawnCli(
@@ -22956,6 +23449,7 @@ var init_claude = __esm({
           getAuthentication: (flowId) => login.get(flowId),
           completeAuthentication: (flowId, code) => login.complete(flowId, code),
           cancelAuthentication: () => login.cancel(),
+          signOut: () => login.signOut(),
           adapter: {
             provider: DRIVER_KIND2,
             capabilities: {
@@ -22987,7 +23481,7 @@ var init_claude = __esm({
             hasSession: (threadId) => active.has(threadId),
             stopAll: async () => {
               for (const { stop } of active.values()) stop();
-              for (const threadId of [...sessions.keys()]) closeSession(threadId, "stopAll");
+              for (const threadId of Array.from(sessions.keys())) closeSession(threadId, "stopAll");
             },
             onEvent: (listener) => {
               listeners.add(listener);
@@ -22997,9 +23491,13 @@ var init_claude = __esm({
           generateText: (prompt) => generateReview(prompt),
           reviewPermission: generateReview,
           dispose: async () => {
-            for (const { stop } of active.values()) stop();
-            for (const threadId of [...sessions.keys()]) closeSession(threadId, "dispose");
-            listeners.clear();
+            try {
+              await login.dispose();
+            } finally {
+              for (const { stop } of active.values()) stop();
+              for (const threadId of Array.from(sessions.keys())) closeSession(threadId, "dispose");
+              listeners.clear();
+            }
           }
         };
       }
@@ -23010,7 +23508,7 @@ var init_claude = __esm({
 // server/drivers/codex-catalog.ts
 import { readdirSync as readdirSync2, readFileSync as readFileSync7 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
-import { basename as basename5, join as join17 } from "node:path";
+import { basename as basename5, join as join19 } from "node:path";
 function encodeCodexSelection(provider, model) {
   return `${provider}${SEP}${model}`;
 }
@@ -23126,7 +23624,7 @@ function readCodexAppServerModelCatalog(cli, env, timeoutMs = 8e3) {
 }
 function codexHome(env) {
   if (env.CODEX_HOME) return env.CODEX_HOME;
-  return join17(env.HOME || env.USERPROFILE || homedir10(), ".codex");
+  return join19(env.HOME || env.USERPROFILE || homedir10(), ".codex");
 }
 function unquote(raw) {
   let value = raw.trim();
@@ -23212,11 +23710,11 @@ function niceLabel(model, provider, known, named) {
 }
 function collectCatalogNames(home) {
   const named = /* @__PURE__ */ new Map();
-  for (const file2 of listDir(join17(home, "model-catalogs"))) {
+  for (const file2 of listDir(join19(home, "model-catalogs"))) {
     if (!file2.endsWith(".json")) continue;
     const provider = basename5(file2, ".json").replace(/-models$/, "");
     if (!PROVIDER_ID.test(provider)) continue;
-    const raw = readText(join17(home, "model-catalogs", file2));
+    const raw = readText(join19(home, "model-catalogs", file2));
     if (!raw) continue;
     let parsed;
     try {
@@ -23268,7 +23766,7 @@ async function probeProviderModels(provider, env, fetchImpl) {
 async function readCodexModelCatalog(env = process.env, fetchImpl = fetch, cli) {
   const official = (cli ? await readCodexAppServerModelCatalog(cli, env) : null) ?? STATIC_CODEX_MODELS;
   const home = codexHome(env);
-  const mainText = readText(join17(home, "config.toml"));
+  const mainText = readText(join19(home, "config.toml"));
   if (!mainText) return mergeLocalInject(official, env, fetchImpl);
   const main2 = parseCodexToml(mainText);
   const known = new Map(main2.providers.map((provider) => [provider.id, provider]));
@@ -23283,7 +23781,7 @@ async function readCodexModelCatalog(env = process.env, fetchImpl = fetch, cli)
   remember(main2.modelProvider, main2.model);
   for (const file2 of listDir(home)) {
     if (!file2.endsWith(".config.toml")) continue;
-    const profile = parseCodexToml(readText(join17(home, file2)) ?? "");
+    const profile = parseCodexToml(readText(join19(home, file2)) ?? "");
     for (const provider of profile.providers) {
       if (!known.has(provider.id)) known.set(provider.id, provider);
     }
@@ -23349,8 +23847,8 @@ var init_codex_catalog = __esm({
 
 // server/drivers/codex-instructions.ts
 import { createHash as createHash6 } from "node:crypto";
-import { mkdirSync as mkdirSync6, readFileSync as readFileSync8 } from "node:fs";
-import { join as join18 } from "node:path";
+import { mkdirSync as mkdirSync7, readFileSync as readFileSync8 } from "node:fs";
+import { join as join20 } from "node:path";
 function codexDeveloperInstructions(config2, botInstructions) {
   if (!config2 || typeof config2 !== "object" || Array.isArray(config2)) {
     throw new Error("Codex returned no effective configuration; cannot safely update bot instructions.");
@@ -23364,8 +23862,8 @@ function codexDeveloperInstructions(config2, botInstructions) {
 ${configured}` : botInstructions;
 }
 async function syncCodexInstructions(key, nativeThreadId, instructions, resumed, request) {
-  const directory = join18(DATA_DIR, "codex-instructions");
-  const path3 = join18(directory, `${digest(JSON.stringify([key, nativeThreadId]))}.sha256`);
+  const directory = join20(DATA_DIR, "codex-instructions");
+  const path3 = join20(directory, `${digest(JSON.stringify([key, nativeThreadId]))}.sha256`);
   const fingerprint = digest(instructions);
   let previous;
   try {
@@ -23394,7 +23892,7 @@ async function syncCodexInstructions(key, nativeThreadId, instructions, resumed,
     }
   }
   if (!resumed || previous !== fingerprint) {
-    mkdirSync6(directory, { recursive: true });
+    mkdirSync7(directory, { recursive: true });
     writeFileAtomic(path3, fingerprint, { mode: 384 });
   }
 }
@@ -23412,18 +23910,18 @@ var init_codex_instructions = __esm({
 import { randomUUID as randomUUID9 } from "node:crypto";
 import { realpathSync as realpathSync2 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
-import { basename as basename6, dirname as dirname9, isAbsolute as isAbsolute5, join as join19, resolve as resolve8 } from "node:path";
-import { stripVTControlCharacters as stripVTControlCharacters4 } from "node:util";
+import { basename as basename6, dirname as dirname9, isAbsolute as isAbsolute5, join as join21, resolve as resolve8 } from "node:path";
+import { stripVTControlCharacters as stripVTControlCharacters5 } from "node:util";
 function canonicalPath2(path3) {
   try {
     return realpathSync2(path3);
   } catch {
     const parent = dirname9(path3);
-    return parent === path3 ? path3 : join19(canonicalPath2(parent), basename6(path3));
+    return parent === path3 ? path3 : join21(canonicalPath2(parent), basename6(path3));
   }
 }
 function codexDevicePrompt(output) {
-  const clean = stripVTControlCharacters4(output);
+  const clean = stripVTControlCharacters5(output);
   const lines = clean.split(/\r?\n/).slice(0, -1).map((line) => line.trim());
   if (!lines.some((line) => /^https:\/\/auth\.openai\.com\/codex\/device\/?$/.test(line))) return null;
   const userCode = lines.find((line) => /^[A-Z0-9]{4,8}-[A-Z0-9]{4,8}$/.test(line));
@@ -23441,13 +23939,13 @@ function loginFailure(output) {
   }
   return "ChatGPT sign-in did not finish. Check the server's connection and that device-code login is enabled in ChatGPT, then try again.";
 }
-var DEVICE_URL, MAX_OUTPUT2, authenticatingHomes2, CodexDeviceAuthController;
+var DEVICE_URL, MAX_OUTPUT3, authenticatingHomes2, CodexDeviceAuthController;
 var init_codex_device_auth = __esm({
   "server/drivers/codex-device-auth.ts"() {
     "use strict";
     init_procs();
     DEVICE_URL = "https://auth.openai.com/codex/device";
-    MAX_OUTPUT2 = 16384;
+    MAX_OUTPUT3 = 16384;
     authenticatingHomes2 = /* @__PURE__ */ new Set();
     CodexDeviceAuthController = class {
       flow = null;
@@ -23470,7 +23968,7 @@ var init_codex_device_auth = __esm({
         if (!isAbsolute5(home) || env.CODEX_HOME && !isAbsolute5(env.CODEX_HOME)) {
           throw new Error("Use an absolute HOME and CODEX_HOME path for this server's Codex provider before signing in.");
         }
-        const homeKey = canonicalPath2(resolve8(env.CODEX_HOME || join19(home, ".codex")));
+        const homeKey = canonicalPath2(resolve8(env.CODEX_HOME || join21(home, ".codex")));
         if (authenticatingHomes2.has(homeKey)) {
           throw new Error("A ChatGPT sign-in is already running for this server account. Finish or cancel it before starting another.");
         }
@@ -23549,7 +24047,7 @@ var init_codex_device_auth = __esm({
         if (!isAbsolute5(home) || env.CODEX_HOME && !isAbsolute5(env.CODEX_HOME)) {
           throw new Error("Use an absolute HOME and CODEX_HOME path for this server's Codex provider before signing out.");
         }
-        const homeKey = canonicalPath2(resolve8(env.CODEX_HOME || join19(home, ".codex")));
+        const homeKey = canonicalPath2(resolve8(env.CODEX_HOME || join21(home, ".codex")));
         if (authenticatingHomes2.has(homeKey)) {
           throw new Error("A ChatGPT sign-in is running for this server account. Finish or cancel it before signing out.");
         }
@@ -23592,7 +24090,7 @@ var init_codex_device_auth = __esm({
           child.stdin.end();
           let output = "";
           const receive = (chunk) => {
-            if (output.length < MAX_OUTPUT2) output += chunk.toString("utf8").slice(0, MAX_OUTPUT2 - output.length);
+            if (output.length < MAX_OUTPUT3) output += chunk.toString("utf8").slice(0, MAX_OUTPUT3 - output.length);
           };
           child.stdout.on("data", receive);
           child.stderr.on("data", receive);
@@ -23609,7 +24107,7 @@ var init_codex_device_auth = __esm({
           child.once("close", (code) => {
             clearTimeout(timer);
             if (this.command === child) this.command = null;
-            resolveExec({ code, output: stripVTControlCharacters4(output) });
+            resolveExec({ code, output: stripVTControlCharacters5(output) });
           });
         });
       }
@@ -23627,7 +24125,7 @@ var init_codex_device_auth = __esm({
         let output = "";
         const receive = (chunk) => {
           if (flow.status.phase !== "waiting") return;
-          if (output.length + chunk.length > MAX_OUTPUT2) {
+          if (output.length + chunk.length > MAX_OUTPUT3) {
             this.finish(flow, "failed", "Codex returned an unexpected sign-in response. Update the server's Codex CLI and try again.");
             return;
           }
@@ -23648,7 +24146,7 @@ var init_codex_device_auth = __esm({
         });
         child.once("close", (code) => {
           if (flow.child === child) flow.child = null;
-          if (flow.status.phase === "waiting") done(code, stripVTControlCharacters4(output));
+          if (flow.status.phase === "waiting") done(code, stripVTControlCharacters5(output));
           output = "";
         });
       }
@@ -23708,11 +24206,11 @@ var init_codex_device_auth = __esm({
 
 // server/drivers/codex-identity.ts
 import { homedir as homedir12 } from "node:os";
-import { isAbsolute as isAbsolute6, join as join20, resolve as resolve9 } from "node:path";
+import { isAbsolute as isAbsolute6, join as join22, resolve as resolve9 } from "node:path";
 function codexHome2(env) {
   if (env.CODEX_HOME) return isAbsolute6(env.CODEX_HOME) ? resolve9(env.CODEX_HOME) : null;
   const home = env.HOME || env.USERPROFILE || homedir12();
-  return isAbsolute6(home) ? join20(home, ".codex") : null;
+  return isAbsolute6(home) ? join22(home, ".codex") : null;
 }
 async function codexAccountEmail(cli, env, timeoutMs = 3e3) {
   const cwd = env.HOME || env.USERPROFILE || homedir12();
@@ -23774,7 +24272,7 @@ async function codexAccountEmail(cli, env, timeoutMs = 3e3) {
     child.stdout.on("data", (chunk) => {
       if (finishing) return;
       outputBytes += Buffer.byteLength(chunk);
-      if (outputBytes > MAX_OUTPUT3) {
+      if (outputBytes > MAX_OUTPUT4) {
         void finish(null);
         return;
       }
@@ -23809,18 +24307,18 @@ async function codexAccountEmail(cli, env, timeoutMs = 3e3) {
     send({ id: 1, method: "initialize", params: { clientInfo: { name: "openmausbot", version: "1" } } });
   });
 }
-var MAX_OUTPUT3, EMAIL;
+var MAX_OUTPUT4, EMAIL;
 var init_codex_identity = __esm({
   "server/drivers/codex-identity.ts"() {
     "use strict";
     init_procs();
-    MAX_OUTPUT3 = 16384;
+    MAX_OUTPUT4 = 16384;
     EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
   }
 });
 
 // server/drivers/codex.ts
-import { existsSync as existsSync7 } from "node:fs";
+import { existsSync as existsSync8 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 function codexPredatesAstra(version2) {
   const value = version2.trim();
@@ -23837,7 +24335,7 @@ function codexPredatesAstra(version2) {
 function codexUpdateCommand(cli, platform = process.platform) {
   if (cli === "codex") return "codex update";
   const trimmed = cli.trim();
-  const tokens = trimmed.includes(" ") && existsSync7(trimmed) ? [trimmed] : splitCliString(trimmed);
+  const tokens = trimmed.includes(" ") && existsSync8(trimmed) ? [trimmed] : splitCliString(trimmed);
   const quote = platform === "win32" ? (token) => `'${token.replaceAll("'", "''")}'` : (token) => `'${token.replaceAll("'", `'\\''`)}'`;
   const command = (tokens.length > 0 ? tokens : [trimmed]).map(quote).join(" ");
   return platform === "win32" ? `& ${command} update` : `${command} update`;
@@ -24089,6 +24587,7 @@ var init_codex = __esm({
     init_env_path();
     init_retry();
     init_native();
+    init_tool_summary();
     init_codex_instructions();
     init_codex_device_auth();
     init_codex_identity();
@@ -24153,7 +24652,7 @@ var init_codex = __esm({
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const emit = (event) => {
-          for (const l of [...listeners]) l(event);
+          for (const l of Array.from(listeners)) l(event);
         };
         const base2 = (threadId, turnId) => ({
           eventId: newEventId(),
@@ -24281,7 +24780,7 @@ var init_codex = __esm({
             const settle = async (ok, stopReason) => {
               if (state.settled) return;
               state.settled = true;
-              for (const finish of [...asks.values()]) finish("deny", "OpenMausBot: the turn ended", "system");
+              for (const finish of Array.from(asks.values())) finish("deny", "OpenMausBot: the turn ended", "system");
               for (const p of rpcPending.values()) p.reject(new Error("turn settled"));
               rpcPending.clear();
               const complete = () => {
@@ -24392,7 +24891,16 @@ var init_codex = __esm({
                 case "item/started": {
                   const item = p.item ?? {};
                   const title = item.type === "commandExecution" ? String(item.command ?? "shell") : item.type === "fileChange" ? "edit" : item.type === "mcpToolCall" ? item.tool ?? item.name ?? "mcp" : item.type === "webSearch" ? "web_search" : null;
-                  if (title) emit({ ...base2(threadId, turnId), type: "item.started", itemType: "tool", itemId: item.id, title });
+                  if (title) {
+                    emit({
+                      ...base2(threadId, turnId),
+                      type: "item.started",
+                      itemType: "tool",
+                      itemId: item.id,
+                      title,
+                      summary: item.type === "commandExecution" ? commandSummary({ command: item.command }) : void 0
+                    });
+                  }
                   break;
                 }
                 case "item/completed": {
@@ -25035,12 +25543,12 @@ var init_grok = __esm({
 });
 
 // server/drivers/acp/grok.ts
-import { existsSync as existsSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync9, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "node:fs";
 import { homedir as homedir14 } from "node:os";
-import { join as join21 } from "node:path";
+import { join as join23 } from "node:path";
 function grokHome(env) {
   if (env.GROK_HOME) return env.GROK_HOME;
-  return join21(env.HOME || env.USERPROFILE || homedir14(), ".grok");
+  return join23(env.HOME || env.USERPROFILE || homedir14(), ".grok");
 }
 function unquote2(raw) {
   const value = raw.trim();
@@ -25050,7 +25558,7 @@ function unquote2(raw) {
   return value;
 }
 function readGrokModelCatalog(env = process.env) {
-  const path3 = join21(grokHome(env), "config.toml");
+  const path3 = join23(grokHome(env), "config.toml");
   let text2 = "";
   try {
     text2 = readFileSync9(path3, "utf8");
@@ -25123,7 +25631,7 @@ function ensureGrokInjectSlug(modelId, env = process.env) {
   if (!inject) return modelId;
   const host = localHost(inject.host);
   if (!host) return modelId;
-  const path3 = join21(grokHome(env), "config.toml");
+  const path3 = join23(grokHome(env), "config.toml");
   let text2 = "";
   try {
     text2 = readFileSync9(path3, "utf8");
@@ -25227,9 +25735,13 @@ var init_grok2 = __esm({
       // and BEFORE `stdio` (`grok agent -m slug stdio`). Putting -m first is
       // accepted as a TUI option and then ignored, so ACP session/new keeps
       // [models].default (grok-4.6) and oMLX never sees a request.
+      // Auto selects Grok's native classifier; if its feature gate is disabled,
+      // residual requests still ask. Never replace it with bypassPermissions.
+      // Verified: grok 1.0.3 --help and xai-org/grok-build@37949780,
+      // crates/codegen/xai-grok-pager-bin/src/main.rs:1259-1273.
       spawnArgs: (config2, turn) => [
         "--permission-mode",
-        config2.fullAuto ? "bypassPermissions" : "default",
+        config2.fullAuto ? "bypassPermissions" : turn.approvalMode === "auto" ? "auto" : "default",
         "agent",
         ...turn.model ? ["-m", turn.model] : [],
         // long form on purpose: `--effort` is documented as an alias, and an
@@ -25258,7 +25770,7 @@ var init_grok2 = __esm({
       // an unauthenticated CLI is a user action, not something to paper over.
       pickAuthMethod: (methods) => methods.some((m) => m.id === "cached_token") ? "cached_token" : null,
       authFailure: "fail",
-      isAuthenticated: () => existsSync8(join21(homedir14(), ".grok", "auth.json")),
+      isAuthenticated: () => existsSync9(join23(homedir14(), ".grok", "auth.json")),
       // `--append-system-prompt`/`--rules` are accepted by the CLI but do NOT
       // reach the agent-stdio system prompt (verified against 1.0.0), so the
       // persona is prepended codex-style.
@@ -25271,12 +25783,12 @@ ${turn.text}` : turn.text
 });
 
 // server/drivers/acp/gemini.ts
-import { existsSync as existsSync9, readFileSync as readFileSync10 } from "node:fs";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { join as join22 } from "node:path";
+import { join as join24 } from "node:path";
 function liveOauthCredential() {
   try {
-    const creds = JSON.parse(readFileSync10(join22(homedir15(), ".gemini", "oauth_creds.json"), "utf8"));
+    const creds = JSON.parse(readFileSync10(join24(homedir15(), ".gemini", "oauth_creds.json"), "utf8"));
     if (typeof creds.access_token !== "string" || creds.access_token.trim().length === 0) return false;
     const hasRefresh = typeof creds.refresh_token === "string" && creds.refresh_token.trim().length > 0;
     if (creds.expiry_date !== void 0) {
@@ -25289,7 +25801,7 @@ function liveOauthCredential() {
   }
 }
 function geminiIsAuthenticated(env) {
-  return nonBlank(env.GEMINI_API_KEY) || nonBlank(env.GOOGLE_API_KEY) || existsSync9(join22(homedir15(), ".gemini", "oauth_creds.json")) && liveOauthCredential();
+  return nonBlank(env.GEMINI_API_KEY) || nonBlank(env.GOOGLE_API_KEY) || existsSync10(join24(homedir15(), ".gemini", "oauth_creds.json")) && liveOauthCredential();
 }
 var AUTH_PREFERENCE, nonBlank, support3, GeminiAgentDriver;
 var init_gemini = __esm({
@@ -25331,17 +25843,17 @@ ${turn.text}` : turn.text
 });
 
 // server/drivers/acp/kimi.ts
-import { existsSync as existsSync10, mkdirSync as mkdirSync7, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
+import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "node:fs";
 import { homedir as homedir16 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join25 } from "node:path";
 function isLocalInjectAlias(slug) {
   return LOCAL_PROVIDER_PREFIXES.some((prefix) => slug.startsWith(prefix));
 }
 function kimiDataRoot(env) {
-  return env.KIMI_CODE_HOME || join23(env.HOME || env.USERPROFILE || homedir16(), ".kimi-code");
+  return env.KIMI_CODE_HOME || join25(env.HOME || env.USERPROFILE || homedir16(), ".kimi-code");
 }
 function credentialsPath(env) {
-  return join23(kimiDataRoot(env), "credentials", "kimi-code.json");
+  return join25(kimiDataRoot(env), "credentials", "kimi-code.json");
 }
 function quoteToml2(value) {
   return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
@@ -25628,8 +26140,8 @@ function ensureKimiInjectAlias(modelId, env = process.env) {
   if (!host) return modelId;
   const alias = `${inject.host}/${inject.model.replace(/\//g, "-")}`;
   const dataRoot = kimiDataRoot(env);
-  mkdirSync7(dataRoot, { recursive: true });
-  const path3 = join23(dataRoot, "config.toml");
+  mkdirSync8(dataRoot, { recursive: true });
+  const path3 = join25(dataRoot, "config.toml");
   let text2 = "";
   try {
     text2 = readFileSync11(path3, "utf8");
@@ -25694,7 +26206,7 @@ function readKimiModelCatalog(env) {
   const dataRoot = kimiDataRoot(env);
   let text2 = "";
   try {
-    text2 = readFileSync11(join23(dataRoot, "config.toml"), "utf8");
+    text2 = readFileSync11(join25(dataRoot, "config.toml"), "utf8");
   } catch {
     return STATIC_KIMI_MODELS;
   }
@@ -25803,7 +26315,7 @@ var init_kimi = __esm({
       authFailure: "continue",
       // Match the child CLI's own data-root precedence. A custom instance HOME or
       // KIMI_CODE_HOME must not be checked against the server user's home instead.
-      isAuthenticated: (env) => existsSync10(credentialsPath(env)),
+      isAuthenticated: (env) => existsSync11(credentialsPath(env)),
       buildPromptText: (turn) => turn.system ? `${turn.system}
 
 ${turn.text}` : turn.text
@@ -25813,12 +26325,12 @@ ${turn.text}` : turn.text
 });
 
 // server/drivers/acp/droid.ts
-import { existsSync as existsSync11, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
+import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync8 } from "node:fs";
 import { homedir as homedir17 } from "node:os";
-import { join as join24 } from "node:path";
+import { join as join26 } from "node:path";
 function authFilePaths(env) {
   const home = env.FACTORY_HOME_OVERRIDE || env.HOME || homedir17();
-  return AUTH_FILES.map((name) => join24(home, ".factory", name));
+  return AUTH_FILES.map((name) => join26(home, ".factory", name));
 }
 function droidInjectId(host, model) {
   const safe = `${host}-${model}`.replace(/[^a-zA-Z0-9._+-]+/g, "-").replace(/-+/g, "-");
@@ -25833,14 +26345,14 @@ function ensureDroidInjectModel(modelId, env = process.env) {
   const host = localHost(inject.host);
   if (!host) return modelId;
   const id = droidInjectId(inject.host, inject.model);
-  const dir = join24(factoryHome(env), ".factory");
-  mkdirSync8(dir, { recursive: true });
-  const path3 = join24(dir, "settings.json");
+  const dir = join26(factoryHome(env), ".factory");
+  mkdirSync9(dir, { recursive: true });
+  const path3 = join26(dir, "settings.json");
   let settings2 = {};
   try {
     settings2 = JSON.parse(readFileSync12(path3, "utf8"));
   } catch (error51) {
-    if (existsSync11(path3)) throw error51;
+    if (existsSync12(path3)) throw error51;
   }
   const custom2 = Array.isArray(settings2.customModels) ? [...settings2.customModels] : [];
   const match = custom2.find(
@@ -25871,11 +26383,11 @@ function ensureDroidInjectModel(modelId, env = process.env) {
 function applyDroidLocalAuthEnv(env, modelId) {
   if (!decodeInjectId(modelId)) return;
   if (env.FACTORY_API_KEY?.trim()) return;
-  if (authFilePaths(env).some(existsSync11)) return;
+  if (authFilePaths(env).some(existsSync12)) return;
   env.FACTORY_API_KEY = "openmausbot-local";
 }
 function readSettings(env) {
-  return JSON.parse(readFileSync12(join24(factoryHome(env), ".factory", "settings.json"), "utf8"));
+  return JSON.parse(readFileSync12(join26(factoryHome(env), ".factory", "settings.json"), "utf8"));
 }
 async function resolveModels(env) {
   let catalog = MODELS3;
@@ -25962,7 +26474,7 @@ var init_droid = __esm({
       // The signed-in CLI is the primary source; FACTORY_API_KEY is the fallback
       // droid itself advertises, and it is checked last so an ambient key can
       // never be what makes an otherwise logged-out instance look ready.
-      isAuthenticated: (env) => authFilePaths(env).some(existsSync11) || Boolean(env.FACTORY_API_KEY),
+      isAuthenticated: (env) => authFilePaths(env).some(existsSync12) || Boolean(env.FACTORY_API_KEY),
       resolveModels,
       resolveTurnModel: (model, env) => model ? ensureDroidInjectModel(model, env) : model,
       applyTurnEnv: (env, { requestedModel }) => {
@@ -26086,7 +26598,7 @@ function decodeCursorModelText(text2) {
   for (const raw of text2.split(/\r?\n/)) {
     const line = raw.trim();
     if (!line || line.startsWith("#") || /^available\s+models?\b/i.test(line) || /^models?\b/i.test(line)) continue;
-    const stripped = line.replace(/^[\s*•\-]+\s*/, "");
+    const stripped = line.replace(/^[\s*•-]+\s*/, "");
     const parts = stripped.split(/\s+[—–|:]\s+|\s+-\s+|\s{2,}/);
     const id = (parts[0] ?? "").trim();
     const rawLabel = parts.slice(1).join(" ").trim();
@@ -26265,9 +26777,9 @@ ${turn.text}` : turn.text
 });
 
 // server/drivers/acp/opencode-go.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync9, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "node:fs";
 import { homedir as homedir18 } from "node:os";
-import { join as join25 } from "node:path";
+import { join as join27 } from "node:path";
 function labelForModel(id) {
   return id.split(/[-_.]+/g).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
 }
@@ -26368,7 +26880,7 @@ async function discoverOpenCodeModels(environment, cli = "opencode") {
 }
 function opencodeConfigDir(env) {
   const home = env.HOME || env.USERPROFILE || homedir18();
-  return join25(env.XDG_CONFIG_HOME || join25(home, ".config"), "opencode");
+  return join27(env.XDG_CONFIG_HOME || join27(home, ".config"), "opencode");
 }
 function ensureOpenCodeInjectModel(modelId, env = process.env) {
   const inject = decodeInjectId(modelId);
@@ -26377,10 +26889,10 @@ function ensureOpenCodeInjectModel(modelId, env = process.env) {
   if (!host) return modelId;
   const native = `${inject.host}/${inject.model}`;
   const dir = opencodeConfigDir(env);
-  mkdirSync9(dir, { recursive: true });
-  const path3 = join25(dir, "opencode.json");
+  mkdirSync10(dir, { recursive: true });
+  const path3 = join27(dir, "opencode.json");
   let config2 = { $schema: "https://opencode.ai/config.json" };
-  if (existsSync12(path3)) {
+  if (existsSync13(path3)) {
     try {
       config2 = JSON.parse(readFileSync13(path3, "utf8"));
     } catch {
@@ -26416,10 +26928,10 @@ function ensureOpenCodeInjectModel(modelId, env = process.env) {
 function storedAuthPaths(env) {
   const home = env.HOME || env.USERPROFILE || homedir18();
   const roots = [
-    env.XDG_DATA_HOME || join25(home, ".local", "share"),
-    process.platform === "darwin" ? join25(home, "Library", "Application Support") : process.platform === "win32" ? env.LOCALAPPDATA || join25(home, "AppData", "Local") : ""
+    env.XDG_DATA_HOME || join27(home, ".local", "share"),
+    process.platform === "darwin" ? join27(home, "Library", "Application Support") : process.platform === "win32" ? env.LOCALAPPDATA || join27(home, "AppData", "Local") : ""
   ].filter(Boolean);
-  return [...new Set(roots)].map((root) => join25(root, "opencode", "auth.json"));
+  return [...new Set(roots)].map((root) => join27(root, "opencode", "auth.json"));
 }
 function usableAuthEntry(parsed) {
   return Object.values(parsed).some((auth) => {
@@ -26549,13 +27061,13 @@ ${turn.text}` : turn.text
 });
 
 // server/drivers/acp/qwen.ts
-import { chmodSync as chmodSync4, existsSync as existsSync13, mkdirSync as mkdirSync10, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
+import { chmodSync as chmodSync4, existsSync as existsSync14, mkdirSync as mkdirSync11, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "node:fs";
 import { createHash as createHash7 } from "node:crypto";
 import { homedir as homedir19 } from "node:os";
-import { join as join26 } from "node:path";
+import { join as join28 } from "node:path";
 function qwenHome(env) {
   const home = process.platform === "win32" ? env.USERPROFILE || env.HOME || homedir19() : env.HOME || env.USERPROFILE || homedir19();
-  return join26(home, ".qwen");
+  return join28(home, ".qwen");
 }
 function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
@@ -26567,7 +27079,7 @@ function qwenModelLabel(id, name) {
 function readQwenRoutes(env) {
   let settings2;
   try {
-    settings2 = JSON.parse(readFileSync14(join26(qwenHome(env), "settings.json"), "utf8"));
+    settings2 = JSON.parse(readFileSync14(join28(qwenHome(env), "settings.json"), "utf8"));
   } catch {
     return [];
   }
@@ -26650,10 +27162,10 @@ function ensureQwenInjectModel(modelId, env = process.env) {
   const host = localHost(inject.host);
   if (!host) return modelId;
   const dir = qwenHome(env);
-  mkdirSync10(dir, { recursive: true });
-  const path3 = join26(dir, "settings.json");
+  mkdirSync11(dir, { recursive: true });
+  const path3 = join28(dir, "settings.json");
   let settings2 = {};
-  if (existsSync13(path3)) {
+  if (existsSync14(path3)) {
     try {
       settings2 = JSON.parse(readFileSync14(path3, "utf8"));
     } catch {
@@ -33650,9 +34162,9 @@ var init_browser = __esm({
 
 // server/drivers/acp/hermes.ts
 import { spawn as spawn5 } from "node:child_process";
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync11 } from "node:fs";
 import { homedir as homedir20 } from "node:os";
-import { join as join27 } from "node:path";
+import { join as join29 } from "node:path";
 function bindHermesScreenshotCompat(env, modelId) {
   delete env[HERMES_OPENMAUS_SCREENSHOT_COMPAT];
   delete env[HERMES_OPENMAUS_SCREENSHOT_COMPAT_MODEL];
@@ -33662,7 +34174,7 @@ function bindHermesScreenshotCompat(env, modelId) {
   env[HERMES_OPENMAUS_SCREENSHOT_COMPAT_MODEL] = inject.model;
 }
 function hermesHome(env) {
-  return env.HERMES_HOME || join27(env.HOME || env.USERPROFILE || homedir20(), ".hermes");
+  return env.HERMES_HOME || join29(env.HOME || env.USERPROFILE || homedir20(), ".hermes");
 }
 function quoteYaml(value) {
   if (/^[\w./:+-]+$/.test(value)) return value;
@@ -33703,8 +34215,8 @@ function ensureHermesInjectProvider(modelId, env = process.env) {
   const host = localHost(inject.host);
   if (!host) return modelId;
   const dir = hermesHome(env);
-  mkdirSync11(dir, { recursive: true });
-  const path3 = join27(dir, "config.yaml");
+  mkdirSync12(dir, { recursive: true });
+  const path3 = join29(dir, "config.yaml");
   let text2 = "";
   try {
     text2 = readFileSync15(path3, "utf8");
@@ -33775,13 +34287,13 @@ function hermesConfiguredModel(env = process.env) {
   const dir = hermesHome(env);
   let secrets = "";
   try {
-    secrets = readFileSync15(join27(dir, ".env"), "utf8");
+    secrets = readFileSync15(join29(dir, ".env"), "utf8");
   } catch {
   }
   const hasHostedProviderKey = HERMES_HOSTED_PROVIDER_KEYS.some((name) => nonEmptyDotenvValue(secrets, name));
   let configuredDefault = null;
   try {
-    configuredDefault = hermesConfigDefault(readFileSync15(join27(dir, "config.yaml"), "utf8"));
+    configuredDefault = hermesConfigDefault(readFileSync15(join29(dir, "config.yaml"), "utf8"));
   } catch {
   }
   const configuredProvider = configuredDefault?.provider.toLowerCase() ?? "";
@@ -34101,9 +34613,9 @@ var init_openai_compat = __esm({
 });
 
 // server/drivers/pi.ts
-import { chmodSync as chmodSync5, existsSync as existsSync14, mkdirSync as mkdirSync12, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as rmSync3, writeFileSync as writeFileSync12 } from "node:fs";
+import { chmodSync as chmodSync5, existsSync as existsSync15, mkdirSync as mkdirSync13, mkdtempSync as mkdtempSync3, readFileSync as readFileSync16, rmSync as rmSync3, writeFileSync as writeFileSync12 } from "node:fs";
 import { homedir as homedir21, tmpdir as tmpdir4 } from "node:os";
-import { join as join28 } from "node:path";
+import { join as join30 } from "node:path";
 function readPiPromptImages(turn) {
   return (turn.images ?? []).map((image) => ({
     type: "image",
@@ -34210,7 +34722,7 @@ async function applyPiLocalCatalog(catalog, env = process.env, fetchImpl = fetch
   return preferPiInjectRows(await mergeLocalInject(catalog, env, fetchImpl));
 }
 function piAgentDir(env) {
-  return join28(env.HOME || env.USERPROFILE || homedir21(), ".pi", "agent");
+  return join30(env.HOME || env.USERPROFILE || homedir21(), ".pi", "agent");
 }
 function ensurePiInjectModel(modelId, env = process.env) {
   const split = splitPiModel(modelId);
@@ -34220,10 +34732,10 @@ function ensurePiInjectModel(modelId, env = process.env) {
   const host = localHost(inject.host);
   if (!host) return split;
   const dir = piAgentDir(env);
-  mkdirSync12(dir, { recursive: true });
-  const path3 = join28(dir, "models.json");
+  mkdirSync13(dir, { recursive: true });
+  const path3 = join30(dir, "models.json");
   let root = { providers: {} };
-  if (existsSync14(path3)) {
+  if (existsSync15(path3)) {
     try {
       const parsed = JSON.parse(readFileSync16(path3, "utf8"));
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
@@ -34395,7 +34907,7 @@ var init_pi = __esm({
         const listeners = /* @__PURE__ */ new Set();
         const active = /* @__PURE__ */ new Map();
         const emit = (event) => {
-          for (const l of [...listeners]) l(event);
+          for (const l of Array.from(listeners)) l(event);
         };
         const base2 = (threadId, turnId) => ({
           eventId: newEventId(),
@@ -34423,9 +34935,9 @@ var init_pi = __esm({
           const mcpServers = buildMcpServers(turn);
           let mcpTempDir = null;
           if (mcpServers) {
-            mcpTempDir = mkdtempSync3(join28(tmpdir4(), "omb-pi-mcp-"));
+            mcpTempDir = mkdtempSync3(join30(tmpdir4(), "omb-pi-mcp-"));
             try {
-              writeFileSync12(join28(mcpTempDir, "mcp.json"), JSON.stringify({ mcpServers }), { mode: 384 });
+              writeFileSync12(join30(mcpTempDir, "mcp.json"), JSON.stringify({ mcpServers }), { mode: 384 });
             } catch (err) {
               try {
                 rmSync3(mcpTempDir, { recursive: true, force: true });
@@ -34443,7 +34955,7 @@ var init_pi = __esm({
                 env: piEnvironment({
                   ...process.env,
                   ...input.environment,
-                  ...mcpServers && mcpTempDir ? { OMB_MCP_CONFIG: join28(mcpTempDir, "mcp.json") } : {}
+                  ...mcpServers && mcpTempDir ? { OMB_MCP_CONFIG: join30(mcpTempDir, "mcp.json") } : {}
                 })
               });
             } catch (err) {
@@ -34782,14 +35294,14 @@ ${turn.text}` : turn.text;
 // server/drivers/minimax.ts
 import { readFileSync as readFileSync17 } from "node:fs";
 import { homedir as homedir22 } from "node:os";
-import { join as join29 } from "node:path";
+import { join as join31 } from "node:path";
 function normalizedApiUrl(value) {
   const root = value.trim().replace(/\/+$/, "");
   return root.endsWith("/v1") ? root : `${root}/v1`;
 }
 function loadLocalMiniMaxConfig(home = homedir22()) {
   try {
-    const raw = localConfigSchema.parse(JSON.parse(readFileSync17(join29(home, ".mmx", "config.json"), "utf8")));
+    const raw = localConfigSchema.parse(JSON.parse(readFileSync17(join31(home, ".mmx", "config.json"), "utf8")));
     const configuredUrl = raw.base_url?.trim() ? raw.base_url : raw.region === "cn" ? CN_URL : DEFAULT_URL2;
     return {
       apiKey: raw.api_key?.trim() ?? "",
@@ -35057,7 +35569,7 @@ __export(cli_setup_exports, {
 });
 import { spawn as spawn6 } from "node:child_process";
 import { readFileSync as readFileSync18 } from "node:fs";
-import { join as join30, resolve as resolve10 } from "node:path";
+import { join as join32, resolve as resolve10 } from "node:path";
 import { randomUUID as randomUUID10 } from "node:crypto";
 async function inspect(id, entry) {
   const registry2 = new ProviderRegistry(BUILT_IN_DRIVERS);
@@ -35094,7 +35606,7 @@ function assertDataDir(dataDir) {
 }
 function checkStoredConfig(dataDir) {
   try {
-    parseStoredConfig(JSON.parse(readFileSync18(join30(dataDir, "config.json"), "utf8")));
+    parseStoredConfig(JSON.parse(readFileSync18(join32(dataDir, "config.json"), "utf8")));
   } catch (error51) {
     if (error51.code === "ENOENT") return;
     throw new Error("Existing config.json could not be read or validated. Setup has not changed it; repair it before continuing.");
@@ -35372,7 +35884,7 @@ var init_browser_engine_release = __esm({
 });
 
 // server/browser-bundle-release.ts
-import { join as join31 } from "node:path";
+import { join as join33 } from "node:path";
 function browserBundleSpec(target) {
   if (!Object.hasOwn(CHROME_ASSETS, target)) throw new Error(`Unsupported desktop browser target: ${target}`);
   const pinned = CHROME_ASSETS[target];
@@ -35408,10 +35920,10 @@ function browserBundlePaths(bundleDirectory, target) {
   const spec = browserBundleSpec(target);
   return {
     directory: bundleDirectory,
-    manifest: join31(bundleDirectory, "manifest.json"),
-    engine: join31(bundleDirectory, spec.engine.executable),
-    chrome: join31(bundleDirectory, spec.chrome.executable),
-    licenses: join31(bundleDirectory, "licenses")
+    manifest: join33(bundleDirectory, "manifest.json"),
+    engine: join33(bundleDirectory, spec.engine.executable),
+    chrome: join33(bundleDirectory, spec.chrome.executable),
+    licenses: join33(bundleDirectory, "licenses")
   };
 }
 var CHROME_VERSION, CHROME_ASSETS;
@@ -35466,9 +35978,9 @@ __export(browser_engine_exports, {
 });
 import { spawn as spawn7 } from "node:child_process";
 import { createHash as createHash8, randomBytes as randomBytes3, randomUUID as randomUUID11 } from "node:crypto";
-import { chmodSync as chmodSync6, constants as constants2, copyFileSync, existsSync as existsSync15, mkdirSync as mkdirSync13, readFileSync as readFileSync19, readdirSync as readdirSync3, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync3, unlinkSync as unlinkSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync as chmodSync6, constants as constants2, copyFileSync, existsSync as existsSync16, mkdirSync as mkdirSync14, readFileSync as readFileSync19, readdirSync as readdirSync3, renameSync as renameSync5, rmSync as rmSync4, statSync as statSync3, 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 dirname10, join as join32, resolve as resolve11 } from "node:path";
+import { delimiter as delimiter6, dirname as dirname10, join as join34, resolve as resolve11 } from "node:path";
 function browserRestoreKey(session) {
   if (!/^[A-Za-z0-9_-]{1,96}$/.test(session)) throw new Error("Invalid browser session.");
   return `omb-${createHash8("sha256").update(session).digest("hex")}`;
@@ -35477,15 +35989,15 @@ function browserSessionsDirectory(env) {
   const namespace = env.AGENT_BROWSER_NAMESPACE;
   if (namespace && !/^[a-z0-9]+(?:[-_][a-z0-9]+)*$/.test(namespace)) throw new Error("Invalid browser namespace.");
   const home = (process.platform === "win32" ? env.USERPROFILE : env.HOME) || homedir23();
-  const stateRoot = namespace ? join32(home, ".agent-browser", "namespaces", namespace, "state") : join32(home, ".agent-browser");
-  return join32(stateRoot, "sessions");
+  const stateRoot = namespace ? join34(home, ".agent-browser", "namespaces", namespace, "state") : join34(home, ".agent-browser");
+  return join34(stateRoot, "sessions");
 }
 function managedBrowserConfigPath(env) {
-  return join32(browserSessionsDirectory(env), "..", "omb-managed-config.json");
+  return join34(browserSessionsDirectory(env), "..", "omb-managed-config.json");
 }
 function ensureManagedBrowserConfig(env) {
   const path3 = managedBrowserConfigPath(env);
-  mkdirSync13(dirname10(path3), { recursive: true, mode: 448 });
+  mkdirSync14(dirname10(path3), { recursive: true, mode: 448 });
   try {
     writeFileSync13(path3, "{}\n", { flag: "wx", mode: 384 });
   } catch (error51) {
@@ -35568,12 +36080,12 @@ async function prepareBrowserSessionState(binaryPath, session, options = {}) {
   ensureManagedBrowserConfig(env);
   if (options.persistent === false) return;
   const directory = browserSessionsDirectory(env);
-  const key = join32(directory, session);
+  const key = join34(directory, session);
   let pending = preparedBrowserSessions.get(key);
   if (!pending) {
     pending = (async () => {
-      const targetBase = join32(directory, `${restoreKey}-${session}`);
-      const hasTarget = () => existsSync15(`${targetBase}.json.enc`) || existsSync15(`${targetBase}.json`);
+      const targetBase = join34(directory, `${restoreKey}-${session}`);
+      const hasTarget = () => existsSync16(`${targetBase}.json.enc`) || existsSync16(`${targetBase}.json`);
       if (hasTarget()) return;
       check2();
       if (!await closeBrowserSession(binaryPath, { ...env, AGENT_BROWSER_RESTORE: session }, options.timeoutMs)) {
@@ -35582,7 +36094,7 @@ async function prepareBrowserSessionState(binaryPath, session, options = {}) {
       check2();
       if (hasTarget()) return;
       const candidates = [".json.enc", ".json"].flatMap((suffix) => {
-        const path3 = join32(directory, `${session}-${session}${suffix}`);
+        const path3 = join34(directory, `${session}-${session}${suffix}`);
         try {
           const stat4 = statSync3(path3);
           if (!stat4.isFile()) throw new Error("Saved browser state is not a file.");
@@ -35612,12 +36124,12 @@ async function prepareBrowserSessionState(binaryPath, session, options = {}) {
 function executableName(platform = process.platform) {
   return platform === "win32" ? "agent-browser.exe" : "agent-browser";
 }
-function isMusl(platform = process.platform, exists = existsSync15) {
+function isMusl(platform = process.platform, exists = existsSync16) {
   return platform === "linux" && (exists("/lib/ld-musl-x86_64.so.1") || exists("/lib/ld-musl-aarch64.so.1"));
 }
 function pinnedBinaryPath(dataDir = DATA_DIR, platform = process.platform, arch = process.arch) {
   const version2 = agentBrowserReleaseVersion(resolveAgentBrowserReleaseAsset(platform, arch));
-  return join32(dataDir, ENGINE_DIR, version2, executableName(platform));
+  return join34(dataDir, ENGINE_DIR, version2, executableName(platform));
 }
 function onPath(env, platform, exists) {
   const pathValue = platform === "win32" ? Object.entries(env).findLast(([key]) => key.toUpperCase() === "PATH")?.[1] : env.PATH;
@@ -35633,7 +36145,7 @@ function packagedBrowser(options) {
   const resources = (options.env ?? process.env).OMB_RESOURCES_PATH;
   if (!resources) return null;
   try {
-    return browserBundlePaths(join32(resolve11(resources), "browser-engine"), `${options.platform ?? process.platform}-${options.arch ?? process.arch}`);
+    return browserBundlePaths(join34(resolve11(resources), "browser-engine"), `${options.platform ?? process.platform}-${options.arch ?? process.arch}`);
   } catch {
     return null;
   }
@@ -35644,7 +36156,7 @@ function completePackage(bundle, exists) {
 function resolveAgentBrowserBinary(options = {}) {
   const env = options.env ?? process.env;
   const platform = options.platform ?? process.platform;
-  const exists = options.exists ?? existsSync15;
+  const exists = options.exists ?? existsSync16;
   const override = env.OMB_AGENT_BROWSER_PATH?.trim();
   if (override) return resolve11(override) && exists(resolve11(override)) ? resolve11(override) : null;
   const bundle = packagedBrowser(options);
@@ -35658,8 +36170,8 @@ async function installAgentBrowserBinary(options = {}) {
   const asset = options.asset ?? resolveAgentBrowserReleaseAsset(platform, options.arch ?? process.arch, options.musl ?? isMusl(platform));
   if (!asset) throw new Error(`agent-browser publishes no build for ${platform}-${options.arch ?? process.arch}.`);
   const destination = pinnedBinaryPath(options.dataDir, platform, options.arch);
-  const directory = join32(destination, "..");
-  mkdirSync13(directory, { recursive: true, mode: 448 });
+  const directory = join34(destination, "..");
+  mkdirSync14(directory, { recursive: true, mode: 448 });
   const url2 = agentBrowserReleaseUrl(asset);
   options.log?.(`downloading agent-browser ${agentBrowserReleaseVersion(asset)} (${Math.round(asset.bytes / 1024 / 1024)} MB, digest pinned)`);
   const controller = new AbortController();
@@ -35684,7 +36196,7 @@ async function installAgentBrowserBinary(options = {}) {
 }
 function ensureChrome(binaryPath, options = {}) {
   const bundle = packagedBrowser(options);
-  if (!options.withDeps && bundle && resolve11(binaryPath) === bundle.engine && completePackage(bundle, existsSync15)) {
+  if (!options.withDeps && bundle && resolve11(binaryPath) === bundle.engine && completePackage(bundle, existsSync16)) {
     options.log?.("agent-browser: the bundled browser is ready; no download needed");
     return Promise.resolve();
   }
@@ -35710,14 +36222,14 @@ function ensureChrome(binaryPath, options = {}) {
   });
 }
 function browserEngineEncryptionKey(dataDir = DATA_DIR) {
-  const file2 = join32(dataDir, KEY_FILE);
+  const file2 = join34(dataDir, KEY_FILE);
   try {
     const existing = readFileSync19(file2, "utf8").trim();
     if (/^[0-9a-f]{64}$/u.test(existing)) return existing;
   } catch {
   }
   const key = randomBytes3(32).toString("hex");
-  mkdirSync13(dataDir, { recursive: true });
+  mkdirSync14(dataDir, { recursive: true });
   writeFileAtomic(file2, `${key}
 `, { mode: 384 });
   return key;
@@ -35731,7 +36243,7 @@ function browserEngineStatus(options = {}) {
     const version2 = managed ? agentBrowserReleaseVersion(resolveAgentBrowserReleaseAsset(platform2, options.arch)) : AGENT_BROWSER_VERSION;
     return { kind: "ready", binaryPath, version: version2 };
   }
-  if (bundle && (options.exists ?? existsSync15)(bundle.directory)) {
+  if (bundle && (options.exists ?? existsSync16)(bundle.directory)) {
     return { kind: "unavailable", reason: "The desktop browser bundle is incomplete. Reinstall or update OpenMausBot to repair it.", installable: false };
   }
   const platform = options.platform ?? process.platform;
@@ -35764,13 +36276,13 @@ function agentBrowserIntegration(input) {
     if (sourceEnv[name]) env[name] = sourceEnv[name];
   }
   const bundle = packagedBrowser({ env: sourceEnv });
-  if (!env.AGENT_BROWSER_EXECUTABLE_PATH && bundle && resolve11(input.binaryPath) === bundle.engine && completePackage(bundle, existsSync15)) {
+  if (!env.AGENT_BROWSER_EXECUTABLE_PATH && bundle && resolve11(input.binaryPath) === bundle.engine && completePackage(bundle, existsSync16)) {
     env.AGENT_BROWSER_EXECUTABLE_PATH = bundle.chrome;
   }
   return { command: input.binaryPath, args: ["mcp", "--tools", "core", "--no-webmcp"], env };
 }
 function agentBrowserFrame(input) {
-  const file2 = join32(tmpdir5(), `openmausbot-browser-${randomUUID11()}.png`);
+  const file2 = join34(tmpdir5(), `openmausbot-browser-${randomUUID11()}.png`);
   return new Promise((settle, fail) => {
     const child = spawn7(input.binaryPath, ["screenshot", file2], {
       env: browserRuntimeEnv(input.env),
@@ -35840,8 +36352,8 @@ async function clearBrowserSessionState(binaryPath, session, options = {}) {
     }
   };
   try {
-    for (const base2 of bases) for (const suffix of [".json", ".json.enc", ".json.previous", ".json.enc.previous"]) remove(join32(directory, base2 + suffix));
-    const pendingDirectory = join32(directory, ".tmp");
+    for (const base2 of bases) for (const suffix of [".json", ".json.enc", ".json.previous", ".json.enc.previous"]) remove(join34(directory, base2 + suffix));
+    const pendingDirectory = join34(directory, ".tmp");
     let pendingFiles = [];
     try {
       pendingFiles = readdirSync3(pendingDirectory);
@@ -35849,8 +36361,8 @@ async function clearBrowserSessionState(binaryPath, session, options = {}) {
       if (error51.code !== "ENOENT") throw error51;
     }
     const candidates = bases.map((base2) => new RegExp(`^${base2}-candidate-[0-9]+\\.json(?:\\.enc)?$`));
-    for (const name of pendingFiles) if (candidates.some((candidate) => candidate.test(name))) remove(join32(pendingDirectory, name));
-    preparedBrowserSessions.delete(join32(directory, session));
+    for (const name of pendingFiles) if (candidates.some((candidate) => candidate.test(name))) remove(join34(pendingDirectory, name));
+    preparedBrowserSessions.delete(join34(directory, session));
     return true;
   } catch {
     return false;
@@ -35877,9 +36389,9 @@ var init_browser_engine = __esm({
 // server/cli.ts
 var import_qrcode_terminal = __toESM(require_main(), 1);
 import { spawn as spawn8 } from "node:child_process";
-import { closeSync as closeSync3, existsSync as existsSync16, mkdirSync as mkdirSync14, openSync as openSync3, readFileSync as readFileSync20 } from "node:fs";
+import { closeSync as closeSync3, existsSync as existsSync17, mkdirSync as mkdirSync15, openSync as openSync3, readFileSync as readFileSync20 } from "node:fs";
 import { homedir as homedir24 } from "node:os";
-import { dirname as dirname11, join as join33, resolve as resolve12 } from "node:path";
+import { dirname as dirname11, join as join35, resolve as resolve12 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline/promises";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -38124,7 +38636,7 @@ function parseArgs(argv, env = process.env) {
   const options = {
     command: command === "--help" || command === "-h" ? "help" : command,
     port: Number(env.OMB_PORT || 8799),
-    dataDir: env.OMB_DATA_DIR || join33(homedir24(), ".openmausbot"),
+    dataDir: env.OMB_DATA_DIR || join35(homedir24(), ".openmausbot"),
     tailscale: false,
     tunnel: false,
     client: false,
@@ -38279,7 +38791,7 @@ async function isWorkspaceRunning(options) {
   try {
     const { status, body } = await api(options.port, "/api/health");
     if (status !== 200 || body?.app !== "openmausbot") return false;
-    const expected = readFileSync20(join33(options.dataDir, "environment-id"), "utf8").trim();
+    const expected = readFileSync20(join35(options.dataDir, "environment-id"), "utf8").trim();
     const descriptor = await api(options.port, "/.well-known/openmausbot/environment");
     return /^[0-9a-f-]{36}$/i.test(expected) && descriptor.status === 200 && descriptor.body?.environmentId === expected;
   } catch {
@@ -38479,9 +38991,9 @@ async function runStatus(options, io = defaultIo()) {
   return code;
 }
 async function runAccess(options, io = defaultIo()) {
-  const file2 = join33(options.dataDir, "config.json");
+  const file2 = join35(options.dataDir, "config.json");
   let raw = {};
-  if (existsSync16(file2)) {
+  if (existsSync17(file2)) {
     try {
       const parsed = JSON.parse(readFileSync20(file2, "utf8"));
       if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("not an object");
@@ -38497,7 +39009,7 @@ async function runAccess(options, io = defaultIo()) {
   const members = list(Reflect.get(current, "members"));
   const overridden = process.env.OMB_SIGNIN_EMAILS !== void 0 || process.env.OMB_SIGNIN_MEMBER_EMAILS !== void 0;
   const write = (next) => {
-    mkdirSync14(options.dataDir, { recursive: true, mode: 448 });
+    mkdirSync15(options.dataDir, { recursive: true, mode: 448 });
     writeFileAtomic(file2, `${JSON.stringify({ ...raw, signIn: next }, null, 2)}
 `, { mode: 384 });
   };
@@ -38631,16 +39143,16 @@ async function runBrowser(options, io = defaultIo()) {
   return 0;
 }
 function serverEntry(here = HERE2) {
-  const bundled = join33(here, "index.js");
+  const bundled = join35(here, "index.js");
   const root = resolve12(here, "..");
-  if (existsSync16(bundled)) {
-    const staticDir2 = [join33(root, "dist"), join33(here, "..", "ui")].find((d) => existsSync16(join33(d, "index.html"))) ?? null;
-    const skillsDir = existsSync16(join33(root, "skills")) ? join33(root, "skills") : null;
+  if (existsSync17(bundled)) {
+    const staticDir2 = [join35(root, "dist"), join35(here, "..", "ui")].find((d) => existsSync17(join35(d, "index.html"))) ?? null;
+    const skillsDir = existsSync17(join35(root, "skills")) ? join35(root, "skills") : null;
     return { command: process.execPath, args: [bundled], staticDir: staticDir2, skillsDir };
   }
-  const source = join33(here, "index.ts");
-  const staticDir = existsSync16(join33(root, "dist", "index.html")) ? join33(root, "dist") : null;
-  return { command: process.execPath, args: ["--experimental-strip-types", source], staticDir, skillsDir: existsSync16(join33(root, "skills")) ? join33(root, "skills") : null };
+  const source = join35(here, "index.ts");
+  const staticDir = existsSync17(join35(root, "dist", "index.html")) ? join35(root, "dist") : null;
+  return { command: process.execPath, args: ["--experimental-strip-types", source], staticDir, skillsDir: existsSync17(join35(root, "skills")) ? join35(root, "skills") : null };
 }
 async function planTunnel(options, log) {
   let access2 = null;
@@ -38740,9 +39252,9 @@ async function runServe(options, log = console.log) {
   let child;
   try {
     if (options.guided) {
-      const logsDir = join33(options.dataDir, "logs");
-      mkdirSync14(logsDir, { recursive: true, mode: 448 });
-      logPath = join33(logsDir, `server-${Date.now()}-${process.pid}.log`);
+      const logsDir = join35(options.dataDir, "logs");
+      mkdirSync15(logsDir, { recursive: true, mode: 448 });
+      logPath = join35(logsDir, `server-${Date.now()}-${process.pid}.log`);
       logFd = openSync3(logPath, "wx", 384);
       log("\nStarting your workspace\u2026");
     }
@@ -38934,7 +39446,7 @@ async function runOnboardingCommand(options, io = defaultIo(), startServer = run
     }
     if (options.command === "setup") {
       io.log("\nAll set. Start with: openmausbot (or npx openmausbot without a global install).");
-      if (options.dataDir !== join33(homedir24(), ".openmausbot") || options.port !== 8799) {
+      if (options.dataDir !== join35(homedir24(), ".openmausbot") || options.port !== 8799) {
         io.log(`Use the same --data-dir (${options.dataDir}) and --port (${options.port}) options when starting.`);
       }
       return 0;