@askexenow/exe-os 0.8.83 → 0.8.86

package/dist/bin/exe-boot.js

@@ -427,6 +427,443 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync3, unlinkSync as unlinkSync2, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
+import path3 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 (existsSync3(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync3(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 = path3.dirname(fileURLToPath(import.meta.url));
+  const { root } = path3.parse(dir);
+  while (dir !== root) {
+    if (existsSync3(path3.join(dir, "package.json"))) return dir;
+    dir = path3.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 = path3.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync3(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 = path3.join(path3.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 ?? path3.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path3.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path3.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);
+  }
+  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";
+  }
+});
+
+// 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;
+    }
+  };
+  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;
+  }
+  const client = createDaemonDbClient(fallbackClient);
+  client._enableDaemon();
+  process.stderr.write("[db-daemon] DB routing through daemon (single-writer)\n");
+  return client;
+}
+var init_db_daemon_client = __esm({
+  "src/lib/db-daemon-client.ts"() {
+    "use strict";
+    init_exe_daemon_client();
+    init_daemon_protocol();
+  }
+});
+
 // src/lib/database.ts
 var database_exports = {};
 __export(database_exports, {
@@ -435,6 +872,7 @@ __export(database_exports, {
   ensureSchema: () => ensureSchema,
   getClient: () => getClient,
   getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
   initDatabase: () => initDatabase,
   initTurso: () => initTurso,
   isInitialized: () => isInitialized
@@ -462,8 +900,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.");
@@ -950,6 +1407,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,
@@ -1002,7 +1465,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,
@@ -1183,6 +1669,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`,
@@ -1316,15 +1829,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";
@@ -1332,6 +1871,7 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -1455,7 +1995,7 @@ __export(global_procedures_exports, {
   loadGlobalProcedures: () => loadGlobalProcedures,
   storeGlobalProcedure: () => storeGlobalProcedure
 });
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
   const result = await client.execute({
@@ -1484,7 +2024,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input) {
-  const id = randomUUID();
+  const id = randomUUID2();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -1535,14 +2075,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import path3 from "path";
+import { existsSync as existsSync4 } from "fs";
+import path4 from "path";
 import os3 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path3.join(os3.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(os3.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path3.join(getKeyDir(), "master.key");
+  return path4.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -1563,13 +2103,21 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync3(keyPath)) {
+  if (!existsSync4(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os3.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
     const content = await readFile3(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;
   }
 }
@@ -1598,7 +2146,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync3(keyPath)) {
+  if (existsSync4(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -1708,12 +2256,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path4 from "path";
-import { existsSync as existsSync4, mkdirSync, readdirSync } from "fs";
+import path5 from "path";
+import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync4(SHARDS_DIR)) {
+  if (!existsSync5(SHARDS_DIR)) {
     mkdirSync(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -1734,7 +2282,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path4.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path5.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -1744,10 +2292,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync4(path4.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync5(path5.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync4(SHARDS_DIR)) return [];
+  if (!existsSync5(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -1933,7 +2481,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path4.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path5.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -1941,6 +2489,7 @@ var init_shard_manager = __esm({
 });
 
 // src/lib/store.ts
+import { createHash } from "crypto";
 function isBusyError2(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -2036,13 +2585,13 @@ __export(session_registry_exports, {
   pruneStaleSessions: () => pruneStaleSessions,
   registerSession: () => registerSession
 });
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, existsSync as existsSync6 } from "fs";
 import { execSync as execSync2 } from "child_process";
-import path5 from "path";
+import path6 from "path";
 import os4 from "os";
 function registerSession(entry) {
-  const dir = path5.dirname(REGISTRY_PATH);
-  if (!existsSync5(dir)) {
+  const dir = path6.dirname(REGISTRY_PATH);
+  if (!existsSync6(dir)) {
     mkdirSync2(dir, { recursive: true });
   }
   const sessions = listSessions();
@@ -2056,7 +2605,7 @@ function registerSession(entry) {
 }
 function listSessions() {
   try {
-    const raw = readFileSync3(REGISTRY_PATH, "utf8");
+    const raw = readFileSync4(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -2085,7 +2634,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path5.join(os4.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path6.join(os4.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -2304,18 +2853,69 @@ var init_provider_table = __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 readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync3 } from "fs";
+import path7 from "path";
+function loadAgentConfig() {
+  if (!existsSync7(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync5(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 = path7.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 readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import path6 from "path";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import path8 from "path";
 import os5 from "os";
 function ensureDir() {
-  const dir = path6.dirname(QUEUE_PATH);
-  if (!existsSync6(dir)) mkdirSync3(dir, { recursive: true });
+  const dir = path8.dirname(QUEUE_PATH);
+  if (!existsSync8(dir)) mkdirSync4(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync6(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync4(QUEUE_PATH, "utf8"));
+    if (!existsSync8(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync6(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -2323,7 +2923,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync4(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -2347,9 +2947,9 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path6.join(os5.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path8.join(os5.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path6.join(os5.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path8.join(os5.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -2370,9 +2970,9 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
-import { randomUUID as randomUUID2 } from "crypto";
-import path7 from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import path9 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -2383,37 +2983,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path7.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path9.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync7(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync5(deviceJsonPath, "utf8"));
+    if (existsSync9(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync7(DEVICE_ID_PATH)) {
-      const id2 = readFileSync5(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync9(DEVICE_ID_PATH)) {
+      const id2 = readFileSync7(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
   }
-  const id = randomUUID2();
-  mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
+  const id = randomUUID3();
+  mkdirSync5(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync7(LICENSE_PATH)) return null;
-    return readFileSync5(LICENSE_PATH, "utf8").trim();
+    if (!existsSync9(LICENSE_PATH)) return null;
+    return readFileSync7(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
-  mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync5(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -2439,8 +3039,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync7(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
+    if (!existsSync9(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -2449,8 +3049,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync7(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
+    if (!existsSync9(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -2484,7 +3084,7 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync5(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -2548,9 +3148,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path7.join(EXE_AI_DIR, "config.json");
-      if (existsSync7(configPath)) {
-        const raw = JSON.parse(readFileSync5(configPath, "utf8"));
+      const configPath = path9.join(EXE_AI_DIR, "config.json");
+      if (existsSync9(configPath)) {
+        const raw = JSON.parse(readFileSync7(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -2709,9 +3309,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    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");
+    LICENSE_PATH = path9.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path9.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path9.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -2741,12 +3341,12 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync6, existsSync as existsSync8 } from "fs";
-import path8 from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import path10 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync8(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync6(CACHE_PATH2, "utf8"));
+    if (!existsSync10(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -2784,8 +3384,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync8(filePath)) {
-      const raw = readFileSync6(filePath, "utf8");
+    if (existsSync10(filePath)) {
+      const raw = readFileSync8(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -2814,19 +3414,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path10.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto from "crypto";
-import path9 from "path";
+import path11 from "path";
 import os6 from "os";
 import {
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync2,
-  unlinkSync as unlinkSync2,
-  existsSync as existsSync9,
+  unlinkSync as unlinkSync3,
+  existsSync as existsSync11,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -2939,9 +3539,9 @@ async function markDoneTaskNotificationsAsRead() {
   }
 }
 async function migrateJsonNotifications() {
-  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path9.join(os6.homedir(), ".exe-os");
-  const notifDir = path9.join(base, "notifications");
-  if (!existsSync9(notifDir)) return 0;
+  const base = process.env.EXE_OS_DIR || process.env.EXE_MEM_DIR || path11.join(os6.homedir(), ".exe-os");
+  const notifDir = path11.join(base, "notifications");
+  if (!existsSync11(notifDir)) return 0;
   let migrated = 0;
   try {
     const files = readdirSync2(notifDir).filter((f) => f.endsWith(".json"));
@@ -2949,8 +3549,8 @@ async function migrateJsonNotifications() {
     const client = getClient();
     for (const file of files) {
       try {
-        const filePath = path9.join(notifDir, file);
-        const data = JSON.parse(readFileSync7(filePath, "utf8"));
+        const filePath = path11.join(notifDir, file);
+        const data = JSON.parse(readFileSync9(filePath, "utf8"));
         await client.execute({
           sql: `INSERT OR IGNORE INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -2966,7 +3566,7 @@ async function migrateJsonNotifications() {
             data.timestamp ?? (/* @__PURE__ */ new Date()).toISOString()
           ]
         });
-        unlinkSync2(filePath);
+        unlinkSync3(filePath);
         migrated++;
       } catch {
       }
@@ -3097,10 +3697,11 @@ var init_session_kill_telemetry = __esm({
 
 // src/lib/tasks-crud.ts
 import crypto3 from "crypto";
-import path10 from "path";
+import path12 from "path";
+import os7 from "os";
 import { execSync as execSync5 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync10 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -3141,6 +3742,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({
@@ -3190,7 +3820,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) {
@@ -3230,22 +3867,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 mkdir4(path10.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path10.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir4(path12.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path12.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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -3272,6 +3911,43 @@ async function createTaskCore(input) {
       now
     ]
   });
+  if (input.baseDir) {
+    try {
+      const EXE_OS_DIR = path12.join(os7.homedir(), ".exe-os");
+      const mdPath = path12.join(EXE_OS_DIR, taskFile);
+      const mdDir = path12.dirname(mdPath);
+      if (!existsSync12(mdDir)) await mkdir4(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 writeFile4(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,
@@ -3464,7 +4140,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}
 `
@@ -3529,9 +4205,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path10.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path12.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync10(archPath)) return;
+    if (existsSync12(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -3564,10 +4240,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path10.join(baseDir, ".gitignore");
+  const gitignorePath = path12.join(baseDir, ".gitignore");
   try {
-    if (existsSync10(gitignorePath)) {
-      const content = readFileSync8(gitignorePath, "utf-8");
+    if (existsSync12(gitignorePath)) {
+      const content = readFileSync10(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -3576,20 +4252,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 path11 from "path";
-import { existsSync as existsSync11, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
+import path13 from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, unlinkSync as unlinkSync4 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -3611,7 +4297,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;
@@ -3629,7 +4315,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]
     });
@@ -3750,14 +4436,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
 `
           );
         }
@@ -3770,11 +4456,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path11.join(EXE_AI_DIR, "session-cache");
-    if (existsSync11(cacheDir)) {
+    const cacheDir = path13.join(EXE_AI_DIR, "session-cache");
+    if (existsSync13(cacheDir)) {
       for (const f of readdirSync3(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync3(path11.join(cacheDir, f));
+          unlinkSync4(path13.join(cacheDir, f));
         }
       }
     }
@@ -3795,7 +4481,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path12 from "path";
+import path14 from "path";
 import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -3812,7 +4498,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path12.join(baseDir, String(ur.task_file));
+        const ubFile = path14.join(baseDir, String(ur.task_file));
         let ubContent = await readFile4(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -3886,7 +4572,7 @@ __export(project_name_exports, {
   getProjectName: () => getProjectName
 });
 import { execSync as execSync6 } from "child_process";
-import path13 from "path";
+import path15 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -3899,7 +4585,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path13.dirname(gitCommonDir);
+      repoRoot = path15.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync6("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -3908,11 +4594,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path13.basename(repoRoot);
+    _cached2 = path15.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path13.basename(dir);
+    _cached2 = path15.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -3948,7 +4634,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;
 }
@@ -3994,7 +4680,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 {
@@ -4389,8 +5075,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path14 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4 } from "fs";
+import path16 from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -4409,14 +5095,14 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path16.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync5(cacheDir, { recursive: true });
-      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync6(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 {
       }
     }
@@ -4473,7 +5159,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();
     }
@@ -4498,7 +5184,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,
@@ -4514,7 +5200,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 {
@@ -4858,7 +5544,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,
@@ -4873,20 +5559,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 execFileSync2, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync6, existsSync as existsSync12, appendFileSync } from "fs";
-import path15 from "path";
-import os7 from "os";
-import { fileURLToPath } from "url";
-import { unlinkSync as unlinkSync5 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, existsSync as existsSync14, appendFileSync } from "fs";
+import path17 from "path";
+import os8 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync6 } from "fs";
 function spawnLockPath(sessionName) {
-  return path15.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path17.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -4896,14 +5582,14 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function acquireSpawnLock(sessionName) {
-  if (!existsSync12(SPAWN_LOCK_DIR)) {
-    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync14(SPAWN_LOCK_DIR)) {
+    mkdirSync7(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync12(lockFile)) {
+  if (existsSync14(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync9(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync11(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -4911,25 +5597,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 = path15.join(
-      path15.dirname(thisFile),
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path17.join(
+      path17.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync12(scriptPath) ? scriptPath : null;
+    return existsSync14(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -4995,12 +5681,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync12(SESSION_CACHE)) {
-    mkdirSync6(SESSION_CACHE, { recursive: true });
+  if (!existsSync14(SESSION_CACHE)) {
+    mkdirSync7(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync6(filePath, JSON.stringify({
+  const filePath = path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync7(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -5008,7 +5694,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync9(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync11(path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -5016,8 +5702,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync9(
-      path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync11(
+      path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -5043,10 +5729,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;
 }
@@ -5078,32 +5764,50 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync12(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync14(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
+    const state = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (typeof val === "number") {
+        state[key] = { lastSent: val, pending: 0 };
+      } else if (val && typeof val === "object" && "lastSent" in val) {
+        state[key] = val;
+      }
+    }
+    return state;
   } catch {
     return {};
   }
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync12(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
-    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync14(SESSION_CACHE)) mkdirSync7(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}
@@ -5148,7 +5852,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 {
@@ -5160,14 +5864,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)) {
@@ -5175,8 +5879,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}`);
@@ -5206,7 +5910,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 {
@@ -5278,26 +5982,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 = path15.join(os7.homedir(), ".exe-os", "session-logs");
-  const logFile = path15.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync12(logDir)) {
-    mkdirSync6(logDir, { recursive: true });
+  const logDir = path17.join(os8.homedir(), ".exe-os", "session-logs");
+  const logFile = path17.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync14(logDir)) {
+    mkdirSync7(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync12(cleanupScript)) {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path17.join(path17.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync14(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path15.join(os7.homedir(), ".claude.json");
+    const claudeJsonPath = path17.join(os8.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync9(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -5305,17 +6009,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 = path15.join(os7.homedir(), ".claude", "projects");
+    const settingsDir = path17.join(os8.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path15.join(settingsDir, normalizedKey);
-    const settingsPath = path15.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path17.join(settingsDir, normalizedKey);
+    const settingsPath = path17.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync9(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -5343,21 +6047,24 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync6(projSettingsDir, { recursive: true });
-      writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync7(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 = path15.join(
-      os7.homedir(),
+    const identityPath = path17.join(
+      os8.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -5366,13 +6073,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync12(identityPath)) {
+    } else if (existsSync14(identityPath)) {
       identityFlag = ` --append-system-prompt-file ${identityPath}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path15.basename(spawnCwd),
+      path17.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -5387,16 +6094,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path15.join(os7.homedir(), ".exe-os", "session-cache");
-    mkdirSync6(ctxDir, { recursive: true });
-    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path17.join(os8.homedir(), ".exe-os", "session-cache");
+    mkdirSync7(ctxDir, { recursive: true });
+    const ctxFile = path17.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 {
   }
@@ -5410,9 +6117,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(
@@ -5428,17 +6174,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 = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync6(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path17.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 {
@@ -5456,6 +6204,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;
@@ -5466,10 +6219,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 {
@@ -5483,7 +6237,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;
@@ -5496,17 +6250,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 = path15.join(os7.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path15.join(os7.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path17.join(os8.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path17.join(os8.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 = path15.join(os7.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path17.join(os8.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path17.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -5541,126 +6297,8 @@ var task_scanner_exports = {};
 __export(task_scanner_exports, {
   PRIORITY_RE: () => PRIORITY_RE,
   STATUS_RE: () => STATUS_RE,
-  TITLE_RE: () => TITLE_RE,
-  formatJson: () => formatJson,
-  formatMandatory: () => formatMandatory,
-  formatText: () => formatText,
-  scanAgentTasks: () => scanAgentTasks
+  TITLE_RE: () => TITLE_RE
 });
-import { readdirSync as readdirSync5, readFileSync as readFileSync11, existsSync as existsSync13, statSync } from "fs";
-import { execSync as execSync9 } from "child_process";
-import path17 from "path";
-function getProjectRoot() {
-  try {
-    return execSync9("git rev-parse --show-toplevel", {
-      encoding: "utf8",
-      stdio: ["pipe", "pipe", "pipe"],
-      timeout: 5e3
-    }).trim();
-  } catch {
-    return process.cwd();
-  }
-}
-function scanAgentTasks(agentId) {
-  const taskDir = path17.join(getProjectRoot(), "exe", agentId);
-  const open = [];
-  const inProgress = [];
-  let done = 0;
-  let total = 0;
-  if (!existsSync13(taskDir)) return { open, inProgress, done, total };
-  try {
-    const files = readdirSync5(taskDir).filter((f) => f.endsWith(".md"));
-    total = files.length;
-    for (const f of files) {
-      try {
-        const content = readFileSync11(path17.join(taskDir, f), "utf8");
-        const statusMatch = content.match(STATUS_RE);
-        const status = statusMatch ? statusMatch[1].toLowerCase() : null;
-        if (status === "done") {
-          done++;
-          continue;
-        }
-        if (status !== "open" && status !== "in_progress") continue;
-        const priMatch = content.match(PRIORITY_RE);
-        const titleMatch = content.match(TITLE_RE);
-        const task = {
-          file: f,
-          title: titleMatch ? titleMatch[1] : f.replace(".md", ""),
-          priority: priMatch ? priMatch[1] : "P2",
-          status,
-          slug: f.replace(".md", "")
-        };
-        if (status === "in_progress") {
-          inProgress.push(task);
-        } else {
-          open.push(task);
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  open.sort((a, b) => a.priority.localeCompare(b.priority));
-  inProgress.sort((a, b) => a.priority.localeCompare(b.priority));
-  return { open, inProgress, done, total };
-}
-function formatText(agentId, result) {
-  const lines = [];
-  if (result.inProgress.length > 0) {
-    lines.push(`IN_PROGRESS (${result.inProgress.length}):`);
-    for (const t of result.inProgress) {
-      lines.push(`  [${t.priority}] ${t.title} \u2014 exe/${agentId}/${t.file}`);
-    }
-  }
-  if (result.open.length > 0) {
-    lines.push(`OPEN (${result.open.length}):`);
-    for (const t of result.open) {
-      lines.push(`  [${t.priority}] ${t.title} \u2014 exe/${agentId}/${t.file}`);
-    }
-  }
-  lines.push(`DONE: ${result.done}`);
-  return lines.join("\n");
-}
-function formatMandatory(agentId, result) {
-  const { open, inProgress } = result;
-  if (open.length === 0 && inProgress.length === 0) return "";
-  const lines = [];
-  if (inProgress.length > 0) {
-    const current = inProgress[0];
-    let stale = false;
-    try {
-      const stat = statSync(path17.join(getProjectRoot(), "exe", agentId, current.file));
-      const ageMin = (Date.now() - stat.mtimeMs) / 6e4;
-      if (ageMin > 30) stale = true;
-    } catch {
-    }
-    if (stale) {
-      lines.push(`MANDATORY: Update task status for: ${current.title} [${current.priority}] (exe/${agentId}/${current.file})`);
-      lines.push("This task has been in_progress for over 30 minutes without updates.");
-      lines.push("If work is done, mark done. If blocked, update status to blocked.");
-    } else {
-      lines.push(`Continue working on: ${current.title} [${current.priority}] (exe/${agentId}/${current.file})`);
-    }
-    if (open.length > 0) {
-      lines.push("Queued: " + open.map((t) => `${t.title} [${t.priority}]`).join(", "));
-    }
-  } else {
-    const top = open[0];
-    lines.push(`MANDATORY: You have ${open.length} unstarted task(s).`);
-    lines.push(`Highest priority: ${top.title} [${top.priority}]`);
-    lines.push(`File: exe/${agentId}/${top.file}`);
-    lines.push("Read this task file and START WORKING NOW.");
-  }
-  return lines.join("\n");
-}
-function formatJson(result) {
-  return JSON.stringify({
-    open: result.open.map((t) => ({ file: t.file, title: t.title, priority: t.priority })),
-    in_progress: result.inProgress.map((t) => ({ file: t.file, title: t.title, priority: t.priority })),
-    done: result.done,
-    total: result.total
-  });
-}
 var STATUS_RE, PRIORITY_RE, TITLE_RE;
 var init_task_scanner = __esm({
   "src/lib/task-scanner.ts"() {
@@ -5681,15 +6319,15 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync6, writeFileSync as writeFileSync8, unlinkSync as unlinkSync7, mkdirSync as mkdirSync8, existsSync as existsSync14 } from "fs";
-import path18 from "path";
+import { readdirSync as readdirSync5, writeFileSync as writeFileSync9, unlinkSync as unlinkSync8, mkdirSync as mkdirSync9, existsSync as existsSync15 } from "fs";
+import path19 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync8(WORKER_PID_DIR, { recursive: true });
+    mkdirSync9(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path18.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync8(reservationPath, String(process.pid));
-    const files = readdirSync6(WORKER_PID_DIR);
+    const reservationPath = path19.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync9(reservationPath, String(process.pid));
+    const files = readdirSync5(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -5705,20 +6343,20 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync7(path18.join(WORKER_PID_DIR, f));
+          unlinkSync8(path19.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
     }
     if (alive > MAX_CONCURRENT_WORKERS) {
       try {
-        unlinkSync7(reservationPath);
+        unlinkSync8(reservationPath);
       } catch {
       }
       return false;
     }
     try {
-      unlinkSync7(reservationPath);
+      unlinkSync8(reservationPath);
     } catch {
     }
     return true;
@@ -5728,21 +6366,21 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync8(WORKER_PID_DIR, { recursive: true });
-    writeFileSync8(path18.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync9(WORKER_PID_DIR, { recursive: true });
+    writeFileSync9(path19.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync7(path18.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path19.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
-    mkdirSync8(WORKER_PID_DIR, { recursive: true });
-    if (existsSync14(BACKFILL_LOCK)) {
+    mkdirSync9(WORKER_PID_DIR, { recursive: true });
+    if (existsSync15(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -5758,7 +6396,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync8(BACKFILL_LOCK, String(process.pid));
+    writeFileSync9(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -5766,7 +6404,7 @@ function tryAcquireBackfillLock() {
 }
 function releaseBackfillLock() {
   try {
-    unlinkSync7(BACKFILL_LOCK);
+    unlinkSync8(BACKFILL_LOCK);
   } catch {
   }
 }
@@ -5775,9 +6413,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path18.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path19.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path18.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path19.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -5860,6 +6498,232 @@ var init_compress = __esm({
   }
 });
 
+// src/lib/crdt-sync.ts
+var crdt_sync_exports = {};
+__export(crdt_sync_exports, {
+  _setStatePath: () => _setStatePath,
+  applyRemoteUpdate: () => applyRemoteUpdate,
+  destroyCrdtDoc: () => destroyCrdtDoc,
+  getDiffUpdate: () => getDiffUpdate,
+  getFullState: () => getFullState,
+  getStateVector: () => getStateVector,
+  importExistingBehaviors: () => importExistingBehaviors,
+  importExistingMemories: () => importExistingMemories,
+  initCrdtDoc: () => initCrdtDoc,
+  isCrdtSyncEnabled: () => isCrdtSyncEnabled,
+  onUpdate: () => onUpdate,
+  readAllBehaviors: () => readAllBehaviors,
+  readAllMemories: () => readAllMemories,
+  rebuildFromDb: () => rebuildFromDb
+});
+import * as Y from "yjs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync10, existsSync as existsSync16, mkdirSync as mkdirSync10, unlinkSync as unlinkSync9 } from "fs";
+import path20 from "path";
+import { homedir } from "os";
+function getStatePath() {
+  return _statePathOverride ?? DEFAULT_STATE_PATH;
+}
+function _setStatePath(p) {
+  _statePathOverride = p;
+}
+function initCrdtDoc() {
+  if (doc) return doc;
+  doc = new Y.Doc();
+  const sp = getStatePath();
+  if (existsSync16(sp)) {
+    try {
+      const state = readFileSync13(sp);
+      Y.applyUpdate(doc, new Uint8Array(state));
+    } catch {
+      console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
+      try {
+        unlinkSync9(sp);
+      } catch {
+      }
+      rebuildFromDb().catch((err) => {
+        console.warn("[crdt-sync] rebuild from DB failed:", err);
+      });
+    }
+  }
+  doc.on("update", () => {
+    persistState();
+  });
+  return doc;
+}
+function getMemoriesMap() {
+  const d = initCrdtDoc();
+  return d.getMap("memories");
+}
+function getBehaviorsMap() {
+  const d = initCrdtDoc();
+  return d.getMap("behaviors");
+}
+function applyRemoteUpdate(update) {
+  const d = initCrdtDoc();
+  Y.applyUpdate(d, update);
+}
+function getFullState() {
+  const d = initCrdtDoc();
+  return Y.encodeStateAsUpdate(d);
+}
+function getDiffUpdate(remoteStateVector) {
+  const d = initCrdtDoc();
+  return Y.encodeStateAsUpdate(d, remoteStateVector);
+}
+function getStateVector() {
+  const d = initCrdtDoc();
+  return Y.encodeStateVector(d);
+}
+function importExistingMemories(memories) {
+  const map = getMemoriesMap();
+  const d = initCrdtDoc();
+  let imported = 0;
+  d.transact(() => {
+    for (const mem of memories) {
+      if (!mem.id) continue;
+      if (map.has(mem.id)) continue;
+      const entry = new Y.Map();
+      entry.set("id", mem.id);
+      entry.set("agent_id", mem.agent_id ?? null);
+      entry.set("agent_role", mem.agent_role ?? null);
+      entry.set("session_id", mem.session_id ?? null);
+      entry.set("timestamp", mem.timestamp ?? null);
+      entry.set("tool_name", mem.tool_name ?? null);
+      entry.set("project_name", mem.project_name ?? null);
+      entry.set("has_error", mem.has_error ?? 0);
+      entry.set("raw_text", mem.raw_text ?? "");
+      entry.set("version", mem.version ?? 0);
+      entry.set("author_device_id", mem.author_device_id ?? null);
+      entry.set("scope", mem.scope ?? "business");
+      map.set(mem.id, entry);
+      imported++;
+    }
+  });
+  return imported;
+}
+function importExistingBehaviors(behaviors) {
+  const map = getBehaviorsMap();
+  const d = initCrdtDoc();
+  let imported = 0;
+  d.transact(() => {
+    for (const beh of behaviors) {
+      if (!beh.id) continue;
+      if (map.has(beh.id)) continue;
+      const entry = new Y.Map();
+      entry.set("id", beh.id);
+      entry.set("agent_id", beh.agent_id ?? null);
+      entry.set("project_name", beh.project_name ?? null);
+      entry.set("domain", beh.domain ?? null);
+      entry.set("content", beh.content ?? null);
+      entry.set("active", beh.active ?? 1);
+      entry.set("priority", beh.priority ?? "p1");
+      entry.set("created_at", beh.created_at ?? null);
+      entry.set("updated_at", beh.updated_at ?? null);
+      map.set(beh.id, entry);
+      imported++;
+    }
+  });
+  return imported;
+}
+function readAllMemories() {
+  const map = getMemoriesMap();
+  const records = [];
+  map.forEach((entry, id) => {
+    records.push({
+      id,
+      agent_id: entry.get("agent_id"),
+      agent_role: entry.get("agent_role"),
+      session_id: entry.get("session_id"),
+      timestamp: entry.get("timestamp"),
+      tool_name: entry.get("tool_name"),
+      project_name: entry.get("project_name"),
+      has_error: entry.get("has_error"),
+      raw_text: entry.get("raw_text"),
+      version: entry.get("version"),
+      author_device_id: entry.get("author_device_id"),
+      scope: entry.get("scope")
+    });
+  });
+  return records;
+}
+function readAllBehaviors() {
+  const map = getBehaviorsMap();
+  const records = [];
+  map.forEach((entry, id) => {
+    records.push({
+      id,
+      agent_id: entry.get("agent_id"),
+      project_name: entry.get("project_name"),
+      domain: entry.get("domain"),
+      content: entry.get("content"),
+      active: entry.get("active"),
+      priority: entry.get("priority"),
+      created_at: entry.get("created_at"),
+      updated_at: entry.get("updated_at")
+    });
+  });
+  return records;
+}
+function onUpdate(callback) {
+  const d = initCrdtDoc();
+  const handler = (update) => callback(update);
+  d.on("update", handler);
+  return () => d.off("update", handler);
+}
+function persistState() {
+  if (!doc) return;
+  try {
+    const sp = getStatePath();
+    const dir = path20.dirname(sp);
+    if (!existsSync16(dir)) mkdirSync10(dir, { recursive: true });
+    const state = Y.encodeStateAsUpdate(doc);
+    writeFileSync10(sp, Buffer.from(state));
+  } catch {
+  }
+}
+function isCrdtSyncEnabled() {
+  return process.env.EXE_CRDT_SYNC !== "0";
+}
+async function rebuildFromDb() {
+  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  const client = getClient2();
+  const result = await client.execute(
+    "SELECT id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text, version, author_device_id, scope FROM memories"
+  );
+  const memories = result.rows.map((row) => ({
+    id: String(row.id),
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error,
+    raw_text: row.raw_text,
+    version: row.version,
+    author_device_id: row.author_device_id,
+    scope: row.scope
+  }));
+  const count = importExistingMemories(memories);
+  persistState();
+  return count;
+}
+function destroyCrdtDoc() {
+  if (doc) {
+    doc.destroy();
+    doc = null;
+  }
+}
+var DEFAULT_STATE_PATH, _statePathOverride, doc;
+var init_crdt_sync = __esm({
+  "src/lib/crdt-sync.ts"() {
+    "use strict";
+    DEFAULT_STATE_PATH = path20.join(homedir(), ".exe-os", "crdt-state.bin");
+    _statePathOverride = null;
+    doc = null;
+  }
+});
+
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
@@ -5888,16 +6752,16 @@ __export(cloud_sync_exports, {
   mergeRosterFromRemote: () => mergeRosterFromRemote,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, existsSync as existsSync15, readdirSync as readdirSync7, mkdirSync as mkdirSync9, appendFileSync as appendFileSync2, unlinkSync as unlinkSync8, openSync, closeSync } from "fs";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync11, existsSync as existsSync17, readdirSync as readdirSync6, mkdirSync as mkdirSync11, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto7 from "crypto";
-import path19 from "path";
-import { homedir } from "os";
+import path21 from "path";
+import { homedir as homedir2 } from "os";
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path19.join(homedir(), ".exe-os", "workers.log");
+    const logPath = path21.join(homedir2(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -5905,20 +6769,20 @@ function logError(msg) {
 }
 async function withRosterLock(fn) {
   try {
-    const fd = openSync(ROSTER_LOCK_PATH, "wx");
-    closeSync(fd);
-    writeFileSync9(ROSTER_LOCK_PATH, String(Date.now()));
+    const fd = openSync2(ROSTER_LOCK_PATH, "wx");
+    closeSync2(fd);
+    writeFileSync11(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts = parseInt(readFileSync12(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts = parseInt(readFileSync14(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
-        unlinkSync8(ROSTER_LOCK_PATH);
-        const fd = openSync(ROSTER_LOCK_PATH, "wx");
-        closeSync(fd);
-        writeFileSync9(ROSTER_LOCK_PATH, String(Date.now()));
+        unlinkSync10(ROSTER_LOCK_PATH);
+        const fd = openSync2(ROSTER_LOCK_PATH, "wx");
+        closeSync2(fd);
+        writeFileSync11(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -5931,7 +6795,7 @@ async function withRosterLock(fn) {
     return await fn();
   } finally {
     try {
-      unlinkSync8(ROSTER_LOCK_PATH);
+      unlinkSync10(ROSTER_LOCK_PATH);
     } catch {
     }
   }
@@ -6076,29 +6940,75 @@ async function cloudSync(config) {
   const pullResult = await cloudPull(lastPullVersion, config);
   let pulled = 0;
   if (pullResult.records.length > 0) {
-    const stmts = pullResult.records.map((rec) => ({
-      sql: `INSERT OR REPLACE INTO memories
-            (id, agent_id, agent_role, session_id, timestamp,
-             tool_name, project_name, has_error, raw_text, version,
-             author_device_id, scope)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-      args: [
-        sqlSafe(rec.id),
-        sqlSafe(rec.agent_id),
-        sqlSafe(rec.agent_role),
-        sqlSafe(rec.session_id),
-        sqlSafe(rec.timestamp),
-        sqlSafe(rec.tool_name),
-        sqlSafe(rec.project_name),
-        sqlSafe(rec.has_error ?? 0),
-        sqlSafe(rec.raw_text ?? ""),
-        sqlSafe(rec.version ?? 0),
-        sqlSafe(rec.author_device_id),
-        sqlSafe(rec.scope ?? "business")
-      ]
-    }));
-    await client.batch(stmts, "write");
-    pulled = pullResult.records.length;
+    if (isCrdtSyncEnabled()) {
+      const { initCrdtDoc: initCrdtDoc2, importExistingMemories: importExistingMemories2, readAllMemories: readAllMemories2 } = await Promise.resolve().then(() => (init_crdt_sync(), crdt_sync_exports));
+      initCrdtDoc2();
+      importExistingMemories2(
+        pullResult.records.map((rec) => ({
+          id: String(rec.id ?? ""),
+          agent_id: rec.agent_id,
+          agent_role: rec.agent_role,
+          session_id: rec.session_id,
+          timestamp: rec.timestamp,
+          tool_name: rec.tool_name,
+          project_name: rec.project_name,
+          has_error: rec.has_error ?? 0,
+          raw_text: rec.raw_text ?? "",
+          version: rec.version ?? 0,
+          author_device_id: rec.author_device_id,
+          scope: rec.scope ?? "business"
+        }))
+      );
+      const pulledIds = new Set(pullResult.records.map((r) => String(r.id ?? "")));
+      const merged = readAllMemories2().filter((rec) => pulledIds.has(rec.id));
+      const stmts = merged.map((rec) => ({
+        sql: `INSERT OR REPLACE INTO memories
+              (id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name, has_error, raw_text, version,
+               author_device_id, scope)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          sqlSafe(rec.id),
+          sqlSafe(rec.agent_id),
+          sqlSafe(rec.agent_role),
+          sqlSafe(rec.session_id),
+          sqlSafe(rec.timestamp),
+          sqlSafe(rec.tool_name),
+          sqlSafe(rec.project_name),
+          sqlSafe(rec.has_error ?? 0),
+          sqlSafe(rec.raw_text ?? ""),
+          sqlSafe(rec.version ?? 0),
+          sqlSafe(rec.author_device_id),
+          sqlSafe(rec.scope ?? "business")
+        ]
+      }));
+      if (stmts.length > 0) await client.batch(stmts, "write");
+      pulled = pullResult.records.length;
+    } else {
+      const stmts = pullResult.records.map((rec) => ({
+        sql: `INSERT OR REPLACE INTO memories
+              (id, agent_id, agent_role, session_id, timestamp,
+               tool_name, project_name, has_error, raw_text, version,
+               author_device_id, scope)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: [
+          sqlSafe(rec.id),
+          sqlSafe(rec.agent_id),
+          sqlSafe(rec.agent_role),
+          sqlSafe(rec.session_id),
+          sqlSafe(rec.timestamp),
+          sqlSafe(rec.tool_name),
+          sqlSafe(rec.project_name),
+          sqlSafe(rec.has_error ?? 0),
+          sqlSafe(rec.raw_text ?? ""),
+          sqlSafe(rec.version ?? 0),
+          sqlSafe(rec.author_device_id),
+          sqlSafe(rec.scope ?? "business")
+        ]
+      }));
+      await client.batch(stmts, "write");
+      pulled = pullResult.records.length;
+    }
   }
   if (pullResult.maxVersion > lastPullVersion) {
     await client.execute({
@@ -6246,9 +7156,9 @@ async function cloudSync(config) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path19.join(EXE_AI_DIR, "identity");
-    if (existsSync15(idDir)) {
-      rosterResult.identities = readdirSync7(idDir).filter((f) => f.endsWith(".md")).length;
+    const idDir = path21.join(EXE_AI_DIR, "identity");
+    if (existsSync17(idDir)) {
+      rosterResult.identities = readdirSync6(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
   }
@@ -6268,55 +7178,63 @@ async function cloudSync(config) {
 function recordRosterDeletion(name) {
   let deletions = [];
   try {
-    if (existsSync15(ROSTER_DELETIONS_PATH)) {
-      deletions = JSON.parse(readFileSync12(ROSTER_DELETIONS_PATH, "utf-8"));
+    if (existsSync17(ROSTER_DELETIONS_PATH)) {
+      deletions = JSON.parse(readFileSync14(ROSTER_DELETIONS_PATH, "utf-8"));
     }
   } catch {
   }
   if (!deletions.includes(name)) deletions.push(name);
-  writeFileSync9(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
+  writeFileSync11(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
 }
 function consumeRosterDeletions() {
   try {
-    if (!existsSync15(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync12(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync9(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync17(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync14(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync11(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path19.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path19.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path19.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path21.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path21.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path21.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync15(rosterPath)) {
+  if (existsSync17(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync12(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync14(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync15(identityDir)) {
-    for (const file of readdirSync7(identityDir).filter((f) => f.endsWith(".md"))) {
+  if (existsSync17(identityDir)) {
+    for (const file of readdirSync6(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync12(path19.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync14(path21.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config;
-  if (existsSync15(configPath)) {
+  if (existsSync17(configPath)) {
     try {
-      config = JSON.parse(readFileSync12(configPath, "utf-8"));
+      config = JSON.parse(readFileSync14(configPath, "utf-8"));
+    } catch {
+    }
+  }
+  let agentConfig;
+  const agentConfigPath = path21.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync17(agentConfigPath)) {
+    try {
+      agentConfig = JSON.parse(readFileSync14(agentConfigPath, "utf-8"));
     } catch {
     }
   }
   const deletedNames = consumeRosterDeletions();
-  const content = JSON.stringify({ roster, identities, config, deletedNames });
+  const content = JSON.stringify({ roster, identities, config, agentConfig, deletedNames });
   const hash = crypto7.createHash("sha256").update(content).digest("hex").slice(0, 16);
-  return { roster, identities, config, deletedNames, version: hash };
+  return { roster, identities, config, agentConfig, deletedNames, version: hash };
 }
 async function cloudPushRoster(config) {
   assertSecureEndpoint(config.endpoint);
@@ -6385,23 +7303,23 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path19.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path21.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync15(cfgPath)) {
+  if (existsSync17(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync12(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync14(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path19.dirname(cfgPath);
-  if (!existsSync15(dir)) mkdirSync9(dir, { recursive: true });
-  writeFileSync9(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path21.dirname(cfgPath);
+  if (!existsSync17(dir)) mkdirSync11(dir, { recursive: true });
+  writeFileSync11(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path19.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path21.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -6422,15 +7340,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync15(identityDir)) mkdirSync9(identityDir, { recursive: true });
-        const idPath = path19.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync17(identityDir)) mkdirSync11(identityDir, { recursive: true });
+        const idPath = path21.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync15(idPath) ? readFileSync12(idPath, "utf-8") : null;
+          localIdentity = existsSync17(idPath) ? readFileSync14(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync9(idPath, remoteIdentity, "utf-8");
+          writeFileSync11(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -6454,6 +7372,21 @@ async function mergeRosterFromRemote(remote, paths) {
       } catch {
       }
     }
+    if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
+      try {
+        const agentConfigPath = path21.join(EXE_AI_DIR, "agent-config.json");
+        let local = {};
+        if (existsSync17(agentConfigPath)) {
+          try {
+            local = JSON.parse(readFileSync14(agentConfigPath, "utf-8"));
+          } catch {
+          }
+        }
+        const merged = { ...remote.agentConfig, ...local };
+        writeFileSync11(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+      } catch {
+      }
+    }
     return { added, identitiesUpdated };
   });
 }
@@ -6883,13 +7816,14 @@ var init_cloud_sync = __esm({
     init_compress();
     init_license();
     init_config();
+    init_crdt_sync();
     init_employees();
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path19.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path21.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
-    ROSTER_DELETIONS_PATH = path19.join(EXE_AI_DIR, "roster-deletions.json");
+    ROSTER_DELETIONS_PATH = path21.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -6902,7 +7836,7 @@ __export(schedules_exports, {
   parseHumanCron: () => parseHumanCron
 });
 import crypto8 from "crypto";
-import { execSync as execSync10 } from "child_process";
+import { execSync as execSync9 } from "child_process";
 async function ensureDb() {
   if (!isInitialized()) {
     await initStore();
@@ -7045,7 +7979,7 @@ function addToCrontab(id, cron, prompt, projectDir) {
     const cwd = projectDir ? `cd ${JSON.stringify(projectDir)} && ` : "";
     const escapedPrompt = prompt.replace(/"/g, '\\"');
     const entry = `${cron} ${cwd}claude -p --dangerously-skip-permissions "${escapedPrompt}" # exe-schedule:${id}`;
-    execSync10(
+    execSync9(
       `(crontab -l 2>/dev/null; echo ${JSON.stringify(entry)}) | crontab -`,
       { timeout: 5e3, stdio: "ignore" }
     );
@@ -7054,7 +7988,7 @@ function addToCrontab(id, cron, prompt, projectDir) {
 }
 function removeFromCrontab(id) {
   try {
-    execSync10(
+    execSync9(
       `crontab -l 2>/dev/null | grep -v "exe-schedule:${id}" | crontab -`,
       { timeout: 5e3, stdio: "ignore" }
     );
@@ -7071,10 +8005,10 @@ var init_schedules = __esm({
 
 // src/bin/exe-boot.ts
 init_employees();
-import path20 from "path";
+import path22 from "path";
 import { mkdir as mkdir5, writeFile as writeFile6 } from "fs/promises";
-import { existsSync as existsSync16, readFileSync as readFileSync13, readdirSync as readdirSync8, unlinkSync as unlinkSync9 } from "fs";
-import os8 from "os";
+import { existsSync as existsSync18, readFileSync as readFileSync15, readdirSync as readdirSync7, unlinkSync as unlinkSync11 } from "fs";
+import os9 from "os";
 
 // src/lib/employee-templates.ts
 init_global_procedures();
@@ -7532,12 +8466,13 @@ init_task_scope();
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { fileURLToPath as fileURLToPath3 } from "url";
 function isMainModule(importMetaUrl) {
   if (process.argv[1] == null) return false;
+  if (process.argv[1].includes("mcp/server")) return false;
   try {
     const scriptPath = realpathSync(process.argv[1]);
-    const modulePath = realpathSync(fileURLToPath2(importMetaUrl));
+    const modulePath = realpathSync(fileURLToPath3(importMetaUrl));
     return scriptPath === modulePath;
   } catch {
     return importMetaUrl === `file://${process.argv[1]}` || importMetaUrl === new URL(process.argv[1], "file://").href;
@@ -7549,24 +8484,24 @@ init_notifications();
 
 // src/adapters/claude/active-agent.ts
 init_config();
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync7, unlinkSync as unlinkSync6, readdirSync as readdirSync4 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7, readdirSync as readdirSync4 } from "fs";
 import { execSync as execSync8 } from "child_process";
-import path16 from "path";
+import path18 from "path";
 
 // src/adapters/claude/session-key.ts
 init_session_key();
 
 // src/adapters/claude/active-agent.ts
 init_employees();
-var CACHE_DIR = path16.join(EXE_AI_DIR, "session-cache");
+var CACHE_DIR = path18.join(EXE_AI_DIR, "session-cache");
 var STALE_MS = 24 * 60 * 60 * 1e3;
 function getMarkerPath() {
-  return path16.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path18.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
-    mkdirSync7(CACHE_DIR, { recursive: true });
-    writeFileSync7(
+    mkdirSync8(CACHE_DIR, { recursive: true });
+    writeFileSync8(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -7576,11 +8511,11 @@ function writeActiveAgent(agentId, agentRole) {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync6(path16.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync7(path18.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync6(path16.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync7(path18.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -7662,18 +8597,18 @@ async function boot(options) {
     } catch {
     }
     try {
-      const { readdirSync: readdirSync9, readFileSync: readFs } = await import("fs");
+      const { readdirSync: readdirSync8, readFileSync: readFs } = await import("fs");
       const { STATUS_RE: STATUS_RE2, PRIORITY_RE: PRIORITY_RE2, TITLE_RE: TITLE_RE2 } = await Promise.resolve().then(() => (init_task_scanner(), task_scanner_exports));
       const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
       const exeDir = "exe";
-      const entries = readdirSync9(exeDir, { withFileTypes: true });
+      const entries = readdirSync8(exeDir, { withFileTypes: true });
       const employeeDirs = entries.filter((e) => e.isDirectory() && !["output", "research"].includes(e.name));
       for (const dir of employeeDirs) {
         const employee = dir.name;
-        const taskDir = path20.join(exeDir, employee);
+        const taskDir = path22.join(exeDir, employee);
         let files;
         try {
-          files = readdirSync9(taskDir).filter((f) => f.endsWith(".md"));
+          files = readdirSync8(taskDir).filter((f) => f.endsWith(".md"));
         } catch {
           continue;
         }
@@ -7681,7 +8616,7 @@ async function boot(options) {
           const taskFilePath = `exe/${employee}/${file}`;
           let content;
           try {
-            content = readFs(path20.join(taskDir, file), "utf8");
+            content = readFs(path22.join(taskDir, file), "utf8");
           } catch {
             continue;
           }
@@ -7767,12 +8702,12 @@ async function boot(options) {
     }
     try {
       for (const reviewDirName of /* @__PURE__ */ new Set(["exe", coordinatorName])) {
-        const reviewDir = path20.join(process.cwd(), "exe", reviewDirName);
-        if (existsSync16(reviewDir)) {
-          for (const f of readdirSync8(reviewDir)) {
+        const reviewDir = path22.join(process.cwd(), "exe", reviewDirName);
+        if (existsSync18(reviewDir)) {
+          for (const f of readdirSync7(reviewDir)) {
             if (f.startsWith("review-") && f.endsWith(".md")) {
               try {
-                unlinkSync9(path20.join(reviewDir, f));
+                unlinkSync11(path22.join(reviewDir, f));
               } catch {
               }
             }
@@ -7818,12 +8753,12 @@ async function boot(options) {
           });
           const taskFile = String(r.task_file);
           try {
-            const filePath = path20.join(process.cwd(), taskFile);
-            if (existsSync16(filePath)) {
-              let content = readFileSync13(filePath, "utf8");
+            const filePath = path22.join(process.cwd(), taskFile);
+            if (existsSync18(filePath)) {
+              let content = readFileSync15(filePath, "utf8");
               content = content.replace(/\*\*Status:\*\* needs_review/, "**Status:** done");
-              const { writeFileSync: writeFileSync10 } = await import("fs");
-              writeFileSync10(filePath, content);
+              const { writeFileSync: writeFileSync12 } = await import("fs");
+              writeFileSync12(filePath, content);
             }
           } catch {
           }
@@ -8154,13 +9089,13 @@ async function boot(options) {
             }));
             const assignedResult = await client.execute({
               sql: `SELECT COUNT(*) as cnt FROM tasks
-                    WHERE project_name = ? AND (assigned_by = ? OR assigned_by = 'exe')
+                    WHERE project_name = ? AND assigned_by = ?
                       AND created_at > datetime('now', '-7 days')${pScope.sql}`,
               args: [p.projectName, coordinatorName, ...pScope.args]
             });
             const tasksAssigned = Number(assignedResult.rows[0]?.cnt) || 0;
             if (tasksAssigned > 0) {
-              const exeEntry = activity.find((a) => a.name === coordinatorName || a.name === "exe");
+              const exeEntry = activity.find((a) => a.name === coordinatorName || isCoordinatorName(a.name));
               if (exeEntry) {
                 exeEntry.tasksAssigned = tasksAssigned;
               } else {
@@ -8184,7 +9119,7 @@ async function boot(options) {
             const projName = s.projectDir.split("/").pop() ?? "";
             const proj = projects.find((p) => p.projectName === projName);
             if (!proj || proj.sessionName) continue;
-            if (s.agentId === coordinatorName || s.agentId === "exe") {
+            if (s.agentId === coordinatorName || isCoordinatorName(s.agentId)) {
               proj.sessionName = s.windowName;
             } else if (s.parentExe) {
               proj.sessionName = s.parentExe;
@@ -8268,8 +9203,8 @@ async function boot(options) {
           updatedAt: String(row.updated_at)
         }));
         try {
-          const { execSync: execSync11 } = await import("child_process");
-          const gitLog = execSync11(
+          const { execSync: execSync10 } = await import("child_process");
+          const gitLog = execSync10(
             "git log --oneline -10 --grep='Co-Authored-By: Claude' --grep='task(' --all-match 2>/dev/null || git log --oneline -5 --grep='Co-Authored-By: Claude' 2>/dev/null || git log --oneline -5 --grep='^task(' 2>/dev/null",
             {
               encoding: "utf8",
@@ -8292,19 +9227,19 @@ async function boot(options) {
     })()
   ]);
   try {
-    const configPath = path20.join(
-      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path20.join(os8.homedir(), ".exe-os"),
+    const configPath = path22.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os9.homedir(), ".exe-os"),
       "config.json"
     );
-    if (existsSync16(configPath)) {
-      const raw = JSON.parse(readFileSync13(configPath, "utf8"));
+    if (existsSync18(configPath)) {
+      const raw = JSON.parse(readFileSync15(configPath, "utf8"));
       briefData.cloudConnected = !!(raw.cloud || raw.turso);
     }
   } catch {
   }
   try {
-    const backfillFlagPath = path20.join(EXE_AI_DIR, "session-cache", "needs-backfill");
-    const isBackfillNeeded = () => existsSync16(backfillFlagPath);
+    const backfillFlagPath = path22.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+    const isBackfillNeeded = () => existsSync18(backfillFlagPath);
     const coverageResult = await client.execute({
       sql: `SELECT COUNT(*) as total,
                    SUM(CASE WHEN vector IS NOT NULL THEN 1 ELSE 0 END) as with_vectors
@@ -8326,16 +9261,16 @@ async function boot(options) {
     let daemonRunning = false;
     let daemonUptime;
     let daemonRequestsServed;
-    const socketPath = path20.join(EXE_AI_DIR, "exed.sock");
-    if (existsSync16(socketPath)) {
+    const socketPath = path22.join(EXE_AI_DIR, "exed.sock");
+    if (existsSync18(socketPath)) {
       try {
-        const net = await import("net");
+        const net2 = await import("net");
         const health = await new Promise((resolve) => {
           const timer = setTimeout(() => {
             sock.destroy();
             resolve(null);
           }, 2e3);
-          const sock = net.createConnection({ path: socketPath });
+          const sock = net2.createConnection({ path: socketPath });
           let buf = "";
           sock.on("connect", () => {
             sock.write(JSON.stringify({ id: "boot-health", type: "health" }) + "\n");
@@ -8369,10 +9304,10 @@ async function boot(options) {
       }
     }
     if (!daemonRunning) {
-      const pidPath = path20.join(EXE_AI_DIR, "exed.pid");
-      if (existsSync16(pidPath)) {
+      const pidPath = path22.join(EXE_AI_DIR, "exed.pid");
+      if (existsSync18(pidPath)) {
         try {
-          const pid = parseInt(readFileSync13(pidPath, "utf8").trim(), 10);
+          const pid = parseInt(readFileSync15(pidPath, "utf8").trim(), 10);
           if (pid > 0) {
             process.kill(pid, 0);
             daemonRunning = true;
@@ -8383,10 +9318,10 @@ async function boot(options) {
     }
     if (nullCount === 0) {
       try {
-        const flagPath = path20.join(EXE_AI_DIR, "session-cache", "needs-backfill");
-        if (existsSync16(flagPath)) {
-          const { unlinkSync: unlinkSync10 } = await import("fs");
-          unlinkSync10(flagPath);
+        const flagPath = path22.join(EXE_AI_DIR, "session-cache", "needs-backfill");
+        if (existsSync18(flagPath)) {
+          const { unlinkSync: unlinkSync12 } = await import("fs");
+          unlinkSync12(flagPath);
         }
       } catch {
       }
@@ -8407,26 +9342,26 @@ async function boot(options) {
         if (!tryAcquireWorkerSlot2()) {
           process.stderr.write("[exe-boot] Backfill needed but worker gate full \u2014 skipping\n");
         } else {
-          const { spawn } = await import("child_process");
-          const { fileURLToPath: fileURLToPath3 } = await import("url");
-          const thisFile = fileURLToPath3(import.meta.url);
-          const backfillPath = path20.resolve(path20.dirname(thisFile), "backfill-vectors.js");
-          if (existsSync16(backfillPath)) {
-            const { openSync: openSync2, closeSync: closeSync2 } = await import("fs");
-            const workerLogPath = path20.join(EXE_AI_DIR, "workers.log");
+          const { spawn: spawn2 } = await import("child_process");
+          const { fileURLToPath: fileURLToPath4 } = await import("url");
+          const thisFile = fileURLToPath4(import.meta.url);
+          const backfillPath = path22.resolve(path22.dirname(thisFile), "backfill-vectors.js");
+          if (existsSync18(backfillPath)) {
+            const { openSync: openSync3, closeSync: closeSync3 } = await import("fs");
+            const workerLogPath = path22.join(EXE_AI_DIR, "workers.log");
             let stderrFd = "ignore";
             try {
-              stderrFd = openSync2(workerLogPath, "a");
+              stderrFd = openSync3(workerLogPath, "a");
             } catch {
             }
-            const child = spawn(process.execPath, [backfillPath], {
+            const child = spawn2(process.execPath, [backfillPath], {
               detached: true,
               stdio: ["ignore", "ignore", stderrFd]
             });
             child.unref();
             if (child.pid) registerWorkerPid2(child.pid);
             if (typeof stderrFd === "number") try {
-              closeSync2(stderrFd);
+              closeSync3(stderrFd);
             } catch {
             }
             briefData.embedding.backfillRunning = true;
@@ -8438,13 +9373,13 @@ async function boot(options) {
   } catch {
   }
   try {
-    const { fileURLToPath: fileURLToPath3 } = await import("url");
-    const thisFile = fileURLToPath3(import.meta.url);
+    const { fileURLToPath: fileURLToPath4 } = await import("url");
+    const thisFile = fileURLToPath4(import.meta.url);
     const criticalBinaries = ["backfill-vectors.js", "scan-tasks.js"];
     const missing = [];
     for (const bin of criticalBinaries) {
-      const binPath = path20.resolve(path20.dirname(thisFile), bin);
-      if (!existsSync16(binPath)) {
+      const binPath = path22.resolve(path22.dirname(thisFile), bin);
+      if (!existsSync18(binPath)) {
         missing.push(`dist/bin/${bin}`);
       }
     }
@@ -8473,7 +9408,7 @@ async function boot(options) {
     console.log(brief);
     return;
   }
-  const sessionDir = path20.join(EXE_AI_DIR, "sessions", coordinatorName);
+  const sessionDir = path22.join(EXE_AI_DIR, "sessions", coordinatorName);
   await mkdir5(sessionDir, { recursive: true });
   const claudeMdContent = `${getSessionPrompt(coordinatorEmployee.systemPrompt)}
 
@@ -8482,7 +9417,7 @@ async function boot(options) {
 # Status Brief
 
 ${brief}`;
-  await writeFile6(path20.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
+  await writeFile6(path22.join(sessionDir, "CLAUDE.md"), claudeMdContent, "utf-8");
   const unread = await readUnreadNotifications();
   if (unread.length > 0) {
     console.log(`\u{1F4EC} ${unread.length} unread notification${unread.length === 1 ? "" : "s"}`);
@@ -8491,12 +9426,12 @@ ${brief}`;
   await cleanupOldNotifications();
   console.log(brief);
   try {
-    const configPath2 = path20.join(
-      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path20.join(os8.homedir(), ".exe-os"),
+    const configPath2 = path22.join(
+      process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path22.join(os9.homedir(), ".exe-os"),
       "config.json"
     );
-    if (existsSync16(configPath2)) {
-      const rawCfg = JSON.parse(readFileSync13(configPath2, "utf8"));
+    if (existsSync18(configPath2)) {
+      const rawCfg = JSON.parse(readFileSync15(configPath2, "utf8"));
       const cloudCfg = rawCfg.cloud;
       if (cloudCfg?.apiKey) {
         const { initSyncCrypto: initSyncCrypto2, isSyncCryptoInitialized: isSyncCryptoInitialized2 } = await Promise.resolve().then(() => (init_crypto(), crypto_exports));
@@ -8556,11 +9491,11 @@ async function updateIdleKillSuspectStreak(client, killsToday, liveSessions, tod
 }
 function runSplash() {
   try {
-    const { execSync: execSync11 } = __require("child_process");
+    const { execSync: execSync10 } = __require("child_process");
     const { loadConfigSync: loadConfigSync2 } = (init_config(), __toCommonJS(config_exports));
     const config = loadConfigSync2();
     if (!config.splashEffect) return;
-    execSync11(
+    execSync10(
       'echo "EXE OS" | python3 -m terminaltexteffects decrypt --typing-speed 2 --ciphertext-colors 6B4C9A F5D76E --final-gradient-stops F5D76E F0EDE8 --final-gradient-direction vertical',
       { stdio: "inherit", timeout: 5e3 }
     );