@askexenow/exe-os 0.9.16 → 0.9.18

package/dist/hooks/codex-stop-task-finalizer.js

@@ -35,12 +35,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"() {
@@ -51,6 +64,21 @@ var init_secure_files = __esm({
 });
 
 // src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
+  CONFIG_PATH: () => CONFIG_PATH,
+  CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
+  DB_PATH: () => DB_PATH,
+  EXE_AI_DIR: () => EXE_AI_DIR,
+  LEGACY_LANCE_PATH: () => LEGACY_LANCE_PATH,
+  MODELS_DIR: () => MODELS_DIR,
+  loadConfig: () => loadConfig,
+  loadConfigFrom: () => loadConfigFrom,
+  loadConfigSync: () => loadConfigSync,
+  migrateConfig: () => migrateConfig,
+  saveConfig: () => saveConfig
+});
 import { readFile, writeFile } from "fs/promises";
 import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
 import path from "path";
@@ -154,6 +182,46 @@ async function loadConfig() {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
 }
+function loadConfigSync() {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  const configPath = path.join(dir, "config.json");
+  if (!existsSync2(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
+  }
+}
+async function saveConfig(config) {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  await ensurePrivateDir(dir);
+  const configPath = path.join(dir, "config.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+  await enforcePrivateFile(configPath);
+}
+async function loadConfigFrom(configPath) {
+  const raw = await readFile(configPath, "utf-8");
+  try {
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    return { ...DEFAULT_CONFIG, ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
 var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
@@ -340,9 +408,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;
   }
 });
 
@@ -930,7 +998,696 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/types/memory.ts
+var EMBEDDING_DIM;
+var init_memory = __esm({
+  "src/types/memory.ts"() {
+    "use strict";
+    EMBEDDING_DIM = 1024;
+  }
+});
+
+// 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 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 = 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" });
+    }
+  });
+}
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
+  }
+  return null;
+}
+function killAndRespawnDaemon() {
+  if (!acquireSpawnLock()) {
+    process.stderr.write("[exed-client] Another process is already restarting daemon \u2014 skipping\n");
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    return;
+  }
+  try {
+    process.stderr.write("[exed-client] Killing daemon for restart...\n");
+    if (existsSync5(PID_PATH)) {
+      try {
+        const pid = parseInt(readFileSync4(PID_PATH, "utf8").trim(), 10);
+        if (pid > 0) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    try {
+      unlinkSync2(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+    spawnDaemon();
+  } finally {
+    releaseSpawnLock();
+  }
+}
+function isDaemonTooYoung() {
+  try {
+    const stat = statSync(PID_PATH);
+    return Date.now() - stat.mtimeMs < MIN_DAEMON_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+async function retryThenRestart(doRequest, label) {
+  const result = await doRequest();
+  if (!result.error) {
+    _consecutiveFailures = 0;
+    return result;
+  }
+  _consecutiveFailures++;
+  for (let i = 0; i < MAX_RETRIES_BEFORE_RESTART; i++) {
+    const delayMs = RETRY_DELAYS_MS[i] ?? 5e3;
+    process.stderr.write(`[exed-client] ${label} failed (${result.error}), retry ${i + 1}/${MAX_RETRIES_BEFORE_RESTART} in ${delayMs}ms
+`);
+    await new Promise((r) => setTimeout(r, delayMs));
+    if (!_connected) {
+      if (!await connectToSocket()) continue;
+    }
+    const retry = await doRequest();
+    if (!retry.error) {
+      _consecutiveFailures = 0;
+      return retry;
+    }
+    _consecutiveFailures++;
+  }
+  if (isDaemonTooYoung()) {
+    process.stderr.write(`[exed-client] ${label}: daemon too young (< ${MIN_DAEMON_AGE_MS / 1e3}s) \u2014 skipping restart
+`);
+    return { error: result.error };
+  }
+  process.stderr.write(`[exed-client] ${label}: ${_consecutiveFailures} consecutive failures \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 { error: "Daemon restart failed" };
+  const final = await doRequest();
+  if (!final.error) _consecutiveFailures = 0;
+  return final;
+}
+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 && !isDaemonTooYoung()) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
+`);
+      killAndRespawnDaemon();
+      const start = Date.now();
+      let d = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, d));
+        if (await connectToSocket()) break;
+        d = Math.min(d * 2, 3e3);
+      }
+      if (!_connected) return null;
+    }
+  }
+  const result = await retryThenRestart(
+    () => sendRequest([text], priority),
+    "Embed"
+  );
+  return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
+}
+function disconnectClient() {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  for (const [id, entry] of _pending) {
+    clearTimeout(entry.timer);
+    _pending.delete(id);
+    entry.resolve({ error: "Client disconnected" });
+  }
+}
+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, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _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 = "";
+    _requestCount = 0;
+    _consecutiveFailures = 0;
+    HEALTH_CHECK_INTERVAL = 100;
+    MAX_RETRIES_BEFORE_RESTART = 3;
+    RETRY_DELAYS_MS = [1e3, 3e3, 5e3];
+    MIN_DAEMON_AGE_MS = 3e4;
+    _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) {
@@ -969,15 +1726,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") {
@@ -988,6 +1748,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.");
@@ -1126,6 +1902,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`,
@@ -1970,30 +2753,51 @@ async function ensureSchema() {
   } catch {
   }
 }
-var _client, _resilientClient, _walCheckpointTimer, _daemonClient, _adapterClient, initTurso;
+async function disposeDatabase() {
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
+  }
+}
+var _client, _resilientClient, _walCheckpointTimer, _daemonClient, _adapterClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
     init_db_retry();
     init_employees();
     init_database_adapter();
+    init_memory();
     _client = null;
     _resilientClient = null;
     _walCheckpointTimer = null;
     _daemonClient = null;
     _adapterClient = null;
     initTurso = initDatabase;
+    disposeTurso = disposeDatabase;
   }
 });
 
 // src/lib/session-registry.ts
-import path4 from "path";
-import os4 from "os";
+import path6 from "path";
+import os5 from "os";
 var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path4.join(os4.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path6.join(os5.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -2239,12 +3043,12 @@ var init_runtime_table = __esm({
 });
 
 // src/lib/agent-config.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
-import path5 from "path";
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6 } from "fs";
+import path7 from "path";
 function loadAgentConfig() {
-  if (!existsSync4(AGENT_CONFIG_PATH)) return {};
+  if (!existsSync6(AGENT_CONFIG_PATH)) return {};
   try {
-    return JSON.parse(readFileSync3(AGENT_CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync5(AGENT_CONFIG_PATH, "utf-8"));
   } catch {
     return {};
   }
@@ -2264,9 +3068,9 @@ var init_agent_config = __esm({
     init_config();
     init_runtime_table();
     init_secure_files();
-    AGENT_CONFIG_PATH = path5.join(EXE_AI_DIR, "agent-config.json");
+    AGENT_CONFIG_PATH = path7.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
-      claude: "claude-opus-4",
+      claude: "claude-opus-4.6",
       codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
       opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
     };
@@ -2282,17 +3086,17 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
-import path6 from "path";
-import os5 from "os";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, renameSync as renameSync3, existsSync as existsSync7, mkdirSync as mkdirSync2 } from "fs";
+import path8 from "path";
+import os6 from "os";
 function ensureDir() {
-  const dir = path6.dirname(QUEUE_PATH);
-  if (!existsSync5(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = path8.dirname(QUEUE_PATH);
+  if (!existsSync7(dir)) mkdirSync2(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync5(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync4(QUEUE_PATH, "utf8"));
+    if (!existsSync7(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync6(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -2300,7 +3104,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync4(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -2392,35 +3196,35 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path6.join(os5.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path8.join(os6.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path6.join(os5.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path8.join(os6.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/license.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID } from "crypto";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { randomUUID as randomUUID2 } from "crypto";
 import { createRequire as createRequire2 } from "module";
 import { pathToFileURL as pathToFileURL2 } from "url";
-import os6 from "os";
-import path7 from "path";
+import os7 from "os";
+import path9 from "path";
 import { jwtVerify, importSPKI } from "jose";
 var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path7.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path7.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path7.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path9.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path9.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path9.join(EXE_AI_DIR, "device-id");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync6, existsSync as existsSync7 } from "fs";
-import path8 from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync9 } from "fs";
+import path10 from "path";
 var CACHE_PATH2;
 var init_plan_limits = __esm({
   "src/lib/plan-limits.ts"() {
@@ -2429,15 +3233,15 @@ var init_plan_limits = __esm({
     init_employees();
     init_license();
     init_config();
-    CACHE_PATH2 = path8.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path10.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/tmux-routing.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync8, appendFileSync, readdirSync } from "fs";
-import path9 from "path";
-import os7 from "os";
-import { fileURLToPath } from "url";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, existsSync as existsSync10, appendFileSync, readdirSync } from "fs";
+import path11 from "path";
+import os8 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function getMySession() {
   return getTransport().getMySession();
 }
@@ -2449,7 +3253,7 @@ function extractRootExe(name) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync7(path9.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync9(path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -2457,8 +3261,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync7(
-      path9.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync9(
+      path11.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -2490,8 +3294,8 @@ function resolveExeSession() {
 }
 function readDebounceState() {
   try {
-    if (!existsSync8(DEBOUNCE_FILE)) return {};
-    const raw = JSON.parse(readFileSync7(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync10(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync9(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
       if (typeof val === "number") {
@@ -2507,8 +3311,8 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync8(SESSION_CACHE)) mkdirSync4(SESSION_CACHE, { recursive: true });
-    writeFileSync5(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync10(SESSION_CACHE)) mkdirSync4(SESSION_CACHE, { recursive: true });
+    writeFileSync6(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
@@ -2568,7 +3372,7 @@ function getSessionState(sessionName) {
 function isExeSession(sessionName) {
   const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
   const coordinatorName = getCoordinatorName();
-  return matchesBaseWithInstance(coordinatorName) || matchesBaseWithInstance("exe");
+  return matchesBaseWithInstance(coordinatorName);
 }
 function sendIntercom(targetSession) {
   const transport = getTransport();
@@ -2603,8 +3407,8 @@ function sendIntercom(targetSession) {
       try {
         const rawAgent = targetSession.split("-")[0] ?? targetSession;
         const agent = baseAgentName(rawAgent);
-        const markerPath = path9.join(SESSION_CACHE, `current-task-${agent}.json`);
-        if (existsSync8(markerPath)) {
+        const markerPath = path11.join(SESSION_CACHE, `current-task-${agent}.json`);
+        if (existsSync10(markerPath)) {
           logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
           return "debounced";
         }
@@ -2614,8 +3418,8 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path9.join(process.cwd(), "exe", agent);
-      if (existsSync8(taskDir)) {
+      const taskDir = path11.join(process.cwd(), "exe", agent);
+      if (existsSync10(taskDir)) {
         const files = readdirSync(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
         );
@@ -2691,12 +3495,12 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path9.join(os7.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path9.join(os7.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path11.join(os8.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path11.join(os8.homedir(), ".exe-os", "session-cache");
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
-    INTERCOM_LOG2 = path9.join(os7.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path9.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path11.join(os8.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path11.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -2736,20 +3540,20 @@ var init_task_scope = __esm({
 });
 
 // src/lib/notifications.ts
-import crypto from "crypto";
-import path10 from "path";
-import os8 from "os";
+import crypto2 from "crypto";
+import path12 from "path";
+import os9 from "os";
 import {
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync10,
   readdirSync as readdirSync2,
-  unlinkSync as unlinkSync2,
-  existsSync as existsSync9,
+  unlinkSync as unlinkSync3,
+  existsSync as existsSync11,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
   try {
     const client = getClient();
-    const id = crypto.randomUUID();
+    const id = crypto2.randomUUID();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const sessionScope = notification.sessionScope === void 0 ? getCurrentSessionScope() : notification.sessionScope;
     await client.execute({
@@ -2848,12 +3652,12 @@ var init_state_bus = __esm({
 });
 
 // src/lib/tasks-crud.ts
-import crypto2 from "crypto";
-import path11 from "path";
-import os9 from "os";
+import crypto3 from "crypto";
+import path13 from "path";
+import os10 from "os";
 import { execSync as execSync4 } from "child_process";
 import { mkdir as mkdir3, writeFile as writeFile3, appendFile } from "fs/promises";
-import { existsSync as existsSync10, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync12, readFileSync as readFileSync11 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -3199,8 +4003,8 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path12 from "path";
-import { existsSync as existsSync11, readdirSync as readdirSync3, unlinkSync as unlinkSync3 } from "fs";
+import path14 from "path";
+import { existsSync as existsSync13, readdirSync as readdirSync3, unlinkSync as unlinkSync4 } from "fs";
 async function cleanupReviewFile(row, taskFile, _baseDir) {
   if (String(row.assigned_by) !== "system" || !taskFile.includes("review-")) return;
   try {
@@ -3245,11 +4049,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path12.join(EXE_AI_DIR, "session-cache");
-    if (existsSync11(cacheDir)) {
+    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
+    if (existsSync13(cacheDir)) {
       for (const f of readdirSync3(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync3(path12.join(cacheDir, f));
+          unlinkSync4(path14.join(cacheDir, f));
         }
       }
     }
@@ -3271,7 +4075,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path13 from "path";
+import path15 from "path";
 import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -3288,7 +4092,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path13.join(baseDir, String(ur.task_file));
+        const ubFile = path15.join(baseDir, String(ur.task_file));
         let ubContent = await readFile3(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -3359,7 +4163,13 @@ var init_tasks_chain = __esm({
 function notifyTaskDone() {
   try {
     const key = getSessionKey();
-    if (key && !process.env.VITEST) notifyParentExe(key);
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
   } catch {
   }
 }
@@ -3380,16 +4190,91 @@ var init_tasks_notify = __esm({
   }
 });
 
+// src/lib/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  disposeEmbedder: () => disposeEmbedder,
+  embed: () => embed,
+  embedDirect: () => embedDirect,
+  getEmbedder: () => getEmbedder
+});
+async function getEmbedder() {
+  const ok = await connectEmbedDaemon();
+  if (!ok) {
+    throw new Error(
+      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
+    );
+  }
+}
+async function embed(text) {
+  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
+  const vector = await embedViaClient(text, priority);
+  if (!vector) {
+    throw new Error(
+      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
+    );
+  }
+  if (vector.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
+    );
+  }
+  return vector;
+}
+async function disposeEmbedder() {
+  disconnectClient();
+}
+async function embedDirect(text) {
+  const llamaCpp = await import("node-llama-cpp");
+  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { existsSync: existsSync16 } = await import("fs");
+  const path20 = await import("path");
+  const modelPath = path20.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync16(modelPath)) {
+    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
+  }
+  const llama = await llamaCpp.getLlama();
+  const model = await llama.loadModel({ modelPath });
+  const context = await model.createEmbeddingContext();
+  try {
+    const embedding = await context.getEmbeddingFor(text);
+    const vector = Array.from(embedding.vector);
+    if (vector.length !== EMBEDDING_DIM) {
+      throw new Error(
+        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
+      );
+    }
+    return vector;
+  } finally {
+    await context.dispose();
+    await model.dispose();
+  }
+}
+var init_embedder = __esm({
+  "src/lib/embedder.ts"() {
+    "use strict";
+    init_memory();
+    init_exe_daemon_client();
+  }
+});
+
 // src/lib/behaviors.ts
-import crypto3 from "crypto";
+import crypto4 from "crypto";
 async function storeBehavior(opts) {
   const client = getClient();
-  const id = crypto3.randomUUID();
+  const id = crypto4.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  let vector = null;
+  try {
+    const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+    const vec = await embed2(opts.content);
+    vector = new Float32Array(vec);
+  } catch {
+  }
   await client.execute({
-    sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
-    args: [id, opts.agentId, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", opts.content, now, now]
+    sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector)
+          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`,
+    args: [id, opts.agentId, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", opts.content, now, now, vector ? vector.buffer : null]
   });
   return id;
 }
@@ -3413,7 +4298,7 @@ __export(skill_learning_exports, {
   storeTrajectory: () => storeTrajectory,
   sweepTrajectories: () => sweepTrajectories
 });
-import crypto4 from "crypto";
+import crypto5 from "crypto";
 async function extractTrajectory(taskId, agentId) {
   const client = getClient();
   const result = await client.execute({
@@ -3442,11 +4327,11 @@ async function extractTrajectory(taskId, agentId) {
   return signature;
 }
 function hashSignature(signature) {
-  return crypto4.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+  return crypto5.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
 }
 async function storeTrajectory(opts) {
   const client = getClient();
-  const id = crypto4.randomUUID();
+  const id = crypto5.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const signatureHash = hashSignature(opts.signature);
   await client.execute({
@@ -3691,20 +4576,20 @@ var init_skill_learning = __esm({
 });
 
 // src/lib/tasks.ts
-import path14 from "path";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4 } from "fs";
+import path16 from "path";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, unlinkSync as unlinkSync5 } from "fs";
 async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path16.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
       mkdirSync5(cacheDir, { recursive: true });
-      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      writeFileSync7(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled" || input.status === "closed") {
       try {
-        unlinkSync4(cachePath);
+        unlinkSync5(cachePath);
       } catch {
       }
     }
@@ -3857,12 +4742,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path16 from "path";
-import { existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "fs";
+import path18 from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync6, readdirSync as readdirSync4 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync13(SHARDS_DIR)) {
+  if (!existsSync15(SHARDS_DIR)) {
     mkdirSync6(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -3892,7 +4777,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path16.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path18.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -3903,10 +4788,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync13(path16.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync15(path18.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync13(SHARDS_DIR)) return [];
+  if (!existsSync15(SHARDS_DIR)) return [];
   return readdirSync4(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -4153,7 +5038,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path16.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path18.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -4273,6 +5158,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(
@@ -4289,7 +5236,7 @@ __export(global_procedures_exports, {
   loadGlobalProcedures: () => loadGlobalProcedures,
   storeGlobalProcedure: () => storeGlobalProcedure
 });
-import { randomUUID as randomUUID2 } from "crypto";
+import { randomUUID as randomUUID3 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
   const result = await client.execute({
@@ -4318,7 +5265,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input) {
-  const id = randomUUID2();
+  const id = randomUUID3();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -4358,21 +5305,22 @@ init_tasks();
 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 readFile4, writeFile as writeFile5, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync12 } from "fs";
-import path15 from "path";
-import os10 from "os";
+import { existsSync as existsSync14 } from "fs";
+import path17 from "path";
+import os11 from "os";
 var SERVICE = "exe-mem";
 var ACCOUNT = "master-key";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path15.join(os10.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path17.join(os11.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path15.join(getKeyDir(), "master.key");
+  return path17.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -4393,9 +5341,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync12(keyPath)) {
+  if (!existsSync14(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os10.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os11.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -4474,6 +5422,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));
@@ -4495,7 +5448,7 @@ async function initStore(options) {
 }
 
 // src/lib/codex-stop-finalizer.ts
-import path17 from "path";
+import path19 from "path";
 var SECRET_PATH_PATTERNS = [
   /(^|\/)\.env($|\.)/i,
   /(^|\/)[^/]*credentials[^/]*(\/|$)/i,
@@ -4538,7 +5491,7 @@ function parseGitStatusPorcelainZ(output) {
 }
 function isSecretLikePath(filePath) {
   const normalized = normalizePath(filePath);
-  const basename = path17.basename(normalized);
+  const basename = path19.basename(normalized);
   if (basename === ".env" || basename.startsWith(".env.")) {
     return true;
   }