@askexenow/exe-os 0.8.83 → 0.8.86

package/dist/tui/App.js

@@ -322,110 +322,6 @@ var init_provider_table = __esm({
   }
 });
 
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
-import path2 from "path";
-import os2 from "os";
-function ensureDir() {
-  const dir = path2.dirname(QUEUE_PATH);
-  if (!existsSync3(dir)) mkdirSync2(dir, { recursive: true });
-}
-function readQueue() {
-  try {
-    if (!existsSync3(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync3(QUEUE_PATH, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writeQueue(queue) {
-  ensureDir();
-  const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
-  renameSync(tmp, QUEUE_PATH);
-}
-function queueIntercom(targetSession, reason) {
-  const queue = readQueue();
-  const existing = queue.find((q) => q.targetSession === targetSession);
-  if (existing) {
-    existing.attempts++;
-    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-    existing.reason = reason;
-  } else {
-    queue.push({
-      targetSession,
-      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      attempts: 0,
-      reason
-    });
-  }
-  writeQueue(queue);
-}
-var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
-var init_intercom_queue = __esm({
-  "src/lib/intercom-queue.ts"() {
-    "use strict";
-    QUEUE_PATH = path2.join(os2.homedir(), ".exe-os", "intercom-queue.json");
-    TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path2.join(os2.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/db-retry.ts
-function isBusyError(err) {
-  if (err instanceof Error) {
-    const msg = err.message.toLowerCase();
-    return msg.includes("sqlite_busy") || msg.includes("database is locked");
-  }
-  return false;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retryOnBusy(fn, label) {
-  let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (!isBusyError(err) || attempt === MAX_RETRIES) {
-        throw err;
-      }
-      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
-      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
-      process.stderr.write(
-        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
-`
-      );
-      await delay(backoff + jitter);
-    }
-  }
-  throw lastError;
-}
-function wrapWithRetry(client) {
-  return new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop === "execute") {
-        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
-      }
-      if (prop === "batch") {
-        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
-var init_db_retry = __esm({
-  "src/lib/db-retry.ts"() {
-    "use strict";
-    MAX_RETRIES = 3;
-    BASE_DELAY_MS = 200;
-    MAX_JITTER_MS = 300;
-  }
-});
-
 // src/lib/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -443,17 +339,17 @@ __export(config_exports, {
   saveConfig: () => saveConfig
 });
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync as readFileSync4, existsSync as existsSync4, renameSync as renameSync2 } from "fs";
-import path3 from "path";
-import os3 from "os";
+import { readFileSync as readFileSync3, existsSync as existsSync3, renameSync } from "fs";
+import path2 from "path";
+import os2 from "os";
 function resolveDataDir() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path3.join(os3.homedir(), ".exe-os");
-  const legacyDir = path3.join(os3.homedir(), ".exe-mem");
-  if (!existsSync4(newDir) && existsSync4(legacyDir)) {
+  const newDir = path2.join(os2.homedir(), ".exe-os");
+  const legacyDir = path2.join(os2.homedir(), ".exe-mem");
+  if (!existsSync3(newDir) && existsSync3(legacyDir)) {
     try {
-      renameSync2(legacyDir, newDir);
+      renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
 `);
     } catch {
@@ -515,9 +411,9 @@ function normalizeAutoUpdate(raw) {
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync4(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync3(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   const raw = await readFile(configPath, "utf-8");
   try {
@@ -535,38 +431,38 @@ async function loadConfig() {
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os3.homedir());
+      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
     }
     return config;
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync4(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync3(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   try {
-    const raw = readFileSync4(configPath, "utf-8");
+    const raw = readFileSync3(configPath, "utf-8");
     let parsed = JSON.parse(raw);
     parsed = migrateLegacyConfig(parsed);
     const { config: migratedCfg } = migrateConfig(parsed);
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 async function saveConfig(config) {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
+  const configPath = path2.join(dir, "config.json");
   await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
   if (config.cloud?.apiKey) {
     await chmod(configPath, 384);
@@ -591,10 +487,10 @@ var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path3.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path3.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path3.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path3.join(EXE_AI_DIR, "local.lance");
+    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
       config_version: CURRENT_CONFIG_VERSION,
@@ -666,6 +562,161 @@ var init_config = __esm({
   }
 });
 
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    "use strict";
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "exec",
+        autoApproveFlag: "--full-auto",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.4"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+// src/lib/agent-config.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import path3 from "path";
+function loadAgentConfig() {
+  if (!existsSync4(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync4(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+var AGENT_CONFIG_PATH, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path3.join(EXE_AI_DIR, "agent-config.json");
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: "minimax-m2.7"
+    };
+  }
+});
+
+// src/lib/intercom-queue.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, renameSync as renameSync2, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
+import path4 from "path";
+import os3 from "os";
+function ensureDir() {
+  const dir = path4.dirname(QUEUE_PATH);
+  if (!existsSync5(dir)) mkdirSync3(dir, { recursive: true });
+}
+function readQueue() {
+  try {
+    if (!existsSync5(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync5(QUEUE_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeQueue(queue) {
+  ensureDir();
+  const tmp = `${QUEUE_PATH}.tmp`;
+  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  renameSync2(tmp, QUEUE_PATH);
+}
+function queueIntercom(targetSession, reason) {
+  const queue = readQueue();
+  const existing = queue.find((q) => q.targetSession === targetSession);
+  if (existing) {
+    existing.attempts++;
+    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    existing.reason = reason;
+  } else {
+    queue.push({
+      targetSession,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0,
+      reason
+    });
+  }
+  writeQueue(queue);
+}
+var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
+var init_intercom_queue = __esm({
+  "src/lib/intercom-queue.ts"() {
+    "use strict";
+    QUEUE_PATH = path4.join(os3.homedir(), ".exe-os", "intercom-queue.json");
+    TTL_MS = 60 * 60 * 1e3;
+    INTERCOM_LOG = path4.join(os3.homedir(), ".exe-os", "intercom.log");
+  }
+});
+
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
+  }
+});
+
 // src/lib/employees.ts
 var employees_exports = {};
 __export(employees_exports, {
@@ -673,6 +724,7 @@ __export(employees_exports, {
   DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
   EMPLOYEES_PATH: () => EMPLOYEES_PATH,
   addEmployee: () => addEmployee,
+  baseAgentName: () => baseAgentName,
   canCoordinate: () => canCoordinate,
   getCoordinatorEmployee: () => getCoordinatorEmployee,
   getCoordinatorName: () => getCoordinatorName,
@@ -692,9 +744,9 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, symlinkSync, readlinkSync, readFileSync as readFileSync6, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import path4 from "path";
+import path5 from "path";
 import os4 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -731,7 +783,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) {
+  if (!existsSync6(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -742,13 +794,13 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path4.dirname(employeesPath), { recursive: true });
+  await mkdir2(path5.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync5(employeesPath)) return [];
+  if (!existsSync6(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync6(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -769,6 +821,14 @@ function hasRole(agentName, role) {
   const emp = getEmployee(employees, agentName);
   return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
 }
+function baseAgentName(name, employees) {
+  const match = name.match(/^([a-zA-Z]+)\d+$/);
+  if (!match) return name;
+  const base = match[1];
+  const roster = employees ?? loadEmployeesSync();
+  if (getEmployee(roster, base)) return base;
+  return name;
+}
 function isMultiInstance(agentName, employees) {
   const roster = employees ?? loadEmployeesSync();
   const emp = getEmployee(roster, agentName);
@@ -791,14 +851,14 @@ async function normalizeRosterCase(rosterPath) {
       emp.name = emp.name.toLowerCase();
       changed = true;
       try {
-        const identityDir = path4.join(os4.homedir(), ".exe-os", "identity");
-        const oldPath = path4.join(identityDir, `${oldName}.md`);
-        const newPath = path4.join(identityDir, `${emp.name}.md`);
-        if (existsSync5(oldPath) && !existsSync5(newPath)) {
+        const identityDir = path5.join(os4.homedir(), ".exe-os", "identity");
+        const oldPath = path5.join(identityDir, `${oldName}.md`);
+        const newPath = path5.join(identityDir, `${emp.name}.md`);
+        if (existsSync6(oldPath) && !existsSync6(newPath)) {
           renameSync3(oldPath, newPath);
-        } else if (existsSync5(oldPath) && oldPath !== newPath) {
-          const content = readFileSync5(oldPath, "utf-8");
-          writeFileSync3(newPath, content, "utf-8");
+        } else if (existsSync6(oldPath) && oldPath !== newPath) {
+          const content = readFileSync6(oldPath, "utf-8");
+          writeFileSync4(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
             unlinkSync(oldPath);
           }
@@ -819,48 +879,485 @@ function findExeBin() {
     return null;
   }
 }
-function registerBinSymlinks(name) {
-  const created = [];
-  const skipped = [];
-  const errors = [];
-  const exeBinPath = findExeBin();
-  if (!exeBinPath) {
-    errors.push("Could not find 'exe-os' in PATH");
-    return { created, skipped, errors };
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  const exeBinPath = findExeBin();
+  if (!exeBinPath) {
+    errors.push("Could not find 'exe-os' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path5.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path5.join(binDir, linkName);
+    if (existsSync6(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync7, unlinkSync as unlinkSync2, readFileSync as readFileSync7, openSync, closeSync, statSync } from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync7(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync7(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync2(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  const { root } = path6.parse(dir);
+  while (dir !== root) {
+    if (existsSync7(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path6.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync7(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path6.join(path6.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const child = spawn(process.execPath, [resolvedPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      TMUX: void 0,
+      // Daemon is global — must not inherit session scope
+      TMUX_PANE: void 0,
+      // Prevents resolveExeSession() from scoping to one session
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+}
+function acquireSpawnLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(SPAWN_LOCK_PATH);
+      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync2(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync2(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
+    const socket = net.createConnection({ path: SOCKET_PATH });
+    const connectTimeout = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 2e3);
+    socket.on("connect", () => {
+      clearTimeout(connectTimeout);
+      _socket = socket;
+      _connected = true;
+      _buffer = "";
+      socket.on("data", handleData);
+      socket.on("close", () => {
+        _connected = false;
+        _socket = null;
+        for (const [id, entry] of _pending) {
+          clearTimeout(entry.timer);
+          _pending.delete(id);
+          entry.resolve({ error: "Connection closed" });
+        }
+      });
+      socket.on("error", () => {
+        _connected = false;
+        _socket = null;
+      });
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
+    });
+  });
+}
+async function connectEmbedDaemon() {
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (acquireSpawnLock()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock();
+    }
+  }
+  const start = Date.now();
+  let delay2 = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay2));
+    if (await connectToSocket()) return true;
+    delay2 = Math.min(delay2 * 2, 3e3);
+  }
+  return false;
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, timeoutMs);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+function isClientConnected() {
+  return _connected;
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _pending, MAX_BUFFER;
+var init_exe_daemon_client = __esm({
+  "src/lib/exe-daemon-client.ts"() {
+    "use strict";
+    init_config();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path6.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path6.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path6.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    _socket = null;
+    _connected = false;
+    _buffer = "";
+    _pending = /* @__PURE__ */ new Map();
+    MAX_BUFFER = 1e7;
+  }
+});
+
+// src/lib/daemon-protocol.ts
+function serializeValue(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (v instanceof Uint8Array) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (ArrayBuffer.isView(v)) {
+    return { __blob: Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("base64") };
+  }
+  if (v instanceof ArrayBuffer) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (typeof v === "string" || typeof v === "number") return v;
+  return String(v);
+}
+function deserializeValue(v) {
+  if (v === null) return null;
+  if (typeof v === "object" && v !== null && "__blob" in v) {
+    const buf = Buffer.from(v.__blob, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
   }
-  const binDir = path4.dirname(exeBinPath);
-  let target;
-  try {
-    target = readlinkSync(exeBinPath);
-  } catch {
-    errors.push("Could not read 'exe' symlink");
-    return { created, skipped, errors };
+  return v;
+}
+function deserializeResultSet(srs) {
+  const rows = srs.rows.map((obj) => {
+    const values = srs.columns.map(
+      (col) => deserializeValue(obj[col] ?? null)
+    );
+    const row = values;
+    for (let i = 0; i < srs.columns.length; i++) {
+      const col = srs.columns[i];
+      if (col !== void 0) {
+        row[col] = values[i] ?? null;
+      }
+    }
+    Object.defineProperty(row, "length", {
+      value: values.length,
+      enumerable: false
+    });
+    return row;
+  });
+  return {
+    columns: srs.columns,
+    columnTypes: srs.columnTypes ?? [],
+    rows,
+    rowsAffected: srs.rowsAffected,
+    lastInsertRowid: srs.lastInsertRowid != null ? BigInt(srs.lastInsertRowid) : void 0,
+    toJSON: () => ({
+      columns: srs.columns,
+      columnTypes: srs.columnTypes ?? [],
+      rows: srs.rows,
+      rowsAffected: srs.rowsAffected,
+      lastInsertRowid: srs.lastInsertRowid
+    })
+  };
+}
+var init_daemon_protocol = __esm({
+  "src/lib/daemon-protocol.ts"() {
+    "use strict";
   }
-  for (const suffix of ["", "-opencode"]) {
-    const linkName = `${name}${suffix}`;
-    const linkPath = path4.join(binDir, linkName);
-    if (existsSync5(linkPath)) {
-      skipped.push(linkName);
-      continue;
+});
+
+// src/lib/db-daemon-client.ts
+var db_daemon_client_exports = {};
+__export(db_daemon_client_exports, {
+  createDaemonDbClient: () => createDaemonDbClient,
+  initDaemonDbClient: () => initDaemonDbClient
+});
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  let args = [];
+  if (Array.isArray(stmt.args)) {
+    args = stmt.args.map((v) => serializeValue(v));
+  } else if (stmt.args && typeof stmt.args === "object") {
+    const named = {};
+    for (const [key, val] of Object.entries(stmt.args)) {
+      named[key] = serializeValue(val);
+    }
+    return { sql, args: named };
+  }
+  return { sql, args };
+}
+function createDaemonDbClient(fallbackClient) {
+  let _useDaemon = false;
+  const client = {
+    async execute(stmt) {
+      if (!_useDaemon || !isClientConnected()) {
+        return fallbackClient.execute(stmt);
+      }
+      const { sql, args } = normalizeStatement(stmt);
+      const response = await sendDaemonRequest({
+        type: "db-execute",
+        sql,
+        args
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed") {
+          process.stderr.write(`[db-daemon] Transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.execute(stmt);
+        }
+        throw new Error(errMsg);
+      }
+      if (response.db) {
+        return deserializeResultSet(response.db);
+      }
+      process.stderr.write("[db-daemon] Unexpected response shape, falling back to direct\n");
+      return fallbackClient.execute(stmt);
+    },
+    async batch(stmts, mode) {
+      if (!_useDaemon || !isClientConnected()) {
+        return fallbackClient.batch(stmts, mode);
+      }
+      const statements = stmts.map(normalizeStatement);
+      const response = await sendDaemonRequest({
+        type: "db-batch",
+        statements,
+        mode: mode ?? "deferred"
+      });
+      if (response.error) {
+        const errMsg = String(response.error);
+        if (errMsg === "Not connected" || errMsg === "Request timeout" || errMsg === "Write failed") {
+          process.stderr.write(`[db-daemon] Batch transport error (${errMsg}), falling back to direct
+`);
+          return fallbackClient.batch(stmts, mode);
+        }
+        throw new Error(errMsg);
+      }
+      const batchResults = response["db-batch"];
+      if (batchResults) {
+        return batchResults.map(deserializeResultSet);
+      }
+      process.stderr.write("[db-daemon] Unexpected batch response shape, falling back to direct\n");
+      return fallbackClient.batch(stmts, mode);
+    },
+    // Transaction support — delegate to fallback (transactions need direct connection)
+    async transaction(mode) {
+      return fallbackClient.transaction(mode);
+    },
+    // executeMultiple — delegate to fallback (used only for schema migrations)
+    async executeMultiple(sql) {
+      return fallbackClient.executeMultiple(sql);
+    },
+    // migrate — delegate to fallback
+    async migrate(stmts) {
+      return fallbackClient.migrate(stmts);
+    },
+    // Sync mode — delegate to fallback
+    sync() {
+      return fallbackClient.sync();
+    },
+    close() {
+      _useDaemon = false;
+    },
+    get closed() {
+      return fallbackClient.closed;
+    },
+    get protocol() {
+      return fallbackClient.protocol;
     }
-    try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+  };
+  return {
+    ...client,
+    /** Enable daemon routing (call after confirming daemon is connected) */
+    _enableDaemon() {
+      _useDaemon = true;
+    },
+    /** Check if daemon routing is active */
+    _isDaemonActive() {
+      return _useDaemon && isClientConnected();
     }
+  };
+}
+async function initDaemonDbClient(fallbackClient) {
+  if (process.env.EXE_IS_DAEMON === "1") return null;
+  const connected = await connectEmbedDaemon();
+  if (!connected) {
+    process.stderr.write("[db-daemon] Daemon unavailable \u2014 using direct SQLite\n");
+    return null;
   }
-  return { created, skipped, errors };
+  const client = createDaemonDbClient(fallbackClient);
+  client._enableDaemon();
+  process.stderr.write("[db-daemon] DB routing through daemon (single-writer)\n");
+  return client;
 }
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
+var init_db_daemon_client = __esm({
+  "src/lib/db-daemon-client.ts"() {
     "use strict";
-    init_config();
-    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
-    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
-    COORDINATOR_ROLE = "COO";
-    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    init_exe_daemon_client();
+    init_daemon_protocol();
   }
 });
 
@@ -872,6 +1369,7 @@ __export(database_exports, {
   ensureSchema: () => ensureSchema,
   getClient: () => getClient,
   getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
   initDatabase: () => initDatabase,
   initTurso: () => initTurso,
   isInitialized: () => isInitialized
@@ -899,8 +1397,27 @@ function getClient() {
   if (!_resilientClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.EXE_IS_DAEMON === "1") {
+    return _resilientClient;
+  }
+  if (_daemonClient && _daemonClient._isDaemonActive()) {
+    return _daemonClient;
+  }
   return _resilientClient;
 }
+async function initDaemonClient() {
+  if (process.env.EXE_IS_DAEMON === "1") return;
+  if (!_resilientClient) return;
+  try {
+    const { initDaemonDbClient: initDaemonDbClient2 } = await Promise.resolve().then(() => (init_db_daemon_client(), db_daemon_client_exports));
+    _daemonClient = await initDaemonDbClient2(_resilientClient);
+  } catch (err) {
+    process.stderr.write(
+      `[database] Daemon client init failed (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
 function getRawClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
@@ -1387,6 +1904,12 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_content_hash ON memories(content_hash, agent_id)`
+    );
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entities (
       id TEXT PRIMARY KEY,
@@ -1439,7 +1962,30 @@ async function ensureSchema() {
       entity_id TEXT NOT NULL,
       PRIMARY KEY (hyperedge_id, entity_id)
     );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS entities_fts USING fts5(
+      name,
+      content=entities,
+      content_rowid=rowid
+    );
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ai AFTER INSERT ON entities BEGIN
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_ad AFTER DELETE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS entities_fts_au AFTER UPDATE ON entities BEGIN
+      INSERT INTO entities_fts(entities_fts, rowid, name) VALUES('delete', old.rowid, old.name);
+      INSERT INTO entities_fts(rowid, name) VALUES (new.rowid, new.name);
+    END;
   `);
+  try {
+    await client.execute("INSERT INTO entities_fts(entities_fts) VALUES('rebuild')");
+  } catch {
+  }
   await client.executeMultiple(`
     CREATE TABLE IF NOT EXISTS entity_aliases (
       alias TEXT NOT NULL PRIMARY KEY,
@@ -1620,6 +2166,33 @@ async function ensureSchema() {
     CREATE INDEX IF NOT EXISTS idx_conversations_channel
       ON conversations(channel_id);
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS session_agent_map (
+      session_uuid TEXT PRIMARY KEY,
+      agent_id TEXT NOT NULL,
+      session_name TEXT,
+      task_id TEXT,
+      project_name TEXT,
+      started_at TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_agent_map_agent
+      ON session_agent_map(agent_id);
+  `);
+  try {
+    const mapCount = await client.execute({ sql: `SELECT COUNT(*) as cnt FROM session_agent_map`, args: [] });
+    if (Number(mapCount.rows[0]?.cnt ?? 0) === 0) {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO session_agent_map (session_uuid, agent_id, session_name, started_at)
+              SELECT session_id, agent_id, '', MIN(timestamp)
+              FROM memories
+              WHERE session_id IS NOT NULL AND session_id != '' AND agent_id IS NOT NULL AND agent_id != ''
+              GROUP BY session_id, agent_id`,
+        args: []
+      });
+    }
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN budget_tokens INTEGER`,
@@ -1753,15 +2326,41 @@ async function ensureSchema() {
     });
   } catch {
   }
+  for (const col of [
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
+  ]) {
+    try {
+      await client.execute(col);
+    } catch {
+    }
+  }
 }
 async function disposeDatabase() {
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
   if (_client) {
     _client.close();
     _client = null;
     _resilientClient = null;
   }
 }
-var _client, _resilientClient, initTurso, disposeTurso;
+var _client, _resilientClient, _daemonClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
@@ -1769,6 +2368,7 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -1791,9 +2391,9 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID } from "crypto";
-import path5 from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import path7 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -1804,37 +2404,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path5.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path7.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync6(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
+    if (existsSync8(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync8(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync6(DEVICE_ID_PATH)) {
-      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync8(DEVICE_ID_PATH)) {
+      const id2 = readFileSync8(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
   }
-  const id = randomUUID();
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
+  const id = randomUUID2();
+  mkdirSync4(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync6(LICENSE_PATH)) return null;
-    return readFileSync6(LICENSE_PATH, "utf8").trim();
+    if (!existsSync8(LICENSE_PATH)) return null;
+    return readFileSync8(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync4(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -1860,8 +2460,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync6(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!existsSync8(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -1870,8 +2470,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync6(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!existsSync8(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -1905,7 +2505,7 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync5(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -1958,8 +2558,8 @@ async function validateLicense(apiKey, deviceId) {
 }
 function getCacheAgeMs() {
   try {
-    const { statSync } = __require("fs");
-    const s = statSync(CACHE_PATH);
+    const { statSync: statSync2 } = __require("fs");
+    const s = statSync2(CACHE_PATH);
     return Date.now() - s.mtimeMs;
   } catch {
     return Infinity;
@@ -1969,9 +2569,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path5.join(EXE_AI_DIR, "config.json");
-      if (existsSync6(configPath)) {
-        const raw = JSON.parse(readFileSync6(configPath, "utf8"));
+      const configPath = path7.join(EXE_AI_DIR, "config.json");
+      if (existsSync8(configPath)) {
+        const raw = JSON.parse(readFileSync8(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -2130,9 +2730,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path5.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path5.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path5.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path7.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path7.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -2162,12 +2762,12 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync7, existsSync as existsSync7 } from "fs";
-import path6 from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync9 } from "fs";
+import path8 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync7(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync7(CACHE_PATH2, "utf8"));
+    if (!existsSync9(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync9(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -2205,8 +2805,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync7(filePath)) {
-      const raw = readFileSync7(filePath, "utf8");
+    if (existsSync9(filePath)) {
+      const raw = readFileSync9(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -2235,19 +2835,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path6.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto from "crypto";
-import path7 from "path";
+import path9 from "path";
 import os5 from "os";
 import {
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync10,
   readdirSync,
-  unlinkSync as unlinkSync2,
-  existsSync as existsSync8,
+  unlinkSync as unlinkSync3,
+  existsSync as existsSync10,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -2398,10 +2998,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto3 from "crypto";
-import path8 from "path";
+import path10 from "path";
+import os6 from "os";
 import { execSync as execSync5 } from "child_process";
 import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
-import { existsSync as existsSync9, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync11 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -2442,6 +3043,35 @@ function extractParentFromContext(contextBody) {
 function slugify(title) {
   return title.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
+function buildKeywordIndex() {
+  const idx = /* @__PURE__ */ new Map();
+  for (const [role, keywords] of Object.entries(LANE_KEYWORDS)) {
+    for (const kw of keywords) {
+      const existing = idx.get(kw) ?? [];
+      existing.push(role);
+      idx.set(kw, existing);
+    }
+  }
+  return idx;
+}
+function checkLaneAffinity(title, context, assigneeName) {
+  const employees = loadEmployeesSync();
+  const employee = employees.find((e) => e.name === assigneeName);
+  if (!employee) return void 0;
+  const assigneeRole = employee.role;
+  const text = `${title} ${context}`.toLowerCase();
+  const matchedRoles = /* @__PURE__ */ new Set();
+  for (const [keyword, roles] of KEYWORD_INDEX) {
+    if (text.includes(keyword)) {
+      for (const role of roles) matchedRoles.add(role);
+    }
+  }
+  if (matchedRoles.size === 0) return void 0;
+  if (matchedRoles.has(assigneeRole)) return void 0;
+  if (assigneeRole === "COO") return void 0;
+  const expectedRoles = Array.from(matchedRoles).join(" or ");
+  return `\u26A0\uFE0F Lane mismatch: task content suggests ${expectedRoles}, but assigned to ${assigneeName} (${assigneeRole}).`;
+}
 async function resolveTask(client, identifier, scopeSession) {
   const scope = sessionScopeFilter(scopeSession);
   let result = await client.execute({
@@ -2491,7 +3121,14 @@ async function createTaskCore(input) {
   const id = crypto3.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const slug = slugify(input.title);
-  const taskFile = input.taskFile ?? `exe/${input.assignedTo}/${slug}.md`;
+  let earlySessionScope = null;
+  try {
+    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+    earlySessionScope = resolveExeSession2();
+  } catch {
+  }
+  const scope = earlySessionScope ?? "default";
+  const taskFile = input.taskFile ?? `tasks/${scope}/${input.assignedTo}/${slug}.md`;
   let blockedById = null;
   const initialStatus = input.blockedBy ? "blocked" : "open";
   if (input.blockedBy) {
@@ -2531,22 +3168,24 @@ async function createTaskCore(input) {
   if (dupCheck.rows.length > 0) {
     warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
   }
+  if (!process.env.DISABLE_LANE_AFFINITY) {
+    const laneWarning = checkLaneAffinity(input.title, input.context, input.assignedTo);
+    if (laneWarning) {
+      warning = warning ? `${warning}
+${laneWarning}` : laneWarning;
+    }
+  }
   if (input.baseDir) {
     try {
-      await mkdir3(path8.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir3(path8.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir3(path10.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir3(path10.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
     }
   }
   const complexity = input.complexity ?? "standard";
-  let sessionScope = null;
-  try {
-    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
-    sessionScope = resolveExeSession2();
-  } catch {
-  }
+  const sessionScope = earlySessionScope;
   await client.execute({
     sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -2573,6 +3212,43 @@ async function createTaskCore(input) {
       now
     ]
   });
+  if (input.baseDir) {
+    try {
+      const EXE_OS_DIR = path10.join(os6.homedir(), ".exe-os");
+      const mdPath = path10.join(EXE_OS_DIR, taskFile);
+      const mdDir = path10.dirname(mdPath);
+      if (!existsSync11(mdDir)) await mkdir3(mdDir, { recursive: true });
+      const reviewer = input.reviewer ?? input.assignedBy;
+      const mdContent = `# ${input.title}
+
+**ID:** ${id}
+**Status:** ${initialStatus}
+**Priority:** ${input.priority}
+**Assigned by:** ${input.assignedBy}
+**Assigned to:** ${input.assignedTo}
+**Project:** ${input.projectName}
+**Created:** ${now.split("T")[0]}${parentTaskId ? `
+**Parent task:** ${parentTaskId}` : ""}
+**Reviewer:** ${reviewer}
+
+## Context
+
+${input.context}
+
+## MANDATORY: When done
+
+You MUST call update_task with status "done" and a result summary when finished.
+If you skip this, your reviewer will not know you're done and your work won't be reviewed.
+Do NOT let a failed commit or any error prevent you from calling update_task(done).
+`;
+      await writeFile3(mdPath, mdContent, "utf-8");
+    } catch (err) {
+      process.stderr.write(
+        `[create-task] WARNING: .md file write failed for ${taskFile}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
   return {
     id,
     title: input.title,
@@ -2765,7 +3441,7 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
           return { row, taskFile, now, taskId };
         }
       }
-      if (curStatus === "in_progress" && input.callerAgentId && (input.callerAgentId === assignedBy || input.callerAgentId === "exe")) {
+      if (curStatus === "in_progress" && input.callerAgentId && (input.callerAgentId === assignedBy || isCoordinatorName(input.callerAgentId))) {
         process.stderr.write(
           `[tasks] Assigner override: ${input.callerAgentId} reclaiming ${taskId}
 `
@@ -2830,9 +3506,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path8.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path10.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync9(archPath)) return;
+    if (existsSync11(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -2865,10 +3541,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path8.join(baseDir, ".gitignore");
+  const gitignorePath = path10.join(baseDir, ".gitignore");
   try {
-    if (existsSync9(gitignorePath)) {
-      const content = readFileSync9(gitignorePath, "utf-8");
+    if (existsSync11(gitignorePath)) {
+      const content = readFileSync11(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -2877,20 +3553,30 @@ async function ensureGitignoreExe(baseDir) {
   } catch {
   }
 }
-var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
+var LANE_KEYWORDS, KEYWORD_INDEX, DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
 var init_tasks_crud = __esm({
   "src/lib/tasks-crud.ts"() {
     "use strict";
     init_database();
     init_task_scope();
+    init_employees();
+    LANE_KEYWORDS = {
+      CMO: ["sales", "script", "pitch", "offer", "copy", "objection", "brand", "content", "seo", "marketing", "newsletter", "carousel", "social", "campaign"],
+      CTO: ["spec", "architecture", "migration", "schema", "database", "design doc", "adr", "security audit", "tech stack"],
+      "Principal Engineer": ["implement", "build", "fix", "commit", "refactor", "bug", "feature", "wire", "integration"],
+      "Staff Code Reviewer": ["critique", "verdict", "review", "audit", "code quality"],
+      "Content Production Specialist": ["render", "video", "image", "b-roll", "remotion", "animation", "thumbnail"],
+      "AI Product Lead": ["competitive", "analysis", "benchmark", "compare", "scout", "evaluate", "poc"]
+    };
+    KEYWORD_INDEX = buildKeywordIndex();
     DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
     TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
 
 // src/lib/tasks-review.ts
-import path9 from "path";
-import { existsSync as existsSync10, readdirSync as readdirSync2, unlinkSync as unlinkSync3 } from "fs";
+import path11 from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync2, unlinkSync as unlinkSync4 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -2912,7 +3598,7 @@ async function countNewPendingReviewsSince(sinceIso, sessionScope) {
     const result2 = await client.execute({
       sql: `SELECT COUNT(*) as cnt FROM tasks
             WHERE status = 'needs_review' AND updated_at > ?
-              AND (session_scope = ? OR session_scope IS NULL)`,
+              AND session_scope = ?`,
       args: [sinceIso, sessionScope]
     });
     return Number(result2.rows[0]?.cnt) || 0;
@@ -2930,7 +3616,7 @@ async function listPendingReviews(limit, sessionScope) {
     const result2 = await client.execute({
       sql: `SELECT title, assigned_to, project_name FROM tasks
             WHERE status = 'needs_review'
-              AND (session_scope = ? OR session_scope IS NULL)
+              AND session_scope = ?
             ORDER BY priority ASC, created_at DESC LIMIT ?`,
       args: [sessionScope, limit]
     });
@@ -3051,14 +3737,14 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
       if (parts.length >= 3 && parts[0] === "review") {
         const agent = parts[1];
         const slug = parts.slice(2).join("-");
-        const originalTaskFile = `exe/${agent}/${slug}.md`;
+        const legacyTaskFile = `exe/${agent}/${slug}.md`;
         const result = await client.execute({
-          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE task_file = ? AND status = 'needs_review'",
-          args: [now, originalTaskFile]
+          sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE (task_file = ? OR task_file LIKE ?) AND status = 'needs_review'",
+          args: [now, legacyTaskFile, `tasks/%/${agent}/${slug}.md`]
         });
         if (result.rowsAffected > 0) {
           process.stderr.write(
-            `[review-cleanup] Cascaded original task to done (legacy path): ${originalTaskFile}
+            `[review-cleanup] Cascaded original task to done: ${agent}/${slug}.md
 `
           );
         }
@@ -3071,11 +3757,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path9.join(EXE_AI_DIR, "session-cache");
-    if (existsSync10(cacheDir)) {
+    const cacheDir = path11.join(EXE_AI_DIR, "session-cache");
+    if (existsSync12(cacheDir)) {
       for (const f of readdirSync2(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync3(path9.join(cacheDir, f));
+          unlinkSync4(path11.join(cacheDir, f));
         }
       }
     }
@@ -3096,7 +3782,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path10 from "path";
+import path12 from "path";
 import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -3113,7 +3799,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path10.join(baseDir, String(ur.task_file));
+        const ubFile = path12.join(baseDir, String(ur.task_file));
         let ubContent = await readFile3(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -3182,7 +3868,7 @@ var init_tasks_chain = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync6 } from "child_process";
-import path11 from "path";
+import path13 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -3195,7 +3881,7 @@ function getProjectName(cwd2) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path11.dirname(gitCommonDir);
+      repoRoot = path13.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync6("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -3204,11 +3890,11 @@ function getProjectName(cwd2) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path11.basename(repoRoot);
+    _cached2 = path13.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path11.basename(dir);
+    _cached2 = path13.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -3240,7 +3926,7 @@ function findSessionForProject(projectName) {
   const sessions = listSessions();
   for (const s of sessions) {
     const proj = s.projectDir.split("/").filter(Boolean).pop();
-    if (proj === projectName && (s.agentId === "exe" || isCoordinatorName(s.agentId))) return s;
+    if (proj === projectName && isCoordinatorName(s.agentId)) return s;
   }
   return null;
 }
@@ -3286,7 +3972,7 @@ var init_session_scope = __esm({
 
 // src/lib/tasks-notify.ts
 async function dispatchTaskToEmployee(input) {
-  if (input.assignedTo === "exe" || isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
+  if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
   let crossProject = false;
   if (input.projectName) {
     try {
@@ -3681,8 +4367,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path12 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4 } from "fs";
+import path14 from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -3701,14 +4387,14 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path12.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path12.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync4(cacheDir, { recursive: true });
-      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync5(cacheDir, { recursive: true });
+      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
-        unlinkSync4(cachePath);
+        unlinkSync5(cachePath);
       } catch {
       }
     }
@@ -3765,7 +4451,7 @@ async function updateTask(input) {
   }
   const isTerminal = input.status === "done" || input.status === "needs_review";
   if (isTerminal) {
-    const isCoordinator = String(row.assigned_to) === "exe" || isCoordinatorName(String(row.assigned_to));
+    const isCoordinator = isCoordinatorName(String(row.assigned_to));
     if (!isCoordinator) {
       notifyTaskDone();
     }
@@ -3790,7 +4476,7 @@ async function updateTask(input) {
       }
     }
   }
-  if (input.status === "done" && String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
+  if (input.status === "done" && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
     Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
       ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
         taskId,
@@ -3806,7 +4492,7 @@ async function updateTask(input) {
     });
   }
   let nextTask;
-  if (isTerminal && String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to))) {
+  if (isTerminal && !isCoordinatorName(String(row.assigned_to))) {
     try {
       nextTask = await findNextTask(String(row.assigned_to));
     } catch {
@@ -4150,7 +4836,7 @@ var init_capacity_monitor = __esm({
 // src/lib/tmux-routing.ts
 var tmux_routing_exports = {};
 __export(tmux_routing_exports, {
-  acquireSpawnLock: () => acquireSpawnLock,
+  acquireSpawnLock: () => acquireSpawnLock2,
   employeeSessionName: () => employeeSessionName,
   ensureEmployee: () => ensureEmployee,
   extractRootExe: () => extractRootExe,
@@ -4165,20 +4851,20 @@ __export(tmux_routing_exports, {
   notifyParentExe: () => notifyParentExe,
   parseParentExe: () => parseParentExe,
   registerParentExe: () => registerParentExe,
-  releaseSpawnLock: () => releaseSpawnLock,
+  releaseSpawnLock: () => releaseSpawnLock2,
   resolveExeSession: () => resolveExeSession,
   sendIntercom: () => sendIntercom,
   spawnEmployee: () => spawnEmployee,
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync3, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync11, appendFileSync } from "fs";
-import path13 from "path";
-import os6 from "os";
-import { fileURLToPath } from "url";
-import { unlinkSync as unlinkSync5 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync13, appendFileSync } from "fs";
+import path15 from "path";
+import os7 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync6 } from "fs";
 function spawnLockPath(sessionName) {
-  return path13.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path15.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -4188,14 +4874,14 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function acquireSpawnLock(sessionName) {
-  if (!existsSync11(SPAWN_LOCK_DIR)) {
-    mkdirSync5(SPAWN_LOCK_DIR, { recursive: true });
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync13(SPAWN_LOCK_DIR)) {
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync11(lockFile)) {
+  if (existsSync13(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync10(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -4203,25 +4889,25 @@ function acquireSpawnLock(sessionName) {
     } catch {
     }
   }
-  writeFileSync6(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync7(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
-function releaseSpawnLock(sessionName) {
+function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync5(spawnLockPath(sessionName));
+    unlinkSync6(spawnLockPath(sessionName));
   } catch {
   }
 }
 function resolveBehaviorsExporterScript() {
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const scriptPath = path13.join(
-      path13.dirname(thisFile),
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path15.join(
+      path15.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync11(scriptPath) ? scriptPath : null;
+    return existsSync13(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -4287,12 +4973,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync11(SESSION_CACHE)) {
-    mkdirSync5(SESSION_CACHE, { recursive: true });
+  if (!existsSync13(SESSION_CACHE)) {
+    mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync6(filePath, JSON.stringify({
+  const filePath = path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync7(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -4300,7 +4986,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync10(path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync12(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -4308,8 +4994,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync10(
-      path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync12(
+      path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -4335,10 +5021,10 @@ function isEmployeeAlive(sessionName) {
 }
 function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
   const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base) && acquireSpawnLock(base)) return 0;
+  if (!isAlive(base) && acquireSpawnLock2(base)) return 0;
   for (let i = 2; i <= maxInstances; i++) {
     const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate) && acquireSpawnLock(candidate)) return i;
+    if (!isAlive(candidate) && acquireSpawnLock2(candidate)) return i;
   }
   return null;
 }
@@ -4370,32 +5056,50 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync11(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync10(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync13(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
   } catch {
     return {};
   }
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync11(SESSION_CACHE)) mkdirSync5(SESSION_CACHE, { recursive: true });
-    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync13(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync7(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
 function isDebounced(targetSession) {
   const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+  const entry = state[targetSession];
+  const lastSent = entry?.lastSent ?? 0;
+  if (Date.now() - lastSent < INTERCOM_DEBOUNCE_MS) {
+    if (!state[targetSession]) state[targetSession] = { lastSent, pending: 0 };
+    state[targetSession].pending++;
+    writeDebounceState(state);
+    return true;
+  }
+  return false;
 }
 function recordDebounce(targetSession) {
   const state = readDebounceState();
-  state[targetSession] = Date.now();
+  const batched = state[targetSession]?.pending ?? 0;
+  state[targetSession] = { lastSent: Date.now(), pending: 0 };
   const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
   for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
+    if ((state[key]?.lastSent ?? 0) < cutoff) delete state[key];
   }
   writeDebounceState(state);
+  return batched;
 }
 function logIntercom(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
@@ -4440,7 +5144,7 @@ function sendIntercom(targetSession) {
     return "skipped_exe";
   }
   if (isDebounced(targetSession)) {
-    logIntercom(`DEBOUNCE \u2192 ${targetSession} (cross-process file debounce)`);
+    logIntercom(`DEBOUNCE \u2192 ${targetSession} (nudge batched, task safe in DB)`);
     return "debounced";
   }
   try {
@@ -4452,14 +5156,14 @@ function sendIntercom(targetSession) {
     const sessionState = getSessionState(targetSession);
     if (sessionState === "no_claude") {
       queueIntercom(targetSession, "claude not running in session");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process \u2014 raw shell detected)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (no claude process)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (sessionState === "thinking" || sessionState === "tool") {
       queueIntercom(targetSession, "session busy at send time");
-      recordDebounce(targetSession);
-      logIntercom(`QUEUED \u2192 ${targetSession} (session busy, will retry from queue)`);
+      const batched2 = recordDebounce(targetSession);
+      logIntercom(`QUEUED \u2192 ${targetSession} (session busy)${batched2 > 0 ? ` [${batched2} batched]` : ""}`);
       return "queued";
     }
     if (transport.isPaneInCopyMode(targetSession)) {
@@ -4467,8 +5171,8 @@ function sendIntercom(targetSession) {
       transport.sendKeys(targetSession, "q");
     }
     transport.sendKeys(targetSession, "/exe-intercom");
-    recordDebounce(targetSession);
-    logIntercom(`DELIVERED \u2192 ${targetSession} (fire-and-forget)`);
+    const batched = recordDebounce(targetSession);
+    logIntercom(`DELIVERED \u2192 ${targetSession}${batched > 0 ? ` [${batched} nudges batched during debounce]` : ""} (fire-and-forget)`);
     return "delivered";
   } catch {
     logIntercom(`FAIL \u2192 ${targetSession}`);
@@ -4498,7 +5202,7 @@ function notifyParentExe(sessionKey) {
   return true;
 }
 function ensureEmployee(employeeName, exeSession, projectDir, opts) {
-  if (employeeName === "exe" || isCoordinatorName(employeeName)) {
+  if (isCoordinatorName(employeeName)) {
     return { status: "failed", sessionName: "", error: "The COO is not a dispatchable employee" };
   }
   try {
@@ -4570,26 +5274,26 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path13.join(os6.homedir(), ".exe-os", "session-logs");
-  const logFile = path13.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync11(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+  const logDir = path15.join(os7.homedir(), ".exe-os", "session-logs");
+  const logFile = path15.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync13(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path13.join(path13.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync11(cleanupScript)) {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync13(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path13.join(os6.homedir(), ".claude.json");
+    const claudeJsonPath = path15.join(os7.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync10(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -4597,17 +5301,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync6(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync7(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path13.join(os6.homedir(), ".claude", "projects");
+    const settingsDir = path15.join(os7.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path13.join(settingsDir, normalizedKey);
-    const settingsPath = path13.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path15.join(settingsDir, normalizedKey);
+    const settingsPath = path15.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync10(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -4635,21 +5339,24 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync5(projSettingsDir, { recursive: true });
-      writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync6(projSettingsDir, { recursive: true });
+      writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
   const spawnCwd = opts?.cwd ?? projectDir;
   const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
+  const agentRtConfig = getAgentRuntime(employeeName);
+  const useCodex = !useExeAgent && agentRtConfig.runtime === "codex";
+  const useOpencode = !useExeAgent && !useCodex && agentRtConfig.runtime === "opencode";
+  const ccProvider = useExeAgent || useCodex || useOpencode ? DEFAULT_PROVIDER : detectActiveProvider();
   const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
   let identityFlag = "";
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path13.join(
-      os6.homedir(),
+    const identityPath = path15.join(
+      os7.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -4658,13 +5365,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync11(identityPath)) {
+    } else if (existsSync13(identityPath)) {
       identityFlag = ` --append-system-prompt-file ${identityPath}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path13.basename(spawnCwd),
+      path15.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -4679,16 +5386,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path13.join(os6.homedir(), ".exe-os", "session-cache");
-    mkdirSync5(ctxDir, { recursive: true });
-    const ctxFile = path13.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path15.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
+    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync6(ctxFile, ctxContent);
+    writeFileSync7(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -4702,9 +5409,48 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       }
     }
   }
+  if (useCodex) {
+    const codexCfg = RUNTIME_TABLE.codex;
+    if (codexCfg?.apiKeyEnv) {
+      const keyVal = process.env[codexCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${codexCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} EXE_AGENT_MODEL=${agentRtConfig.model}`;
+  }
+  if (useOpencode) {
+    const ocCfg = PROVIDER_TABLE.opencode;
+    if (ocCfg?.apiKeyEnv) {
+      const keyVal = process.env[ocCfg.apiKeyEnv];
+      if (keyVal) {
+        envPrefix = `${envPrefix} ${ocCfg.apiKeyEnv}=${keyVal}`;
+      }
+    }
+    envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+  }
+  if (!useExeAgent && !useCodex && !useOpencode && !useBinSymlink) {
+    const defaultClaudeModel = DEFAULT_MODELS.claude;
+    if (agentRtConfig.runtime === "claude" && agentRtConfig.model !== defaultClaudeModel) {
+      envPrefix = `${envPrefix} ANTHROPIC_MODEL=${agentRtConfig.model}`;
+    }
+  }
   let spawnCommand;
   if (useExeAgent) {
     spawnCommand = `${envPrefix} exe-agent --employee ${employeeName} --model ${opts.model} --provider ${opts.provider}${cleanupSuffix}`;
+  } else if (useCodex) {
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 codex (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} exe-start-codex --agent ${employeeName}${cleanupSuffix}`;
+  } else if (useOpencode) {
+    const binName = `${employeeName}-opencode`;
+    process.stderr.write(
+      `[tmux-routing] agent-config: ${employeeName} \u2192 opencode (${agentRtConfig.model})
+`
+    );
+    spawnCommand = `${envPrefix} ${binName}${cleanupSuffix}`;
   } else if (useBinSymlink) {
     const binName = `${employeeName}-${ccProvider}`;
     process.stderr.write(
@@ -4720,17 +5466,19 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     command: spawnCommand
   });
   if (spawnResult.error) {
-    releaseSpawnLock(sessionName);
+    releaseSpawnLock2(sessionName);
     return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
   }
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path13.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync6(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync7(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
+      runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+      model: useCodex ? agentRtConfig.model : useOpencode ? agentRtConfig.model : void 0,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }));
   } catch {
@@ -4748,6 +5496,11 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
           booted = true;
           break;
         }
+      } else if (useCodex) {
+        if (pane.includes("codex") || pane.includes("Codex") || pane.includes("exe-start-codex")) {
+          booted = true;
+          break;
+        }
       } else {
         if (pane.includes("Claude Code") || pane.includes("\u276F")) {
           booted = true;
@@ -4758,10 +5511,11 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
   }
   if (!booted) {
-    releaseSpawnLock(sessionName);
-    return { sessionName, error: `${useExeAgent ? "exe-agent" : "claude"} did not boot within 15s` };
+    releaseSpawnLock2(sessionName);
+    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 {
@@ -4775,7 +5529,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     pid: 0,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  releaseSpawnLock(sessionName);
+  releaseSpawnLock2(sessionName);
   return { sessionName };
 }
 var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
@@ -4788,17 +5542,19 @@ var init_tmux_routing = __esm({
     init_cc_agent_support();
     init_mcp_prefix();
     init_provider_table();
+    init_agent_config();
+    init_runtime_table();
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path13.join(os6.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path13.join(os6.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path15.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path15.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path13.join(os6.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path13.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path15.join(os7.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -6191,7 +6947,7 @@ __export(global_procedures_exports, {
   loadGlobalProcedures: () => loadGlobalProcedures,
   storeGlobalProcedure: () => storeGlobalProcedure
 });
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
   const result = await client.execute({
@@ -6220,7 +6976,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input) {
-  const id = randomUUID2();
+  const id = randomUUID3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -6358,7 +7114,7 @@ var init_anthropic = __esm({
 
 // src/gateway/providers/openai-compat.ts
 import OpenAI from "openai";
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 var OpenAICompatProvider;
 var init_openai_compat = __esm({
   "src/gateway/providers/openai-compat.ts"() {
@@ -6475,7 +7231,7 @@ var init_openai_compat = __esm({
             }
             content.push({
               type: "tool_use",
-              id: call.id ?? randomUUID3(),
+              id: call.id ?? randomUUID4(),
               name: fn.name,
               input
             });
@@ -6667,10 +7423,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path14 from "path";
-import os7 from "os";
+import path16 from "path";
+import os8 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path14.resolve(filePath);
+  const resolved = path16.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -6680,7 +7436,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path14.resolve(filePath);
+  const resolved = path16.resolve(filePath);
   const credPatterns = BYPASS_IMMUNE_PATTERNS.filter(
     (p) => typeof p.pattern !== "function" && (p.reason.includes("secrets") || p.reason.includes("Private key") || p.reason.includes("Credential"))
   );
@@ -6695,7 +7451,7 @@ var HOME, BYPASS_IMMUNE_PATTERNS;
 var init_safety_checks = __esm({
   "src/runtime/safety-checks.ts"() {
     "use strict";
-    HOME = os7.homedir();
+    HOME = os8.homedir();
     BYPASS_IMMUNE_PATTERNS = [
       {
         pattern: /\/\.git\/hooks\//,
@@ -6706,11 +7462,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path14.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path16.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path14.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path16.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -6727,7 +7483,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path14.basename(p);
+          const name = path16.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -6754,7 +7510,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path15 from "path";
+import path17 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -6790,7 +7546,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path15.isAbsolute(input.file_path) ? input.file_path : path15.resolve(context.cwd, input.file_path);
+        const filePath = path17.isAbsolute(input.file_path) ? input.file_path : path17.resolve(context.cwd, input.file_path);
         let stat;
         try {
           stat = await fs3.stat(filePath);
@@ -6830,7 +7586,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path16 from "path";
+import path18 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -6846,7 +7602,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path16.join(current, entry.name);
+      const fullPath = path18.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -6880,11 +7636,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path16.isAbsolute(input.path) ? input.path : path16.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path18.isAbsolute(input.path) ? input.path : path18.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path16.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path18.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -6908,9 +7664,9 @@ var grep_exports = {};
 __export(grep_exports, {
   GrepTool: () => GrepTool
 });
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path17 from "path";
+import path19 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -6922,7 +7678,7 @@ function runRipgrep(input, searchPath, context) {
       args.push("--glob", input.include);
     }
     args.push(input.pattern, searchPath);
-    const child = spawn("rg", args, {
+    const child = spawn2("rg", args, {
       cwd: searchPath,
       timeout: 3e4,
       stdio: ["ignore", "pipe", "pipe"]
@@ -6964,7 +7720,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path17.join(dir, entry.name);
+      const fullPath = path19.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -7010,7 +7766,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path17.isAbsolute(input.path) ? input.path : path17.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path19.isAbsolute(input.path) ? input.path : path19.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -7035,7 +7791,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path18 from "path";
+import path20 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -7063,8 +7819,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path18.isAbsolute(input.file_path) ? input.file_path : path18.resolve(context.cwd, input.file_path);
-        const dir = path18.dirname(filePath);
+        const filePath = path20.isAbsolute(input.file_path) ? input.file_path : path20.resolve(context.cwd, input.file_path);
+        const dir = path20.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -7082,7 +7838,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path19 from "path";
+import path21 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -7123,7 +7879,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path19.isAbsolute(input.file_path) ? input.file_path : path19.resolve(context.cwd, input.file_path);
+        const filePath = path21.isAbsolute(input.file_path) ? input.file_path : path21.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -7280,7 +8036,7 @@ var bash_exports = {};
 __export(bash_exports, {
   BashTool: () => BashTool
 });
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { z as z6 } from "zod";
 var DEFAULT_TIMEOUT_MS, inputSchema6, BashTool;
 var init_bash = __esm({
@@ -7311,7 +8067,7 @@ var init_bash = __esm({
       async call(input, context) {
         const timeout = input.timeout ?? DEFAULT_TIMEOUT_MS;
         return new Promise((resolve) => {
-          const child = spawn2("bash", ["-c", input.command], {
+          const child = spawn3("bash", ["-c", input.command], {
             cwd: context.cwd,
             timeout,
             stdio: ["ignore", "pipe", "pipe"],
@@ -7363,7 +8119,7 @@ var init_bash = __esm({
 });
 
 // src/lib/task-router.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
   const tier = config.complexityToTier[complexity];
   const rule = config.tierRules[tier];
@@ -7788,14 +8544,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path22 from "path";
-import os8 from "os";
+import { existsSync as existsSync14 } from "fs";
+import path24 from "path";
+import os9 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os8.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path24.join(os9.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path22.join(getKeyDir(), "master.key");
+  return path24.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -7816,13 +8572,21 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync12(keyPath)) {
+  if (!existsSync14(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os9.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
     const content = await readFile4(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
     return null;
   }
 }
@@ -7851,7 +8615,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync12(keyPath)) {
+  if (existsSync14(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -8151,14 +8915,14 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path24, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path24}`;
+async function wikiFetch(config, path26, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path26}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
   };
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS2);
   try {
     let response;
     try {
@@ -8171,7 +8935,7 @@ async function wikiFetch(config, path24, method = "GET", body) {
     } catch {
       clearTimeout(timeout);
       const retryController = new AbortController();
-      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS);
+      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS2);
       try {
         await new Promise((r) => setTimeout(r, 500));
         response = await fetch(url, {
@@ -8185,7 +8949,7 @@ async function wikiFetch(config, path24, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path24}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path26}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -8275,12 +9039,12 @@ async function getChatHistory(client, workspaceSlug, limit = 50) {
     sentAt: h.sentAt ?? 0
   }));
 }
-var LOCAL_WIKI_URL, REQUEST_TIMEOUT_MS;
+var LOCAL_WIKI_URL, REQUEST_TIMEOUT_MS2;
 var init_wiki_client = __esm({
   "src/lib/wiki-client.ts"() {
     "use strict";
-    LOCAL_WIKI_URL = "http://localhost:3001";
-    REQUEST_TIMEOUT_MS = 8e3;
+    LOCAL_WIKI_URL = process.env.EXE_WIKI_URL || "http://localhost:3001";
+    REQUEST_TIMEOUT_MS2 = 8e3;
   }
 });
 
@@ -8306,13 +9070,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path23 from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
+import path25 from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync13(SHARDS_DIR)) {
-    mkdirSync6(SHARDS_DIR, { recursive: true });
+  if (!existsSync15(SHARDS_DIR)) {
+    mkdirSync7(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
 }
@@ -8332,7 +9096,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path23.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path25.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -8342,10 +9106,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync13(path23.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync15(path25.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync13(SHARDS_DIR)) return [];
+  if (!existsSync15(SHARDS_DIR)) return [];
   return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -8531,7 +9295,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path23.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path25.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -8555,6 +9319,7 @@ __export(store_exports, {
   vectorToBlob: () => vectorToBlob,
   writeMemory: () => writeMemory
 });
+import { createHash } from "crypto";
 function isBusyError2(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -8628,12 +9393,52 @@ function classifyTier(record) {
   if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
   return 3;
 }
+function inferFilePaths(record) {
+  if (!["Read", "Write", "Edit"].includes(record.tool_name)) return null;
+  const firstLine = record.raw_text.split("\n")[0] ?? "";
+  const match = firstLine.match(/(\/[\w./-]+\.\w+)/);
+  return match ? JSON.stringify([match[1]]) : null;
+}
+function inferCommitHash(record) {
+  if (record.tool_name !== "Bash") return null;
+  const match = record.raw_text.match(/\b([a-f0-9]{7,40})\b/);
+  return match ? match[1] : null;
+}
+function inferLanguageType(record) {
+  const text = record.raw_text;
+  if (!text || text.length < 10) return null;
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+  if (/\b(SELECT|INSERT|UPDATE|DELETE|CREATE TABLE|ALTER TABLE)\b/i.test(text)) return "sql";
+  if (/\b(function |const |import |export |class |def |async |=>)\b/.test(text)) return "code";
+  if (trimmed.startsWith("#") || trimmed.startsWith("*")) return "prose";
+  return "mixed";
+}
+function inferDomain(record) {
+  const proj = (record.project_name ?? "").toLowerCase();
+  if (proj.includes("marketing") || proj.includes("content")) return "marketing";
+  if (proj.includes("crm") || proj.includes("customer")) return "customer";
+  return null;
+}
 async function writeMemory(record) {
   if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
     throw new Error(
       `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
     );
   }
+  const contentHash = createHash("md5").update(record.raw_text).digest("hex");
+  if (_pendingRecords.some((r) => r.content_hash === contentHash && r.agent_id === record.agent_id)) {
+    return;
+  }
+  try {
+    const client = getClient();
+    const existing = await client.execute({
+      sql: "SELECT id FROM memories WHERE content_hash = ? AND agent_id = ? LIMIT 1",
+      args: [contentHash, record.agent_id]
+    });
+    if (existing.rows.length > 0) return;
+  } catch {
+  }
   const dbRow = {
     id: record.id,
     agent_id: record.agent_id,
@@ -8663,7 +9468,23 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null,
     draft: record.draft ? 1 : 0,
     memory_type: record.memory_type ?? "raw",
-    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null
+    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null,
+    content_hash: contentHash,
+    intent: record.intent ?? null,
+    outcome: record.outcome ?? null,
+    domain: record.domain ?? inferDomain(record),
+    referenced_entities: record.referenced_entities ?? null,
+    retrieval_count: record.retrieval_count ?? 0,
+    chain_position: record.chain_position ?? null,
+    review_status: record.review_status ?? null,
+    context_window_pct: record.context_window_pct ?? null,
+    file_paths: record.file_paths ?? inferFilePaths(record),
+    commit_hash: record.commit_hash ?? inferCommitHash(record),
+    duration_ms: record.duration_ms ?? null,
+    token_cost: record.token_cost ?? null,
+    audience: record.audience ?? null,
+    language_type: record.language_type ?? inferLanguageType(record),
+    parent_memory_id: record.parent_memory_id ?? null
   };
   _pendingRecords.push(dbRow);
   orgBus.emit({
@@ -8721,80 +9542,85 @@ async function flushBatch() {
       const draft = row.draft ? 1 : 0;
       const memoryType = row.memory_type ?? "raw";
       const trajectory = row.trajectory ?? null;
-      return {
-        sql: hasVector ? `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
-               tool_name, project_name,
-               has_error, raw_text, vector, version, task_id, importance, status,
-               confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
+      const contentHash = row.content_hash ?? null;
+      const intent = row.intent ?? null;
+      const outcome = row.outcome ?? null;
+      const domain = row.domain ?? null;
+      const referencedEntities = row.referenced_entities ?? null;
+      const retrievalCount = row.retrieval_count ?? 0;
+      const chainPosition = row.chain_position ?? null;
+      const reviewStatus = row.review_status ?? null;
+      const contextWindowPct = row.context_window_pct ?? null;
+      const filePaths = row.file_paths ?? null;
+      const commitHash = row.commit_hash ?? null;
+      const durationMs = row.duration_ms ?? null;
+      const tokenCost = row.token_cost ?? null;
+      const audience = row.audience ?? null;
+      const languageType = row.language_type ?? null;
+      const parentMemoryId = row.parent_memory_id ?? null;
+      const cols = `id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: hasVector ? [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          vectorToBlob(row.vector),
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ] : [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ]
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory, content_hash,
+               intent, outcome, domain, referenced_entities, retrieval_count,
+               chain_position, review_status, context_window_pct, file_paths, commit_hash,
+               duration_ms, token_cost, audience, language_type, parent_memory_id`;
+      const metaArgs = [
+        intent,
+        outcome,
+        domain,
+        referencedEntities,
+        retrievalCount,
+        chainPosition,
+        reviewStatus,
+        contextWindowPct,
+        filePaths,
+        commitHash,
+        durationMs,
+        tokenCost,
+        audience,
+        languageType,
+        parentMemoryId
+      ];
+      const baseArgs = [
+        row.id,
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        row.raw_text
+      ];
+      const sharedArgs = [
+        row.version,
+        taskId,
+        importance,
+        status,
+        confidence,
+        lastAccessed,
+        workspaceId,
+        documentId,
+        userId,
+        charOffset,
+        pageNumber,
+        sourcePath,
+        sourceType,
+        tier,
+        supersedesId,
+        draft,
+        memoryType,
+        trajectory,
+        contentHash
+      ];
+      return {
+        sql: hasVector ? `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [...baseArgs, vectorToBlob(row.vector), ...sharedArgs, ...metaArgs] : [...baseArgs, ...sharedArgs, ...metaArgs]
       };
     };
     const globalClient = getClient();
@@ -13039,8 +13865,8 @@ function Text({ color, backgroundColor, dimColor = false, bold = false, italic =
 }
 
 // src/tui/ink/components/ErrorOverview.js
-var cleanupPath = (path24) => {
-  return path24?.replace(`file://${cwd()}/`, "");
+var cleanupPath = (path26) => {
+  return path26?.replace(`file://${cwd()}/`, "");
 };
 var stackUtils = new StackUtils({
   cwd: cwd(),
@@ -14639,7 +15465,7 @@ var useInput = (inputHandler, options = {}) => {
     if (options.isActive === false) {
       return;
     }
-    const handleData = (data) => {
+    const handleData2 = (data) => {
       const keypress = parse_keypress_default(data);
       const key = {
         upArrow: keypress.name === "up",
@@ -14698,9 +15524,9 @@ var useInput = (inputHandler, options = {}) => {
         });
       }
     };
-    internal_eventEmitter?.on("input", handleData);
+    internal_eventEmitter?.on("input", handleData2);
     return () => {
-      internal_eventEmitter?.removeListener("input", handleData);
+      internal_eventEmitter?.removeListener("input", handleData2);
     };
   }, [options.isActive, stdin, internal_exitOnCtrlC, inputHandler]);
 };
@@ -14972,11 +15798,11 @@ function Footer() {
       } catch {
       }
       try {
-        const { existsSync: existsSync14 } = await import("fs");
+        const { existsSync: existsSync16 } = await import("fs");
         const { join } = await import("path");
         const home = process.env.HOME ?? "";
         const pidPath = join(home, ".exe-os", "exed.pid");
-        setDaemon(existsSync14(pidPath) ? "running" : "stopped");
+        setDaemon(existsSync16(pidPath) ? "running" : "stopped");
       } catch {
         setDaemon("unknown");
       }
@@ -15058,7 +15884,7 @@ function Footer() {
 // src/tui/views/CommandCenter.tsx
 import { useState as useState6, useEffect as useEffect8, useMemo as useMemo4, useCallback as useCallback4, useRef as useRef4 } from "react";
 import TextInput from "ink-text-input";
-import path20 from "path";
+import path22 from "path";
 import { homedir } from "os";
 
 // src/tui/components/StatusDot.tsx
@@ -15845,15 +16671,15 @@ function CommandCenterView({
         const { createPermissionsFromPreset: createPermissionsFromPreset2, EMPLOYEE_PERMISSIONS: EMPLOYEE_PERMISSIONS2 } = await Promise.resolve().then(() => (init_permissions(), permissions_exports));
         const { getPresetByRole: getPresetByRole2 } = await Promise.resolve().then(() => (init_permission_presets(), permission_presets_exports));
         const { createDefaultHooks: createDefaultHooks2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
-        const { readFileSync: readFileSync11, existsSync: existsSync14 } = await import("fs");
+        const { readFileSync: readFileSync13, existsSync: existsSync16 } = await import("fs");
         const { join } = await import("path");
         const { homedir: homedir3 } = await import("os");
         const configPath = join(homedir3(), ".exe-os", "config.json");
         let failoverChain = ["anthropic", "opencode", "gemini", "openai"];
         let providerConfigs = {};
-        if (existsSync14(configPath)) {
+        if (existsSync16(configPath)) {
           try {
-            const raw = JSON.parse(readFileSync11(configPath, "utf8"));
+            const raw = JSON.parse(readFileSync13(configPath, "utf8"));
             if (Array.isArray(raw.failoverChain)) failoverChain = raw.failoverChain;
             if (raw.providers && typeof raw.providers === "object") {
               providerConfigs = raw.providers;
@@ -15914,7 +16740,7 @@ function CommandCenterView({
           const markerDir = join(homedir3(), ".exe-os", "session-cache");
           const agentFiles = (await import("fs")).readdirSync(markerDir).filter((f) => f.startsWith("active-agent-"));
           for (const f of agentFiles) {
-            const data = JSON.parse(readFileSync11(join(markerDir, f), "utf8"));
+            const data = JSON.parse(readFileSync13(join(markerDir, f), "utf8"));
             if (data.agentRole) {
               agentRole = data.agentRole;
               break;
@@ -16059,7 +16885,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path20.join(homedir(), p.projectName),
+        projectDir: path22.join(homedir(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -16097,7 +16923,7 @@ function CommandCenterView({
         const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
         const { listTmuxSessions: listTmuxSessions2, inTmux: inTmux2 } = await Promise.resolve().then(() => (init_tmux_status(), tmux_status_exports));
         const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
-        const { existsSync: existsSync14 } = await import("fs");
+        const { existsSync: existsSync16 } = await import("fs");
         const { join } = await import("path");
         const client = getClient2();
         if (!client) {
@@ -16142,12 +16968,12 @@ function CommandCenterView({
         const registry = listSessions2();
         const tmuxSessions = inTmux2() ? new Set(listTmuxSessions2()) : /* @__PURE__ */ new Set();
         const roster = await loadEmployees2();
-        const { getCoordinatorName: getCoordinatorName2, isCoordinatorRole: isCoordinatorRole2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
+        const { getCoordinatorName: getCoordinatorName2, isCoordinatorName: isCoordinatorName2, isCoordinatorRole: isCoordinatorRole2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
         const coordinatorName = getCoordinatorName2(roster);
         const employeeNames = roster.filter((e) => !isCoordinatorRole2(e.role)).map((e) => e.name);
         const projectSessions = /* @__PURE__ */ new Map();
         for (const entry of registry) {
-          if ((entry.agentId === coordinatorName || entry.agentId === "exe") && tmuxSessions.has(entry.windowName)) {
+          if ((entry.agentId === coordinatorName || isCoordinatorName2(entry.agentId)) && tmuxSessions.has(entry.windowName)) {
             const projName = entry.projectDir.split("/").filter(Boolean).pop() ?? "";
             if (projName) {
               projectSessions.set(projName, { exeSession: entry.windowName, projectDir: entry.projectDir });
@@ -16168,7 +16994,7 @@ function CommandCenterView({
           }
           const memoryCount = memoryCounts.get(name) ?? 0;
           const openTaskCount = openTaskCounts.get(name) ?? 0;
-          const hasGit = projectDir ? existsSync14(join(projectDir, ".git")) : false;
+          const hasGit = projectDir ? existsSync16(join(projectDir, ".git")) : false;
           const type = hasGit ? "code" : memoryCount > 0 ? "code" : "automation";
           projectList.push({
             projectName: name,
@@ -16193,7 +17019,7 @@ function CommandCenterView({
         setHealth((h) => ({ ...h, memories: Number(totalResult.rows[0]?.cnt ?? 0) }));
         try {
           const pidPath = join(process.env.HOME ?? "", ".exe-os", "exed.pid");
-          setHealth((h) => ({ ...h, daemon: existsSync14(pidPath) ? "running" : "stopped" }));
+          setHealth((h) => ({ ...h, daemon: existsSync16(pidPath) ? "running" : "stopped" }));
         } catch {
         }
         const activityResult = await client.execute(
@@ -16408,7 +17234,7 @@ function ChatMessageRow({ msg }) {
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path21 from "path";
+import path23 from "path";
 import { homedir as homedir2 } from "os";
 
 // src/tui/components/TmuxPane.tsx
@@ -16671,12 +17497,13 @@ function useOrchestrator(enabled = true) {
 }
 
 // src/tui/views/Sessions.tsx
+init_employees();
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 var SESSION_REFRESH_MS = 5e3;
 var ACTIVE_PANE_PATTERN = /█|░|Calculating|tokens|writing|Reading/;
 var ACTIVITY_PREVIEW_MAX = 50;
 function isCoordinatorEntry(entry) {
-  return entry.role.toLowerCase() === "coo" || entry.name === "exe";
+  return entry.role.toLowerCase() === "coo" || isCoordinatorName(entry.name);
 }
 function SessionsView({
   initialProject,
@@ -16710,7 +17537,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path21.join(homedir2(), p.projectName),
+        projectDir: path23.join(homedir2(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -16900,7 +17727,7 @@ function SessionsView({
         const coordinatorName = getCoordinatorName2(roster);
         const exeSessions = /* @__PURE__ */ new Map();
         for (const entry of registry) {
-          if ((entry.agentId === coordinatorName || entry.agentId === "exe") && tmuxSessions.has(entry.windowName)) {
+          if ((entry.agentId === coordinatorName || isCoordinatorName(entry.agentId)) && tmuxSessions.has(entry.windowName)) {
             exeSessions.set(entry.windowName, entry.projectDir);
           }
         }
@@ -17607,12 +18434,12 @@ async function loadGatewayConfig() {
     state.running = false;
   }
   try {
-    const { existsSync: existsSync14, readFileSync: readFileSync11 } = await import("fs");
+    const { existsSync: existsSync16, readFileSync: readFileSync13 } = await import("fs");
     const { join } = await import("path");
     const home = process.env.HOME ?? "";
     const configPath = join(home, ".exe-os", "gateway.json");
-    if (existsSync14(configPath)) {
-      const raw = JSON.parse(readFileSync11(configPath, "utf8"));
+    if (existsSync16(configPath)) {
+      const raw = JSON.parse(readFileSync13(configPath, "utf8"));
       state.port = raw.port ?? 3100;
       state.gatewayUrl = raw.gatewayUrl ?? "";
       if (raw.adapters) {
@@ -18138,12 +18965,12 @@ function TeamView({ onBack, onViewSessions }) {
         setMembers(teamData);
         setDbError(null);
         try {
-          const { existsSync: existsSync14, readFileSync: readFileSync11 } = await import("fs");
+          const { existsSync: existsSync16, readFileSync: readFileSync13 } = await import("fs");
           const { join } = await import("path");
           const home = process.env.HOME ?? "";
           const gatewayConfig = join(home, ".exe-os", "gateway.json");
-          if (existsSync14(gatewayConfig)) {
-            const raw = JSON.parse(readFileSync11(gatewayConfig, "utf8"));
+          if (existsSync16(gatewayConfig)) {
+            const raw = JSON.parse(readFileSync13(gatewayConfig, "utf8"));
             if (raw.agents && raw.agents.length > 0) {
               setExternals(raw.agents.map((a) => ({
                 name: a.name,
@@ -18807,12 +19634,12 @@ function SettingsView({ onBack }) {
     }
     setProviders(providerList);
     try {
-      const { existsSync: existsSync14 } = await import("fs");
+      const { existsSync: existsSync16 } = await import("fs");
       const { join } = await import("path");
       const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const cfg = await loadConfig2();
       const home = process.env.HOME ?? "";
-      const hasKey = existsSync14(join(home, ".exe-os", "master.key"));
+      const hasKey = existsSync16(join(home, ".exe-os", "master.key"));
       if (cfg.cloud) {
         setCloud({
           configured: true,
@@ -18825,22 +19652,22 @@ function SettingsView({ onBack }) {
       const pidPath = join(home, ".exe-os", "exed.pid");
       let daemon = "unknown";
       try {
-        daemon = existsSync14(pidPath) ? "running" : "stopped";
+        daemon = existsSync16(pidPath) ? "running" : "stopped";
       } catch {
       }
       let version = "unknown";
       try {
-        const { readFileSync: readFileSync11 } = await import("fs");
+        const { readFileSync: readFileSync13 } = await import("fs");
         const { createRequire } = await import("module");
         const require2 = createRequire(import.meta.url);
         const pkgPath = require2.resolve("@askexenow/exe-os/package.json");
-        const pkg = JSON.parse(readFileSync11(pkgPath, "utf8"));
+        const pkg = JSON.parse(readFileSync13(pkgPath, "utf8"));
         version = pkg.version;
       } catch {
         try {
-          const { readFileSync: readFileSync11 } = await import("fs");
+          const { readFileSync: readFileSync13 } = await import("fs");
           const { join: joinPath } = await import("path");
-          const pkg = JSON.parse(readFileSync11(joinPath(process.cwd(), "package.json"), "utf8"));
+          const pkg = JSON.parse(readFileSync13(joinPath(process.cwd(), "package.json"), "utf8"));
           version = pkg.version;
         } catch {
         }