@askexenow/exe-os 0.8.85 → 0.8.87

package/dist/tui/App.js

@@ -322,110 +322,6 @@ var init_provider_table = __esm({
   }
 });
 
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import path2 from "path";
-import os2 from "os";
-function ensureDir() {
-  const dir = path2.dirname(QUEUE_PATH);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-}
-function readQueue() {
-  try {
-    if (!existsSync3(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync3(QUEUE_PATH, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writeQueue(queue) {
-  ensureDir();
-  const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
-  renameSync(tmp, QUEUE_PATH);
-}
-function queueIntercom(targetSession, reason) {
-  const queue = readQueue();
-  const existing = queue.find((q) => q.targetSession === targetSession);
-  if (existing) {
-    existing.attempts++;
-    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-    existing.reason = reason;
-  } else {
-    queue.push({
-      targetSession,
-      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      attempts: 0,
-      reason
-    });
-  }
-  writeQueue(queue);
-}
-var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
-var init_intercom_queue = __esm({
-  "src/lib/intercom-queue.ts"() {
-    "use strict";
-    QUEUE_PATH = path2.join(os2.homedir(), ".exe-os", "intercom-queue.json");
-    TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path2.join(os2.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/db-retry.ts
-function isBusyError(err) {
-  if (err instanceof Error) {
-    const msg = err.message.toLowerCase();
-    return msg.includes("sqlite_busy") || msg.includes("database is locked");
-  }
-  return false;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retryOnBusy(fn, label) {
-  let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (!isBusyError(err) || attempt === MAX_RETRIES) {
-        throw err;
-      }
-      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
-      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
-      process.stderr.write(
-        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
-`
-      );
-      await delay(backoff + jitter);
-    }
-  }
-  throw lastError;
-}
-function wrapWithRetry(client) {
-  return new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop === "execute") {
-        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
-      }
-      if (prop === "batch") {
-        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
-var init_db_retry = __esm({
-  "src/lib/db-retry.ts"() {
-    "use strict";
-    MAX_RETRIES = 3;
-    BASE_DELAY_MS = 200;
-    MAX_JITTER_MS = 300;
-  }
-});
-
 // src/lib/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -443,17 +339,17 @@ __export(config_exports, {
   saveConfig: () => saveConfig
 });
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync as readFileSync4, existsSync as existsSync4, renameSync as renameSync2 } from "fs";
-import path3 from "path";
-import os3 from "os";
+import { readFileSync as readFileSync3, existsSync as existsSync3, renameSync } from "fs";
+import path2 from "path";
+import os2 from "os";
 function resolveDataDir() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path3.join(os3.homedir(), ".exe-os");
-  const legacyDir = path3.join(os3.homedir(), ".exe-mem");
-  if (!existsSync4(newDir) && existsSync4(legacyDir)) {
+  const newDir = path2.join(os2.homedir(), ".exe-os");
+  const legacyDir = path2.join(os2.homedir(), ".exe-mem");
+  if (!existsSync3(newDir) && existsSync3(legacyDir)) {
     try {
-      renameSync2(legacyDir, newDir);
+      renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
 `);
     } catch {
@@ -515,9 +411,9 @@ function normalizeAutoUpdate(raw) {
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync4(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync3(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   const raw = await readFile(configPath, "utf-8");
   try {
@@ -535,38 +431,38 @@ async function loadConfig() {
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os3.homedir());
+      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
     }
     return config;
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync4(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync3(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   try {
-    const raw = readFileSync4(configPath, "utf-8");
+    const raw = readFileSync3(configPath, "utf-8");
     let parsed = JSON.parse(raw);
     parsed = migrateLegacyConfig(parsed);
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 async function saveConfig(config) {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
+  const configPath = path2.join(dir, "config.json");
   await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
   if (config.cloud?.apiKey) {
     await chmod(configPath, 384);
@@ -591,10 +487,10 @@ var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path3.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path3.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path3.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path3.join(EXE_AI_DIR, "local.lance");
+    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
       config_version: CURRENT_CONFIG_VERSION,
@@ -666,6 +562,161 @@ var init_config = __esm({
   }
 });
 
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    "use strict";
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "exec",
+        autoApproveFlag: "--full-auto",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.4"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+// src/lib/agent-config.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import path3 from "path";
+function loadAgentConfig() {
+  if (!existsSync4(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync4(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+var AGENT_CONFIG_PATH, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path3.join(EXE_AI_DIR, "agent-config.json");
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: "minimax-m2.7"
+    };
+  }
+});
+
+// src/lib/intercom-queue.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync as renameSync2, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import path4 from "path";
+import os3 from "os";
+function ensureDir() {
+  const dir = path4.dirname(QUEUE_PATH);
+  if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
+}
+function readQueue() {
+  try {
+    if (!existsSync5(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync5(QUEUE_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeQueue(queue) {
+  ensureDir();
+  const tmp = `${QUEUE_PATH}.tmp`;
+  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  renameSync2(tmp, QUEUE_PATH);
+}
+function queueIntercom(targetSession, reason) {
+  const queue = readQueue();
+  const existing = queue.find((q) => q.targetSession === targetSession);
+  if (existing) {
+    existing.attempts++;
+    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    existing.reason = reason;
+  } else {
+    queue.push({
+      targetSession,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0,
+      reason
+    });
+  }
+  writeQueue(queue);
+}
+var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
+var init_intercom_queue = __esm({
+  "src/lib/intercom-queue.ts"() {
+    "use strict";
+    QUEUE_PATH = path4.join(os3.homedir(), ".exe-os", "intercom-queue.json");
+    TTL_MS = 60 * 60 * 1e3;
+    INTERCOM_LOG = path4.join(os3.homedir(), ".exe-os", "intercom.log");
+  }
+});
+
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
+  }
+});
+
 // src/lib/employees.ts
 var employees_exports = {};
 __export(employees_exports, {
@@ -693,9 +744,9 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, symlinkSync, readlinkSync, readFileSync as readFileSync6, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import path4 from "path";
+import path5 from "path";
 import os4 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -732,7 +783,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) {
+  if (!existsSync6(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -743,13 +794,13 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path4.dirname(employeesPath), { recursive: true });
+  await mkdir2(path5.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) return [];
+  if (!existsSync6(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync6(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -800,14 +851,14 @@ async function normalizeRosterCase(rosterPath) {
       emp.name = emp.name.toLowerCase();
       changed = true;
       try {
-        const identityDir = path4.join(os4.homedir(), ".exe-os", "identity");
-        const oldPath = path4.join(identityDir, `${oldName}.md`);
-        const newPath = path4.join(identityDir, `${emp.name}.md`);
-        if (existsSync5(oldPath) && !existsSync5(newPath)) {
+        const identityDir = path5.join(os4.homedir(), ".exe-os", "identity");
+        const oldPath = path5.join(identityDir, `${oldName}.md`);
+        const newPath = path5.join(identityDir, `${emp.name}.md`);
+        if (existsSync6(oldPath) && !existsSync6(newPath)) {
           renameSync3(oldPath, newPath);
-        } else if (existsSync5(oldPath) && oldPath !== newPath) {
-          const content = readFileSync5(oldPath, "utf-8");
-          writeFileSync3(newPath, content, "utf-8");
+        } else if (existsSync6(oldPath) && oldPath !== newPath) {
+          const content = readFileSync6(oldPath, "utf-8");
+          writeFileSync4(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
             unlinkSync(oldPath);
           }
@@ -837,7 +888,7 @@ function registerBinSymlinks(name) {
     errors.push("Could not find 'exe-os' in PATH");
     return { created, skipped, errors };
   }
-  const binDir = path4.dirname(exeBinPath);
+  const binDir = path5.dirname(exeBinPath);
   let target;
   try {
     target = readlinkSync(exeBinPath);
@@ -847,8 +898,8 @@ function registerBinSymlinks(name) {
   }
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
-    const linkPath = path4.join(binDir, linkName);
-    if (existsSync5(linkPath)) {
+    const linkPath = path5.join(binDir, linkName);
+    if (existsSync6(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -866,7 +917,7 @@ var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
-    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
+    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
     DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
     COORDINATOR_ROLE = "COO";
     MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
@@ -877,8 +928,8 @@ var init_employees = __esm({
 import net from "net";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync6, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
-import path5 from "path";
+import { existsSync as existsSync7, unlinkSync as unlinkSync2, readFileSync as readFileSync7, openSync, closeSync, statSync } from "fs";
+import path6 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -906,9 +957,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync6(PID_PATH)) {
+  if (existsSync7(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync7(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -929,11 +980,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path5.dirname(fileURLToPath(import.meta.url));
-  const { root } = path5.parse(dir);
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  const { root } = path6.parse(dir);
   while (dir !== root) {
-    if (existsSync6(path5.join(dir, "package.json"))) return dir;
-    dir = path5.dirname(dir);
+    if (existsSync7(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
   }
   return null;
 }
@@ -943,8 +994,8 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path5.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync6(daemonPath)) {
+  const daemonPath = path6.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync7(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -952,7 +1003,7 @@ function spawnDaemon() {
   const resolvedPath = daemonPath;
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path5.join(path5.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path6.join(path6.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -1097,9 +1148,9 @@ var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path5.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path5.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path5.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path6.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path6.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path6.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -2340,9 +2391,9 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path6 from "path";
+import path7 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -2353,37 +2404,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path6.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path7.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync7(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
+    if (existsSync8(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync8(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync7(DEVICE_ID_PATH)) {
-      const id2 = readFileSync7(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync8(DEVICE_ID_PATH)) {
+      const id2 = readFileSync8(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
   }
   const id = randomUUID2();
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
+  mkdirSync4(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync7(LICENSE_PATH)) return null;
-    return readFileSync7(LICENSE_PATH, "utf8").trim();
+    if (!existsSync8(LICENSE_PATH)) return null;
+    return readFileSync8(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync4(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -2409,8 +2460,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync7(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
+    if (!existsSync8(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -2419,8 +2470,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync7(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
+    if (!existsSync8(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -2454,7 +2505,7 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync5(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -2518,9 +2569,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path6.join(EXE_AI_DIR, "config.json");
-      if (existsSync7(configPath)) {
-        const raw = JSON.parse(readFileSync7(configPath, "utf8"));
+      const configPath = path7.join(EXE_AI_DIR, "config.json");
+      if (existsSync8(configPath)) {
+        const raw = JSON.parse(readFileSync8(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -2679,9 +2730,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path6.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path6.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path6.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path7.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path7.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -2711,12 +2762,12 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
-import path7 from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
+import path8 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync8(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
+    if (!existsSync9(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync9(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -2754,8 +2805,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync8(filePath)) {
-      const raw = readFileSync8(filePath, "utf8");
+    if (existsSync9(filePath)) {
+      const raw = readFileSync9(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -2784,19 +2835,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path7.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto from "crypto";
-import path8 from "path";
+import path9 from "path";
 import os5 from "os";
 import {
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   readdirSync,
   unlinkSync as unlinkSync3,
-  existsSync as existsSync9,
+  existsSync as existsSync10,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -2947,11 +2998,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto3 from "crypto";
-import path9 from "path";
+import path10 from "path";
 import os6 from "os";
 import { execSync as execSync5 } from "child_process";
 import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -3126,8 +3177,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir3(path9.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir3(path9.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir3(path10.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir3(path10.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -3163,10 +3214,10 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path9.join(os6.homedir(), ".exe-os");
-      const mdPath = path9.join(EXE_OS_DIR, taskFile);
-      const mdDir = path9.dirname(mdPath);
-      if (!existsSync10(mdDir)) await mkdir3(mdDir, { recursive: true });
+      const EXE_OS_DIR = path10.join(os6.homedir(), ".exe-os");
+      const mdPath = path10.join(EXE_OS_DIR, taskFile);
+      const mdDir = path10.dirname(mdPath);
+      if (!existsSync11(mdDir)) await mkdir3(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
 
@@ -3191,7 +3242,11 @@ If you skip this, your reviewer will not know you're done and your work won't be
 Do NOT let a failed commit or any error prevent you from calling update_task(done).
 `;
       await writeFile3(mdPath, mdContent, "utf-8");
-    } catch {
+    } catch (err) {
+      process.stderr.write(
+        `[create-task] WARNING: .md file write failed for ${taskFile}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
     }
   }
   return {
@@ -3451,9 +3506,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path9.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path10.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync10(archPath)) return;
+    if (existsSync11(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -3486,10 +3541,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path9.join(baseDir, ".gitignore");
+  const gitignorePath = path10.join(baseDir, ".gitignore");
   try {
-    if (existsSync10(gitignorePath)) {
-      const content = readFileSync10(gitignorePath, "utf-8");
+    if (existsSync11(gitignorePath)) {
+      const content = readFileSync11(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -3520,8 +3575,8 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path10 from "path";
-import { existsSync as existsSync11, readdirSync as readdirSync2, unlinkSync as unlinkSync4 } from "fs";
+import path11 from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync2, unlinkSync as unlinkSync4 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -3702,11 +3757,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path10.join(EXE_AI_DIR, "session-cache");
-    if (existsSync11(cacheDir)) {
+    const cacheDir = path11.join(EXE_AI_DIR, "session-cache");
+    if (existsSync12(cacheDir)) {
       for (const f of readdirSync2(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync4(path10.join(cacheDir, f));
+          unlinkSync4(path11.join(cacheDir, f));
         }
       }
     }
@@ -3727,7 +3782,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path11 from "path";
+import path12 from "path";
 import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -3744,7 +3799,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path11.join(baseDir, String(ur.task_file));
+        const ubFile = path12.join(baseDir, String(ur.task_file));
         let ubContent = await readFile3(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -3813,7 +3868,7 @@ var init_tasks_chain = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync6 } from "child_process";
-import path12 from "path";
+import path13 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -3826,7 +3881,7 @@ function getProjectName(cwd2) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path12.dirname(gitCommonDir);
+      repoRoot = path13.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync6("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -3835,11 +3890,11 @@ function getProjectName(cwd2) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path12.basename(repoRoot);
+    _cached2 = path13.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path12.basename(dir);
+    _cached2 = path13.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -4312,8 +4367,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path13 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, unlinkSync as unlinkSync5 } from "fs";
+import path14 from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -4332,11 +4387,11 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path13.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path13.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync4(cacheDir, { recursive: true });
-      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync5(cacheDir, { recursive: true });
+      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
         unlinkSync5(cachePath);
@@ -4803,13 +4858,13 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync3, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync12, appendFileSync } from "fs";
-import path14 from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync13, appendFileSync } from "fs";
+import path15 from "path";
 import os7 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { unlinkSync as unlinkSync6 } from "fs";
 function spawnLockPath(sessionName) {
-  return path14.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path15.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -4820,13 +4875,13 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync12(SPAWN_LOCK_DIR)) {
-    mkdirSync5(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync13(SPAWN_LOCK_DIR)) {
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync12(lockFile)) {
+  if (existsSync13(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync11(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -4834,7 +4889,7 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync6(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync7(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
@@ -4846,13 +4901,13 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path14.join(
-      path14.dirname(thisFile),
+    const scriptPath = path15.join(
+      path15.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync12(scriptPath) ? scriptPath : null;
+    return existsSync13(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -4918,12 +4973,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync12(SESSION_CACHE)) {
-    mkdirSync5(SESSION_CACHE, { recursive: true });
+  if (!existsSync13(SESSION_CACHE)) {
+    mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync6(filePath, JSON.stringify({
+  const filePath = path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync7(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -4931,7 +4986,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync12(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -4939,8 +4994,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(
-      path14.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync12(
+      path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -5001,32 +5056,50 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync12(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync13(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
   } catch {
     return {};
   }
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync12(SESSION_CACHE)) mkdirSync5(SESSION_CACHE, { recursive: true });
-    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync13(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync7(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
 function isDebounced(targetSession) {
   const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+  const entry = state[targetSession];
+  const lastSent = entry?.lastSent ?? 0;
+  if (Date.now() - lastSent < INTERCOM_DEBOUNCE_MS) {
+    if (!state[targetSession]) state[targetSession] = { lastSent, pending: 0 };
+    state[targetSession].pending++;
+    writeDebounceState(state);
+    return true;
+  }
+  return false;
 }
 function recordDebounce(targetSession) {
   const state = readDebounceState();
-  state[targetSession] = Date.now();
+  const batched = state[targetSession]?.pending ?? 0;
+  state[targetSession] = { lastSent: Date.now(), pending: 0 };
   const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
   for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
+    if ((state[key]?.lastSent ?? 0) < cutoff) delete state[key];
   }
   writeDebounceState(state);
+  return batched;
 }
 function logIntercom(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
@@ -5071,7 +5144,7 @@ function sendIntercom(targetSession) {
     return "skipped_exe";
   }
   if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (nudge batched, task safe in DB)`);
     return "debounced";
   }
   try {
@@ -5083,14 +5156,14 @@ function sendIntercom(targetSession) {
     const sessionState = getSessionState(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (sessionState === "thinking" || sessionState === "tool") {
       queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (transport.isPaneInCopyMode(targetSession)) {
@@ -5098,8 +5171,8 @@ function sendIntercom(targetSession) {
       transport.sendKeys(targetSession, "q");
     }
     transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    const batched = recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession}${batched > 0 ? ` [${batched} nudges batched during debounce]` : ""} (fire-and-forget)`);
     return "delivered";
   } catch {
     logIntercom(`FAIL \u2192 ${targetSession}`);
@@ -5201,26 +5274,26 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path14.join(os7.homedir(), ".exe-os", "session-logs");
-  const logFile = path14.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync12(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+  const logDir = path15.join(os7.homedir(), ".exe-os", "session-logs");
+  const logFile = path15.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync13(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path14.join(path14.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync12(cleanupScript)) {
+    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync13(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path14.join(os7.homedir(), ".claude.json");
+    const claudeJsonPath = path15.join(os7.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -5228,17 +5301,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync6(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync7(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path14.join(os7.homedir(), ".claude", "projects");
+    const settingsDir = path15.join(os7.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path14.join(settingsDir, normalizedKey);
-    const settingsPath = path14.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path15.join(settingsDir, normalizedKey);
+    const settingsPath = path15.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -5266,20 +5339,23 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync5(projSettingsDir, { recursive: true });
-      writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync6(projSettingsDir, { recursive: true });
+      writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
   const spawnCwd = opts?.cwd ?? projectDir;
   const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
+  const agentRtConfig = getAgentRuntime(employeeName);
+  const useCodex = !useExeAgent && agentRtConfig.runtime === "codex";
+  const useOpencode = !useExeAgent && !useCodex && agentRtConfig.runtime === "opencode";
+  const ccProvider = useExeAgent || useCodex || useOpencode ? DEFAULT_PROVIDER : detectActiveProvider();
   const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
   let identityFlag = "";
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path14.join(
+    const identityPath = path15.join(
       os7.homedir(),
       ".exe-os",
       "identity",
@@ -5289,13 +5365,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync12(identityPath)) {
+    } else if (existsSync13(identityPath)) {
       identityFlag = ` --append-system-prompt-file ${identityPath}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path14.basename(spawnCwd),
+      path15.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -5310,16 +5386,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path14.join(os7.homedir(), ".exe-os", "session-cache");
-    mkdirSync5(ctxDir, { recursive: true });
-    const ctxFile = path14.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path15.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
+    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync6(ctxFile, ctxContent);
+    writeFileSync7(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -5333,9 +5409,48 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       }
     }
   }
+  if (useCodex) {
+    const codexCfg = RUNTIME_TABLE.codex;
+    if (codexCfg?.apiKeyEnv) {
+      const keyVal = process.env[codexCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${codexCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} EXE_AGENT_MODEL=${agentRtConfig.model}`;
+  }
+  if (useOpencode) {
+    const ocCfg = PROVIDER_TABLE.opencode;
+    if (ocCfg?.apiKeyEnv) {
+      const keyVal = process.env[ocCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${ocCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+  }
+  if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
+    const defaultClaudeModel = DEFAULT_MODELS.claude;
+    if (agentRtConfig.runtime === "claude" && agentRtConfig.model !== defaultClaudeModel) {
+      envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+    }
+  }
   let spawnCommand;
   if (useExeAgent) {
     spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
+  } else if (useCodex) {
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+  } else if (useOpencode) {
+    const binName = `${employeeName}-opencode`;
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 opencode (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
   } else if (useBinSymlink) {
     const binName = `${employeeName}-${ccProvider}`;
     process.stderr.write(
@@ -5357,11 +5472,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path14.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync6(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync7(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
+      runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+      model: useCodex ? agentRtConfig.model : useOpencode ? agentRtConfig.model : void 0,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }));
   } catch {
@@ -5379,6 +5496,11 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
           booted = true;
           break;
         }
+      } else if (useCodex) {
+        if (pane.includes("codex") || pane.includes("Codex") || pane.includes("exe-start-codex")) {
+          booted = true;
+          break;
+        }
       } else {
         if (pane.includes("Claude Code") || pane.includes("\u276F")) {
           booted = true;
@@ -5390,9 +5512,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   if (!booted) {
     releaseSpawnLock2(sessionName);
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
+    const runtimeLabel = useExeAgent ? "exe-agent" : useCodex ? "codex" : "claude";
+    return { sessionName, error: `${runtimeLabel} did not boot within 15s` };
   }
-  if (!useExeAgent) {
+  if (!useExeAgent && !useCodex) {
     try {
       transport.sendKeys(sessionName, `/exe-call ${employeeName}`);
     } catch {
@@ -5419,17 +5542,19 @@ var init_tmux_routing = __esm({
     init_cc_agent_support();
     init_mcp_prefix();
     init_provider_table();
+    init_agent_config();
+    init_runtime_table();
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path14.join(os7.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path14.join(os7.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path15.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path15.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path14.join(os7.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path14.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path15.join(os7.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -7298,10 +7423,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path15 from "path";
+import path16 from "path";
 import os8 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path15.resolve(filePath);
+  const resolved = path16.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -7311,7 +7436,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path15.resolve(filePath);
+  const resolved = path16.resolve(filePath);
   const credPatterns = BYPASS_IMMUNE_PATTERNS.filter(
     (p) => typeof p.pattern !== "function" && (p.reason.includes("secrets") || p.reason.includes("Private key") || p.reason.includes("Credential"))
   );
@@ -7337,11 +7462,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path15.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path16.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path15.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path16.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -7358,7 +7483,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path15.basename(p);
+          const name = path16.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -7385,7 +7510,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path16 from "path";
+import path17 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -7421,7 +7546,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path16.isAbsolute(input.file_path) ? input.file_path : path16.resolve(context.cwd, input.file_path);
+        const filePath = path17.isAbsolute(input.file_path) ? input.file_path : path17.resolve(context.cwd, input.file_path);
         let stat;
         try {
           stat = await fs3.stat(filePath);
@@ -7461,7 +7586,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path17 from "path";
+import path18 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -7477,7 +7602,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path17.join(current, entry.name);
+      const fullPath = path18.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -7511,11 +7636,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path17.isAbsolute(input.path) ? input.path : path17.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path18.isAbsolute(input.path) ? input.path : path18.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path17.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path18.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -7541,7 +7666,7 @@ __export(grep_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path18 from "path";
+import path19 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -7595,7 +7720,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path18.join(dir, entry.name);
+      const fullPath = path19.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -7641,7 +7766,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path18.isAbsolute(input.path) ? input.path : path18.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path19.isAbsolute(input.path) ? input.path : path19.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -7666,7 +7791,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path19 from "path";
+import path20 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -7694,8 +7819,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path19.isAbsolute(input.file_path) ? input.file_path : path19.resolve(context.cwd, input.file_path);
-        const dir = path19.dirname(filePath);
+        const filePath = path20.isAbsolute(input.file_path) ? input.file_path : path20.resolve(context.cwd, input.file_path);
+        const dir = path20.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -7713,7 +7838,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path20 from "path";
+import path21 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -7754,7 +7879,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path20.isAbsolute(input.file_path) ? input.file_path : path20.resolve(context.cwd, input.file_path);
+        const filePath = path21.isAbsolute(input.file_path) ? input.file_path : path21.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -8419,14 +8544,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync13 } from "fs";
-import path23 from "path";
+import { existsSync as existsSync14 } from "fs";
+import path24 from "path";
 import os9 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path23.join(os9.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path24.join(os9.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path23.join(getKeyDir(), "master.key");
+  return path24.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -8447,7 +8572,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync13(keyPath)) {
+  if (!existsSync14(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os9.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
@@ -8490,7 +8615,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync13(keyPath)) {
+  if (existsSync14(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -8790,8 +8915,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path25, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path25}`;
+async function wikiFetch(config, path26, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path26}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
@@ -8824,7 +8949,7 @@ async function wikiFetch(config, path25, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path25}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path26}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -8945,13 +9070,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path24 from "path";
-import { existsSync as existsSync14, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
+import path25 from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync14(SHARDS_DIR)) {
-    mkdirSync6(SHARDS_DIR, { recursive: true });
+  if (!existsSync15(SHARDS_DIR)) {
+    mkdirSync7(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
 }
@@ -8971,7 +9096,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path24.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path25.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -8981,10 +9106,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync14(path24.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync15(path25.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync14(SHARDS_DIR)) return [];
+  if (!existsSync15(SHARDS_DIR)) return [];
   return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -9170,7 +9295,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path24.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path25.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -13740,8 +13865,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // src/tui/ink/components/ErrorOverview.js
-var cleanupPath = (path25) => {
-  return path25?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path26) => {
+  return path26?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new StackUtils({
   cwd: cwd(),
@@ -15673,11 +15798,11 @@ function Footer() {
       } catch {
       }
       try {
-        const { existsSync: existsSync15 } = await import("fs");
+        const { existsSync: existsSync16 } = await import("fs");
         const { join } = await import("path");
         const home = process.env.HOME ?? "";
         const pidPath = join(home, ".exe-os", "exed.pid");
-        setDaemon(existsSync15(pidPath) ? "running" : "stopped");
+        setDaemon(existsSync16(pidPath) ? "running" : "stopped");
       } catch {
         setDaemon("unknown");
       }
@@ -15759,7 +15884,7 @@ function Footer() {
 // src/tui/views/CommandCenter.tsx
 import { useState as useState6, useEffect as useEffect8, useMemo as useMemo4, useCallback as useCallback4, useRef as useRef4 } from "react";
 import TextInput from "ink-text-input";
-import path21 from "path";
+import path22 from "path";
 import { homedir } from "os";
 
 // src/tui/components/StatusDot.tsx
@@ -16546,15 +16671,15 @@ function CommandCenterView({
         const { createPermissionsFromPreset: createPermissionsFromPreset2, EMPLOYEE_PERMISSIONS: EMPLOYEE_PERMISSIONS2 } = await Promise.resolve().then(() => (init_permissions(), permissions_exports));
         const { getPresetByRole: getPresetByRole2 } = await Promise.resolve().then(() => (init_permission_presets(), permission_presets_exports));
         const { createDefaultHooks: createDefaultHooks2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
-        const { readFileSync: readFileSync12, existsSync: existsSync15 } = await import("fs");
+        const { readFileSync: readFileSync13, existsSync: existsSync16 } = await import("fs");
         const { join } = await import("path");
         const { homedir: homedir3 } = await import("os");
         const configPath = join(homedir3(), ".exe-os", "config.json");
         let failoverChain = ["anthropic", "opencode", "gemini", "openai"];
         let providerConfigs = {};
-        if (existsSync15(configPath)) {
+        if (existsSync16(configPath)) {
           try {
-            const raw = JSON.parse(readFileSync12(configPath, "utf8"));
+            const raw = JSON.parse(readFileSync13(configPath, "utf8"));
             if (Array.isArray(raw.failoverChain)) failoverChain = raw.failoverChain;
             if (raw.providers && typeof raw.providers === "object") {
               providerConfigs = raw.providers;
@@ -16615,7 +16740,7 @@ function CommandCenterView({
           const markerDir = join(homedir3(), ".exe-os", "session-cache");
           const agentFiles = (await import("fs")).readdirSync(markerDir).filter((f) => f.startsWith("active-agent-"));
           for (const f of agentFiles) {
-            const data = JSON.parse(readFileSync12(join(markerDir, f), "utf8"));
+            const data = JSON.parse(readFileSync13(join(markerDir, f), "utf8"));
             if (data.agentRole) {
               agentRole = data.agentRole;
               break;
@@ -16760,7 +16885,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path21.join(homedir(), p.projectName),
+        projectDir: path22.join(homedir(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -16798,7 +16923,7 @@ function CommandCenterView({
         const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
         const { listTmuxSessions: listTmuxSessions2, inTmux: inTmux2 } = await Promise.resolve().then(() => (init_tmux_status(), tmux_status_exports));
         const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
-        const { existsSync: existsSync15 } = await import("fs");
+        const { existsSync: existsSync16 } = await import("fs");
         const { join } = await import("path");
         const client = getClient2();
         if (!client) {
@@ -16869,7 +16994,7 @@ function CommandCenterView({
           }
           const memoryCount = memoryCounts.get(name) ?? 0;
           const openTaskCount = openTaskCounts.get(name) ?? 0;
-          const hasGit = projectDir ? existsSync15(join(projectDir, ".git")) : false;
+          const hasGit = projectDir ? existsSync16(join(projectDir, ".git")) : false;
           const type = hasGit ? "code" : memoryCount > 0 ? "code" : "automation";
           projectList.push({
             projectName: name,
@@ -16894,7 +17019,7 @@ function CommandCenterView({
         setHealth((h) => ({ ...h, memories: Number(totalResult.rows[0]?.cnt ?? 0) }));
         try {
           const pidPath = join(process.env.HOME ?? "", ".exe-os", "exed.pid");
-          setHealth((h) => ({ ...h, daemon: existsSync15(pidPath) ? "running" : "stopped" }));
+          setHealth((h) => ({ ...h, daemon: existsSync16(pidPath) ? "running" : "stopped" }));
         } catch {
         }
         const activityResult = await client.execute(
@@ -17109,7 +17234,7 @@ function ChatMessageRow({ msg }) {
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path22 from "path";
+import path23 from "path";
 import { homedir as homedir2 } from "os";
 
 // src/tui/components/TmuxPane.tsx
@@ -17412,7 +17537,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path22.join(homedir2(), p.projectName),
+        projectDir: path23.join(homedir2(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -18309,12 +18434,12 @@ async function loadGatewayConfig() {
     state.running = false;
   }
   try {
-    const { existsSync: existsSync15, readFileSync: readFileSync12 } = await import("fs");
+    const { existsSync: existsSync16, readFileSync: readFileSync13 } = await import("fs");
     const { join } = await import("path");
     const home = process.env.HOME ?? "";
     const configPath = join(home, ".exe-os", "gateway.json");
-    if (existsSync15(configPath)) {
-      const raw = JSON.parse(readFileSync12(configPath, "utf8"));
+    if (existsSync16(configPath)) {
+      const raw = JSON.parse(readFileSync13(configPath, "utf8"));
       state.port = raw.port ?? 3100;
       state.gatewayUrl = raw.gatewayUrl ?? "";
       if (raw.adapters) {
@@ -18840,12 +18965,12 @@ function TeamView({ onBack, onViewSessions }) {
         setMembers(teamData);
         setDbError(null);
         try {
-          const { existsSync: existsSync15, readFileSync: readFileSync12 } = await import("fs");
+          const { existsSync: existsSync16, readFileSync: readFileSync13 } = await import("fs");
           const { join } = await import("path");
           const home = process.env.HOME ?? "";
           const gatewayConfig = join(home, ".exe-os", "gateway.json");
-          if (existsSync15(gatewayConfig)) {
-            const raw = JSON.parse(readFileSync12(gatewayConfig, "utf8"));
+          if (existsSync16(gatewayConfig)) {
+            const raw = JSON.parse(readFileSync13(gatewayConfig, "utf8"));
             if (raw.agents && raw.agents.length > 0) {
               setExternals(raw.agents.map((a) => ({
                 name: a.name,
@@ -19509,12 +19634,12 @@ function SettingsView({ onBack }) {
     }
     setProviders(providerList);
     try {
-      const { existsSync: existsSync15 } = await import("fs");
+      const { existsSync: existsSync16 } = await import("fs");
       const { join } = await import("path");
       const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const cfg = await loadConfig2();
       const home = process.env.HOME ?? "";
-      const hasKey = existsSync15(join(home, ".exe-os", "master.key"));
+      const hasKey = existsSync16(join(home, ".exe-os", "master.key"));
       if (cfg.cloud) {
         setCloud({
           configured: true,
@@ -19527,22 +19652,22 @@ function SettingsView({ onBack }) {
       const pidPath = join(home, ".exe-os", "exed.pid");
       let daemon = "unknown";
       try {
-        daemon = existsSync15(pidPath) ? "running" : "stopped";
+        daemon = existsSync16(pidPath) ? "running" : "stopped";
       } catch {
       }
       let version = "unknown";
       try {
-        const { readFileSync: readFileSync12 } = await import("fs");
+        const { readFileSync: readFileSync13 } = await import("fs");
         const { createRequire } = await import("module");
         const require2 = createRequire(import.meta.url);
         const pkgPath = require2.resolve("@askexenow/exe-os/package.json");
-        const pkg = JSON.parse(readFileSync12(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         version = pkg.version;
       } catch {
         try {
-          const { readFileSync: readFileSync12 } = await import("fs");
+          const { readFileSync: readFileSync13 } = await import("fs");
           const { join: joinPath } = await import("path");
-          const pkg = JSON.parse(readFileSync12(joinPath(process.cwd(), "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync13(joinPath(process.cwd(), "package.json"), "utf8"));
           version = pkg.version;
         } catch {
         }