@askexenow/exe-os 0.9.16 → 0.9.18

package/dist/bin/exe-start-codex.js

@@ -15,6 +15,15 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/types/memory.ts
+var EMBEDDING_DIM;
+var init_memory = __esm({
+  "src/types/memory.ts"() {
+    "use strict";
+    EMBEDDING_DIM = 1024;
+  }
+});
+
 // src/lib/db-retry.ts
 function isBusyError(err) {
   if (err instanceof Error) {
@@ -64,9 +73,9 @@ 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;
+    MAX_RETRIES = 5;
+    BASE_DELAY_MS = 250;
+    MAX_JITTER_MS = 400;
   }
 });
 
@@ -80,12 +89,25 @@ async function ensurePrivateDir(dirPath) {
   } catch {
   }
 }
+function ensurePrivateDirSync(dirPath) {
+  mkdirSync(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    chmodSync(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
 async function enforcePrivateFile(filePath) {
   try {
     await chmod(filePath, PRIVATE_FILE_MODE);
   } catch {
   }
 }
+function enforcePrivateFileSync(filePath) {
+  try {
+    if (existsSync(filePath)) chmodSync(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
 var PRIVATE_DIR_MODE, PRIVATE_FILE_MODE;
 var init_secure_files = __esm({
   "src/lib/secure-files.ts"() {
@@ -913,7 +935,538 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/lib/daemon-auth.ts
+import crypto from "crypto";
+import path4 from "path";
+import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync4(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync3(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto.randomBytes(32).toString("hex");
+  ensurePrivateDirSync(EXE_AI_DIR);
+  writeFileSync2(DAEMON_TOKEN_PATH, `${token}
+`, "utf8");
+  enforcePrivateFileSync(DAEMON_TOKEN_PATH);
+  return token;
+}
+var DAEMON_TOKEN_PATH;
+var init_daemon_auth = __esm({
+  "src/lib/daemon-auth.ts"() {
+    "use strict";
+    init_config();
+    init_secure_files();
+    DAEMON_TOKEN_PATH = path4.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import os4 from "os";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync5, unlinkSync as unlinkSync2, readFileSync as readFileSync4, openSync, closeSync, statSync } from "fs";
+import path5 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 (existsSync5(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync4(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 = path5.dirname(fileURLToPath(import.meta.url));
+  const { root } = path5.parse(dir);
+  while (dir !== root) {
+    if (existsSync5(path5.join(dir, "package.json"))) return dir;
+    dir = path5.dirname(dir);
+  }
+  return null;
+}
+function getAvailableMemoryGB() {
+  if (process.platform === "darwin") {
+    try {
+      const { execSync: execSync5 } = __require("child_process");
+      const vmstat = execSync5("vm_stat", { encoding: "utf8" });
+      const pageSize = 16384;
+      const pageSizeMatch = vmstat.match(/page size of (\d+) bytes/);
+      const actualPageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : pageSize;
+      const free = vmstat.match(/Pages free:\s+(\d+)/);
+      const inactive = vmstat.match(/Pages inactive:\s+(\d+)/);
+      const speculative = vmstat.match(/Pages speculative:\s+(\d+)/);
+      const freePages = free ? parseInt(free[1], 10) : 0;
+      const inactivePages = inactive ? parseInt(inactive[1], 10) : 0;
+      const speculativePages = speculative ? parseInt(speculative[1], 10) : 0;
+      return (freePages + inactivePages + speculativePages) * actualPageSize / (1024 * 1024 * 1024);
+    } catch {
+      return os4.freemem() / (1024 * 1024 * 1024);
+    }
+  }
+  return os4.freemem() / (1024 * 1024 * 1024);
+}
+function spawnDaemon() {
+  const freeGB = getAvailableMemoryGB();
+  const totalGB = os4.totalmem() / (1024 * 1024 * 1024);
+  if (totalGB <= 8) {
+    process.stderr.write(
+      `[exed-client] SKIP: ${totalGB.toFixed(0)}GB system \u2014 embedding daemon disabled. Using keyword search only. Minimum 16GB recommended for vector search.
+`
+    );
+    return;
+  }
+  if (totalGB <= 16 && freeGB < 2) {
+    process.stderr.write(
+      `[exed-client] SKIP: low memory (${freeGB.toFixed(1)}GB available / ${totalGB.toFixed(0)}GB total). Embedding daemon not started \u2014 using keyword search only.
+`
+    );
+    return;
+  }
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path5.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync5(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path5.join(path5.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const heapCapMB = totalGB <= 8 ? 256 : 512;
+  const nodeArgs = [`--max-old-space-size=${heapCapMB}`, resolvedPath];
+  const child = spawn(process.execPath, nodeArgs, {
+    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,
+      [DAEMON_TOKEN_ENV]: daemonToken
+    }
+  });
+  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 token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, timeoutMs);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, token, ...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, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _pending, MAX_BUFFER;
+var init_exe_daemon_client = __esm({
+  "src/lib/exe-daemon-client.ts"() {
+    "use strict";
+    init_config();
+    init_daemon_auth();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path5.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path5.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path5.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    DAEMON_TOKEN_ENV = "EXE_DAEMON_TOKEN";
+    _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 normalizeStatement2(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 } = normalizeStatement2(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" || errMsg === "DB not initialized") {
+          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(normalizeStatement2);
+      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" || errMsg === "DB not initialized") {
+          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, {
+  disposeDatabase: () => disposeDatabase,
+  disposeTurso: () => disposeTurso,
+  ensureSchema: () => ensureSchema,
+  getClient: () => getClient,
+  getRawClient: () => getRawClient,
+  initDaemonClient: () => initDaemonClient,
+  initDatabase: () => initDatabase,
+  initTurso: () => initTurso,
+  isInitialized: () => isInitialized
+});
 import { createClient } from "@libsql/client";
 async function initDatabase(config) {
   if (_walCheckpointTimer) {
@@ -952,15 +1505,18 @@ async function initDatabase(config) {
     });
   }, 3e4);
   _walCheckpointTimer.unref();
-  if (process.env.DATABASE_URL) {
+  if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") {
     _adapterClient = await createPrismaDbAdapter(_resilientClient);
   }
 }
+function isInitialized() {
+  return _adapterClient !== null || _client !== null;
+}
 function getClient() {
   if (!_adapterClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
-  if (process.env.DATABASE_URL) {
+  if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") {
     return _adapterClient;
   }
   if (process.env.EXE_IS_DAEMON === "1") {
@@ -971,6 +1527,22 @@ function getClient() {
   }
   return _resilientClient;
 }
+async function initDaemonClient() {
+  if (process.env.DATABASE_URL && process.env.EXE_USE_POSTGRES === "1") return;
+  if (process.env.EXE_IS_DAEMON === "1") return;
+  if (process.env.VITEST) return;
+  if (!_resilientClient) return;
+  if (_daemonClient) 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.");
@@ -1109,6 +1681,13 @@ async function ensureSchema() {
     });
   } catch {
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE behaviors ADD COLUMN vector F32_BLOB(${EMBEDDING_DIM})`,
+      args: []
+    });
+  } catch {
+  }
   try {
     await client.execute({
       sql: `ALTER TABLE tasks ADD COLUMN blocked_by TEXT`,
@@ -1979,6 +2558,7 @@ var init_database = __esm({
     init_db_retry();
     init_employees();
     init_database_adapter();
+    init_memory();
     _client = null;
     _resilientClient = null;
     _walCheckpointTimer = null;
@@ -2003,12 +2583,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path5 from "path";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import path7 from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync5(SHARDS_DIR)) {
+  if (!existsSync7(SHARDS_DIR)) {
     mkdirSync2(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -2038,7 +2618,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path5.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path7.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -2049,10 +2629,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync5(path5.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync7(path7.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync5(SHARDS_DIR)) return [];
+  if (!existsSync7(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -2299,7 +2879,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path5.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path7.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -2419,6 +2999,68 @@ var init_platform_procedures = __esm({
         domain: "architecture",
         priority: "p0",
         content: "Tasks live in the DB. Intercom (tmux send-keys) is fire-and-forget \u2014 it may fail, get garbled, or arrive mid-work. Never rely on intercom for task delivery. The UserPromptSubmit hook checks the DB for new tasks on every prompt. Your operating procedures step 7 says check for next work. The daemon nudges idle agents as a speedup. If you have no tasks, you found them all."
+      },
+      // --- MCP is the ONLY data interface ---
+      {
+        title: "MCP disconnect \u2014 ask the user, never work around it",
+        domain: "workflow",
+        priority: "p0",
+        content: "If MCP tools are unavailable, disconnected, or returning connection errors: STOP. Tell the user clearly: 'MCP server is disconnected. Please run /mcp to reconnect.' Do NOT attempt workarounds \u2014 no raw Node imports, no direct DB access, no CLI hacks, no daemon socket calls. MCP is the ONLY data interface. Working around it wastes time, hits bundling issues, and bypasses the contract boundary. Ask once, wait, proceed when reconnected."
+      },
+      // --- MCP Tool Catalog (Layer 0 — every agent knows what tools exist) ---
+      {
+        title: "MCP tools \u2014 memory and search",
+        domain: "tool-use",
+        priority: "p1",
+        content: "recall_my_memory: search your own memories (semantic + FTS). ask_team_memory: search a colleague's memories by agent name. store_memory: persist a memory (decisions, summaries, context). commit_memory: high-importance memory that survives consolidation. search_everything: unified search across memories, tasks, entities, conversations. get_session_context: temporal window of memories around a timestamp. consolidate_memories: merge duplicate/related memories into insights. get_memory_cardinality: count memories per agent (health check)."
+      },
+      {
+        title: "MCP tools \u2014 task orchestration",
+        domain: "tool-use",
+        priority: "p1",
+        content: "create_task: dispatch work to an employee (auto-spawns session). The ONLY dispatch path. list_tasks: query tasks by status, assignee, project. get_task: fetch full task details by ID. update_task: change status (in_progress, done, blocked, cancelled) + add result summary. close_task: finalize a reviewed task (COO only). checkpoint_task: save progress state for crash recovery. resume_employee: re-spawn an employee session for an existing task."
+      },
+      {
+        title: "MCP tools \u2014 knowledge graph (GraphRAG)",
+        domain: "tool-use",
+        priority: "p1",
+        content: "query_relationships: find connections between entities in the knowledge graph. get_entity_neighbors: explore an entity's direct connections. get_hot_entities: find most-referenced entities (trending topics). get_graph_stats: graph health \u2014 entity/relationship counts, density. export_graph: export graph data for visualization. merge_entities: deduplicate entities (alias resolution). find_similar_trajectories: match tool-call patterns to past task solutions."
+      },
+      {
+        title: "MCP tools \u2014 identity, behavior, and decisions",
+        domain: "tool-use",
+        priority: "p1",
+        content: "get_identity: read an agent's exe.md (Layer 1 identity). update_identity: write an agent's exe.md. Identity > behavior \u2014 use for permanent rules. store_behavior: record a correction or pattern for an agent (Layer 2 expertise). list_behaviors: view an agent's active behaviors. deactivate_behavior: soft-delete a stale or conflicting behavior. store_decision: record an ADR (architectural decision record). get_decision: retrieve a past decision by query."
+      },
+      {
+        title: "MCP tools \u2014 communication and messaging",
+        domain: "tool-use",
+        priority: "p1",
+        content: "send_message: send supplementary context to another agent (NOT for actionable work \u2014 use create_task). acknowledge_messages: mark messages as read. send_whatsapp: send WhatsApp message via gateway (customer-facing alerts). query_conversations: search ingested conversations across all channels (WhatsApp, email, etc.)."
+      },
+      {
+        title: "MCP tools \u2014 wiki, documents, and content",
+        domain: "tool-use",
+        priority: "p1",
+        content: "create_wiki_page: create a wiki page in exe-wiki. list_wiki_pages: browse wiki pages. get_wiki_page: read a wiki page. update_wiki_page: edit a wiki page. ingest_document: import a file (PDF, MD, etc.) into memory as chunks. list_documents: browse ingested documents by workspace. purge_document: remove a document and its memory chunks. set_document_importance: adjust chunk importance scores. rerank_documents: re-score document relevance for a query."
+      },
+      {
+        title: "MCP tools \u2014 system, operations, and admin",
+        domain: "tool-use",
+        priority: "p1",
+        content: "get_agent_spend: token usage per agent/session (cost tracking). list_agent_sessions: view agent session history. get_session_kills: audit log of killed sessions. get_daemon_health: check exed daemon status. get_auto_wake_status: daemon auto-wake configuration. get_worker_gate: check worker deployment gates. run_memory_audit: health check \u2014 duplicates, null vectors, orphaned rows. run_consolidation: trigger sleep-time memory consolidation. cloud_sync: force a cloud sync cycle. backup_vps: trigger VPS backup."
+      },
+      {
+        title: "MCP tools \u2014 config, licensing, and team",
+        domain: "tool-use",
+        priority: "p1",
+        content: "set_agent_config: view/change per-agent runtime and model settings. list_employees: view the employee roster. add_person: add a person to the CRM contacts roster. list_people: browse CRM contacts. get_person: fetch contact details. get_license_status: check license validity. create_license: generate a new license key (admin). list_licenses: view all issued licenses. activate_license: activate a license on a device."
+      },
+      {
+        title: "MCP tools \u2014 advanced (triggers, skills, orchestration)",
+        domain: "tool-use",
+        priority: "p1",
+        content: "create_trigger: set up a scheduled recurring agent job (cron). list_triggers: view active triggers. load_skill: load a slash-command skill dynamically. apply_starter_pack: import a pre-built behavior + identity pack for a role. export_orchestration: export full org state (tasks, behaviors, identities) as portable JSON. import_orchestration: import org state into a new instance. deploy_client: deploy a customer client instance. query_company_brain: unified RAG query across all company knowledge. create_reminder: set a text reminder (shown in boot brief). list_reminders: view pending reminders. complete_reminder: mark a reminder done. global_procedure: manage Layer 0 procedures (actions: store, list, deactivate). Legacy aliases: store_global_procedure, list_global_procedures, deactivate_global_procedure."
       }
     ];
     PLATFORM_PROCEDURE_TITLES = new Set(
@@ -2435,7 +3077,7 @@ __export(global_procedures_exports, {
   loadGlobalProcedures: () => loadGlobalProcedures,
   storeGlobalProcedure: () => storeGlobalProcedure
 });
-import { randomUUID } from "crypto";
+import { randomUUID as randomUUID2 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
   const result = await client.execute({
@@ -2464,7 +3106,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input) {
-  const id = randomUUID();
+  const id = randomUUID2();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -2602,9 +3244,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import path7 from "path";
+import path9 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -2648,12 +3290,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path7.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path9.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
     mkdirSync4(CACHE_DIR, { recursive: true });
-    writeFileSync3(
+    writeFileSync4(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -2662,21 +3304,21 @@ function writeActiveAgent(agentId, agentRole) {
 }
 function clearActiveAgent() {
   try {
-    unlinkSync3(getMarkerPath());
+    unlinkSync4(getMarkerPath());
   } catch {
   }
 }
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync3(markerPath, "utf8");
+    const raw = readFileSync5(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
         const age = Date.now() - new Date(data.startedAt).getTime();
         if (age > STALE_MS) {
           try {
-            unlinkSync3(markerPath);
+            unlinkSync4(markerPath);
           } catch {
           }
         } else {
@@ -2717,14 +3359,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync3(path7.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync5(path9.join(CACHE_DIR, file), "utf8");
         const data = JSON.parse(raw);
         if (!data.agentId) continue;
         if (data.startedAt) {
           const age = Date.now() - new Date(data.startedAt).getTime();
           if (age > STALE_MS) {
             try {
-              unlinkSync3(path7.join(CACHE_DIR, file));
+              unlinkSync4(path9.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -2747,11 +3389,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync3(path7.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync4(path9.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync3(path7.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync4(path9.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -2762,16 +3404,16 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path7.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path9.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
 
 // src/lib/agent-symlinks.ts
-import os6 from "os";
-import path8 from "path";
+import os7 from "os";
+import path10 from "path";
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync9,
   lstatSync,
   mkdirSync as mkdirSync5,
   readlinkSync as readlinkSync2,
@@ -2799,14 +3441,14 @@ var init_mcp_prefix = __esm({
 });
 
 // src/lib/preferences.ts
-import { existsSync as existsSync8, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
-import path9 from "path";
-import os7 from "os";
-function loadPreferences(homeDir = os7.homedir()) {
-  const configPath = path9.join(homeDir, ".exe-os", "config.json");
-  if (!existsSync8(configPath)) return {};
+import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import path11 from "path";
+import os8 from "os";
+function loadPreferences(homeDir = os8.homedir()) {
+  const configPath = path11.join(homeDir, ".exe-os", "config.json");
+  if (!existsSync10(configPath)) return {};
   try {
-    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync6(configPath, "utf-8"));
     return config.preferences ?? {};
   } catch {
     return {};
@@ -2821,27 +3463,27 @@ var init_preferences = __esm({
 
 // src/adapters/claude/installer.ts
 import { readFile as readFile4, writeFile as writeFile4, mkdir as mkdir4, readdir } from "fs/promises";
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync5, copyFileSync, mkdirSync as mkdirSync6 } from "fs";
-import path10 from "path";
-import os8 from "os";
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync6, copyFileSync, mkdirSync as mkdirSync6 } from "fs";
+import path12 from "path";
+import os9 from "os";
 import { execSync as execSync4 } from "child_process";
-import { fileURLToPath } from "url";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function resolvePackageRoot() {
-  const thisFile = fileURLToPath(import.meta.url);
-  let dir = path10.dirname(thisFile);
-  const root = path10.parse(dir).root;
+  const thisFile = fileURLToPath2(import.meta.url);
+  let dir = path12.dirname(thisFile);
+  const root = path12.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path10.join(dir, "package.json");
-    if (existsSync9(pkgPath)) {
+    const pkgPath = path12.join(dir, "package.json");
+    if (existsSync11(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path10.dirname(dir);
+    dir = path12.dirname(dir);
   }
-  return path10.resolve(path10.dirname(thisFile), "..", "..", "..");
+  return path12.resolve(path12.dirname(thisFile), "..", "..", "..");
 }
 var EXE_SECTION_START, EXE_SECTION_END, ORCHESTRATION_RULES;
 var init_installer = __esm({
@@ -2875,19 +3517,19 @@ __export(installer_exports, {
   verifyCodexHooks: () => verifyCodexHooks
 });
 import { readFile as readFile5, writeFile as writeFile5, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync10 } from "fs";
-import path11 from "path";
-import os9 from "os";
-async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
-  const codexDir = path11.join(homeDir, ".codex");
-  const hooksPath = path11.join(codexDir, "hooks.json");
-  const logsDir = path11.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path11.join(logsDir, "hooks.log");
+import { existsSync as existsSync12 } from "fs";
+import path13 from "path";
+import os10 from "os";
+async function mergeCodexHooks(packageRoot, homeDir = os10.homedir()) {
+  const codexDir = path13.join(homeDir, ".codex");
+  const hooksPath = path13.join(codexDir, "hooks.json");
+  const logsDir = path13.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path13.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir5(codexDir, { recursive: true });
   await mkdir5(logsDir, { recursive: true });
   let hooksJson = {};
-  if (existsSync10(hooksPath)) {
+  if (existsSync12(hooksPath)) {
     try {
       hooksJson = JSON.parse(await readFile5(hooksPath, "utf-8"));
     } catch {
@@ -2904,7 +3546,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
             timeout: 30,
             statusMessage: "exe-os: loading memory brief"
           }
@@ -2919,11 +3561,11 @@ async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
           }
         ]
       },
@@ -2935,11 +3577,11 @@ async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
             timeout: 5
           }
         ]
@@ -2952,7 +3594,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -2965,7 +3607,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path11.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path13.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -2996,9 +3638,9 @@ async function mergeCodexHooks(packageRoot, homeDir = os9.homedir()) {
   await writeFile5(hooksPath, JSON.stringify(hooksJson, null, 2) + "\n");
   return { added, skipped };
 }
-function verifyCodexHooks(homeDir = os9.homedir()) {
-  const hooksPath = path11.join(homeDir, ".codex", "hooks.json");
-  if (!existsSync10(hooksPath)) return false;
+function verifyCodexHooks(homeDir = os10.homedir()) {
+  const hooksPath = path13.join(homeDir, ".codex", "hooks.json");
+  if (!existsSync12(hooksPath)) return false;
   try {
     const hooksJson = JSON.parse(
       __require("fs").readFileSync(hooksPath, "utf-8")
@@ -3018,14 +3660,14 @@ function verifyCodexHooks(homeDir = os9.homedir()) {
     return false;
   }
 }
-async function installCodexStatusLine(homeDir = os9.homedir()) {
+async function installCodexStatusLine(homeDir = os10.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.codexStatusLine === false) return "opted-out";
-  const codexDir = path11.join(homeDir, ".codex");
-  const configPath = path11.join(codexDir, "config.toml");
+  const codexDir = path13.join(homeDir, ".codex");
+  const configPath = path13.join(codexDir, "config.toml");
   await mkdir5(codexDir, { recursive: true });
   let content = "";
-  if (existsSync10(configPath)) {
+  if (existsSync12(configPath)) {
     content = await readFile5(configPath, "utf-8");
     if (/\[tui\][\s\S]*?status_line\s*=/.test(content)) {
       return "already-configured";
@@ -3073,33 +3715,34 @@ var init_installer2 = __esm({
 });
 
 // src/bin/exe-start-codex.ts
-import os10 from "os";
-import path12 from "path";
+import os11 from "os";
+import path14 from "path";
 import {
-  existsSync as existsSync11,
-  readFileSync as readFileSync6,
-  writeFileSync as writeFileSync6,
+  existsSync as existsSync13,
+  readFileSync as readFileSync8,
+  writeFileSync as writeFileSync7,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync4
 } from "fs";
 import { spawnSync } from "child_process";
 
 // src/lib/store.ts
-import { createHash } from "crypto";
+init_memory();
 init_database();
+import { createHash } from "crypto";
 
 // src/lib/keychain.ts
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
-import os4 from "os";
+import { existsSync as existsSync6 } from "fs";
+import path6 from "path";
+import os5 from "os";
 var SERVICE = "exe-mem";
 var ACCOUNT = "master-key";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(os4.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path6.join(os5.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path4.join(getKeyDir(), "master.key");
+  return path6.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -3120,9 +3763,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync4(keyPath)) {
+  if (!existsSync6(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os4.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os5.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -3251,6 +3894,11 @@ async function initStore(options) {
     encryptionKey: hexKey
   });
   await retryOnBusy2(() => ensureSchema(), "ensureSchema");
+  try {
+    const { initDaemonClient: initDaemonClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    await initDaemonClient2();
+  } catch {
+  }
   if (!options?.lightweight) {
     try {
       const { initShardManager: initShardManager2 } = await Promise.resolve().then(() => (init_shard_manager(), shard_manager_exports));
@@ -3433,24 +4081,24 @@ function vectorToBlob(vector) {
 }
 
 // src/lib/behaviors-export.ts
-import os5 from "os";
-import path6 from "path";
+import os6 from "os";
+import path8 from "path";
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync8,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
-  statSync,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync2
+  statSync as statSync2,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync3
 } from "fs";
 
 // src/lib/behaviors.ts
 init_database();
-import crypto from "crypto";
+import crypto2 from "crypto";
 async function listBehaviors(agentId, projectName, limit = 30) {
   const client = getClient();
   const result = await client.execute({
-    sql: `SELECT id, agent_id, project_name, domain, priority, content, active, created_at, updated_at
+    sql: `SELECT id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector
           FROM behaviors
           WHERE agent_id = ? AND active = 1
             AND (project_name IS NULL OR project_name = ?)
@@ -3471,20 +4119,21 @@ async function listBehaviors(agentId, projectName, limit = 30) {
     content: String(r.content),
     active: Number(r.active),
     created_at: String(r.created_at),
-    updated_at: String(r.updated_at)
+    updated_at: String(r.updated_at),
+    vector: r.vector ? Array.from(new Float32Array(r.vector)) : null
   }));
 }
 
 // src/lib/behaviors-export.ts
-var BEHAVIORS_EXPORT_DIR = path6.join(
-  os5.homedir(),
+var BEHAVIORS_EXPORT_DIR = path8.join(
+  os6.homedir(),
   ".exe-os",
   "behaviors-export"
 );
 var STALE_EXPORT_AGE_MS = 60 * 60 * 1e3;
 var EXPORT_BEHAVIOR_LIMIT = 30;
 function sweepStaleBehaviorExports(now = Date.now()) {
-  if (!existsSync6(BEHAVIORS_EXPORT_DIR)) return;
+  if (!existsSync8(BEHAVIORS_EXPORT_DIR)) return;
   let entries;
   try {
     entries = readdirSync2(BEHAVIORS_EXPORT_DIR);
@@ -3492,11 +4141,11 @@ function sweepStaleBehaviorExports(now = Date.now()) {
     return;
   }
   for (const entry of entries) {
-    const filePath = path6.join(BEHAVIORS_EXPORT_DIR, entry);
+    const filePath = path8.join(BEHAVIORS_EXPORT_DIR, entry);
     try {
-      const stat = statSync(filePath);
+      const stat = statSync2(filePath);
       if (now - stat.mtimeMs > STALE_EXPORT_AGE_MS) {
-        unlinkSync2(filePath);
+        unlinkSync3(filePath);
       }
     } catch {
     }
@@ -3525,10 +4174,10 @@ function renderBehaviorExport(behaviors) {
 }
 function exportFilePath(agentId, projectName, sessionKey) {
   if (!sessionKey) {
-    return path6.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
+    return path8.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
   }
   const safeProject = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path6.join(
+  return path8.join(
     BEHAVIORS_EXPORT_DIR,
     `${agentId}-${safeProject}-${sessionKey}.md`
   );
@@ -3540,7 +4189,7 @@ async function exportBehaviorsForAgent(agentId, projectName, sessionKey) {
   if (behaviors.length === 0) return null;
   const body = renderBehaviorExport(behaviors);
   const target = exportFilePath(agentId, projectName, sessionKey);
-  writeFileSync2(target, body, "utf-8");
+  writeFileSync3(target, body, "utf-8");
   return target;
 }
 
@@ -3557,7 +4206,7 @@ When done with a task: call update_task with status "done".
 Always call store_memory to persist important findings.
 `;
 function resolveAgent(argv) {
-  const invokedAs = path12.basename(argv[1] ?? "");
+  const invokedAs = path14.basename(argv[1] ?? "");
   if (invokedAs && invokedAs !== "exe-start-codex" && !invokedAs.endsWith(".js")) {
     const agent2 = invokedAs.replace(/-codex$/, "").toLowerCase();
     return { agent: agent2, passthrough: argv.slice(2) };
@@ -3583,24 +4232,24 @@ function resolveAgent(argv) {
   return { agent, passthrough, sessionName };
 }
 function loadIdentity(agent) {
-  const dir = path12.join(os10.homedir(), ".exe-os", "identity");
-  const exact = path12.join(dir, `${agent}.md`);
-  if (existsSync11(exact)) {
-    const content = readFileSync6(exact, "utf-8").trim();
+  const dir = path14.join(os11.homedir(), ".exe-os", "identity");
+  const exact = path14.join(dir, `${agent}.md`);
+  if (existsSync13(exact)) {
+    const content = readFileSync8(exact, "utf-8").trim();
     if (content) return content;
   }
   try {
     const files = readdirSync4(dir);
     const match = files.find((f) => f.toLowerCase() === `${agent.toLowerCase()}.md`);
     if (match) {
-      const content = readFileSync6(path12.join(dir, match), "utf-8").trim();
+      const content = readFileSync8(path14.join(dir, match), "utf-8").trim();
       if (content) return content;
     }
   } catch {
   }
   try {
-    const rosterPath = path12.join(os10.homedir(), ".exe-os", "exe-employees.json");
-    const roster = JSON.parse(readFileSync6(rosterPath, "utf8"));
+    const rosterPath = path14.join(os11.homedir(), ".exe-os", "exe-employees.json");
+    const roster = JSON.parse(readFileSync8(rosterPath, "utf8"));
     const emp = roster.find((e) => e.name.toLowerCase() === agent.toLowerCase());
     if (emp?.systemPrompt && emp.systemPrompt.trim().length > 20) {
       return emp.systemPrompt;
@@ -3610,18 +4259,18 @@ function loadIdentity(agent) {
   return null;
 }
 function writePromptFile(agent, identity, behaviorsPath) {
-  const promptDir = path12.join(os10.homedir(), ".exe-os", "codex-prompt");
+  const promptDir = path14.join(os11.homedir(), ".exe-os", "codex-prompt");
   mkdirSync7(promptDir, { recursive: true });
   let prompt = identity;
-  if (behaviorsPath && existsSync11(behaviorsPath)) {
-    const behaviors = readFileSync6(behaviorsPath, "utf-8").trim();
+  if (behaviorsPath && existsSync13(behaviorsPath)) {
+    const behaviors = readFileSync8(behaviorsPath, "utf-8").trim();
     if (behaviors) {
       prompt += "\n\n" + behaviors;
     }
   }
   prompt += "\n" + BOOT_INSTRUCTIONS;
-  const outPath = path12.join(promptDir, `${agent}.md`);
-  writeFileSync6(outPath, prompt, "utf-8");
+  const outPath = path14.join(promptDir, `${agent}.md`);
+  writeFileSync7(outPath, prompt, "utf-8");
   return outPath;
 }
 async function main() {
@@ -3700,8 +4349,8 @@ async function main() {
   process.env.EXE_RUNTIME = "codex";
   const empRole = (() => {
     try {
-      const emps = readFileSync6(
-        path12.join(os10.homedir(), ".exe-os", "exe-employees.json"),
+      const emps = readFileSync8(
+        path14.join(os11.homedir(), ".exe-os", "exe-employees.json"),
         "utf-8"
       );
       const found = JSON.parse(emps).find(
@@ -3738,14 +4387,14 @@ async function main() {
   if (WORKTREE_ROLES.has(empRole)) {
     try {
       const { execSync: es } = await import("child_process");
-      const worktreeDir = path12.join(process.cwd(), ".worktrees", worktreeName);
+      const worktreeDir = path14.join(process.cwd(), ".worktrees", worktreeName);
       const branchName = `${worktreeName}/codex-${Date.now()}`;
-      if (existsSync11(worktreeDir)) {
+      if (existsSync13(worktreeDir)) {
         worktreePath = worktreeDir;
         process.stderr.write(`[exe-start-codex] Reusing worktree at ${worktreeDir}
 `);
       } else {
-        mkdirSync7(path12.dirname(worktreeDir), { recursive: true });
+        mkdirSync7(path14.dirname(worktreeDir), { recursive: true });
         es(`git worktree add "${worktreeDir}" -b "${branchName}" HEAD`, {
           encoding: "utf-8",
           timeout: 3e4