@askexenow/exe-os 0.8.85 → 0.8.86

package/dist/bin/cli.js

@@ -4081,10 +4081,18 @@ function buildRosterBlob(paths) {
     } catch {
     }
   }
+  let agentConfig;
+  const agentConfigPath = path9.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync9(agentConfigPath)) {
+    try {
+      agentConfig = JSON.parse(readFileSync7(agentConfigPath, "utf-8"));
+    } catch {
+    }
+  }
   const deletedNames = consumeRosterDeletions();
-  const content = JSON.stringify({ roster, identities, config, deletedNames });
+  const content = JSON.stringify({ roster, identities, config, agentConfig, deletedNames });
   const hash = crypto3.createHash("sha256").update(content).digest("hex").slice(0, 16);
-  return { roster, identities, config, deletedNames, version: hash };
+  return { roster, identities, config, agentConfig, deletedNames, version: hash };
 }
 async function cloudPushRoster(config) {
   assertSecureEndpoint(config.endpoint);
@@ -4222,6 +4230,21 @@ async function mergeRosterFromRemote(remote, paths) {
       } catch {
       }
     }
+    if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
+      try {
+        const agentConfigPath = path9.join(EXE_AI_DIR, "agent-config.json");
+        let local = {};
+        if (existsSync9(agentConfigPath)) {
+          try {
+            local = JSON.parse(readFileSync7(agentConfigPath, "utf-8"));
+          } catch {
+          }
+        }
+        const merged = { ...remote.agentConfig, ...local };
+        writeFileSync5(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      } catch {
+      }
+    }
     return { added, identitiesUpdated };
   });
 }
@@ -6717,9 +6740,9 @@ Unclassified: ${unclassified}
 }
 async function exportBatches(options) {
   const fs8 = await import("fs");
-  const path38 = await import("path");
+  const path39 = await import("path");
   const client = getClient();
-  const outDir = path38.join(process.cwd(), "exe/output/classifications/input");
+  const outDir = path39.join(process.cwd(), "exe/output/classifications/input");
   fs8.mkdirSync(outDir, { recursive: true });
   const countResult = await client.execute({
     sql: "SELECT COUNT(*) as cnt FROM memories WHERE intent IS NULL AND outcome IS NULL AND domain IS NULL",
@@ -6743,7 +6766,7 @@ async function exportBatches(options) {
       const text = String(row.text || "").replace(/\n/g, " ");
       return JSON.stringify({ id: row.id, text });
     });
-    const batchFile = path38.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
+    const batchFile = path39.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
     fs8.writeFileSync(batchFile, lines.join("\n") + "\n");
     exported += batch.rows.length;
     offset += options.batchSize;
@@ -6759,7 +6782,7 @@ async function exportBatches(options) {
 }
 async function importClassifications(importDir) {
   const fs8 = await import("fs");
-  const path38 = await import("path");
+  const path39 = await import("path");
   const client = getClient();
   const files = fs8.readdirSync(importDir).filter((f) => f.endsWith(".jsonl")).sort();
   process.stderr.write(`[backfill-metadata] Found ${files.length} JSONL files to import from ${importDir}
@@ -6767,7 +6790,7 @@ async function importClassifications(importDir) {
   let imported = 0;
   let invalid = 0;
   for (const file of files) {
-    const lines = fs8.readFileSync(path38.join(importDir, file), "utf-8").split("\n").filter(Boolean);
+    const lines = fs8.readFileSync(path39.join(importDir, file), "utf-8").split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -7156,18 +7179,69 @@ var init_provider_table = __esm({
   }
 });
 
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, renameSync as renameSync3, existsSync as existsSync12, mkdirSync as mkdirSync8 } from "fs";
+// 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 readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync12, mkdirSync as mkdirSync8 } from "fs";
 import path13 from "path";
+function loadAgentConfig() {
+  if (!existsSync12(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync9(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 = path13.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 readFileSync10, writeFileSync as writeFileSync8, renameSync as renameSync3, existsSync as existsSync13, mkdirSync as mkdirSync9 } from "fs";
+import path14 from "path";
 import os7 from "os";
 function ensureDir() {
-  const dir = path13.dirname(QUEUE_PATH);
-  if (!existsSync12(dir)) mkdirSync8(dir, { recursive: true });
+  const dir = path14.dirname(QUEUE_PATH);
+  if (!existsSync13(dir)) mkdirSync9(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync12(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync9(QUEUE_PATH, "utf8"));
+    if (!existsSync13(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync10(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -7175,7 +7249,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync7(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync8(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -7199,19 +7273,19 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path13.join(os7.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path14.join(os7.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path13.join(os7.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path14.join(os7.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync10, existsSync as existsSync13 } from "fs";
-import path14 from "path";
+import { readFileSync as readFileSync11, existsSync as existsSync14 } from "fs";
+import path15 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync13(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync10(CACHE_PATH2, "utf8"));
+    if (!existsSync14(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync11(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -7249,8 +7323,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync13(filePath)) {
-      const raw = readFileSync10(filePath, "utf8");
+    if (existsSync14(filePath)) {
+      const raw = readFileSync11(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -7279,19 +7353,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path14.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path15.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto5 from "crypto";
-import path15 from "path";
+import path16 from "path";
 import os8 from "os";
 import {
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync12,
   readdirSync as readdirSync3,
   unlinkSync as unlinkSync5,
-  existsSync as existsSync14,
+  existsSync as existsSync15,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -7416,11 +7490,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto7 from "crypto";
-import path16 from "path";
+import path17 from "path";
 import os9 from "os";
 import { execSync as execSync6 } from "child_process";
 import { mkdir as mkdir5, writeFile as writeFile5, appendFile } from "fs/promises";
-import { existsSync as existsSync15, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -7595,8 +7669,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir5(path16.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir5(path16.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir5(path17.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir5(path17.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -7632,10 +7706,10 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path16.join(os9.homedir(), ".exe-os");
-      const mdPath = path16.join(EXE_OS_DIR, taskFile);
-      const mdDir = path16.dirname(mdPath);
-      if (!existsSync15(mdDir)) await mkdir5(mdDir, { recursive: true });
+      const EXE_OS_DIR = path17.join(os9.homedir(), ".exe-os");
+      const mdPath = path17.join(EXE_OS_DIR, taskFile);
+      const mdDir = path17.dirname(mdPath);
+      if (!existsSync16(mdDir)) await mkdir5(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
 
@@ -7660,7 +7734,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 writeFile5(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 {
@@ -7920,9 +7998,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path16.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path17.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync15(archPath)) return;
+    if (existsSync16(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -7955,10 +8033,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path16.join(baseDir, ".gitignore");
+  const gitignorePath = path17.join(baseDir, ".gitignore");
   try {
-    if (existsSync15(gitignorePath)) {
-      const content = readFileSync12(gitignorePath, "utf-8");
+    if (existsSync16(gitignorePath)) {
+      const content = readFileSync13(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -7989,8 +8067,8 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path17 from "path";
-import { existsSync as existsSync16, readdirSync as readdirSync4, unlinkSync as unlinkSync6 } from "fs";
+import path18 from "path";
+import { existsSync as existsSync17, readdirSync as readdirSync4, unlinkSync as unlinkSync6 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -8171,11 +8249,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path17.join(EXE_AI_DIR, "session-cache");
-    if (existsSync16(cacheDir)) {
+    const cacheDir = path18.join(EXE_AI_DIR, "session-cache");
+    if (existsSync17(cacheDir)) {
       for (const f of readdirSync4(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path17.join(cacheDir, f));
+          unlinkSync6(path18.join(cacheDir, f));
         }
       }
     }
@@ -8196,7 +8274,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path18 from "path";
+import path19 from "path";
 import { readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -8213,7 +8291,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path18.join(baseDir, String(ur.task_file));
+        const ubFile = path19.join(baseDir, String(ur.task_file));
         let ubContent = await readFile5(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -8282,7 +8360,7 @@ var init_tasks_chain = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync7 } from "child_process";
-import path19 from "path";
+import path20 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -8295,7 +8373,7 @@ function getProjectName(cwd2) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path19.dirname(gitCommonDir);
+      repoRoot = path20.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync7("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -8304,11 +8382,11 @@ function getProjectName(cwd2) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path19.basename(repoRoot);
+    _cached2 = path20.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path19.basename(dir);
+    _cached2 = path20.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -8781,8 +8859,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path20 from "path";
-import { writeFileSync as writeFileSync8, mkdirSync as mkdirSync9, unlinkSync as unlinkSync7 } from "fs";
+import path21 from "path";
+import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -8801,11 +8879,11 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path20.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path20.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path21.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path21.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync9(cacheDir, { recursive: true });
-      writeFileSync8(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync10(cacheDir, { recursive: true });
+      writeFileSync9(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
         unlinkSync7(cachePath);
@@ -9272,13 +9350,13 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
-import { readFileSync as readFileSync13, writeFileSync as writeFileSync9, mkdirSync as mkdirSync10, existsSync as existsSync17, appendFileSync as appendFileSync2 } from "fs";
-import path21 from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, existsSync as existsSync18, appendFileSync as appendFileSync2 } from "fs";
+import path22 from "path";
 import os10 from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { unlinkSync as unlinkSync8 } from "fs";
 function spawnLockPath(sessionName) {
-  return path21.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path22.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -9289,13 +9367,13 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync17(SPAWN_LOCK_DIR)) {
-    mkdirSync10(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync18(SPAWN_LOCK_DIR)) {
+    mkdirSync11(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync17(lockFile)) {
+  if (existsSync18(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync13(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync14(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -9303,7 +9381,7 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync9(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync10(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
@@ -9315,13 +9393,13 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const scriptPath = path21.join(
-      path21.dirname(thisFile),
+    const scriptPath = path22.join(
+      path22.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync17(scriptPath) ? scriptPath : null;
+    return existsSync18(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -9387,12 +9465,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync17(SESSION_CACHE)) {
-    mkdirSync10(SESSION_CACHE, { recursive: true });
+  if (!existsSync18(SESSION_CACHE)) {
+    mkdirSync11(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path21.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync9(filePath, JSON.stringify({
+  const filePath = path22.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync10(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -9400,7 +9478,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync13(path21.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync14(path22.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -9408,8 +9486,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync13(
-      path21.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync14(
+      path22.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -9470,32 +9548,50 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync17(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync13(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync18(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync14(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 (!existsSync17(SESSION_CACHE)) mkdirSync10(SESSION_CACHE, { recursive: true });
-    writeFileSync9(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync18(SESSION_CACHE)) mkdirSync11(SESSION_CACHE, { recursive: true });
+    writeFileSync10(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}
@@ -9540,7 +9636,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 {
@@ -9552,14 +9648,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)) {
@@ -9567,8 +9663,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}`);
@@ -9670,26 +9766,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 = path21.join(os10.homedir(), ".exe-os", "session-logs");
-  const logFile = path21.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync17(logDir)) {
-    mkdirSync10(logDir, { recursive: true });
+  const logDir = path22.join(os10.homedir(), ".exe-os", "session-logs");
+  const logFile = path22.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync18(logDir)) {
+    mkdirSync11(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const cleanupScript = path21.join(path21.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync17(cleanupScript)) {
+    const cleanupScript = path22.join(path22.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync18(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path21.join(os10.homedir(), ".claude.json");
+    const claudeJsonPath = path22.join(os10.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync13(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync14(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -9697,17 +9793,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync9(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync10(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path21.join(os10.homedir(), ".claude", "projects");
+    const settingsDir = path22.join(os10.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path21.join(settingsDir, normalizedKey);
-    const settingsPath = path21.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path22.join(settingsDir, normalizedKey);
+    const settingsPath = path22.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync13(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync14(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -9735,20 +9831,23 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync10(projSettingsDir, { recursive: true });
-      writeFileSync9(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync11(projSettingsDir, { recursive: true });
+      writeFileSync10(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 identityPath2 = path21.join(
+    const identityPath2 = path22.join(
       os10.homedir(),
       ".exe-os",
       "identity",
@@ -9758,13 +9857,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync17(identityPath2)) {
+    } else if (existsSync18(identityPath2)) {
       identityFlag = ` --append-system-prompt-file ${identityPath2}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path21.basename(spawnCwd),
+      path22.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -9779,16 +9878,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path21.join(os10.homedir(), ".exe-os", "session-cache");
-    mkdirSync10(ctxDir, { recursive: true });
-    const ctxFile = path21.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path22.join(os10.homedir(), ".exe-os", "session-cache");
+    mkdirSync11(ctxDir, { recursive: true });
+    const ctxFile = path22.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");
-    writeFileSync9(ctxFile, ctxContent);
+    writeFileSync10(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -9802,9 +9901,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(
@@ -9826,11 +9964,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path21.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync9(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path22.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync10(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 {
@@ -9848,6 +9988,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;
@@ -9859,9 +10004,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 {
@@ -9888,17 +10034,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 = path21.join(os10.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path21.join(os10.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path22.join(os10.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path22.join(os10.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 = path21.join(os10.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path21.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path22.join(os10.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path22.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -10173,9 +10321,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, unlinkSync as unlinkSync9, readdirSync as readdirSync5 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, unlinkSync as unlinkSync9, readdirSync as readdirSync5 } from "fs";
 import { execSync as execSync9 } from "child_process";
-import path22 from "path";
+import path23 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -10219,12 +10367,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path22.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path23.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
-    mkdirSync11(CACHE_DIR, { recursive: true });
-    writeFileSync10(
+    mkdirSync12(CACHE_DIR, { recursive: true });
+    writeFileSync11(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -10240,7 +10388,7 @@ function clearActiveAgent() {
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync14(markerPath, "utf8");
+    const raw = readFileSync15(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
@@ -10288,14 +10436,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync14(path22.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync15(path23.join(CACHE_DIR, file), "utf8");
         const data = JSON.parse(raw);
         if (!data.agentId) continue;
         if (data.startedAt) {
           const age = Date.now() - new Date(data.startedAt).getTime();
           if (age > STALE_MS) {
             try {
-              unlinkSync9(path22.join(CACHE_DIR, file));
+              unlinkSync9(path23.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -10318,11 +10466,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync9(path22.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync9(path23.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync9(path22.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync9(path23.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -10333,7 +10481,7 @@ var init_active_agent = __esm({
     init_config();
     init_session_key2();
     init_employees();
-    CACHE_DIR = path22.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path23.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -10961,14 +11109,14 @@ __export(exe_rename_exports, {
   main: () => main2,
   renameEmployee: () => renameEmployee
 });
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, renameSync as renameSync4, unlinkSync as unlinkSync10, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, renameSync as renameSync4, unlinkSync as unlinkSync10, existsSync as existsSync19 } from "fs";
 import { execSync as execSync10 } from "child_process";
-import path23 from "path";
+import path24 from "path";
 import { homedir as homedir4 } from "os";
 async function renameEmployee(oldName, newName, opts = {}) {
-  const rosterPath = opts.rosterPath ?? path23.join(homedir4(), ".exe-os", "exe-employees.json");
-  const identityDir = opts.identityDir ?? path23.join(homedir4(), ".exe-os", "identity");
-  const agentsDir = opts.agentsDir ?? path23.join(homedir4(), ".claude", "agents");
+  const rosterPath = opts.rosterPath ?? path24.join(homedir4(), ".exe-os", "exe-employees.json");
+  const identityDir = opts.identityDir ?? path24.join(homedir4(), ".exe-os", "identity");
+  const agentsDir = opts.agentsDir ?? path24.join(homedir4(), ".claude", "agents");
   const validation = validateEmployeeName(newName);
   if (!validation.valid) {
     return { success: false, error: validation.error };
@@ -10997,40 +11145,40 @@ async function renameEmployee(oldName, newName, opts = {}) {
       undo: () => {
         employee.name = originalName;
         employee.systemPrompt = originalPrompt;
-        writeFileSync11(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+        writeFileSync12(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
       }
     });
-    const oldIdentityPath = path23.join(identityDir, `${rosterOldName}.md`);
-    const newIdentityPath = path23.join(identityDir, `${newName}.md`);
-    if (existsSync18(oldIdentityPath)) {
-      const content = readFileSync15(oldIdentityPath, "utf-8");
+    const oldIdentityPath = path24.join(identityDir, `${rosterOldName}.md`);
+    const newIdentityPath = path24.join(identityDir, `${newName}.md`);
+    if (existsSync19(oldIdentityPath)) {
+      const content = readFileSync16(oldIdentityPath, "utf-8");
       const updatedContent = content.replace(
         /^(agent_id:\s*)\S+/m,
         `$1${newName}`
       );
       renameSync4(oldIdentityPath, newIdentityPath);
-      writeFileSync11(newIdentityPath, updatedContent, "utf-8");
+      writeFileSync12(newIdentityPath, updatedContent, "utf-8");
       rollbackStack.push({
         description: "restore identity file",
         undo: () => {
-          if (existsSync18(newIdentityPath)) {
-            writeFileSync11(newIdentityPath, content, "utf-8");
+          if (existsSync19(newIdentityPath)) {
+            writeFileSync12(newIdentityPath, content, "utf-8");
             renameSync4(newIdentityPath, oldIdentityPath);
           }
         }
       });
     }
-    const oldAgentPath = path23.join(agentsDir, `${rosterOldName}.md`);
-    const newAgentPath = path23.join(agentsDir, `${newName}.md`);
-    if (existsSync18(oldAgentPath)) {
-      const agentContent = readFileSync15(oldAgentPath, "utf-8");
+    const oldAgentPath = path24.join(agentsDir, `${rosterOldName}.md`);
+    const newAgentPath = path24.join(agentsDir, `${newName}.md`);
+    if (existsSync19(oldAgentPath)) {
+      const agentContent = readFileSync16(oldAgentPath, "utf-8");
       renameSync4(oldAgentPath, newAgentPath);
       rollbackStack.push({
         description: "restore agent file",
         undo: () => {
-          if (existsSync18(newAgentPath)) {
+          if (existsSync19(newAgentPath)) {
             renameSync4(newAgentPath, oldAgentPath);
-            writeFileSync11(oldAgentPath, agentContent, "utf-8");
+            writeFileSync12(oldAgentPath, agentContent, "utf-8");
           }
         }
       });
@@ -11108,10 +11256,10 @@ function removeOldSymlinks(name) {
   try {
     const exeBinPath = findExeBin2();
     if (!exeBinPath) return;
-    const binDir = path23.dirname(exeBinPath);
+    const binDir = path24.dirname(exeBinPath);
     for (const suffix of ["", "-opencode"]) {
-      const linkPath = path23.join(binDir, `${name}${suffix}`);
-      if (existsSync18(linkPath)) {
+      const linkPath = path24.join(binDir, `${name}${suffix}`);
+      if (existsSync19(linkPath)) {
         try {
           unlinkSync10(linkPath);
         } catch {
@@ -11156,16 +11304,16 @@ var init_exe_rename = __esm({
 });
 
 // src/lib/model-downloader.ts
-import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync19, unlinkSync as unlinkSync11, renameSync as renameSync5 } from "fs";
+import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync20, unlinkSync as unlinkSync11, renameSync as renameSync5 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
 import { createHash as createHash2 } from "crypto";
-import path24 from "path";
+import path25 from "path";
 async function downloadModel(opts) {
   const { destDir, onProgress, fetchFn = globalThis.fetch } = opts;
-  const destPath = path24.join(destDir, LOCAL_FILENAME);
+  const destPath = path25.join(destDir, LOCAL_FILENAME);
   const tmpPath = destPath + ".tmp";
   await mkdir6(destDir, { recursive: true });
-  if (existsSync19(destPath)) {
+  if (existsSync20(destPath)) {
     const hash = await fileHash(destPath);
     if (hash === EXPECTED_SHA256) {
       return destPath;
@@ -11177,7 +11325,7 @@ async function downloadModel(opts) {
   let downloaded = 0;
   for (let attempt = 1; attempt <= MAX_RETRIES3; attempt++) {
     try {
-      if (existsSync19(tmpPath)) unlinkSync11(tmpPath);
+      if (existsSync20(tmpPath)) unlinkSync11(tmpPath);
       const response = await fetchFn(GGUF_URL, {
         redirect: "follow",
         signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
@@ -11222,7 +11370,7 @@ async function downloadModel(opts) {
         process.stderr.write(`
 Download attempt ${attempt} failed, retrying...
 `);
-        if (existsSync19(tmpPath)) unlinkSync11(tmpPath);
+        if (existsSync20(tmpPath)) unlinkSync11(tmpPath);
       }
     }
   }
@@ -11285,10 +11433,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync25 } = await import("fs");
-  const path38 = await import("path");
-  const modelPath = path38.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync25(modelPath)) {
+  const { existsSync: existsSync26 } = await import("fs");
+  const path39 = await import("path");
+  const modelPath = path39.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync26(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -11325,17 +11473,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync16, writeFileSync as writeFileSync12 } from "fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync13, readFileSync as readFileSync17, writeFileSync as writeFileSync13 } from "fs";
 import { readdirSync as readdirSync6 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import { createHash as createHash3 } from "crypto";
 function ensureDir2() {
-  if (!existsSync20(IDENTITY_DIR)) {
-    mkdirSync12(IDENTITY_DIR, { recursive: true });
+  if (!existsSync21(IDENTITY_DIR)) {
+    mkdirSync13(IDENTITY_DIR, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path25.join(IDENTITY_DIR, `${agentId}.md`);
+  return path26.join(IDENTITY_DIR, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -11376,8 +11524,8 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync20(filePath)) return null;
-  const raw = readFileSync16(filePath, "utf-8");
+  if (!existsSync21(filePath)) return null;
+  const raw = readFileSync17(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -11391,7 +11539,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir2();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync12(filePath, content, "utf-8");
+  writeFileSync13(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -11447,7 +11595,7 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR = path25.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR = path26.join(EXE_AI_DIR, "identity");
   }
 });
 
@@ -11987,36 +12135,36 @@ __export(session_wrappers_exports, {
   generateSessionWrappers: () => generateSessionWrappers
 });
 import {
-  existsSync as existsSync21,
-  readFileSync as readFileSync17,
-  writeFileSync as writeFileSync13,
-  mkdirSync as mkdirSync13,
+  existsSync as existsSync22,
+  readFileSync as readFileSync18,
+  writeFileSync as writeFileSync14,
+  mkdirSync as mkdirSync14,
   chmodSync,
   readdirSync as readdirSync7,
   unlinkSync as unlinkSync12
 } from "fs";
-import path26 from "path";
+import path27 from "path";
 import { homedir as homedir5 } from "os";
 function generateSessionWrappers(packageRoot, homeDir) {
   const home = homeDir ?? homedir5();
-  const binDir = path26.join(home, ".exe-os", "bin");
-  const rosterPath = path26.join(home, ".exe-os", "exe-employees.json");
-  mkdirSync13(binDir, { recursive: true });
-  const exeStartDst = path26.join(binDir, "exe-start");
+  const binDir = path27.join(home, ".exe-os", "bin");
+  const rosterPath = path27.join(home, ".exe-os", "exe-employees.json");
+  mkdirSync14(binDir, { recursive: true });
+  const exeStartDst = path27.join(binDir, "exe-start");
   const candidates = [
-    path26.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path26.join(packageRoot, "src", "bin", "exe-start.sh")
+    path27.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path27.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
-    if (existsSync21(src)) {
-      writeFileSync13(exeStartDst, readFileSync17(src));
+    if (existsSync22(src)) {
+      writeFileSync14(exeStartDst, readFileSync18(src));
       chmodSync(exeStartDst, 493);
       break;
     }
   }
   let employees = [];
   try {
-    employees = JSON.parse(readFileSync17(rosterPath, "utf8"));
+    employees = JSON.parse(readFileSync18(rosterPath, "utf8"));
   } catch {
     return { created: 0, pathConfigured: false };
   }
@@ -12026,9 +12174,9 @@ function generateSessionWrappers(packageRoot, homeDir) {
   try {
     for (const f of readdirSync7(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path26.join(binDir, f);
+      const fPath = path27.join(binDir, f);
       try {
-        const content = readFileSync17(fPath, "utf8");
+        const content = readFileSync18(fPath, "utf8");
         if (content.includes("exe-start")) {
           unlinkSync12(fPath);
         }
@@ -12043,8 +12191,30 @@ exec "${exeStartDst}" "$0" "$@"
 `;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      const wrapperPath = path26.join(binDir, `${emp.name}${n}`);
-      writeFileSync13(wrapperPath, wrapperContent);
+      const wrapperPath = path27.join(binDir, `${emp.name}${n}`);
+      writeFileSync14(wrapperPath, wrapperContent);
+      chmodSync(wrapperPath, 493);
+      created++;
+    }
+  }
+  const codexLauncherCandidates = [
+    path27.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path27.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+  ];
+  let codexLauncher = null;
+  for (const c of codexLauncherCandidates) {
+    if (existsSync22(c)) {
+      codexLauncher = c;
+      break;
+    }
+  }
+  if (codexLauncher) {
+    for (const emp of employees) {
+      const wrapperPath = path27.join(binDir, `${emp.name}-codex`);
+      const content = `#!/bin/bash
+exec node "${codexLauncher}" --agent ${emp.name} "$@"
+`;
+      writeFileSync14(wrapperPath, content);
       chmodSync(wrapperPath, 493);
       created++;
     }
@@ -12063,24 +12233,24 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path26.join(home, ".zshrc"));
+    profilePaths.push(path27.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path26.join(home, ".bashrc"));
-    profilePaths.push(path26.join(home, ".bash_profile"));
+    profilePaths.push(path27.join(home, ".bashrc"));
+    profilePaths.push(path27.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path26.join(home, ".profile"));
+    profilePaths.push(path27.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
       let content = "";
       try {
-        content = readFileSync17(profilePath, "utf8");
+        content = readFileSync18(profilePath, "utf8");
       } catch {
       }
       if (content.includes(".exe-os/bin")) {
         return false;
       }
-      writeFileSync13(profilePath, content + exportLine);
+      writeFileSync14(profilePath, content + exportLine);
       return true;
     } catch {
       continue;
@@ -12103,36 +12273,36 @@ __export(setup_wizard_exports, {
   validateModel: () => validateModel
 });
 import crypto11 from "crypto";
-import { existsSync as existsSync22, mkdirSync as mkdirSync14, readFileSync as readFileSync18, writeFileSync as writeFileSync14, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync23, mkdirSync as mkdirSync15, readFileSync as readFileSync19, writeFileSync as writeFileSync15, unlinkSync as unlinkSync13 } from "fs";
 import os11 from "os";
-import path27 from "path";
+import path28 from "path";
 import { createInterface as createInterface3 } from "readline";
 function findPackageRoot2() {
-  let dir = path27.dirname(new URL(import.meta.url).pathname);
-  const root = path27.parse(dir).root;
+  let dir = path28.dirname(new URL(import.meta.url).pathname);
+  const root = path28.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path27.join(dir, "package.json");
-    if (existsSync22(pkgPath)) {
+    const pkgPath = path28.join(dir, "package.json");
+    if (existsSync23(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync18(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path27.dirname(dir);
+    dir = path28.dirname(dir);
   }
   return null;
 }
 function loadSetupState() {
   try {
-    return JSON.parse(readFileSync18(SETUP_STATE_PATH, "utf8"));
+    return JSON.parse(readFileSync19(SETUP_STATE_PATH, "utf8"));
   } catch {
     return { completedSteps: [], startedAt: (/* @__PURE__ */ new Date()).toISOString() };
   }
 }
 function saveSetupState(state) {
-  mkdirSync14(path27.dirname(SETUP_STATE_PATH), { recursive: true });
-  writeFileSync14(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
+  mkdirSync15(path28.dirname(SETUP_STATE_PATH), { recursive: true });
+  writeFileSync15(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
 }
 function clearSetupState() {
   try {
@@ -12230,7 +12400,7 @@ async function runSetupWizard(opts = {}) {
     if (state.completedSteps.length > 0) {
       log(`Resuming setup from step ${Math.max(...state.completedSteps) + 1}...`);
     }
-    if (existsSync22(LEGACY_LANCE_PATH)) {
+    if (existsSync23(LEGACY_LANCE_PATH)) {
       log("\u26A0 Found v1.0 LanceDB at ~/.exe-os/local.lance");
       log("  v1.1 uses libSQL (SQLite). Your existing memories are not automatically migrated.");
       log("  The old directory will not be modified or deleted.");
@@ -12378,10 +12548,10 @@ async function runSetupWizard(opts = {}) {
       await saveConfig(config);
       log("");
       try {
-        const claudeJsonPath = path27.join(os11.homedir(), ".claude.json");
+        const claudeJsonPath = path28.join(os11.homedir(), ".claude.json");
         let claudeJson = {};
         try {
-          claudeJson = JSON.parse(readFileSync18(claudeJsonPath, "utf8"));
+          claudeJson = JSON.parse(readFileSync19(claudeJsonPath, "utf8"));
         } catch {
         }
         if (!claudeJson.projects) claudeJson.projects = {};
@@ -12390,7 +12560,7 @@ async function runSetupWizard(opts = {}) {
           if (!projects[dir]) projects[dir] = {};
           projects[dir].hasTrustDialogAccepted = true;
         }
-        writeFileSync14(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+        writeFileSync15(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
       } catch {
       }
       state.completedSteps.push(5);
@@ -12429,7 +12599,7 @@ async function runSetupWizard(opts = {}) {
       let missingIdentities = [];
       for (const emp of roster) {
         const idPath = identityPath2(emp.name);
-        if (!existsSync22(idPath)) {
+        if (!existsSync23(idPath)) {
           missingIdentities.push(emp.name);
         }
       }
@@ -12461,7 +12631,7 @@ async function runSetupWizard(opts = {}) {
           }
           missingIdentities = [];
           for (const emp of roster) {
-            if (!existsSync22(identityPath2(emp.name))) {
+            if (!existsSync23(identityPath2(emp.name))) {
               missingIdentities.push(emp.name);
             }
           }
@@ -12518,9 +12688,9 @@ async function runSetupWizard(opts = {}) {
       const cooIdentityContent = getIdentityTemplate("coo");
       if (cooIdentityContent) {
         const cooIdPath = identityPath2(cooName);
-        mkdirSync14(path27.dirname(cooIdPath), { recursive: true });
+        mkdirSync15(path28.dirname(cooIdPath), { recursive: true });
         const replaced = cooIdentityContent.replace(/agent_id:\s*exe/g, `agent_id: ${cooName}`).replace(/\$\{agent_id\}/g, cooName);
-        writeFileSync14(cooIdPath, replaced, "utf-8");
+        writeFileSync15(cooIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(cooName);
       createdEmployees.push({ name: cooName, role: "COO" });
@@ -12614,9 +12784,9 @@ async function runSetupWizard(opts = {}) {
       const ctoIdentityContent = getIdentityTemplate("cto");
       if (ctoIdentityContent) {
         const ctoIdPath = identityPath2(ctoName);
-        mkdirSync14(path27.dirname(ctoIdPath), { recursive: true });
+        mkdirSync15(path28.dirname(ctoIdPath), { recursive: true });
         const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
-        writeFileSync14(ctoIdPath, replaced, "utf-8");
+        writeFileSync15(ctoIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(ctoName);
       createdEmployees.push({ name: ctoName, role: "CTO" });
@@ -12637,9 +12807,9 @@ async function runSetupWizard(opts = {}) {
       const cmoIdentityContent = getIdentityTemplate("cmo");
       if (cmoIdentityContent) {
         const cmoIdPath = identityPath2(cmoName);
-        mkdirSync14(path27.dirname(cmoIdPath), { recursive: true });
+        mkdirSync15(path28.dirname(cmoIdPath), { recursive: true });
         const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
-        writeFileSync14(cmoIdPath, replaced, "utf-8");
+        writeFileSync15(cmoIdPath, replaced, "utf-8");
       }
       registerBinSymlinks2(cmoName);
       createdEmployees.push({ name: cmoName, role: "CMO" });
@@ -12661,7 +12831,7 @@ async function runSetupWizard(opts = {}) {
             log(`Session shortcuts generated (${cooName}1, ${cooName}2, ...)`);
           }
           if (wrapResult.pathConfigured) {
-            const binDir = path27.join(os11.homedir(), ".exe-os", "bin");
+            const binDir = path28.join(os11.homedir(), ".exe-os", "bin");
             process.env.PATH = `${binDir}:${process.env.PATH ?? ""}`;
             pathJustConfigured = true;
           }
@@ -12701,7 +12871,7 @@ async function runSetupWizard(opts = {}) {
     const pkgRoot2 = findPackageRoot2();
     if (pkgRoot2) {
       try {
-        version = JSON.parse(readFileSync18(path27.join(pkgRoot2, "package.json"), "utf-8")).version;
+        version = JSON.parse(readFileSync19(path28.join(pkgRoot2, "package.json"), "utf-8")).version;
       } catch {
       }
     }
@@ -12738,17 +12908,17 @@ var init_setup_wizard = __esm({
     init_config();
     init_keychain();
     init_model_downloader();
-    SETUP_STATE_PATH = path27.join(os11.homedir(), ".exe-os", "setup-state.json");
+    SETUP_STATE_PATH = path28.join(os11.homedir(), ".exe-os", "setup-state.json");
   }
 });
 
 // src/lib/update-check.ts
 import { execSync as execSync11 } from "child_process";
-import { readFileSync as readFileSync19 } from "fs";
-import path28 from "path";
+import { readFileSync as readFileSync20 } from "fs";
+import path29 from "path";
 function getLocalVersion(packageRoot) {
-  const pkgPath = path28.join(packageRoot, "package.json");
-  const pkg = JSON.parse(readFileSync19(pkgPath, "utf-8"));
+  const pkgPath = path29.join(packageRoot, "package.json");
+  const pkg = JSON.parse(readFileSync20(pkgPath, "utf-8"));
   return pkg.version;
 }
 function getRemoteVersion() {
@@ -17271,8 +17441,8 @@ var init_ErrorOverview = __esm({
     "use strict";
     init_Box();
     init_Text();
-    cleanupPath = (path38) => {
-      return path38?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path39) => {
+      return path39?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new StackUtils({
       cwd: cwd(),
@@ -19680,11 +19850,11 @@ function Footer() {
       } catch {
       }
       try {
-        const { existsSync: existsSync25 } = await import("fs");
+        const { existsSync: existsSync26 } = await import("fs");
         const { join } = await import("path");
         const home = process.env.HOME ?? "";
         const pidPath = join(home, ".exe-os", "exed.pid");
-        setDaemon(existsSync25(pidPath) ? "running" : "stopped");
+        setDaemon(existsSync26(pidPath) ? "running" : "stopped");
       } catch {
         setDaemon("unknown");
       }
@@ -21715,10 +21885,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path29 from "path";
+import path30 from "path";
 import os12 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path29.resolve(filePath);
+  const resolved = path30.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -21728,7 +21898,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path29.resolve(filePath);
+  const resolved = path30.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"))
   );
@@ -21754,11 +21924,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path29.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path30.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path29.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path30.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -21775,7 +21945,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path29.basename(p);
+          const name = path30.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -21802,7 +21972,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path30 from "path";
+import path31 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -21838,7 +22008,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path30.isAbsolute(input.file_path) ? input.file_path : path30.resolve(context.cwd, input.file_path);
+        const filePath = path31.isAbsolute(input.file_path) ? input.file_path : path31.resolve(context.cwd, input.file_path);
         let stat2;
         try {
           stat2 = await fs3.stat(filePath);
@@ -21878,7 +22048,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path31 from "path";
+import path32 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -21894,7 +22064,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path31.join(current, entry.name);
+      const fullPath = path32.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -21928,11 +22098,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path31.isAbsolute(input.path) ? input.path : path31.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path32.isAbsolute(input.path) ? input.path : path32.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path31.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path32.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -21958,7 +22128,7 @@ __export(grep_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path32 from "path";
+import path33 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -22012,7 +22182,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path32.join(dir, entry.name);
+      const fullPath = path33.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -22058,7 +22228,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path32.isAbsolute(input.path) ? input.path : path32.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path33.isAbsolute(input.path) ? input.path : path33.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -22083,7 +22253,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path33 from "path";
+import path34 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -22111,8 +22281,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path33.isAbsolute(input.file_path) ? input.file_path : path33.resolve(context.cwd, input.file_path);
-        const dir = path33.dirname(filePath);
+        const filePath = path34.isAbsolute(input.file_path) ? input.file_path : path34.resolve(context.cwd, input.file_path);
+        const dir = path34.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -22130,7 +22300,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -22171,7 +22341,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path34.isAbsolute(input.file_path) ? input.file_path : path34.resolve(context.cwd, input.file_path);
+        const filePath = path35.isAbsolute(input.file_path) ? input.file_path : path35.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -22413,7 +22583,7 @@ var init_bash = __esm({
 // 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 path35 from "path";
+import path36 from "path";
 import { homedir as homedir6 } from "os";
 import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function CommandCenterView({
@@ -22448,15 +22618,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: readFileSync22, existsSync: existsSync25 } = await import("fs");
+        const { readFileSync: readFileSync23, existsSync: existsSync26 } = await import("fs");
         const { join } = await import("path");
         const { homedir: homedir8 } = await import("os");
         const configPath = join(homedir8(), ".exe-os", "config.json");
         let failoverChain = ["anthropic", "opencode", "gemini", "openai"];
         let providerConfigs = {};
-        if (existsSync25(configPath)) {
+        if (existsSync26(configPath)) {
           try {
-            const raw = JSON.parse(readFileSync22(configPath, "utf8"));
+            const raw = JSON.parse(readFileSync23(configPath, "utf8"));
             if (Array.isArray(raw.failoverChain)) failoverChain = raw.failoverChain;
             if (raw.providers && typeof raw.providers === "object") {
               providerConfigs = raw.providers;
@@ -22517,7 +22687,7 @@ function CommandCenterView({
           const markerDir = join(homedir8(), ".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(readFileSync22(join(markerDir, f), "utf8"));
+            const data = JSON.parse(readFileSync23(join(markerDir, f), "utf8"));
             if (data.agentRole) {
               agentRole = data.agentRole;
               break;
@@ -22662,7 +22832,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path35.join(homedir6(), p.projectName),
+        projectDir: path36.join(homedir6(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -22700,7 +22870,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: existsSync25 } = await import("fs");
+        const { existsSync: existsSync26 } = await import("fs");
         const { join } = await import("path");
         const client = getClient2();
         if (!client) {
@@ -22771,7 +22941,7 @@ function CommandCenterView({
           }
           const memoryCount = memoryCounts.get(name) ?? 0;
           const openTaskCount = openTaskCounts.get(name) ?? 0;
-          const hasGit = projectDir ? existsSync25(join(projectDir, ".git")) : false;
+          const hasGit = projectDir ? existsSync26(join(projectDir, ".git")) : false;
           const type = hasGit ? "code" : memoryCount > 0 ? "code" : "automation";
           projectList.push({
             projectName: name,
@@ -22796,7 +22966,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: existsSync25(pidPath) ? "running" : "stopped" }));
+          setHealth((h) => ({ ...h, daemon: existsSync26(pidPath) ? "running" : "stopped" }));
         } catch {
         }
         const activityResult = await client.execute(
@@ -23665,7 +23835,7 @@ var init_useOrchestrator = __esm({
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path36 from "path";
+import path37 from "path";
 import { homedir as homedir7 } from "os";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function isCoordinatorEntry(entry) {
@@ -23703,7 +23873,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path36.join(homedir7(), p.projectName),
+        projectDir: path37.join(homedir7(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -24807,12 +24977,12 @@ async function loadGatewayConfig() {
     state.running = false;
   }
   try {
-    const { existsSync: existsSync25, readFileSync: readFileSync22 } = await import("fs");
+    const { existsSync: existsSync26, readFileSync: readFileSync23 } = await import("fs");
     const { join } = await import("path");
     const home = process.env.HOME ?? "";
     const configPath = join(home, ".exe-os", "gateway.json");
-    if (existsSync25(configPath)) {
-      const raw = JSON.parse(readFileSync22(configPath, "utf8"));
+    if (existsSync26(configPath)) {
+      const raw = JSON.parse(readFileSync23(configPath, "utf8"));
       state.port = raw.port ?? 3100;
       state.gatewayUrl = raw.gatewayUrl ?? "";
       if (raw.adapters) {
@@ -25435,12 +25605,12 @@ function TeamView({ onBack, onViewSessions }) {
         setMembers(teamData);
         setDbError(null);
         try {
-          const { existsSync: existsSync25, readFileSync: readFileSync22 } = await import("fs");
+          const { existsSync: existsSync26, readFileSync: readFileSync23 } = await import("fs");
           const { join } = await import("path");
           const home = process.env.HOME ?? "";
           const gatewayConfig = join(home, ".exe-os", "gateway.json");
-          if (existsSync25(gatewayConfig)) {
-            const raw = JSON.parse(readFileSync22(gatewayConfig, "utf8"));
+          if (existsSync26(gatewayConfig)) {
+            const raw = JSON.parse(readFileSync23(gatewayConfig, "utf8"));
             if (raw.agents && raw.agents.length > 0) {
               setExternals(raw.agents.map((a) => ({
                 name: a.name,
@@ -25621,8 +25791,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path38, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path38}`;
+async function wikiFetch(config, path39, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path39}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
@@ -25655,7 +25825,7 @@ async function wikiFetch(config, path38, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path38}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path39}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -26265,12 +26435,12 @@ function SettingsView({ onBack }) {
     }
     setProviders(providerList);
     try {
-      const { existsSync: existsSync25 } = await import("fs");
+      const { existsSync: existsSync26 } = 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 = existsSync25(join(home, ".exe-os", "master.key"));
+      const hasKey = existsSync26(join(home, ".exe-os", "master.key"));
       if (cfg.cloud) {
         setCloud({
           configured: true,
@@ -26283,22 +26453,22 @@ function SettingsView({ onBack }) {
       const pidPath = join(home, ".exe-os", "exed.pid");
       let daemon = "unknown";
       try {
-        daemon = existsSync25(pidPath) ? "running" : "stopped";
+        daemon = existsSync26(pidPath) ? "running" : "stopped";
       } catch {
       }
       let version = "unknown";
       try {
-        const { readFileSync: readFileSync22 } = await import("fs");
+        const { readFileSync: readFileSync23 } = 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(readFileSync22(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync23(pkgPath, "utf8"));
         version = pkg.version;
       } catch {
         try {
-          const { readFileSync: readFileSync22 } = await import("fs");
+          const { readFileSync: readFileSync23 } = await import("fs");
           const { join: joinPath } = await import("path");
-          const pkg = JSON.parse(readFileSync22(joinPath(process.cwd(), "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync23(joinPath(process.cwd(), "package.json"), "utf8"));
           version = pkg.version;
         } catch {
         }
@@ -26907,14 +27077,14 @@ Unhandled rejection: ${reason}
 });
 
 // src/bin/cli.ts
-import { existsSync as existsSync24, readFileSync as readFileSync21, writeFileSync as writeFileSync15, readdirSync as readdirSync8, rmSync } from "fs";
-import path37 from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync22, writeFileSync as writeFileSync16, readdirSync as readdirSync8, rmSync } from "fs";
+import path38 from "path";
 import os13 from "os";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   try {
-    const pkgPath = path37.join(path37.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
-    const pkg = JSON.parse(readFileSync21(pkgPath, "utf8"));
+    const pkgPath = path38.join(path38.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync22(pkgPath, "utf8"));
     console.log(pkg.version);
   } catch {
     console.log("unknown");
@@ -27052,11 +27222,11 @@ ID: ${result.id}`);
   });
   await init_App2().then(() => App_exports);
 } else {
-  const claudeDir = path37.join(os13.homedir(), ".claude");
-  const settingsPath = path37.join(claudeDir, "settings.json");
-  const hasClaudeCode = existsSync24(settingsPath) && (() => {
+  const claudeDir = path38.join(os13.homedir(), ".claude");
+  const settingsPath = path38.join(claudeDir, "settings.json");
+  const hasClaudeCode = existsSync25(settingsPath) && (() => {
     try {
-      const raw = readFileSync21(settingsPath, "utf8");
+      const raw = readFileSync22(settingsPath, "utf8");
       return raw.includes("exe-os") || raw.includes("exe-mem");
     } catch {
       return false;
@@ -27065,9 +27235,9 @@ ID: ${result.id}`);
   if (hasClaudeCode) {
     let cooName = "exe";
     try {
-      const rosterPath = path37.join(os13.homedir(), ".exe-os", "exe-employees.json");
-      if (existsSync24(rosterPath)) {
-        const roster = JSON.parse(readFileSync21(rosterPath, "utf8"));
+      const rosterPath = path38.join(os13.homedir(), ".exe-os", "exe-employees.json");
+      if (existsSync25(rosterPath)) {
+        const roster = JSON.parse(readFileSync22(rosterPath, "utf8"));
         const coo = roster.find((e) => e.role === "COO");
         if (coo) cooName = coo.name;
       }
@@ -27107,14 +27277,14 @@ async function runClaudeInstall() {
   }
 }
 async function runClaudeCheck() {
-  const claudeDir = path37.join(os13.homedir(), ".claude");
-  const settingsPath = path37.join(claudeDir, "settings.json");
-  const claudeJsonPath = path37.join(os13.homedir(), ".claude.json");
+  const claudeDir = path38.join(os13.homedir(), ".claude");
+  const settingsPath = path38.join(claudeDir, "settings.json");
+  const claudeJsonPath = path38.join(os13.homedir(), ".claude.json");
   let ok = true;
-  if (existsSync24(settingsPath)) {
+  if (existsSync25(settingsPath)) {
     let settings;
     try {
-      settings = JSON.parse(readFileSync21(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync22(settingsPath, "utf8"));
     } catch {
       console.log("\x1B[31m\u2717\x1B[0m settings.json is malformed (invalid JSON)");
       ok = false;
@@ -27140,10 +27310,10 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m settings.json not found");
     ok = false;
   }
-  if (existsSync24(claudeJsonPath)) {
+  if (existsSync25(claudeJsonPath)) {
     let claudeJson;
     try {
-      claudeJson = JSON.parse(readFileSync21(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync22(claudeJsonPath, "utf8"));
     } catch {
       console.log("\x1B[31m\u2717\x1B[0m claude.json is malformed (invalid JSON)");
       ok = false;
@@ -27162,8 +27332,8 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m claude.json not found");
     ok = false;
   }
-  const skillsDir = path37.join(claudeDir, "skills");
-  if (existsSync24(skillsDir)) {
+  const skillsDir = path38.join(claudeDir, "skills");
+  if (existsSync25(skillsDir)) {
     console.log("\x1B[32m\u2713\x1B[0m Slash skills directory exists");
   } else {
     console.log("\x1B[31m\u2717\x1B[0m Slash skills directory missing");
@@ -27180,16 +27350,16 @@ async function runClaudeUninstall(flags = []) {
   const dryRun = flags.includes("--dry-run");
   const purge = flags.includes("--purge");
   const homeDir = os13.homedir();
-  const claudeDir = path37.join(homeDir, ".claude");
-  const settingsPath = path37.join(claudeDir, "settings.json");
-  const claudeJsonPath = path37.join(homeDir, ".claude.json");
-  const exeOsDir = path37.join(homeDir, ".exe-os");
+  const claudeDir = path38.join(homeDir, ".claude");
+  const settingsPath = path38.join(claudeDir, "settings.json");
+  const claudeJsonPath = path38.join(homeDir, ".claude.json");
+  const exeOsDir = path38.join(homeDir, ".exe-os");
   let removed = 0;
   const log = (msg) => console.log(dryRun ? `[dry-run] ${msg}` : msg);
   let settings = {};
-  if (existsSync24(settingsPath)) {
+  if (existsSync25(settingsPath)) {
     try {
-      settings = JSON.parse(readFileSync21(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync22(settingsPath, "utf8"));
     } catch {
       console.error("Your ~/.claude/settings.json appears malformed.");
       if (purge) {
@@ -27227,15 +27397,15 @@ async function runClaudeUninstall(flags = []) {
         permCount = before - settings.permissions.allow.length;
       }
       if (!dryRun) {
-        writeFileSync15(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+        writeFileSync16(settingsPath, JSON.stringify(settings, null, 2) + "\n");
       }
       log("\u2713 Removed exe-os hooks from settings.json");
       if (permCount > 0) log(`\u2713 Removed ${permCount} MCP permission entries`);
       removed++;
     }
   }
-  if (existsSync24(claudeJsonPath)) {
-    const raw = readFileSync21(claudeJsonPath, "utf8");
+  if (existsSync25(claudeJsonPath)) {
+    const raw = readFileSync22(claudeJsonPath, "utf8");
     if (raw.length > 1e6) {
       console.error("claude.json exceeds 1 MB \u2014 skipping parse.");
     } else {
@@ -27256,7 +27426,7 @@ async function runClaudeUninstall(flags = []) {
         }
         if (removedMcp) {
           if (!dryRun) {
-            writeFileSync15(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+            writeFileSync16(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
           }
           log("\u2713 Removed exe-os MCP server from claude.json");
           removed++;
@@ -27264,14 +27434,14 @@ async function runClaudeUninstall(flags = []) {
       }
     }
   }
-  const skillsDir = path37.join(claudeDir, "skills");
-  if (existsSync24(skillsDir)) {
+  const skillsDir = path38.join(claudeDir, "skills");
+  if (existsSync25(skillsDir)) {
     let skillCount = 0;
     try {
       const entries = readdirSync8(skillsDir);
       for (const entry of entries) {
         if (entry.startsWith("exe")) {
-          const fullPath = path37.join(skillsDir, entry);
+          const fullPath = path38.join(skillsDir, entry);
           if (!dryRun) rmSync(fullPath, { recursive: true, force: true });
           skillCount++;
         }
@@ -27283,30 +27453,30 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const claudeMdPath = path37.join(claudeDir, "CLAUDE.md");
-  if (existsSync24(claudeMdPath)) {
-    const content = readFileSync21(claudeMdPath, "utf8");
+  const claudeMdPath = path38.join(claudeDir, "CLAUDE.md");
+  if (existsSync25(claudeMdPath)) {
+    const content = readFileSync22(claudeMdPath, "utf8");
     const startMarker = "<!-- exe-os:orchestration-start -->";
     const endMarker = "<!-- exe-os:orchestration-end -->";
     const startIdx = content.indexOf(startMarker);
     const endIdx = content.indexOf(endMarker);
     if (startIdx !== -1 && endIdx !== -1) {
       const cleaned = (content.slice(0, startIdx) + content.slice(endIdx + endMarker.length)).replace(/\n{3,}/g, "\n\n").trim() + "\n";
-      if (!dryRun) writeFileSync15(claudeMdPath, cleaned);
+      if (!dryRun) writeFileSync16(claudeMdPath, cleaned);
       log("\u2713 Removed orchestration block from CLAUDE.md");
       removed++;
     }
   }
-  const agentsDir = path37.join(claudeDir, "agents");
-  if (existsSync24(agentsDir)) {
+  const agentsDir = path38.join(claudeDir, "agents");
+  if (existsSync25(agentsDir)) {
     let agentCount = 0;
     try {
       const entries = readdirSync8(agentsDir).filter((f) => f.endsWith(".md"));
       let knownNames = /* @__PURE__ */ new Set();
-      const rosterPath = path37.join(exeOsDir, "exe-employees.json");
-      if (existsSync24(rosterPath)) {
+      const rosterPath = path38.join(exeOsDir, "exe-employees.json");
+      if (existsSync25(rosterPath)) {
         try {
-          const roster = JSON.parse(readFileSync21(rosterPath, "utf8"));
+          const roster = JSON.parse(readFileSync22(rosterPath, "utf8"));
           knownNames = new Set(roster.map((e) => e.name));
         } catch {
         }
@@ -27314,7 +27484,7 @@ async function runClaudeUninstall(flags = []) {
       for (const entry of entries) {
         const name = entry.replace(/\.md$/, "");
         if (knownNames.has(name)) {
-          if (!dryRun) rmSync(path37.join(agentsDir, entry), { force: true });
+          if (!dryRun) rmSync(path38.join(agentsDir, entry), { force: true });
           agentCount++;
         }
       }
@@ -27325,16 +27495,16 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const projectsDir = path37.join(claudeDir, "projects");
-  if (existsSync24(projectsDir)) {
+  const projectsDir = path38.join(claudeDir, "projects");
+  if (existsSync25(projectsDir)) {
     let projectCount = 0;
     try {
       const projects = readdirSync8(projectsDir);
       for (const proj of projects) {
-        const projSettings = path37.join(projectsDir, proj, "settings.json");
-        if (!existsSync24(projSettings)) continue;
+        const projSettings = path38.join(projectsDir, proj, "settings.json");
+        if (!existsSync25(projSettings)) continue;
         try {
-          const pSettings = JSON.parse(readFileSync21(projSettings, "utf8"));
+          const pSettings = JSON.parse(readFileSync22(projSettings, "utf8"));
           let changed = false;
           if (Array.isArray(pSettings.permissions?.allow)) {
             const before = pSettings.permissions.allow.length;
@@ -27344,7 +27514,7 @@ async function runClaudeUninstall(flags = []) {
             if (pSettings.permissions.allow.length < before) changed = true;
           }
           if (changed && !dryRun) {
-            writeFileSync15(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
+            writeFileSync16(projSettings, JSON.stringify(pSettings, null, 2) + "\n");
           }
           if (changed) projectCount++;
         } catch {
@@ -27368,17 +27538,17 @@ async function runClaudeUninstall(flags = []) {
     };
     const exeBinPath = findExeBin3();
     if (!exeBinPath) throw new Error("exe-os not found in PATH");
-    const binDir = path37.dirname(exeBinPath);
+    const binDir = path38.dirname(exeBinPath);
     let symlinkCount = 0;
-    const rosterPath = path37.join(exeOsDir, "exe-employees.json");
-    if (existsSync24(rosterPath)) {
-      const roster = JSON.parse(readFileSync21(rosterPath, "utf8"));
+    const rosterPath = path38.join(exeOsDir, "exe-employees.json");
+    if (existsSync25(rosterPath)) {
+      const roster = JSON.parse(readFileSync22(rosterPath, "utf8"));
       const coordinatorName = roster.find((e) => e.role?.toLowerCase() === "coo")?.name ?? "exe";
       for (const emp of roster) {
         if (emp.name === coordinatorName) continue;
         for (const suffix of ["", "-opencode"]) {
-          const linkPath = path37.join(binDir, `${emp.name}${suffix}`);
-          if (existsSync24(linkPath)) {
+          const linkPath = path38.join(binDir, `${emp.name}${suffix}`);
+          if (existsSync25(linkPath)) {
             if (!dryRun) rmSync(linkPath, { force: true });
             symlinkCount++;
           }
@@ -27391,7 +27561,7 @@ async function runClaudeUninstall(flags = []) {
     }
   } catch {
   }
-  if (purge && existsSync24(exeOsDir)) {
+  if (purge && existsSync25(exeOsDir)) {
     if (!dryRun) {
       process.stdout.write("\x1B[33m\u26A0 This will delete all memories, identities, and agent data.\x1B[0m\n");
       process.stdout.write("  Removing ~/.exe-os...\n");
@@ -27416,7 +27586,7 @@ async function checkForUpdateOnBoot() {
     const config = await loadConfig2();
     if (!config.autoUpdate.checkOnBoot) return;
     const { checkForUpdate: checkForUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
-    const packageRoot = path37.resolve(
+    const packageRoot = path38.resolve(
       new URL("../..", import.meta.url).pathname
     );
     const result = checkForUpdate2(packageRoot);
@@ -27475,7 +27645,7 @@ async function runActivate(key) {
       const idTemplate = getIdentityTemplate(identityKey);
       if (idTemplate) {
         const idPath = identityPath2(name);
-        const dir = path37.dirname(idPath);
+        const dir = path38.dirname(idPath);
         if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
         fs8.writeFileSync(idPath, idTemplate.replace(/^agent_id: \w+/m, `agent_id: ${name}`), "utf-8");
       }