@askexenow/exe-os 0.8.83 → 0.8.86

package/dist/hooks/commit-complete.js

@@ -268,123 +268,19 @@ var init_provider_table = __esm({
   }
 });
 
-// src/lib/intercom-queue.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import path2 from "path";
-import os2 from "os";
-function ensureDir() {
-  const dir = path2.dirname(QUEUE_PATH);
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
-}
-function readQueue() {
-  try {
-    if (!existsSync2(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync2(QUEUE_PATH, "utf8"));
-  } catch {
-    return [];
-  }
-}
-function writeQueue(queue) {
-  ensureDir();
-  const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
-  renameSync(tmp, QUEUE_PATH);
-}
-function queueIntercom(targetSession, reason) {
-  const queue = readQueue();
-  const existing = queue.find((q) => q.targetSession === targetSession);
-  if (existing) {
-    existing.attempts++;
-    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
-    existing.reason = reason;
-  } else {
-    queue.push({
-      targetSession,
-      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      attempts: 0,
-      reason
-    });
-  }
-  writeQueue(queue);
-}
-var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
-var init_intercom_queue = __esm({
-  "src/lib/intercom-queue.ts"() {
-    "use strict";
-    QUEUE_PATH = path2.join(os2.homedir(), ".exe-os", "intercom-queue.json");
-    TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path2.join(os2.homedir(), ".exe-os", "intercom.log");
-  }
-});
-
-// src/lib/db-retry.ts
-function isBusyError(err) {
-  if (err instanceof Error) {
-    const msg = err.message.toLowerCase();
-    return msg.includes("sqlite_busy") || msg.includes("database is locked");
-  }
-  return false;
-}
-function delay(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-async function retryOnBusy(fn, label) {
-  let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (!isBusyError(err) || attempt === MAX_RETRIES) {
-        throw err;
-      }
-      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
-      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
-      process.stderr.write(
-        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
-`
-      );
-      await delay(backoff + jitter);
-    }
-  }
-  throw lastError;
-}
-function wrapWithRetry(client) {
-  return new Proxy(client, {
-    get(target, prop, receiver) {
-      if (prop === "execute") {
-        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
-      }
-      if (prop === "batch") {
-        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
-      }
-      return Reflect.get(target, prop, receiver);
-    }
-  });
-}
-var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
-var init_db_retry = __esm({
-  "src/lib/db-retry.ts"() {
-    "use strict";
-    MAX_RETRIES = 3;
-    BASE_DELAY_MS = 200;
-    MAX_JITTER_MS = 300;
-  }
-});
-
 // src/lib/config.ts
 import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync as readFileSync3, existsSync as existsSync3, renameSync as renameSync2 } from "fs";
-import path3 from "path";
-import os3 from "os";
+import { readFileSync as readFileSync2, existsSync as existsSync2, renameSync } from "fs";
+import path2 from "path";
+import os2 from "os";
 function resolveDataDir() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path3.join(os3.homedir(), ".exe-os");
-  const legacyDir = path3.join(os3.homedir(), ".exe-mem");
-  if (!existsSync3(newDir) && existsSync3(legacyDir)) {
+  const newDir = path2.join(os2.homedir(), ".exe-os");
+  const legacyDir = path2.join(os2.homedir(), ".exe-mem");
+  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
     try {
-      renameSync2(legacyDir, newDir);
+      renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
 `);
     } catch {
@@ -446,9 +342,9 @@ function normalizeAutoUpdate(raw) {
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   await mkdir(dir, { recursive: true });
-  const configPath = path3.join(dir, "config.json");
-  if (!existsSync3(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync2(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
   const raw = await readFile(configPath, "utf-8");
   try {
@@ -466,13 +362,13 @@ async function loadConfig() {
     normalizeScalingRoadmap(migratedCfg);
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
-    const config = { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db"), ...migratedCfg };
+    const config = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
     if (config.dbPath.startsWith("~")) {
-      config.dbPath = config.dbPath.replace(/^~/, os3.homedir());
+      config.dbPath = config.dbPath.replace(/^~/, os2.homedir());
     }
     return config;
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path3.join(dir, "memories.db") };
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
 var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
@@ -480,10 +376,10 @@ var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
     EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path3.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path3.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path3.join(EXE_AI_DIR, "config.json");
-    LEGACY_LANCE_PATH = path3.join(EXE_AI_DIR, "local.lance");
+    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
       config_version: CURRENT_CONFIG_VERSION,
@@ -555,11 +451,166 @@ var init_config = __esm({
   }
 });
 
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    "use strict";
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "exec",
+        autoApproveFlag: "--full-auto",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.4"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+// src/lib/agent-config.ts
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync3, mkdirSync as mkdirSync2 } from "fs";
+import path3 from "path";
+function loadAgentConfig() {
+  if (!existsSync3(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync3(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+var AGENT_CONFIG_PATH, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path3.join(EXE_AI_DIR, "agent-config.json");
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: "minimax-m2.7"
+    };
+  }
+});
+
+// src/lib/intercom-queue.ts
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2, existsSync as existsSync4, mkdirSync as mkdirSync3 } from "fs";
+import path4 from "path";
+import os3 from "os";
+function ensureDir() {
+  const dir = path4.dirname(QUEUE_PATH);
+  if (!existsSync4(dir)) mkdirSync3(dir, { recursive: true });
+}
+function readQueue() {
+  try {
+    if (!existsSync4(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync4(QUEUE_PATH, "utf8"));
+  } catch {
+    return [];
+  }
+}
+function writeQueue(queue) {
+  ensureDir();
+  const tmp = `${QUEUE_PATH}.tmp`;
+  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  renameSync2(tmp, QUEUE_PATH);
+}
+function queueIntercom(targetSession, reason) {
+  const queue = readQueue();
+  const existing = queue.find((q) => q.targetSession === targetSession);
+  if (existing) {
+    existing.attempts++;
+    existing.queuedAt = (/* @__PURE__ */ new Date()).toISOString();
+    existing.reason = reason;
+  } else {
+    queue.push({
+      targetSession,
+      queuedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      attempts: 0,
+      reason
+    });
+  }
+  writeQueue(queue);
+}
+var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
+var init_intercom_queue = __esm({
+  "src/lib/intercom-queue.ts"() {
+    "use strict";
+    QUEUE_PATH = path4.join(os3.homedir(), ".exe-os", "intercom-queue.json");
+    TTL_MS = 60 * 60 * 1e3;
+    INTERCOM_LOG = path4.join(os3.homedir(), ".exe-os", "intercom.log");
+  }
+});
+
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
+  }
+});
+
 // src/lib/employees.ts
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync4, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync5, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync4 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import path4 from "path";
+import path5 from "path";
 import os4 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -578,9 +629,9 @@ function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
   return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync4(employeesPath)) return [];
+  if (!existsSync5(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync4(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -599,13 +650,450 @@ var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
-    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
+    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
     DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
     COORDINATOR_ROLE = "COO";
     MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync6, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync6(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync2(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  const { root } = path6.parse(dir);
+  while (dir !== root) {
+    if (existsSync6(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path6.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync6(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path6.join(path6.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const child = spawn(process.execPath, [resolvedPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      TMUX: void 0,
+      // Daemon is global — must not inherit session scope
+      TMUX_PANE: void 0,
+      // Prevents resolveExeSession() from scoping to one session
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+}
+function acquireSpawnLock() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(SPAWN_LOCK_PATH);
+      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync2(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync2(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
+    const socket = net.createConnection({ path: SOCKET_PATH });
+    const connectTimeout = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 2e3);
+    socket.on("connect", () => {
+      clearTimeout(connectTimeout);
+      _socket = socket;
+      _connected = true;
+      _buffer = "";
+      socket.on("data", handleData);
+      socket.on("close", () => {
+        _connected = false;
+        _socket = null;
+        for (const [id, entry] of _pending) {
+          clearTimeout(entry.timer);
+          _pending.delete(id);
+          entry.resolve({ error: "Connection closed" });
+        }
+      });
+      socket.on("error", () => {
+        _connected = false;
+        _socket = null;
+      });
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
+    });
+  });
+}
+async function connectEmbedDaemon() {
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (acquireSpawnLock()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock();
+    }
+  }
+  const start = Date.now();
+  let delay2 = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay2));
+    if (await connectToSocket()) return true;
+    delay2 = Math.min(delay2 * 2, 3e3);
+  }
+  return false;
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, timeoutMs);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+function isClientConnected() {
+  return _connected;
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _pending, MAX_BUFFER;
+var init_exe_daemon_client = __esm({
+  "src/lib/exe-daemon-client.ts"() {
+    "use strict";
+    init_config();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path6.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path6.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path6.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    _socket = null;
+    _connected = false;
+    _buffer = "";
+    _pending = /* @__PURE__ */ new Map();
+    MAX_BUFFER = 1e7;
+  }
+});
+
+// src/lib/daemon-protocol.ts
+function serializeValue(v) {
+  if (v === null || v === void 0) return null;
+  if (typeof v === "bigint") return Number(v);
+  if (typeof v === "boolean") return v ? 1 : 0;
+  if (v instanceof Uint8Array) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (ArrayBuffer.isView(v)) {
+    return { __blob: Buffer.from(v.buffer, v.byteOffset, v.byteLength).toString("base64") };
+  }
+  if (v instanceof ArrayBuffer) {
+    return { __blob: Buffer.from(v).toString("base64") };
+  }
+  if (typeof v === "string" || typeof v === "number") return v;
+  return String(v);
+}
+function deserializeValue(v) {
+  if (v === null) return null;
+  if (typeof v === "object" && v !== null && "__blob" in v) {
+    const buf = Buffer.from(v.__blob, "base64");
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+  }
+  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, {
@@ -614,6 +1102,7 @@ __export(database_exports, {
   ensureSchema: () => ensureSchema,
   getClient: () => getClient,
   getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
   initDatabase: () => initDatabase,
   initTurso: () => initTurso,
   isInitialized: () => isInitialized
@@ -641,8 +1130,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.");
@@ -1129,6 +1637,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,
@@ -1181,7 +1695,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,
@@ -1362,6 +1899,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`,
@@ -1495,15 +2059,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";
@@ -1511,24 +2101,25 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync5, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID } from "crypto";
-import path5 from "path";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync7, mkdirSync as mkdirSync4 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
+import path7 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, PLAN_LIMITS;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path5.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path5.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path5.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path7.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path7.join(EXE_AI_DIR, "device-id");
     PLAN_LIMITS = {
       free: { devices: 1, employees: 1, memories: 5e3 },
       pro: { devices: 3, employees: 5, memories: 1e5 },
@@ -1540,12 +2131,12 @@ var init_license = __esm({
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync6, existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync8 } from "fs";
+import path8 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync6(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync6(CACHE_PATH2, "utf8"));
+    if (!existsSync8(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();
@@ -1583,8 +2174,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync6(filePath)) {
-      const raw = readFileSync6(filePath, "utf8");
+    if (existsSync8(filePath)) {
+      const raw = readFileSync8(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -1613,19 +2204,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path6.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto from "crypto";
-import path7 from "path";
+import path9 from "path";
 import os5 from "os";
 import {
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync9,
   readdirSync,
-  unlinkSync as unlinkSync2,
-  existsSync as existsSync7,
+  unlinkSync as unlinkSync3,
+  existsSync as existsSync9,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -1776,10 +2367,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto3 from "crypto";
-import path8 from "path";
+import path10 from "path";
+import os6 from "os";
 import { execSync as execSync4 } from "child_process";
 import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
-import { existsSync as existsSync8, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync10, readFileSync as readFileSync10 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -1820,6 +2412,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({
@@ -1869,7 +2490,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) {
@@ -1909,22 +2537,24 @@ async function createTaskCore(input) {
   if (dupCheck.rows.length > 0) {
     warning = `similar active task already exists (${String(dupCheck.rows[0].id)}). Created new task anyway.`;
   }
+  if (!process.env.DISABLE_LANE_AFFINITY) {
+    const laneWarning = checkLaneAffinity(input.title, input.context, input.assignedTo);
+    if (laneWarning) {
+      warning = warning ? `${warning}
+${laneWarning}` : laneWarning;
+    }
+  }
   if (input.baseDir) {
     try {
-      await mkdir3(path8.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir3(path8.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir3(path10.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir3(path10.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
     }
   }
   const complexity = input.complexity ?? "standard";
-  let sessionScope = null;
-  try {
-    const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
-    sessionScope = resolveExeSession2();
-  } catch {
-  }
+  const sessionScope = earlySessionScope;
   await client.execute({
     sql: `INSERT INTO tasks (id, title, assigned_to, assigned_by, project_name, priority, status, task_file, blocked_by, parent_task_id, reviewer, context, complexity, budget_tokens, budget_fallback_model, tokens_used, tokens_warned_at, session_scope, created_at, updated_at)
           VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -1951,6 +2581,43 @@ async function createTaskCore(input) {
       now
     ]
   });
+  if (input.baseDir) {
+    try {
+      const EXE_OS_DIR = path10.join(os6.homedir(), ".exe-os");
+      const mdPath = path10.join(EXE_OS_DIR, taskFile);
+      const mdDir = path10.dirname(mdPath);
+      if (!existsSync10(mdDir)) await mkdir3(mdDir, { recursive: true });
+      const reviewer = input.reviewer ?? input.assignedBy;
+      const mdContent = `# ${input.title}
+
+**ID:** ${id}
+**Status:** ${initialStatus}
+**Priority:** ${input.priority}
+**Assigned by:** ${input.assignedBy}
+**Assigned to:** ${input.assignedTo}
+**Project:** ${input.projectName}
+**Created:** ${now.split("T")[0]}${parentTaskId ? `
+**Parent task:** ${parentTaskId}` : ""}
+**Reviewer:** ${reviewer}
+
+## Context
+
+${input.context}
+
+## MANDATORY: When done
+
+You MUST call update_task with status "done" and a result summary when finished.
+If you skip this, your reviewer will not know you're done and your work won't be reviewed.
+Do NOT let a failed commit or any error prevent you from calling update_task(done).
+`;
+      await writeFile3(mdPath, mdContent, "utf-8");
+    } catch (err) {
+      process.stderr.write(
+        `[create-task] WARNING: .md file write failed for ${taskFile}: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
   return {
     id,
     title: input.title,
@@ -2143,7 +2810,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}
 `
@@ -2208,9 +2875,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path8.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path10.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync8(archPath)) return;
+    if (existsSync10(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -2243,10 +2910,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path8.join(baseDir, ".gitignore");
+  const gitignorePath = path10.join(baseDir, ".gitignore");
   try {
-    if (existsSync8(gitignorePath)) {
-      const content = readFileSync8(gitignorePath, "utf-8");
+    if (existsSync10(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 {
@@ -2255,20 +2922,30 @@ async function ensureGitignoreExe(baseDir) {
   } catch {
   }
 }
-var DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
+var LANE_KEYWORDS, KEYWORD_INDEX, DELEGATION_KEYWORDS, TASK_ALREADY_CLAIMED_PREFIX;
 var init_tasks_crud = __esm({
   "src/lib/tasks-crud.ts"() {
     "use strict";
     init_database();
     init_task_scope();
+    init_employees();
+    LANE_KEYWORDS = {
+      CMO: ["sales", "script", "pitch", "offer", "copy", "objection", "brand", "content", "seo", "marketing", "newsletter", "carousel", "social", "campaign"],
+      CTO: ["spec", "architecture", "migration", "schema", "database", "design doc", "adr", "security audit", "tech stack"],
+      "Principal Engineer": ["implement", "build", "fix", "commit", "refactor", "bug", "feature", "wire", "integration"],
+      "Staff Code Reviewer": ["critique", "verdict", "review", "audit", "code quality"],
+      "Content Production Specialist": ["render", "video", "image", "b-roll", "remotion", "animation", "thumbnail"],
+      "AI Product Lead": ["competitive", "analysis", "benchmark", "compare", "scout", "evaluate", "poc"]
+    };
+    KEYWORD_INDEX = buildKeywordIndex();
     DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
     TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
 
 // src/lib/tasks-review.ts
-import path9 from "path";
-import { existsSync as existsSync9, readdirSync as readdirSync2, unlinkSync as unlinkSync3 } from "fs";
+import path11 from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync2, unlinkSync as unlinkSync4 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
@@ -2290,7 +2967,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;
@@ -2308,7 +2985,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]
     });
@@ -2429,14 +3106,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
 `
           );
         }
@@ -2449,11 +3126,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path9.join(EXE_AI_DIR, "session-cache");
-    if (existsSync9(cacheDir)) {
+    const cacheDir = path11.join(EXE_AI_DIR, "session-cache");
+    if (existsSync11(cacheDir)) {
       for (const f of readdirSync2(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync3(path9.join(cacheDir, f));
+          unlinkSync4(path11.join(cacheDir, f));
         }
       }
     }
@@ -2474,7 +3151,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path10 from "path";
+import path12 from "path";
 import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -2491,7 +3168,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path10.join(baseDir, String(ur.task_file));
+        const ubFile = path12.join(baseDir, String(ur.task_file));
         let ubContent = await readFile3(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -2560,7 +3237,7 @@ var init_tasks_chain = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync5 } from "child_process";
-import path11 from "path";
+import path13 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -2573,7 +3250,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path11.dirname(gitCommonDir);
+      repoRoot = path13.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync5("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -2582,11 +3259,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path11.basename(repoRoot);
+    _cached2 = path13.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path11.basename(dir);
+    _cached2 = path13.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -2618,7 +3295,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;
 }
@@ -2664,7 +3341,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 {
@@ -3059,8 +3736,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path12 from "path";
-import { writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4 } from "fs";
+import path14 from "path";
+import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -3079,14 +3756,14 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path12.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path12.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync4(cacheDir, { recursive: true });
-      writeFileSync5(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      mkdirSync5(cacheDir, { recursive: true });
+      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
       try {
-        unlinkSync4(cachePath);
+        unlinkSync5(cachePath);
       } catch {
       }
     }
@@ -3143,7 +3820,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();
     }
@@ -3168,7 +3845,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,
@@ -3184,7 +3861,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 {
@@ -3528,7 +4205,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,
@@ -3543,20 +4220,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 execSync6 } from "child_process";
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, existsSync as existsSync10, appendFileSync } from "fs";
-import path13 from "path";
-import os6 from "os";
-import { fileURLToPath } from "url";
-import { unlinkSync as unlinkSync5 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync12, appendFileSync } from "fs";
+import path15 from "path";
+import os7 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync6 } from "fs";
 function spawnLockPath(sessionName) {
-  return path13.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path15.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -3566,14 +4243,14 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function acquireSpawnLock(sessionName) {
-  if (!existsSync10(SPAWN_LOCK_DIR)) {
-    mkdirSync5(SPAWN_LOCK_DIR, { recursive: true });
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync12(SPAWN_LOCK_DIR)) {
+    mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync10(lockFile)) {
+  if (existsSync12(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;
@@ -3581,25 +4258,25 @@ function acquireSpawnLock(sessionName) {
     } catch {
     }
   }
-  writeFileSync6(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync7(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
-function releaseSpawnLock(sessionName) {
+function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync5(spawnLockPath(sessionName));
+    unlinkSync6(spawnLockPath(sessionName));
   } catch {
   }
 }
 function resolveBehaviorsExporterScript() {
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const scriptPath = path13.join(
-      path13.dirname(thisFile),
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path15.join(
+      path15.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync10(scriptPath) ? scriptPath : null;
+    return existsSync12(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -3665,12 +4342,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync10(SESSION_CACHE)) {
-    mkdirSync5(SESSION_CACHE, { recursive: true });
+  if (!existsSync12(SESSION_CACHE)) {
+    mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync6(filePath, JSON.stringify({
+  const filePath = path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync7(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3678,7 +4355,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync9(path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync11(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -3686,8 +4363,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync9(
-      path13.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync11(
+      path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -3713,10 +4390,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;
 }
@@ -3748,32 +4425,50 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync10(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync12(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 (!existsSync10(SESSION_CACHE)) mkdirSync5(SESSION_CACHE, { recursive: true });
-    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync12(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync7(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
 function isDebounced(targetSession) {
   const state = readDebounceState();
-  const lastSent = state[targetSession] ?? 0;
-  return Date.now() - lastSent < INTERCOM_DEBOUNCE_MS;
+  const entry = state[targetSession];
+  const lastSent = entry?.lastSent ?? 0;
+  if (Date.now() - lastSent < INTERCOM_DEBOUNCE_MS) {
+    if (!state[targetSession]) state[targetSession] = { lastSent, pending: 0 };
+    state[targetSession].pending++;
+    writeDebounceState(state);
+    return true;
+  }
+  return false;
 }
 function recordDebounce(targetSession) {
   const state = readDebounceState();
-  state[targetSession] = Date.now();
+  const batched = state[targetSession]?.pending ?? 0;
+  state[targetSession] = { lastSent: Date.now(), pending: 0 };
   const cutoff = Date.now() - DEBOUNCE_CLEANUP_AGE_MS;
   for (const key of Object.keys(state)) {
-    if ((state[key] ?? 0) < cutoff) delete state[key];
+    if ((state[key]?.lastSent ?? 0) < cutoff) delete state[key];
   }
   writeDebounceState(state);
+  return batched;
 }
 function logIntercom(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
@@ -3818,7 +4513,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 {
@@ -3830,14 +4525,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)) {
@@ -3845,8 +4540,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}`);
@@ -3876,7 +4571,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 {
@@ -3948,26 +4643,26 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path13.join(os6.homedir(), ".exe-os", "session-logs");
-  const logFile = path13.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync10(logDir)) {
-    mkdirSync5(logDir, { recursive: true });
+  const logDir = path15.join(os7.homedir(), ".exe-os", "session-logs");
+  const logFile = path15.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync12(logDir)) {
+    mkdirSync6(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path13.join(path13.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync10(cleanupScript)) {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync12(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path13.join(os6.homedir(), ".claude.json");
+    const claudeJsonPath = path15.join(os7.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync9(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -3975,17 +4670,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync6(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync7(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path13.join(os6.homedir(), ".claude", "projects");
+    const settingsDir = path15.join(os7.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path13.join(settingsDir, normalizedKey);
-    const settingsPath = path13.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path15.join(settingsDir, normalizedKey);
+    const settingsPath = path15.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync9(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -4013,21 +4708,24 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync5(projSettingsDir, { recursive: true });
-      writeFileSync6(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      mkdirSync6(projSettingsDir, { recursive: true });
+      writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
   const spawnCwd = opts?.cwd ?? projectDir;
   const useExeAgent = !!(opts?.model && opts?.provider);
-  const ccProvider = useExeAgent ? DEFAULT_PROVIDER : detectActiveProvider();
+  const agentRtConfig = getAgentRuntime(employeeName);
+  const useCodex = !useExeAgent && agentRtConfig.runtime === "codex";
+  const useOpencode = !useExeAgent && !useCodex && agentRtConfig.runtime === "opencode";
+  const ccProvider = useExeAgent || useCodex || useOpencode ? DEFAULT_PROVIDER : detectActiveProvider();
   const useBinSymlink = ccProvider !== DEFAULT_PROVIDER;
   let identityFlag = "";
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path13.join(
-      os6.homedir(),
+    const identityPath = path15.join(
+      os7.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -4036,13 +4734,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync10(identityPath)) {
+    } else if (existsSync12(identityPath)) {
       identityFlag = ` --append-system-prompt-file ${identityPath}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path13.basename(spawnCwd),
+      path15.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -4057,16 +4755,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path13.join(os6.homedir(), ".exe-os", "session-cache");
-    mkdirSync5(ctxDir, { recursive: true });
-    const ctxFile = path13.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path15.join(os7.homedir(), ".exe-os", "session-cache");
+    mkdirSync6(ctxDir, { recursive: true });
+    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync6(ctxFile, ctxContent);
+    writeFileSync7(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -4080,9 +4778,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(
@@ -4098,17 +4835,19 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     command: spawnCommand
   });
   if (spawnResult.error) {
-    releaseSpawnLock(sessionName);
+    releaseSpawnLock2(sessionName);
     return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
   }
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path13.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync6(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync7(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
-      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : "anthropic",
+      provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
+      runtime: useCodex ? "codex" : useOpencode ? "opencode" : useExeAgent ? "exe-agent" : "claude",
+      model: useCodex ? agentRtConfig.model : useOpencode ? agentRtConfig.model : void 0,
       createdAt: (/* @__PURE__ */ new Date()).toISOString()
     }));
   } catch {
@@ -4126,6 +4865,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;
@@ -4136,10 +4880,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 {
@@ -4153,7 +4898,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;
@@ -4166,17 +4911,19 @@ var init_tmux_routing = __esm({
     init_cc_agent_support();
     init_mcp_prefix();
     init_provider_table();
+    init_agent_config();
+    init_runtime_table();
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path13.join(os6.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path13.join(os6.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path15.join(os7.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path15.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
-    INTERCOM_LOG2 = path13.join(os6.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path13.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path15.join(os7.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…/;
   }
@@ -4217,14 +4964,14 @@ var init_memory = __esm({
 
 // src/lib/keychain.ts
 import { readFile as readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync11 } from "fs";
-import path14 from "path";
-import os7 from "os";
+import { existsSync as existsSync13 } from "fs";
+import path16 from "path";
+import os8 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path14.join(os7.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path16.join(os8.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path14.join(getKeyDir(), "master.key");
+  return path16.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -4245,13 +4992,21 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync11(keyPath)) {
+  if (!existsSync13(keyPath)) {
+    process.stderr.write(
+      `[keychain] Key not found at ${keyPath} (HOME=${os8.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+`
+    );
     return null;
   }
   try {
     const content = await readFile4(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
-  } catch {
+  } catch (err) {
+    process.stderr.write(
+      `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
+`
+    );
     return null;
   }
 }
@@ -4277,13 +5032,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path15 from "path";
-import { existsSync as existsSync12, mkdirSync as mkdirSync6, readdirSync as readdirSync3 } from "fs";
+import path17 from "path";
+import { existsSync as existsSync14, mkdirSync as mkdirSync7, readdirSync as readdirSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync12(SHARDS_DIR)) {
-    mkdirSync6(SHARDS_DIR, { recursive: true });
+  if (!existsSync14(SHARDS_DIR)) {
+    mkdirSync7(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
 }
@@ -4303,7 +5058,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path15.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path17.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -4313,10 +5068,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync12(path15.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync14(path17.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync12(SHARDS_DIR)) return [];
+  if (!existsSync14(SHARDS_DIR)) return [];
   return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -4502,7 +5257,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path15.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path17.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -4627,7 +5382,7 @@ __export(global_procedures_exports, {
   loadGlobalProcedures: () => loadGlobalProcedures,
   storeGlobalProcedure: () => storeGlobalProcedure
 });
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
   const result = await client.execute({
@@ -4656,7 +5411,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input) {
-  const id = randomUUID2();
+  const id = randomUUID3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -4707,6 +5462,7 @@ __export(store_exports, {
   vectorToBlob: () => vectorToBlob,
   writeMemory: () => writeMemory
 });
+import { createHash } from "crypto";
 function isBusyError2(err) {
   if (err instanceof Error) {
     const msg = err.message.toLowerCase();
@@ -4780,12 +5536,52 @@ function classifyTier(record) {
   if (["store_memory", "manual"].includes(record.tool_name ?? "") && (record.importance ?? 0) >= 5) return 2;
   return 3;
 }
+function inferFilePaths(record) {
+  if (!["Read", "Write", "Edit"].includes(record.tool_name)) return null;
+  const firstLine = record.raw_text.split("\n")[0] ?? "";
+  const match = firstLine.match(/(\/[\w./-]+\.\w+)/);
+  return match ? JSON.stringify([match[1]]) : null;
+}
+function inferCommitHash(record) {
+  if (record.tool_name !== "Bash") return null;
+  const match = record.raw_text.match(/\b([a-f0-9]{7,40})\b/);
+  return match ? match[1] : null;
+}
+function inferLanguageType(record) {
+  const text = record.raw_text;
+  if (!text || text.length < 10) return null;
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) return "json";
+  if (/\b(SELECT|INSERT|UPDATE|DELETE|CREATE TABLE|ALTER TABLE)\b/i.test(text)) return "sql";
+  if (/\b(function |const |import |export |class |def |async |=>)\b/.test(text)) return "code";
+  if (trimmed.startsWith("#") || trimmed.startsWith("*")) return "prose";
+  return "mixed";
+}
+function inferDomain(record) {
+  const proj = (record.project_name ?? "").toLowerCase();
+  if (proj.includes("marketing") || proj.includes("content")) return "marketing";
+  if (proj.includes("crm") || proj.includes("customer")) return "customer";
+  return null;
+}
 async function writeMemory(record) {
   if (record.vector !== null && record.vector.length !== EMBEDDING_DIM) {
     throw new Error(
       `Expected ${EMBEDDING_DIM}-dim vector, got ${record.vector.length}`
     );
   }
+  const contentHash = createHash("md5").update(record.raw_text).digest("hex");
+  if (_pendingRecords.some((r) => r.content_hash === contentHash && r.agent_id === record.agent_id)) {
+    return;
+  }
+  try {
+    const client = getClient();
+    const existing = await client.execute({
+      sql: "SELECT id FROM memories WHERE content_hash = ? AND agent_id = ? LIMIT 1",
+      args: [contentHash, record.agent_id]
+    });
+    if (existing.rows.length > 0) return;
+  } catch {
+  }
   const dbRow = {
     id: record.id,
     agent_id: record.agent_id,
@@ -4815,7 +5611,23 @@ async function writeMemory(record) {
     supersedes_id: record.supersedes_id ?? null,
     draft: record.draft ? 1 : 0,
     memory_type: record.memory_type ?? "raw",
-    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null
+    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null,
+    content_hash: contentHash,
+    intent: record.intent ?? null,
+    outcome: record.outcome ?? null,
+    domain: record.domain ?? inferDomain(record),
+    referenced_entities: record.referenced_entities ?? null,
+    retrieval_count: record.retrieval_count ?? 0,
+    chain_position: record.chain_position ?? null,
+    review_status: record.review_status ?? null,
+    context_window_pct: record.context_window_pct ?? null,
+    file_paths: record.file_paths ?? inferFilePaths(record),
+    commit_hash: record.commit_hash ?? inferCommitHash(record),
+    duration_ms: record.duration_ms ?? null,
+    token_cost: record.token_cost ?? null,
+    audience: record.audience ?? null,
+    language_type: record.language_type ?? inferLanguageType(record),
+    parent_memory_id: record.parent_memory_id ?? null
   };
   _pendingRecords.push(dbRow);
   orgBus.emit({
@@ -4873,80 +5685,85 @@ async function flushBatch() {
       const draft = row.draft ? 1 : 0;
       const memoryType = row.memory_type ?? "raw";
       const trajectory = row.trajectory ?? null;
-      return {
-        sql: hasVector ? `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
+      const contentHash = row.content_hash ?? null;
+      const intent = row.intent ?? null;
+      const outcome = row.outcome ?? null;
+      const domain = row.domain ?? null;
+      const referencedEntities = row.referenced_entities ?? null;
+      const retrievalCount = row.retrieval_count ?? 0;
+      const chainPosition = row.chain_position ?? null;
+      const reviewStatus = row.review_status ?? null;
+      const contextWindowPct = row.context_window_pct ?? null;
+      const filePaths = row.file_paths ?? null;
+      const commitHash = row.commit_hash ?? null;
+      const durationMs = row.duration_ms ?? null;
+      const tokenCost = row.token_cost ?? null;
+      const audience = row.audience ?? null;
+      const languageType = row.language_type ?? null;
+      const parentMemoryId = row.parent_memory_id ?? null;
+      const cols = `id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
-               tool_name, project_name,
-               has_error, raw_text, vector, version, task_id, importance, status,
-               confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: hasVector ? [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          vectorToBlob(row.vector),
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ] : [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ]
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory, content_hash,
+               intent, outcome, domain, referenced_entities, retrieval_count,
+               chain_position, review_status, context_window_pct, file_paths, commit_hash,
+               duration_ms, token_cost, audience, language_type, parent_memory_id`;
+      const metaArgs = [
+        intent,
+        outcome,
+        domain,
+        referencedEntities,
+        retrievalCount,
+        chainPosition,
+        reviewStatus,
+        contextWindowPct,
+        filePaths,
+        commitHash,
+        durationMs,
+        tokenCost,
+        audience,
+        languageType,
+        parentMemoryId
+      ];
+      const baseArgs = [
+        row.id,
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        row.raw_text
+      ];
+      const sharedArgs = [
+        row.version,
+        taskId,
+        importance,
+        status,
+        confidence,
+        lastAccessed,
+        workspaceId,
+        documentId,
+        userId,
+        charOffset,
+        pageNumber,
+        sourcePath,
+        sourceType,
+        tier,
+        supersedesId,
+        draft,
+        memoryType,
+        trajectory,
+        contentHash
+      ];
+      return {
+        sql: hasVector ? `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [...baseArgs, vectorToBlob(row.vector), ...sharedArgs, ...metaArgs] : [...baseArgs, ...sharedArgs, ...metaArgs]
       };
     };
     const globalClient = getClient();