@askexenow/exe-os 0.8.83 → 0.8.85

package/dist/bin/exe-assign.js

@@ -243,369 +243,693 @@ var init_employees = __esm({
   }
 });
 
-// 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");
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } 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;
   }
-  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++) {
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
     try {
-      return await fn();
-    } catch (err) {
-      lastError = err;
-      if (!isBusyError(err) || attempt === MAX_RETRIES) {
-        throw err;
+      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);
       }
-      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);
+    } catch {
     }
   }
-  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");
+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 {
+        }
       }
-      return Reflect.get(target, prop, receiver);
+    } catch {
     }
-  });
+    try {
+      unlinkSync2(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+  }
 }
-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;
+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);
   }
-});
-
-// src/lib/database.ts
-import { createClient } from "@libsql/client";
-async function initDatabase(config) {
-  if (_client) {
-    _client.close();
-    _client = null;
-    _resilientClient = null;
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
   }
-  const opts = {
-    url: `file:${config.dbPath}`
-  };
-  if (config.encryptionKey) {
-    opts.encryptionKey = config.encryptionKey;
+  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;
   }
-  _client = createClient(opts);
-  _resilientClient = wrapWithRetry(_client);
-}
-function getClient() {
-  if (!_resilientClient) {
-    throw new Error("Database client not initialized. Call initDatabase() first.");
+  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 {
+    }
   }
-  return _resilientClient;
 }
-function getRawClient() {
-  if (!_client) {
-    throw new Error("Database client not initialized. Call initDatabase() first.");
+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;
   }
-  return _client;
 }
-async function ensureSchema() {
-  const client = getRawClient();
-  await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 30000");
-  await client.execute("PRAGMA wal_autocheckpoint = 1000");
+function releaseSpawnLock() {
   try {
-    await client.execute("PRAGMA libsql_vector_search_ef = 128");
+    unlinkSync2(SPAWN_LOCK_PATH);
   } catch {
   }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS memories (
-      id            TEXT PRIMARY KEY,
-      agent_id      TEXT NOT NULL,
-      agent_role    TEXT NOT NULL,
-      session_id    TEXT NOT NULL,
-      timestamp     TEXT NOT NULL,
-      tool_name     TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      has_error     INTEGER NOT NULL DEFAULT 0,
-      raw_text      TEXT NOT NULL,
-      vector        F32_BLOB(1024),
-      version       INTEGER NOT NULL DEFAULT 0
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent
-      ON memories(agent_id);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_timestamp
-      ON memories(timestamp);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_session
-      ON memories(session_id);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_project
-      ON memories(project_name);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_tool
-      ON memories(tool_name);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_version
-      ON memories(version);
-
-    CREATE INDEX IF NOT EXISTS idx_memories_agent_project
-      ON memories(agent_id, project_name);
-  `);
-  await client.executeMultiple(`
-    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
-      raw_text,
-      content='memories',
-      content_rowid='rowid'
-    );
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-    END;
-
-    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
-      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
-      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
-    END;
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS sync_meta (
-      key   TEXT PRIMARY KEY,
-      value TEXT NOT NULL
-    );
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS tasks (
-      id            TEXT PRIMARY KEY,
-      title         TEXT NOT NULL,
-      assigned_to   TEXT NOT NULL,
-      assigned_by   TEXT NOT NULL,
-      project_name  TEXT NOT NULL,
-      priority      TEXT NOT NULL DEFAULT 'p1',
-      status        TEXT NOT NULL DEFAULT 'open',
-      task_file     TEXT,
-      created_at    TEXT NOT NULL,
-      updated_at    TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_tasks_assignee_status
-      ON tasks(assigned_to, status);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS behaviors (
-      id           TEXT PRIMARY KEY,
-      agent_id     TEXT NOT NULL,
-      project_name TEXT,
-      domain       TEXT,
-      content      TEXT NOT NULL,
-      active       INTEGER NOT NULL DEFAULT 1,
-      created_at   TEXT NOT NULL,
-      updated_at   TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_behaviors_agent
-      ON behaviors(agent_id, active);
-  `);
-  try {
-    const coordinatorName = getCoordinatorName();
-    const existing = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = ?",
-      args: [coordinatorName]
-    });
-    if (Number(existing.rows[0]?.cnt) === 0) {
-      const seededAt = "2026-03-25T00:00:00Z";
-      for (const [domain, content] of [
-        ["workflow", `Don't ask "keep going?" \u2014 just keep executing phases/plans autonomously`],
-        ["tool-use", "Always use create_task MCP tool, never write .md files directly for task creation"],
-        ["workflow", "Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission"]
-      ]) {
-        await client.execute({
-          sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-                VALUES (hex(randomblob(16)), ?, NULL, ?, ?, 1, ?, ?)`,
-          args: [coordinatorName, domain, content, seededAt, seededAt]
-        });
-      }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
     }
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE behaviors ADD COLUMN priority TEXT DEFAULT 'p1'`,
-      args: []
+    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);
     });
-  } catch {
-  }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
-      args: []
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
     });
-  } catch {
+  });
+}
+async function connectEmbedDaemon() {
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (acquireSpawnLock()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock();
+    }
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`,
-      args: []
-    });
-  } catch {
+  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);
   }
-  try {
-    await client.execute({
-      sql: `CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
-              ON tasks(parent_task_id)
-              WHERE parent_task_id IS NOT NULL`,
-      args: []
-    });
-  } catch {
+  return false;
+}
+function sendRequest(texts, priority) {
+  return sendDaemonRequest({ texts, priority });
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID2();
+    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" });
+    }
+  });
+}
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
   }
-  try {
-    await client.execute({
-      sql: `UPDATE tasks SET status = 'done' WHERE status = 'completed'`,
-      args: []
-    });
-  } catch {
+  return null;
+}
+function killAndRespawnDaemon() {
+  process.stderr.write("[exed-client] Killing daemon for restart...\n");
+  if (existsSync3(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, "SIGKILL");
+        } catch {
+        }
+      }
+    } catch {
+    }
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN reviewer TEXT`,
-      args: []
-    });
-  } catch {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
   }
+  _connected = false;
+  _buffer = "";
   try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN context TEXT`,
-      args: []
-    });
+    unlinkSync2(PID_PATH);
   } catch {
   }
   try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN result TEXT`,
-      args: []
-    });
+    unlinkSync2(SOCKET_PATH);
   } catch {
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN assigned_tmux TEXT`,
-      args: []
-    });
-  } catch {
+  spawnDaemon();
+}
+async function embedViaClient(text, priority = "high") {
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
+    const health = await pingDaemon();
+    if (!health) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
+`);
+      killAndRespawnDaemon();
+      const start = Date.now();
+      let delay2 = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, delay2));
+        if (await connectToSocket()) break;
+        delay2 = Math.min(delay2 * 2, 3e3);
+      }
+      if (!_connected) return null;
+    }
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
-      args: []
-    });
-  } catch {
+  const result = await sendRequest([text], priority);
+  if (!result.error && result.vectors?.[0]) return result.vectors[0];
+  if (result.error) {
+    process.stderr.write(`[exed-client] Embed failed (${result.error}) \u2014 attempting restart
+`);
+    killAndRespawnDaemon();
+    const start = Date.now();
+    let delay2 = 200;
+    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+      await new Promise((r) => setTimeout(r, delay2));
+      if (await connectToSocket()) break;
+      delay2 = Math.min(delay2 * 2, 3e3);
+    }
+    if (!_connected) return null;
+    const retry = await sendRequest([text], priority);
+    if (!retry.error && retry.vectors?.[0]) return retry.vectors[0];
+    process.stderr.write(`[exed-client] Embed retry also failed: ${retry.error ?? "no vector"}
+`);
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
-      args: []
-    });
-  } catch {
+  return null;
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, HEALTH_CHECK_INTERVAL, _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 = "";
+    _requestCount = 0;
+    HEALTH_CHECK_INTERVAL = 100;
+    _pending = /* @__PURE__ */ new Map();
+    MAX_BUFFER = 1e7;
   }
-  try {
-    await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
-      args: []
-    });
+});
+
+// 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/database.ts
+import { createClient } from "@libsql/client";
+async function initDatabase(config) {
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+  const opts = {
+    url: `file:${config.dbPath}`
+  };
+  if (config.encryptionKey) {
+    opts.encryptionKey = config.encryptionKey;
+  }
+  _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
+}
+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;
+}
+function getRawClient() {
+  if (!_client) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _client;
+}
+async function ensureSchema() {
+  const client = getRawClient();
+  await client.execute("PRAGMA journal_mode = WAL");
+  await client.execute("PRAGMA busy_timeout = 30000");
+  await client.execute("PRAGMA wal_autocheckpoint = 1000");
+  try {
+    await client.execute("PRAGMA libsql_vector_search_ef = 128");
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS memories (
+      id            TEXT PRIMARY KEY,
+      agent_id      TEXT NOT NULL,
+      agent_role    TEXT NOT NULL,
+      session_id    TEXT NOT NULL,
+      timestamp     TEXT NOT NULL,
+      tool_name     TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      has_error     INTEGER NOT NULL DEFAULT 0,
+      raw_text      TEXT NOT NULL,
+      vector        F32_BLOB(1024),
+      version       INTEGER NOT NULL DEFAULT 0
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent
+      ON memories(agent_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_timestamp
+      ON memories(timestamp);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_session
+      ON memories(session_id);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_project
+      ON memories(project_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_tool
+      ON memories(tool_name);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_version
+      ON memories(version);
+
+    CREATE INDEX IF NOT EXISTS idx_memories_agent_project
+      ON memories(agent_id, project_name);
+  `);
+  await client.executeMultiple(`
+    CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      raw_text,
+      content='memories',
+      content_rowid='rowid'
+    );
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ai AFTER INSERT ON memories BEGIN
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+    END;
+
+    CREATE TRIGGER IF NOT EXISTS memories_fts_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, raw_text) VALUES('delete', old.rowid, old.raw_text);
+      INSERT INTO memories_fts(rowid, raw_text) VALUES (new.rowid, new.raw_text);
+    END;
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS sync_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id            TEXT PRIMARY KEY,
+      title         TEXT NOT NULL,
+      assigned_to   TEXT NOT NULL,
+      assigned_by   TEXT NOT NULL,
+      project_name  TEXT NOT NULL,
+      priority      TEXT NOT NULL DEFAULT 'p1',
+      status        TEXT NOT NULL DEFAULT 'open',
+      task_file     TEXT,
+      created_at    TEXT NOT NULL,
+      updated_at    TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_tasks_assignee_status
+      ON tasks(assigned_to, status);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS behaviors (
+      id           TEXT PRIMARY KEY,
+      agent_id     TEXT NOT NULL,
+      project_name TEXT,
+      domain       TEXT,
+      content      TEXT NOT NULL,
+      active       INTEGER NOT NULL DEFAULT 1,
+      created_at   TEXT NOT NULL,
+      updated_at   TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_behaviors_agent
+      ON behaviors(agent_id, active);
+  `);
+  try {
+    const coordinatorName = getCoordinatorName();
+    const existing = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = ?",
+      args: [coordinatorName]
+    });
+    if (Number(existing.rows[0]?.cnt) === 0) {
+      const seededAt = "2026-03-25T00:00:00Z";
+      for (const [domain, content] of [
+        ["workflow", `Don't ask "keep going?" \u2014 just keep executing phases/plans autonomously`],
+        ["tool-use", "Always use create_task MCP tool, never write .md files directly for task creation"],
+        ["workflow", "Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission"]
+      ]) {
+        await client.execute({
+          sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+                VALUES (hex(randomblob(16)), ?, NULL, ?, ?, 1, ?, ?)`,
+          args: [coordinatorName, domain, content, seededAt, seededAt]
+        });
+      }
+    }
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE tasks ADD COLUMN session_scope TEXT`,
+      sql: `ALTER TABLE behaviors ADD COLUMN priority TEXT DEFAULT 'p1'`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
+      sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
+      sql: `ALTER TABLE tasks ADD COLUMN parent_task_id TEXT`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN author_device_id TEXT`,
+      sql: `CREATE INDEX IF NOT EXISTS idx_tasks_parent_task_id
+              ON tasks(parent_task_id)
+              WHERE parent_task_id IS NOT NULL`,
       args: []
     });
   } catch {
   }
   try {
     await client.execute({
-      sql: `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`,
+      sql: `UPDATE tasks SET status = 'done' WHERE status = 'completed'`,
       args: []
     });
   } catch {
   }
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS consolidations (
-      id                    TEXT PRIMARY KEY,
-      consolidated_memory_id TEXT NOT NULL,
-      source_memory_id      TEXT NOT NULL,
-      created_at            TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_consolidations_source
-      ON consolidations(source_memory_id);
-
-    CREATE INDEX IF NOT EXISTS idx_consolidations_consolidated
-      ON consolidations(consolidated_memory_id);
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS reminders (
-      id            TEXT PRIMARY KEY,
-      text          TEXT NOT NULL,
-      created_at    TEXT NOT NULL,
-      due_date      TEXT,
-      completed_at  TEXT
-    );
-  `);
-  await client.executeMultiple(`
-    CREATE TABLE IF NOT EXISTS notifications (
-      id          TEXT PRIMARY KEY,
-      agent_id    TEXT NOT NULL,
-      agent_role  TEXT NOT NULL,
-      event       TEXT NOT NULL,
-      project     TEXT NOT NULL,
-      summary     TEXT NOT NULL,
-      task_file   TEXT,
-      read        INTEGER NOT NULL DEFAULT 0,
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN reviewer TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN context TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN result TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN assigned_tmux TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN checkpoint_count INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN complexity TEXT NOT NULL DEFAULT 'standard'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE tasks ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN task_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN author_device_id TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS consolidations (
+      id                    TEXT PRIMARY KEY,
+      consolidated_memory_id TEXT NOT NULL,
+      source_memory_id      TEXT NOT NULL,
+      created_at            TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_source
+      ON consolidations(source_memory_id);
+
+    CREATE INDEX IF NOT EXISTS idx_consolidations_consolidated
+      ON consolidations(consolidated_memory_id);
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS reminders (
+      id            TEXT PRIMARY KEY,
+      text          TEXT NOT NULL,
+      created_at    TEXT NOT NULL,
+      due_date      TEXT,
+      completed_at  TEXT
+    );
+  `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS notifications (
+      id          TEXT PRIMARY KEY,
+      agent_id    TEXT NOT NULL,
+      agent_role  TEXT NOT NULL,
+      event       TEXT NOT NULL,
+      project     TEXT NOT NULL,
+      summary     TEXT NOT NULL,
+      task_file   TEXT,
+      read        INTEGER NOT NULL DEFAULT 0,
       created_at  TEXT NOT NULL
     );
 
@@ -807,6 +1131,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,
@@ -859,7 +1189,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,
@@ -1040,6 +1393,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`,
@@ -1173,8 +1553,30 @@ 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 {
+    }
+  }
 }
-var _client, _resilientClient, initTurso;
+var _client, _resilientClient, _daemonClient, initTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
@@ -1182,6 +1584,7 @@ var init_database = __esm({
     init_employees();
     _client = null;
     _resilientClient = null;
+    _daemonClient = null;
     initTurso = initDatabase;
   }
 });
@@ -1566,509 +1969,184 @@ ${p.content}`).join("\n\n");
   }
   _cacheLoaded = true;
   return customerOnly;
-}
-function getGlobalProceduresBlock() {
-  const sections = [];
-  if (_platformCache) sections.push(_platformCache);
-  if (_cacheLoaded && _customerCache) sections.push(_customerCache);
-  if (sections.length === 0) return "";
-  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
-
-${sections.join("\n\n")}
-`;
-}
-async function storeGlobalProcedure(input) {
-  const id = randomUUID3();
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const client = getClient();
-  await client.execute({
-    sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
-    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now, now]
-  });
-  await loadGlobalProcedures();
-  return id;
-}
-async function deactivateGlobalProcedure(id) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  const client = getClient();
-  const result = await client.execute({
-    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE id = ?",
-    args: [now, id]
-  });
-  await loadGlobalProcedures();
-  return result.rowsAffected > 0;
-}
-var _customerCache, _cacheLoaded, _platformCache;
-var init_global_procedures = __esm({
-  "src/lib/global-procedures.ts"() {
-    "use strict";
-    init_database();
-    init_platform_procedures();
-    _customerCache = "";
-    _cacheLoaded = false;
-    _platformCache = PLATFORM_PROCEDURES.map((p) => `### ${p.title}
-${p.content}`).join("\n\n");
-  }
-});
-
-// src/bin/exe-assign.ts
-init_employees();
-
-// src/lib/task-router.ts
-init_employees();
-import { randomUUID } from "crypto";
-var DEFAULT_BLOOM_CONFIG = {
-  complexityToTier: {
-    routine: "junior",
-    standard: "standard",
-    complex: "senior",
-    critical: "specialist"
-  },
-  tierRules: {
-    junior: {
-      eligible: [],
-      // resolved dynamically from roster (Principal Engineer role)
-      reviewRequired: false,
-      manualOnly: false
-    },
-    standard: {
-      eligible: [],
-      // resolved dynamically from roster (Principal Engineer role)
-      reviewRequired: false,
-      manualOnly: false
-    },
-    senior: {
-      eligible: [],
-      // any specialist, but review required
-      reviewRequired: true,
-      manualOnly: false
-    },
-    specialist: {
-      eligible: [],
-      reviewRequired: true,
-      manualOnly: true
-    }
-  }
-};
-function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
-  const tier = config.complexityToTier[complexity];
-  const rule = config.tierRules[tier];
-  return {
-    tier,
-    reviewRequired: rule.reviewRequired,
-    manualOnly: rule.manualOnly,
-    eligible: rule.eligible
-  };
-}
-async function scoreEmployee(taskVector, agentId, searchFn) {
-  const results = await searchFn(taskVector, agentId, { limit: 5 });
-  if (results.length === 0) {
-    return { agentId, score: 0 };
-  }
-  const distances = results.map((r) => r["_distance"]).filter((d) => typeof d === "number");
-  if (distances.length > 0) {
-    const avgDistance = distances.reduce((sum, d) => sum + d, 0) / distances.length;
-    return { agentId, score: 1 / (1 + avgDistance) };
-  }
-  return { agentId, score: results.length / 5 };
-}
-async function routeTask(taskDescription, employees, embedFn, searchFn, options) {
-  let specialists = employees.filter((e) => !isCoordinatorRole(e.role));
-  if (specialists.length === 0) {
-    throw new Error(
-      "No specialist employees available. Create one with /exe-new-employee."
-    );
-  }
-  let bloomRouting;
-  if (options?.complexity) {
-    bloomRouting = resolveBloomRouting(options.complexity, options.bloomConfig);
-    if (bloomRouting.manualOnly) {
-      throw new Error(
-        `Task complexity "${options.complexity}" requires manual assignment (tier: ${bloomRouting.tier}).`
-      );
-    }
-    if (bloomRouting.eligible.length > 0) {
-      const eligible = new Set(bloomRouting.eligible);
-      const filtered = specialists.filter((e) => eligible.has(e.name));
-      if (filtered.length > 0) {
-        specialists = filtered;
-      }
-    }
-  }
-  const taskVector = await embedFn(taskDescription);
-  const scored = await Promise.all(
-    specialists.map(async (emp) => {
-      const { score } = await scoreEmployee(taskVector, emp.name, searchFn);
-      return { employee: emp, score };
-    })
-  );
-  scored.sort((a, b) => b.score - a.score);
-  return { ...scored[0], bloomRouting };
-}
-function createAssignmentMemory(taskDescription, assignedTo, assignedBy) {
-  return {
-    id: randomUUID(),
-    agent_id: assignedTo.name,
-    agent_role: assignedTo.role,
-    session_id: `assign-${Date.now()}`,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    tool_name: "assignment",
-    project_name: "",
-    has_error: false,
-    raw_text: `Task assigned by ${assignedBy}: ${taskDescription}`,
-    vector: null
-    // Will be backfilled
-  };
-}
-function formatAssignmentOutput(employee, task, score, mode, bloomRouting) {
-  const modeLabel = mode === "auto" ? "auto-routed" : "direct";
-  const percent = Math.round(score * 100);
-  const lines = [
-    `Assigned to ${employee.name} (${employee.role})`,
-    `Mode: ${modeLabel}`,
-    `Relevance: ${percent}%`,
-    `Task: ${task}`
-  ];
-  if (bloomRouting) {
-    lines.push(`Complexity tier: ${bloomRouting.tier}`);
-    if (bloomRouting.reviewRequired) {
-      lines.push(`Review: required`);
-    }
-  }
-  return lines.join("\n");
-}
-
-// src/types/memory.ts
-var EMBEDDING_DIM = 1024;
-
-// src/lib/exe-daemon-client.ts
-init_config();
-import net from "net";
-import { spawn } from "child_process";
-import { randomUUID as randomUUID2 } 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";
-var SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path3.join(EXE_AI_DIR, "exed.sock");
-var PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path3.join(EXE_AI_DIR, "exed.pid");
-var SPAWN_LOCK_PATH = path3.join(EXE_AI_DIR, "exed-spawn.lock");
-var SPAWN_LOCK_STALE_MS = 3e4;
-var CONNECT_TIMEOUT_MS = 15e3;
-var REQUEST_TIMEOUT_MS = 3e4;
-var _socket = null;
-var _connected = false;
-var _buffer = "";
-var _requestCount = 0;
-var HEALTH_CHECK_INTERVAL = 100;
-var _pending = /* @__PURE__ */ new Map();
-var MAX_BUFFER = 1e7;
-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 entry = _pending.get(response.id);
-      if (entry) {
-        clearTimeout(entry.timer);
-        _pending.delete(response.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 sendRequest(texts, priority) {
-  return new Promise((resolve) => {
-    if (!_socket || !_connected) {
-      resolve({ error: "Not connected" });
-      return;
-    }
-    const id = randomUUID2();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve({ error: "Request timeout" });
-    }, REQUEST_TIMEOUT_MS);
-    _pending.set(id, { resolve, timer });
-    try {
-      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve({ error: "Write failed" });
-    }
+}
+function getGlobalProceduresBlock() {
+  const sections = [];
+  if (_platformCache) sections.push(_platformCache);
+  if (_cacheLoaded && _customerCache) sections.push(_customerCache);
+  if (sections.length === 0) return "";
+  return `## Organization-Wide Procedures (MANDATORY \u2014 supersedes all other rules)
+
+${sections.join("\n\n")}
+`;
+}
+async function storeGlobalProcedure(input) {
+  const id = randomUUID3();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  await client.execute({
+    sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+    args: [id, input.title, input.content, input.priority ?? "p0", input.domain ?? null, now, now]
   });
+  await loadGlobalProcedures();
+  return id;
 }
-async function pingDaemon() {
-  if (!_socket || !_connected) return null;
-  return new Promise((resolve) => {
-    const id = randomUUID2();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve(null);
-    }, 5e3);
-    _pending.set(id, {
-      resolve: (data) => {
-        if (data.health) {
-          resolve(data.health);
-        } else {
-          resolve(null);
-        }
-      },
-      timer
-    });
-    try {
-      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve(null);
-    }
+async function deactivateGlobalProcedure(id) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const client = getClient();
+  const result = await client.execute({
+    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE id = ?",
+    args: [now, id]
   });
+  await loadGlobalProcedures();
+  return result.rowsAffected > 0;
 }
-function killAndRespawnDaemon() {
-  process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync3(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      }
-    } catch {
-    }
+var _customerCache, _cacheLoaded, _platformCache;
+var init_global_procedures = __esm({
+  "src/lib/global-procedures.ts"() {
+    "use strict";
+    init_database();
+    init_platform_procedures();
+    _customerCache = "";
+    _cacheLoaded = false;
+    _platformCache = PLATFORM_PROCEDURES.map((p) => `### ${p.title}
+${p.content}`).join("\n\n");
   }
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
+});
+
+// src/bin/exe-assign.ts
+init_employees();
+
+// src/lib/task-router.ts
+init_employees();
+import { randomUUID } from "crypto";
+var DEFAULT_BLOOM_CONFIG = {
+  complexityToTier: {
+    routine: "junior",
+    standard: "standard",
+    complex: "senior",
+    critical: "specialist"
+  },
+  tierRules: {
+    junior: {
+      eligible: [],
+      // resolved dynamically from roster (Principal Engineer role)
+      reviewRequired: false,
+      manualOnly: false
+    },
+    standard: {
+      eligible: [],
+      // resolved dynamically from roster (Principal Engineer role)
+      reviewRequired: false,
+      manualOnly: false
+    },
+    senior: {
+      eligible: [],
+      // any specialist, but review required
+      reviewRequired: true,
+      manualOnly: false
+    },
+    specialist: {
+      eligible: [],
+      reviewRequired: true,
+      manualOnly: true
+    }
   }
-  _connected = false;
-  _buffer = "";
-  try {
-    unlinkSync2(PID_PATH);
-  } catch {
+};
+function resolveBloomRouting(complexity, config = DEFAULT_BLOOM_CONFIG) {
+  const tier = config.complexityToTier[complexity];
+  const rule = config.tierRules[tier];
+  return {
+    tier,
+    reviewRequired: rule.reviewRequired,
+    manualOnly: rule.manualOnly,
+    eligible: rule.eligible
+  };
+}
+async function scoreEmployee(taskVector, agentId, searchFn) {
+  const results = await searchFn(taskVector, agentId, { limit: 5 });
+  if (results.length === 0) {
+    return { agentId, score: 0 };
   }
-  try {
-    unlinkSync2(SOCKET_PATH);
-  } catch {
+  const distances = results.map((r) => r["_distance"]).filter((d) => typeof d === "number");
+  if (distances.length > 0) {
+    const avgDistance = distances.reduce((sum, d) => sum + d, 0) / distances.length;
+    return { agentId, score: 1 / (1 + avgDistance) };
   }
-  spawnDaemon();
+  return { agentId, score: results.length / 5 };
 }
-async function embedViaClient(text, priority = "high") {
-  if (!_connected && !await connectEmbedDaemon()) return null;
-  _requestCount++;
-  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
-    const health = await pingDaemon();
-    if (!health) {
-      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
-`);
-      killAndRespawnDaemon();
-      const start = Date.now();
-      let delay2 = 200;
-      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay2));
-        if (await connectToSocket()) break;
-        delay2 = Math.min(delay2 * 2, 3e3);
+async function routeTask(taskDescription, employees, embedFn, searchFn, options) {
+  let specialists = employees.filter((e) => !isCoordinatorRole(e.role));
+  if (specialists.length === 0) {
+    throw new Error(
+      "No specialist employees available. Create one with /exe-new-employee."
+    );
+  }
+  let bloomRouting;
+  if (options?.complexity) {
+    bloomRouting = resolveBloomRouting(options.complexity, options.bloomConfig);
+    if (bloomRouting.manualOnly) {
+      throw new Error(
+        `Task complexity "${options.complexity}" requires manual assignment (tier: ${bloomRouting.tier}).`
+      );
+    }
+    if (bloomRouting.eligible.length > 0) {
+      const eligible = new Set(bloomRouting.eligible);
+      const filtered = specialists.filter((e) => eligible.has(e.name));
+      if (filtered.length > 0) {
+        specialists = filtered;
       }
-      if (!_connected) return null;
     }
   }
-  const result = await sendRequest([text], priority);
-  if (!result.error && result.vectors?.[0]) return result.vectors[0];
-  if (result.error) {
-    process.stderr.write(`[exed-client] Embed failed (${result.error}) \u2014 attempting restart
-`);
-    killAndRespawnDaemon();
-    const start = Date.now();
-    let delay2 = 200;
-    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay2));
-      if (await connectToSocket()) break;
-      delay2 = Math.min(delay2 * 2, 3e3);
+  const taskVector = await embedFn(taskDescription);
+  const scored = await Promise.all(
+    specialists.map(async (emp) => {
+      const { score } = await scoreEmployee(taskVector, emp.name, searchFn);
+      return { employee: emp, score };
+    })
+  );
+  scored.sort((a, b) => b.score - a.score);
+  return { ...scored[0], bloomRouting };
+}
+function createAssignmentMemory(taskDescription, assignedTo, assignedBy) {
+  return {
+    id: randomUUID(),
+    agent_id: assignedTo.name,
+    agent_role: assignedTo.role,
+    session_id: `assign-${Date.now()}`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    tool_name: "assignment",
+    project_name: "",
+    has_error: false,
+    raw_text: `Task assigned by ${assignedBy}: ${taskDescription}`,
+    vector: null
+    // Will be backfilled
+  };
+}
+function formatAssignmentOutput(employee, task, score, mode, bloomRouting) {
+  const modeLabel = mode === "auto" ? "auto-routed" : "direct";
+  const percent = Math.round(score * 100);
+  const lines = [
+    `Assigned to ${employee.name} (${employee.role})`,
+    `Mode: ${modeLabel}`,
+    `Relevance: ${percent}%`,
+    `Task: ${task}`
+  ];
+  if (bloomRouting) {
+    lines.push(`Complexity tier: ${bloomRouting.tier}`);
+    if (bloomRouting.reviewRequired) {
+      lines.push(`Review: required`);
     }
-    if (!_connected) return null;
-    const retry = await sendRequest([text], priority);
-    if (!retry.error && retry.vectors?.[0]) return retry.vectors[0];
-    process.stderr.write(`[exed-client] Embed retry also failed: ${retry.error ?? "no vector"}
-`);
   }
-  return null;
+  return lines.join("\n");
 }
 
+// src/types/memory.ts
+var EMBEDDING_DIM = 1024;
+
 // src/lib/embedder.ts
+init_exe_daemon_client();
 async function embed(text) {
   const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
   const vector = await embedViaClient(text, priority);
@@ -2086,6 +2164,7 @@ async function embed(text) {
 }
 
 // src/lib/store.ts
+import { createHash } from "crypto";
 init_database();
 
 // src/lib/keychain.ts
@@ -2121,12 +2200,20 @@ async function getMasterKey() {
   }
   const keyPath = getKeyPath();
   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;
   }
 }
@@ -2265,12 +2352,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,
@@ -2300,7 +2427,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({
@@ -2358,80 +2501,85 @@ async function flushBatch() {
       const draft = row.draft ? 1 : 0;
       const memoryType = row.memory_type ?? "raw";
       const trajectory = row.trajectory ?? null;
-      return {
-        sql: hasVector ? `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
-               tool_name, project_name,
-               has_error, raw_text, vector, version, task_id, importance, status,
-               confidence, last_accessed,
-               workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
-              (id, agent_id, agent_role, session_id, timestamp,
+      const contentHash = row.content_hash ?? null;
+      const intent = row.intent ?? null;
+      const outcome = row.outcome ?? null;
+      const domain = row.domain ?? null;
+      const referencedEntities = row.referenced_entities ?? null;
+      const retrievalCount = row.retrieval_count ?? 0;
+      const chainPosition = row.chain_position ?? null;
+      const reviewStatus = row.review_status ?? null;
+      const contextWindowPct = row.context_window_pct ?? null;
+      const filePaths = row.file_paths ?? null;
+      const commitHash = row.commit_hash ?? null;
+      const durationMs = row.duration_ms ?? null;
+      const tokenCost = row.token_cost ?? null;
+      const audience = row.audience ?? null;
+      const languageType = row.language_type ?? null;
+      const parentMemoryId = row.parent_memory_id ?? null;
+      const cols = `id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-        args: hasVector ? [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          vectorToBlob(row.vector),
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ] : [
-          row.id,
-          row.agent_id,
-          row.agent_role,
-          row.session_id,
-          row.timestamp,
-          row.tool_name,
-          row.project_name,
-          row.has_error,
-          row.raw_text,
-          row.version,
-          taskId,
-          importance,
-          status,
-          confidence,
-          lastAccessed,
-          workspaceId,
-          documentId,
-          userId,
-          charOffset,
-          pageNumber,
-          sourcePath,
-          sourceType,
-          tier,
-          supersedesId,
-          draft,
-          memoryType,
-          trajectory
-        ]
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory, content_hash,
+               intent, outcome, domain, referenced_entities, retrieval_count,
+               chain_position, review_status, context_window_pct, file_paths, commit_hash,
+               duration_ms, token_cost, audience, language_type, parent_memory_id`;
+      const metaArgs = [
+        intent,
+        outcome,
+        domain,
+        referencedEntities,
+        retrievalCount,
+        chainPosition,
+        reviewStatus,
+        contextWindowPct,
+        filePaths,
+        commitHash,
+        durationMs,
+        tokenCost,
+        audience,
+        languageType,
+        parentMemoryId
+      ];
+      const baseArgs = [
+        row.id,
+        row.agent_id,
+        row.agent_role,
+        row.session_id,
+        row.timestamp,
+        row.tool_name,
+        row.project_name,
+        row.has_error,
+        row.raw_text
+      ];
+      const sharedArgs = [
+        row.version,
+        taskId,
+        importance,
+        status,
+        confidence,
+        lastAccessed,
+        workspaceId,
+        documentId,
+        userId,
+        charOffset,
+        pageNumber,
+        sourcePath,
+        sourceType,
+        tier,
+        supersedesId,
+        draft,
+        memoryType,
+        trajectory,
+        contentHash
+      ];
+      return {
+        sql: hasVector ? `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories (${cols})
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        args: hasVector ? [...baseArgs, vectorToBlob(row.vector), ...sharedArgs, ...metaArgs] : [...baseArgs, ...sharedArgs, ...metaArgs]
       };
     };
     const globalClient = getClient();
@@ -2575,6 +2723,7 @@ import { realpathSync } from "fs";
 import { fileURLToPath as fileURLToPath2 } 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));