@askexenow/exe-os 0.8.85 → 0.8.87

package/dist/mcp/server.js

@@ -679,10 +679,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: existsSync30 } = await import("fs");
-  const path37 = await import("path");
-  const modelPath = path37.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync30(modelPath)) {
+  const { existsSync: existsSync31 } = await import("fs");
+  const path38 = await import("path");
+  const modelPath = path38.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync31(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -4425,6 +4425,7 @@ __export(hybrid_search_exports, {
   estimateCardinality: () => estimateCardinality,
   hybridSearch: () => hybridSearch,
   lightweightSearch: () => lightweightSearch,
+  recentRecords: () => recentRecords,
   rrfMerge: () => rrfMerge,
   rrfMergeMulti: () => rrfMergeMulti
 });
@@ -4485,7 +4486,7 @@ async function hybridSearch(queryText, agentId, options) {
     process.stderr.write("[hybrid-search] Embed daemon unavailable \u2014 FTS-only mode\n");
   }
   let grepPromise = Promise.resolve([]);
-  if (config2.fileGrepEnabled !== false) {
+  if (config2.fileGrepEnabled === true) {
     try {
       const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
       const projectRoot = process.cwd();
@@ -4754,7 +4755,7 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
     source_type: row.source_type ?? null
   }));
 }
-async function recentRecords(agentId, options, limit) {
+async function recentRecords(agentId, options, limit, textFilter) {
   const client = getClient();
   const statusFilter = options?.includeArchived ? "" : `
                AND COALESCE(status, 'active') = 'active'`;
@@ -4794,6 +4795,10 @@ async function recentRecords(agentId, options, limit) {
     sql += ` AND memory_type = ?`;
     args.push(options.memoryType);
   }
+  if (textFilter) {
+    sql += ` AND raw_text LIKE '%' || ? || '%'`;
+    args.push(textFilter);
+  }
   sql += ` ORDER BY timestamp DESC LIMIT ?`;
   args.push(limit);
   const result = await client.execute({ sql, args });
@@ -5910,18 +5915,98 @@ var init_provider_table = __esm({
   }
 });
 
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, renameSync as renameSync3, existsSync as existsSync12, mkdirSync as mkdirSync5 } 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 readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync12, mkdirSync as mkdirSync5 } from "fs";
 import path16 from "path";
+function loadAgentConfig() {
+  if (!existsSync12(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync10(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config2) {
+  const dir = path16.dirname(AGENT_CONFIG_PATH);
+  if (!existsSync12(dir)) mkdirSync5(dir, { recursive: true });
+  writeFileSync7(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+}
+function getAgentRuntime(agentId) {
+  const config2 = loadAgentConfig();
+  const entry = config2[agentId];
+  if (entry) return entry;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+function setAgentRuntime(agentId, runtime, model) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
+  }
+  if (!knownModels.includes(model)) {
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
+    };
+  }
+  const config2 = loadAgentConfig();
+  config2[agentId] = { runtime, model };
+  saveAgentConfig(config2);
+  return { ok: true };
+}
+var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path16.join(EXE_AI_DIR, "agent-config.json");
+    KNOWN_RUNTIMES = {
+      claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-3.5"],
+      codex: ["gpt-5.4", "gpt-5.5", "o3", "o4-mini"],
+      opencode: ["minimax-m2.7"]
+    };
+    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 readFileSync11, writeFileSync as writeFileSync8, renameSync as renameSync3, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
+import path17 from "path";
 import os6 from "os";
 function ensureDir() {
-  const dir = path16.dirname(QUEUE_PATH);
-  if (!existsSync12(dir)) mkdirSync5(dir, { recursive: true });
+  const dir = path17.dirname(QUEUE_PATH);
+  if (!existsSync13(dir)) mkdirSync6(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync12(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync10(QUEUE_PATH, "utf8"));
+    if (!existsSync13(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync11(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -5929,7 +6014,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) {
@@ -5953,9 +6038,9 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path16.join(os6.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path17.join(os6.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path16.join(os6.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path17.join(os6.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -6333,13 +6418,13 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, existsSync as existsSync13, appendFileSync } from "fs";
-import path17 from "path";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync14, appendFileSync } from "fs";
+import path18 from "path";
 import os7 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { unlinkSync as unlinkSync5 } from "fs";
 function spawnLockPath(sessionName) {
-  return path17.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path18.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -6350,13 +6435,13 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync13(SPAWN_LOCK_DIR)) {
-    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync14(SPAWN_LOCK_DIR)) {
+    mkdirSync7(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync13(lockFile)) {
+  if (existsSync14(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync11(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -6364,7 +6449,7 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync8(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync9(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
@@ -6376,13 +6461,13 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path17.join(
-      path17.dirname(thisFile),
+    const scriptPath = path18.join(
+      path18.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync13(scriptPath) ? scriptPath : null;
+    return existsSync14(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -6448,12 +6533,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync13(SESSION_CACHE)) {
-    mkdirSync6(SESSION_CACHE, { recursive: true });
+  if (!existsSync14(SESSION_CACHE)) {
+    mkdirSync7(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync8(filePath, JSON.stringify({
+  const filePath = path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync9(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -6461,7 +6546,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync12(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -6469,8 +6554,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(
-      path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync12(
+      path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -6531,32 +6616,50 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync13(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync14(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
   } catch {
     return {};
   }
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync13(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
-    writeFileSync8(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync14(SESSION_CACHE)) mkdirSync7(SESSION_CACHE, { recursive: true });
+    writeFileSync9(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}
@@ -6601,7 +6704,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 {
@@ -6613,14 +6716,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)) {
@@ -6628,8 +6731,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}`);
@@ -6731,26 +6834,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 = path17.join(os7.homedir(), ".exe-os", "session-logs");
-  const logFile = path17.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync13(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
+  const logDir = path18.join(os7.homedir(), ".exe-os", "session-logs");
+  const logFile = path18.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync14(logDir)) {
+    mkdirSync7(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path17.join(path17.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync13(cleanupScript)) {
+    const cleanupScript = path18.join(path18.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync14(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path17.join(os7.homedir(), ".claude.json");
+    const claudeJsonPath = path18.join(os7.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -6758,17 +6861,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync8(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync9(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path17.join(os7.homedir(), ".claude", "projects");
+    const settingsDir = path18.join(os7.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path17.join(settingsDir, normalizedKey);
-    const settingsPath = path17.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path18.join(settingsDir, normalizedKey);
+    const settingsPath = path18.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -6796,20 +6899,23 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync6(projSettingsDir, { recursive: true });
-      writeFileSync8(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync7(projSettingsDir, { recursive: true });
+      writeFileSync9(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 = path17.join(
+    const identityPath2 = path18.join(
       os7.homedir(),
       ".exe-os",
       "identity",
@@ -6819,13 +6925,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync13(identityPath2)) {
+    } else if (existsSync14(identityPath2)) {
       identityFlag = ` --append-system-prompt-file ${identityPath2}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path17.basename(spawnCwd),
+      path18.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -6840,16 +6946,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path17.join(os7.homedir(), ".exe-os", "session-cache");
-    mkdirSync6(ctxDir, { recursive: true });
-    const ctxFile = path17.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path18.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync7(ctxDir, { recursive: true });
+    const ctxFile = path18.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");
-    writeFileSync8(ctxFile, ctxContent);
+    writeFileSync9(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -6863,9 +6969,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(
@@ -6887,11 +7032,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path17.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync8(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path18.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync9(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 {
@@ -6909,6 +7056,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;
@@ -6920,9 +7072,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 {
@@ -6949,17 +7102,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 = path17.join(os7.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path17.join(os7.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path18.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path18.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path17.join(os7.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path17.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path18.join(os7.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path18.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -7007,11 +7162,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto6 from "crypto";
-import path18 from "path";
+import path19 from "path";
 import os8 from "os";
 import { execSync as execSync8 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -7186,8 +7341,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir4(path18.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path18.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir4(path19.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path19.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -7223,10 +7378,10 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path18.join(os8.homedir(), ".exe-os");
-      const mdPath = path18.join(EXE_OS_DIR, taskFile);
-      const mdDir = path18.dirname(mdPath);
-      if (!existsSync14(mdDir)) await mkdir4(mdDir, { recursive: true });
+      const EXE_OS_DIR = path19.join(os8.homedir(), ".exe-os");
+      const mdPath = path19.join(EXE_OS_DIR, taskFile);
+      const mdDir = path19.dirname(mdPath);
+      if (!existsSync15(mdDir)) await mkdir4(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
 
@@ -7251,7 +7406,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 writeFile4(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 {
@@ -7511,9 +7670,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path18.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path19.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync14(archPath)) return;
+    if (existsSync15(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -7546,10 +7705,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path18.join(baseDir, ".gitignore");
+  const gitignorePath = path19.join(baseDir, ".gitignore");
   try {
-    if (existsSync14(gitignorePath)) {
-      const content = readFileSync12(gitignorePath, "utf-8");
+    if (existsSync15(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 {
@@ -7580,8 +7739,8 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path19 from "path";
-import { existsSync as existsSync15, readdirSync as readdirSync5, unlinkSync as unlinkSync6 } from "fs";
+import path20 from "path";
+import { existsSync as existsSync16, readdirSync as readdirSync5, unlinkSync as unlinkSync6 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -7762,11 +7921,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path19.join(EXE_AI_DIR, "session-cache");
-    if (existsSync15(cacheDir)) {
+    const cacheDir = path20.join(EXE_AI_DIR, "session-cache");
+    if (existsSync16(cacheDir)) {
       for (const f of readdirSync5(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path19.join(cacheDir, f));
+          unlinkSync6(path20.join(cacheDir, f));
         }
       }
     }
@@ -7787,7 +7946,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path20 from "path";
+import path21 from "path";
 import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -7804,7 +7963,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path20.join(baseDir, String(ur.task_file));
+        const ubFile = path21.join(baseDir, String(ur.task_file));
         let ubContent = await readFile4(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -8358,8 +8517,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path21 from "path";
-import { writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, unlinkSync as unlinkSync7 } from "fs";
+import path22 from "path";
+import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -8378,11 +8537,11 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path21.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path21.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path22.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path22.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync7(cacheDir, { recursive: true });
-      writeFileSync9(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync8(cacheDir, { recursive: true });
+      writeFileSync10(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
         unlinkSync7(cachePath);
@@ -8548,17 +8707,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
 import { readdirSync as readdirSync6 } from "fs";
-import path22 from "path";
+import path23 from "path";
 import { createHash as createHash2 } from "crypto";
 function ensureDir2() {
-  if (!existsSync16(IDENTITY_DIR)) {
-    mkdirSync8(IDENTITY_DIR, { recursive: true });
+  if (!existsSync17(IDENTITY_DIR)) {
+    mkdirSync9(IDENTITY_DIR, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path22.join(IDENTITY_DIR, `${agentId}.md`);
+  return path23.join(IDENTITY_DIR, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -8599,8 +8758,8 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync16(filePath)) return null;
-  const raw = readFileSync13(filePath, "utf-8");
+  if (!existsSync17(filePath)) return null;
+  const raw = readFileSync14(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -8614,7 +8773,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir2();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync10(filePath, content, "utf-8");
+  writeFileSync11(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -8670,7 +8829,7 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR = path22.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR = path23.join(EXE_AI_DIR, "identity");
   }
 });
 
@@ -9353,13 +9512,13 @@ var init_messaging = __esm({
 });
 
 // src/gateway/whatsapp-accounts.ts
-import { readFileSync as readFileSync14 } from "fs";
+import { readFileSync as readFileSync15 } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 function loadAccounts() {
   if (cachedAccounts !== null) return cachedAccounts;
   try {
-    const raw = readFileSync14(CONFIG_PATH2, "utf8");
+    const raw = readFileSync15(CONFIG_PATH2, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       console.warn("[whatsapp] Config is not an array, ignoring");
@@ -9772,8 +9931,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path37, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path37}`;
+async function wikiFetch(config2, path38, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path38}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
@@ -9806,7 +9965,7 @@ async function wikiFetch(config2, path37, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path37}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path38}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -9915,14 +10074,14 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync9, writeFileSync as writeFileSync14, unlinkSync as unlinkSync8, mkdirSync as mkdirSync11, existsSync as existsSync23 } from "fs";
-import path30 from "path";
+import { readdirSync as readdirSync9, writeFileSync as writeFileSync15, unlinkSync as unlinkSync8, mkdirSync as mkdirSync12, existsSync as existsSync24 } from "fs";
+import path31 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync11(WORKER_PID_DIR, { recursive: true });
+    mkdirSync12(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path30.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync14(reservationPath, String(process.pid));
+    const reservationPath = path31.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync15(reservationPath, String(process.pid));
     const files = readdirSync9(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -9939,7 +10098,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path30.join(WORKER_PID_DIR, f));
+          unlinkSync8(path31.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -9962,21 +10121,21 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync11(WORKER_PID_DIR, { recursive: true });
-    writeFileSync14(path30.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync12(WORKER_PID_DIR, { recursive: true });
+    writeFileSync15(path31.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path30.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path31.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
-    mkdirSync11(WORKER_PID_DIR, { recursive: true });
-    if (existsSync23(BACKFILL_LOCK)) {
+    mkdirSync12(WORKER_PID_DIR, { recursive: true });
+    if (existsSync24(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -9992,7 +10151,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync14(BACKFILL_LOCK, String(process.pid));
+    writeFileSync15(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -10009,9 +10168,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path30.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path31.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path30.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path31.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -10034,8 +10193,8 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync15, existsSync as existsSync26, mkdirSync as mkdirSync12, unlinkSync as unlinkSync9 } from "fs";
-import path33 from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, existsSync as existsSync27, mkdirSync as mkdirSync13, unlinkSync as unlinkSync9 } from "fs";
+import path34 from "path";
 import { homedir as homedir5 } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -10047,9 +10206,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync26(sp)) {
+  if (existsSync27(sp)) {
     try {
-      const state = readFileSync20(sp);
+      const state = readFileSync21(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -10191,10 +10350,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path33.dirname(sp);
-    if (!existsSync26(dir)) mkdirSync12(dir, { recursive: true });
+    const dir = path34.dirname(sp);
+    if (!existsSync27(dir)) mkdirSync13(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync15(sp, Buffer.from(state));
+    writeFileSync16(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -10235,7 +10394,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path33.join(homedir5(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path34.join(homedir5(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -10248,12 +10407,13 @@ init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync29, openSync as openSync3, mkdirSync as mkdirSync14, closeSync as closeSync3 } from "fs";
-import path36 from "path";
+import { existsSync as existsSync30, openSync as openSync3, mkdirSync as mkdirSync15, closeSync as closeSync3 } from "fs";
+import path37 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/mcp/tools/recall-my-memory.ts
 init_hybrid_search();
+init_store();
 init_active_agent();
 import { z } from "zod";
 function formatSourceLine(record) {
@@ -10273,7 +10433,10 @@ function registerRecallMyMemory(server2) {
       title: "Recall My Memory",
       description: "Search your past work memories using semantic search. Returns relevant past tool calls, outputs, and decisions.",
       inputSchema: {
-        query: z.string().describe("What to search for in your memories"),
+        query: z.string().optional().describe("What to search for in your memories"),
+        recent: z.boolean().optional().default(false).describe(
+          "When true, return most recent memories sorted by time (no semantic search). Use for session recovery after crashes."
+        ),
         project_name: z.string().optional().describe("Filter by project name"),
         has_error: z.boolean().optional().describe("Filter for error-containing memories"),
         tool_name: z.string().optional().describe("Filter by tool name (Bash, Write, etc)"),
@@ -10293,6 +10456,7 @@ function registerRecallMyMemory(server2) {
     },
     async ({
       query,
+      recent,
       project_name,
       has_error,
       tool_name,
@@ -10304,6 +10468,12 @@ function registerRecallMyMemory(server2) {
       include_source
     }) => {
       try {
+        if (!recent && !query) {
+          return {
+            content: [{ type: "text", text: "query is required when recent mode is not enabled." }],
+            isError: true
+          };
+        }
         const { agentId } = getActiveAgent();
         const searchOptions = {
           projectName: project_name,
@@ -10317,7 +10487,15 @@ function registerRecallMyMemory(server2) {
           includeDrafts: true,
           ...user_id !== void 0 ? { userId: user_id } : {}
         };
-        const results = await hybridSearch(query, agentId, searchOptions);
+        let results;
+        if (recent) {
+          results = await recentRecords(agentId, searchOptions, limit, query);
+          if (include_source && results.length > 0) {
+            await attachDocumentMetadata(results);
+          }
+        } else {
+          results = await hybridSearch(query, agentId, searchOptions);
+        }
         if (results.length === 0) {
           return {
             content: [
@@ -10900,10 +11078,10 @@ function registerCreateTask(server2) {
         skipDispatch: true
       });
       try {
-        const { existsSync: existsSync30, mkdirSync: mkdirSync15, writeFileSync: writeFileSync17 } = await import("fs");
+        const { existsSync: existsSync31, mkdirSync: mkdirSync16, writeFileSync: writeFileSync18 } = await import("fs");
         const { identityPath: identityPath2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
         const idPath = identityPath2(assigned_to);
-        if (!existsSync30(idPath)) {
+        if (!existsSync31(idPath)) {
           const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
           const employees = await loadEmployees2();
           const emp = employees.find((e) => e.name === assigned_to);
@@ -10912,8 +11090,8 @@ function registerCreateTask(server2) {
             const template = getTemplateForTitle2(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync30(dir)) mkdirSync15(dir, { recursive: true });
-              writeFileSync17(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+              if (!existsSync31(dir)) mkdirSync16(dir, { recursive: true });
+              writeFileSync18(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
         }
@@ -12745,15 +12923,15 @@ function registerSendWhatsapp(server2) {
 import { z as z29 } from "zod";
 
 // src/automation/trigger-engine.ts
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync11, existsSync as existsSync17, mkdirSync as mkdirSync9 } from "fs";
+import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync18, mkdirSync as mkdirSync10 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
-import path23 from "path";
+import path24 from "path";
 import os9 from "os";
-var TRIGGERS_PATH = path23.join(os9.homedir(), ".exe-os", "triggers.json");
+var TRIGGERS_PATH = path24.join(os9.homedir(), ".exe-os", "triggers.json");
 function loadTriggers(project) {
-  if (!existsSync17(TRIGGERS_PATH)) return [];
+  if (!existsSync18(TRIGGERS_PATH)) return [];
   try {
-    const raw = readFileSync15(TRIGGERS_PATH, "utf-8");
+    const raw = readFileSync16(TRIGGERS_PATH, "utf-8");
     const all = JSON.parse(raw);
     if (!Array.isArray(all)) return [];
     if (project) {
@@ -12765,9 +12943,9 @@ function loadTriggers(project) {
   }
 }
 function saveTriggers(triggers) {
-  const dir = path23.dirname(TRIGGERS_PATH);
-  if (!existsSync17(dir)) mkdirSync9(dir, { recursive: true });
-  writeFileSync11(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
+  const dir = path24.dirname(TRIGGERS_PATH);
+  if (!existsSync18(dir)) mkdirSync10(dir, { recursive: true });
+  writeFileSync12(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
 }
 function createNewTrigger(input) {
   const triggers = loadTriggers();
@@ -13051,48 +13229,48 @@ function registerListTriggers(server2) {
 import { z as z31 } from "zod";
 
 // src/automation/starter-packs/index.ts
-import { readFileSync as readFileSync16, readdirSync as readdirSync7, existsSync as existsSync18 } from "fs";
-import path24 from "path";
+import { readFileSync as readFileSync17, readdirSync as readdirSync7, existsSync as existsSync19 } from "fs";
+import path25 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname = path24.dirname(fileURLToPath3(import.meta.url));
+var __dirname = path25.dirname(fileURLToPath3(import.meta.url));
 function listPacks() {
-  const packsDir = path24.join(__dirname, ".");
-  if (!existsSync18(packsDir)) return [];
+  const packsDir = path25.join(__dirname, ".");
+  if (!existsSync19(packsDir)) return [];
   return readdirSync7(packsDir, { withFileTypes: true }).filter(
-    (d) => d.isDirectory() && existsSync18(path24.join(packsDir, d.name, "custom-objects.json"))
+    (d) => d.isDirectory() && existsSync19(path25.join(packsDir, d.name, "custom-objects.json"))
   ).map((d) => d.name);
 }
 function loadPack(industry) {
-  const packDir = path24.join(__dirname, industry);
-  const objectsPath = path24.join(packDir, "custom-objects.json");
-  const triggersPath = path24.join(packDir, "triggers.json");
-  const wikiDir = path24.join(packDir, "wiki-seeds");
-  const manifestPath = path24.join(packDir, "pack.json");
-  const identityContextPath = path24.join(packDir, "identity-context.md");
-  if (!existsSync18(objectsPath)) return null;
+  const packDir = path25.join(__dirname, industry);
+  const objectsPath = path25.join(packDir, "custom-objects.json");
+  const triggersPath = path25.join(packDir, "triggers.json");
+  const wikiDir = path25.join(packDir, "wiki-seeds");
+  const manifestPath = path25.join(packDir, "pack.json");
+  const identityContextPath = path25.join(packDir, "identity-context.md");
+  if (!existsSync19(objectsPath)) return null;
   let customObjects = [];
   try {
     customObjects = JSON.parse(
-      readFileSync16(objectsPath, "utf-8")
+      readFileSync17(objectsPath, "utf-8")
     );
   } catch {
     customObjects = [];
   }
   let triggers = [];
-  if (existsSync18(triggersPath)) {
+  if (existsSync19(triggersPath)) {
     try {
       triggers = JSON.parse(
-        readFileSync16(triggersPath, "utf-8")
+        readFileSync17(triggersPath, "utf-8")
       );
     } catch {
       triggers = [];
     }
   }
   const wikiSeeds = [];
-  if (existsSync18(wikiDir)) {
+  if (existsSync19(wikiDir)) {
     const files = readdirSync7(wikiDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync16(path24.join(wikiDir, file), "utf-8");
+      const content = readFileSync17(path25.join(wikiDir, file), "utf-8");
       const titleMatch = content.match(/^#\s+(.+)/m);
       wikiSeeds.push({
         filename: file,
@@ -13102,17 +13280,17 @@ function loadPack(industry) {
     }
   }
   let manifest = {};
-  if (existsSync18(manifestPath)) {
+  if (existsSync19(manifestPath)) {
     try {
-      manifest = JSON.parse(readFileSync16(manifestPath, "utf-8"));
+      manifest = JSON.parse(readFileSync17(manifestPath, "utf-8"));
     } catch {
       manifest = {};
     }
   }
   let identityContext = null;
-  if (existsSync18(identityContextPath)) {
+  if (existsSync19(identityContextPath)) {
     try {
-      identityContext = readFileSync16(identityContextPath, "utf-8");
+      identityContext = readFileSync17(identityContextPath, "utf-8");
     } catch {
       identityContext = null;
     }
@@ -13169,8 +13347,8 @@ function applyPack(industry, project) {
 
 // src/lib/client-coo.ts
 init_config();
-import { existsSync as existsSync19, mkdirSync as mkdirSync10, writeFileSync as writeFileSync12 } from "fs";
-import path25 from "path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync11, writeFileSync as writeFileSync13 } from "fs";
+import path26 from "path";
 
 // src/lib/employee-templates.ts
 init_global_procedures();
@@ -13308,18 +13486,18 @@ var ClientCOOClobberError = class extends Error {
 var COO_ROLE = "Chief Operating Officer";
 var FEEDBACK_BEHAVIOR_CONTENT = "Tag exe-os issues with needs_improvement \u2014 this is the feedback loop that surfaces bugs, gaps, and friction to the founder each Monday.";
 async function provisionClientCOO(vars, opts = {}) {
-  const identityDir = opts.identityDir ?? path25.join(EXE_AI_DIR, "identity");
+  const identityDir = opts.identityDir ?? path26.join(EXE_AI_DIR, "identity");
   const rosterPath = opts.employeesPath ?? EMPLOYEES_PATH;
   const storeFeedbackBehavior = opts.storeFeedbackBehavior ?? true;
-  const identityPath2 = path25.join(identityDir, `${vars.agent_name}.md`);
-  if (existsSync19(identityPath2)) {
+  const identityPath2 = path26.join(identityDir, `${vars.agent_name}.md`);
+  if (existsSync20(identityPath2)) {
     throw new ClientCOOClobberError(vars.agent_name, identityPath2);
   }
   const body = renderClientCOOTemplate(vars);
-  if (!existsSync19(identityDir)) {
-    mkdirSync10(identityDir, { recursive: true });
+  if (!existsSync20(identityDir)) {
+    mkdirSync11(identityDir, { recursive: true });
   }
-  writeFileSync12(identityPath2, body, "utf-8");
+  writeFileSync13(identityPath2, body, "utf-8");
   const employees = await loadEmployees(rosterPath);
   const existing = employees.find((e) => e.name === vars.agent_name);
   let addedToRoster = false;
@@ -14209,8 +14387,8 @@ function registerUpdateWikiPage(server2) {
 import { z as z37 } from "zod";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import path26 from "path";
-import { existsSync as existsSync20 } from "fs";
+import path27 from "path";
+import { existsSync as existsSync21 } from "fs";
 
 // src/lib/hostinger-api.ts
 var DEFAULT_BASE_URL = "https://developers.hostinger.com/api/vps/v1";
@@ -14258,9 +14436,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path37, body) {
+  async request(method, path38, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path37}`;
+    const url = `${this.baseUrl}${path38}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -14411,12 +14589,12 @@ async function waitForReady(client, vpsId) {
 }
 async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
   const safeClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, "-");
-  const playbookDir = path26.resolve(process.cwd(), "infrastructure", "ansible");
-  const playbookPath = path26.join(playbookDir, "deploy.yml");
-  const inventoryPath = path26.join(playbookDir, "inventory", "hosts.yml");
-  const clientVarsPath = path26.join(playbookDir, "vars", `${safeClientName}.yml`);
-  const varsDir = path26.join(playbookDir, "vars");
-  if (!path26.resolve(clientVarsPath).startsWith(path26.resolve(varsDir))) {
+  const playbookDir = path27.resolve(process.cwd(), "infrastructure", "ansible");
+  const playbookPath = path27.join(playbookDir, "deploy.yml");
+  const inventoryPath = path27.join(playbookDir, "inventory", "hosts.yml");
+  const clientVarsPath = path27.join(playbookDir, "vars", `${safeClientName}.yml`);
+  const varsDir = path27.join(playbookDir, "vars");
+  if (!path27.resolve(clientVarsPath).startsWith(path27.resolve(varsDir))) {
     throw new Error(`Invalid client name for vars path: ${clientName}`);
   }
   const args = [
@@ -14432,7 +14610,7 @@ async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
     "-e",
     `client_name=${safeClientName}`
   ];
-  if (existsSync20(clientVarsPath)) {
+  if (existsSync21(clientVarsPath)) {
     args.push("-e", `@${clientVarsPath}`);
   }
   try {
@@ -14595,18 +14773,18 @@ function registerQueryConversations(server2) {
 
 // src/mcp/tools/load-skill.ts
 import { z as z39 } from "zod";
-import { readFileSync as readFileSync17, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
-import path27 from "path";
+import { readFileSync as readFileSync18, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
+import path28 from "path";
 import { homedir as homedir2 } from "os";
-var SKILLS_DIR = path27.join(homedir2(), ".claude", "skills");
+var SKILLS_DIR = path28.join(homedir2(), ".claude", "skills");
 function listAvailableSkills() {
   try {
     const entries = readdirSync8(SKILLS_DIR);
     return entries.filter((entry) => {
       try {
-        const entryPath = path27.join(SKILLS_DIR, entry);
+        const entryPath = path28.join(SKILLS_DIR, entry);
         if (!statSync3(entryPath).isDirectory()) return false;
-        const skillFile = path27.join(entryPath, "SKILL.md");
+        const skillFile = path28.join(entryPath, "SKILL.md");
         statSync3(skillFile);
         return true;
       } catch {
@@ -14649,10 +14827,10 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
           }]
         };
       }
-      const sanitized = path27.basename(skill_name);
-      const skillFile = path27.join(SKILLS_DIR, sanitized, "SKILL.md");
+      const sanitized = path28.basename(skill_name);
+      const skillFile = path28.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
-        const content = readFileSync17(skillFile, "utf-8");
+        const content = readFileSync18(skillFile, "utf-8");
         return {
           content: [{
             type: "text",
@@ -15291,7 +15469,7 @@ init_database();
 import { readdir } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
-import path28 from "path";
+import path29 from "path";
 import os10 from "os";
 var MODEL_PRICING = {
   // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
@@ -15340,18 +15518,18 @@ async function getAgentSpend(period = "7d") {
   for (const row of result.rows) {
     sessionAgent.set(row.session_uuid, row.agent_id);
   }
-  const claudeDir = path28.join(os10.homedir(), ".claude", "projects");
+  const claudeDir = path29.join(os10.homedir(), ".claude", "projects");
   let projectDirs = [];
   try {
     const entries = await readdir(claudeDir);
-    projectDirs = entries.map((e) => path28.join(claudeDir, e));
+    projectDirs = entries.map((e) => path29.join(claudeDir, e));
   } catch {
     return [];
   }
   const agentTotals = /* @__PURE__ */ new Map();
   for (const [sessionUuid, agentId] of sessionAgent) {
     for (const dir of projectDirs) {
-      const jsonlPath = path28.join(dir, `${sessionUuid}.jsonl`);
+      const jsonlPath = path29.join(dir, `${sessionUuid}.jsonl`);
       try {
         const usage = await extractSessionUsage(jsonlPath);
         if (usage.input === 0 && usage.output === 0) continue;
@@ -15929,12 +16107,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path37 = await import("path");
+        const path38 = await import("path");
         const os11 = await import("os");
-        const outDir = path37.join(os11.homedir(), ".exe-os", "exports");
+        const outDir = path38.join(os11.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path37.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path38.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -16155,10 +16333,10 @@ function registerListAgentSessions(server2) {
 
 // src/mcp/tools/get-daemon-health.ts
 import { z as z54 } from "zod";
-import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
-import path29 from "path";
+import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
+import path30 from "path";
 import { homedir as homedir3 } from "os";
-var PID_PATH2 = path29.join(homedir3(), ".exe-os", "exed.pid");
+var PID_PATH2 = path30.join(homedir3(), ".exe-os", "exed.pid");
 function formatUptime(seconds) {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor(seconds % 3600 / 60);
@@ -16169,8 +16347,8 @@ function formatUptime(seconds) {
 }
 function isDaemonAlive() {
   try {
-    if (!existsSync21(PID_PATH2)) return { alive: false, pid: null };
-    const pid = parseInt(readFileSync18(PID_PATH2, "utf8").trim(), 10);
+    if (!existsSync22(PID_PATH2)) return { alive: false, pid: null };
+    const pid = parseInt(readFileSync19(PID_PATH2, "utf8").trim(), 10);
     if (isNaN(pid) || pid <= 0) return { alive: false, pid: null };
     process.kill(pid, 0);
     return { alive: true, pid };
@@ -16244,7 +16422,7 @@ init_tmux_routing();
 init_task_scope();
 init_employees();
 import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync22, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
+import { existsSync as existsSync23, readFileSync as readFileSync20, writeFileSync as writeFileSync14 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join2 } from "path";
 var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
@@ -16346,15 +16524,15 @@ function registerGetAutoWakeStatus(server2) {
 init_worker_gate();
 init_config();
 import { z as z56 } from "zod";
-import { readdirSync as readdirSync10, existsSync as existsSync24 } from "fs";
-import path31 from "path";
-var WORKER_PID_DIR2 = path31.join(EXE_AI_DIR, "worker-pids");
+import { readdirSync as readdirSync10, existsSync as existsSync25 } from "fs";
+import path32 from "path";
+var WORKER_PID_DIR2 = path32.join(EXE_AI_DIR, "worker-pids");
 function countAliveWorkers() {
   let alive = 0;
   let stale = 0;
   let reservations = 0;
   try {
-    if (!existsSync24(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
+    if (!existsSync25(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
     const files = readdirSync10(WORKER_PID_DIR2);
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -16441,9 +16619,9 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/exe-doctor.ts
-import { existsSync as existsSync25 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path32 from "path";
+import path33 from "path";
 import { randomUUID as randomUUID6 } from "crypto";
 
 // src/lib/conflict-detector.ts
@@ -16846,7 +17024,7 @@ async function auditOrphanedProjects(client) {
   for (const row of result.rows) {
     const name = row.project_name;
     const count = Number(row.cnt);
-    const exists = existsSync25(path32.join(home, name)) || existsSync25(path32.join(home, "..", name)) || existsSync25(path32.join(process.cwd(), "..", name));
+    const exists = existsSync26(path33.join(home, name)) || existsSync26(path33.join(home, "..", name)) || existsSync26(path33.join(process.cwd(), "..", name));
     if (!exists) {
       orphans.push({ project_name: name, count });
     }
@@ -17004,7 +17182,7 @@ async function fixNullVectors() {
     }
   }
   const npmRoot = (await import("child_process")).execSync("npm root -g", { encoding: "utf8" }).trim();
-  const backfillPath = path32.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
+  const backfillPath = path33.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
   return new Promise((resolve, reject) => {
     const child = spawn2("node", [backfillPath], { stdio: "inherit" });
     if (child.pid) registerWorkerPid2(child.pid);
@@ -17202,9 +17380,9 @@ import { z as z58 } from "zod";
 
 // src/lib/cloud-sync.ts
 init_database();
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, existsSync as existsSync27, readdirSync as readdirSync11, mkdirSync as mkdirSync13, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync22, writeFileSync as writeFileSync17, existsSync as existsSync28, readdirSync as readdirSync11, mkdirSync as mkdirSync14, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto16 from "crypto";
-import path34 from "path";
+import path35 from "path";
 import { homedir as homedir6 } from "os";
 
 // src/lib/crypto.ts
@@ -17278,7 +17456,7 @@ function sqlSafe(v) {
 }
 function logError(msg) {
   try {
-    const logPath = path34.join(homedir6(), ".exe-os", "workers.log");
+    const logPath = path35.join(homedir6(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -17287,24 +17465,24 @@ function logError(msg) {
 var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
 var FETCH_TIMEOUT_MS4 = 3e4;
 var PUSH_BATCH_SIZE = 5e3;
-var ROSTER_LOCK_PATH = path34.join(EXE_AI_DIR, "roster-merge.lock");
+var ROSTER_LOCK_PATH = path35.join(EXE_AI_DIR, "roster-merge.lock");
 var LOCK_STALE_MS = 3e4;
 async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync16(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts2 = parseInt(readFileSync21(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts2 = parseInt(readFileSync22(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts2 < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync10(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync16(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -17678,8 +17856,8 @@ async function cloudSync(config2) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path34.join(EXE_AI_DIR, "identity");
-    if (existsSync27(idDir)) {
+    const idDir = path35.join(EXE_AI_DIR, "identity");
+    if (existsSync28(idDir)) {
       rosterResult.identities = readdirSync11(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -17697,48 +17875,56 @@ async function cloudSync(config2) {
     roster: rosterResult
   };
 }
-var ROSTER_DELETIONS_PATH = path34.join(EXE_AI_DIR, "roster-deletions.json");
+var ROSTER_DELETIONS_PATH = path35.join(EXE_AI_DIR, "roster-deletions.json");
 function consumeRosterDeletions() {
   try {
-    if (!existsSync27(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync21(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync16(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync28(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync22(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync17(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path34.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path34.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path34.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path35.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path35.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path35.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync27(rosterPath)) {
+  if (existsSync28(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync21(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync22(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync27(identityDir)) {
+  if (existsSync28(identityDir)) {
     for (const file of readdirSync11(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync21(path34.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync22(path35.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config2;
-  if (existsSync27(configPath)) {
+  if (existsSync28(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync21(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync22(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  let agentConfig;
+  const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync28(agentConfigPath)) {
+    try {
+      agentConfig = JSON.parse(readFileSync22(agentConfigPath, "utf-8"));
     } catch {
     }
   }
   const deletedNames = consumeRosterDeletions();
-  const content = JSON.stringify({ roster, identities, config: config2, deletedNames });
+  const content = JSON.stringify({ roster, identities, config: config2, agentConfig, deletedNames });
   const hash = crypto16.createHash("sha256").update(content).digest("hex").slice(0, 16);
-  return { roster, identities, config: config2, deletedNames, version: hash };
+  return { roster, identities, config: config2, agentConfig, deletedNames, version: hash };
 }
 async function cloudPushRoster(config2) {
   assertSecureEndpoint(config2.endpoint);
@@ -17807,23 +17993,23 @@ async function cloudPullRoster(config2) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path34.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path35.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync27(cfgPath)) {
+  if (existsSync28(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync21(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync22(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path34.dirname(cfgPath);
-  if (!existsSync27(dir)) mkdirSync13(dir, { recursive: true });
-  writeFileSync16(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path35.dirname(cfgPath);
+  if (!existsSync28(dir)) mkdirSync14(dir, { recursive: true });
+  writeFileSync17(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path34.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path35.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -17844,15 +18030,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync27(identityDir)) mkdirSync13(identityDir, { recursive: true });
-        const idPath = path34.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync28(identityDir)) mkdirSync14(identityDir, { recursive: true });
+        const idPath = path35.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync27(idPath) ? readFileSync21(idPath, "utf-8") : null;
+          localIdentity = existsSync28(idPath) ? readFileSync22(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync16(idPath, remoteIdentity, "utf-8");
+          writeFileSync17(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -17876,6 +18062,21 @@ async function mergeRosterFromRemote(remote, paths) {
       } catch {
       }
     }
+    if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
+      try {
+        const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
+        let local = {};
+        if (existsSync28(agentConfigPath)) {
+          try {
+            local = JSON.parse(readFileSync22(agentConfigPath, "utf-8"));
+          } catch {
+          }
+        }
+        const merged = { ...remote.agentConfig, ...local };
+        writeFileSync17(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      } catch {
+      }
+    }
     return { added, identitiesUpdated };
   });
 }
@@ -18598,11 +18799,11 @@ import { z as z62 } from "zod";
 // src/lib/people.ts
 init_config();
 import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync28, readFileSync as readFileSync22 } from "fs";
-import path35 from "path";
-var PEOPLE_PATH = path35.join(EXE_AI_DIR, "people.json");
+import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
+import path36 from "path";
+var PEOPLE_PATH = path36.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {
-  if (!existsSync28(PEOPLE_PATH)) return [];
+  if (!existsSync29(PEOPLE_PATH)) return [];
   try {
     const raw = await readFile5(PEOPLE_PATH, "utf-8");
     return JSON.parse(raw);
@@ -18611,7 +18812,7 @@ async function loadPeople() {
   }
 }
 async function savePeople(people) {
-  await mkdir5(path35.dirname(PEOPLE_PATH), { recursive: true });
+  await mkdir5(path36.dirname(PEOPLE_PATH), { recursive: true });
   await writeFile6(PEOPLE_PATH, JSON.stringify(people, null, 2) + "\n", "utf-8");
 }
 async function addPerson(person) {
@@ -18713,6 +18914,103 @@ Notes: ${person.notes}` : ""}`
   );
 }
 
+// src/mcp/tools/set-agent-config.ts
+init_active_agent();
+init_agent_config();
+init_runtime_table();
+init_employees();
+import { z as z63 } from "zod";
+function registerSetAgentConfig(server2) {
+  server2.registerTool(
+    "set_agent_config",
+    {
+      title: "Set Agent Config",
+      description: "Set or view per-agent runtime + model configuration. Controls which runtime (claude, codex, opencode) and model each agent uses when dispatched. COO-only. Omit runtime/model to view current config for an agent or all agents.",
+      inputSchema: {
+        agent_id: z63.string().optional().describe("Agent name. Omit to view all agents."),
+        runtime: z63.string().optional().describe("Runtime: claude, codex, or opencode"),
+        model: z63.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, minimax-m2.7)")
+      }
+    },
+    async ({ agent_id, runtime, model }) => {
+      const { agentRole } = getActiveAgent();
+      if (agentRole !== "COO") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Access denied. set_agent_config is COO-only. Your role: ${agentRole}`
+            }
+          ],
+          isError: true
+        };
+      }
+      if (!runtime || !model) {
+        if (agent_id) {
+          const cfg = getAgentRuntime(agent_id);
+          return {
+            content: [
+              {
+                type: "text",
+                text: `${agent_id}: runtime=${cfg.runtime} model=${cfg.model}`
+              }
+            ]
+          };
+        }
+        const config2 = loadAgentConfig();
+        let employees = [];
+        try {
+          employees = loadEmployeesSync();
+        } catch {
+        }
+        const lines = ["Agent Runtime Configuration", "\u2550".repeat(55)];
+        lines.push(
+          "Agent".padEnd(12) + "Role".padEnd(16) + "Runtime".padEnd(12) + "Model"
+        );
+        lines.push("\u2500".repeat(55));
+        for (const emp of employees) {
+          const entry = config2[emp.name];
+          const rt = entry?.runtime ?? DEFAULT_RUNTIME;
+          const mdl = entry?.model ?? DEFAULT_MODELS[DEFAULT_RUNTIME];
+          const tag = entry ? "" : " (default)";
+          lines.push(
+            emp.name.padEnd(12) + (emp.role ?? "").padEnd(16) + rt.padEnd(12) + mdl + tag
+          );
+        }
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      }
+      if (!agent_id) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "agent_id is required when setting runtime/model."
+            }
+          ],
+          isError: true
+        };
+      }
+      const result = setAgentRuntime(agent_id, runtime, model);
+      if (!result.ok) {
+        return {
+          content: [{ type: "text", text: result.error }],
+          isError: true
+        };
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Set ${agent_id} \u2192 runtime=${runtime} model=${model}`
+          }
+        ]
+      };
+    }
+  );
+}
+
 // src/lib/telemetry.ts
 var ENABLED = process.env.EXE_TELEMETRY === "1";
 var initialized = false;
@@ -18844,6 +19142,7 @@ registerGetLicenseStatus(server);
 registerAddPerson(server);
 registerListPeople(server);
 registerGetPerson(server);
+registerSetAgentConfig(server);
 try {
   await initStore();
   process.stderr.write("[exe-os] MCP server starting...\n");
@@ -18904,14 +19203,14 @@ try {
 `
       );
       const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path36.resolve(
-        path36.dirname(thisFile),
+      const backfillPath = path37.resolve(
+        path37.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
-      if (existsSync29(backfillPath)) {
+      if (existsSync30(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path36.join(exeDir, "workers.log");
-        mkdirSync14(path36.dirname(logPath), { recursive: true });
+        const logPath = path37.join(exeDir, "workers.log");
+        mkdirSync15(path37.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
           logFd = openSync3(logPath, "a");