@askexenow/exe-os 0.9.16 → 0.9.18

package/dist/bin/exe-launch-agent.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;
   }
 });
 
@@ -392,7 +401,7 @@ var init_agent_config = __esm({
     init_secure_files();
     AGENT_CONFIG_PATH = path2.join(EXE_AI_DIR, "agent-config.json");
     KNOWN_RUNTIMES = {
-      claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-4.5"],
+      claude: ["claude-opus-4.6", "claude-opus-4", "claude-sonnet-4.6", "claude-sonnet-4", "claude-haiku-4.5"],
       codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
       opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
     };
@@ -402,7 +411,7 @@ var init_agent_config = __esm({
       opencode: "OpenCode (open source)"
     };
     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"
     };
@@ -1249,7 +1258,538 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/lib/daemon-auth.ts
+import crypto from "crypto";
+import path5 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync5(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync4(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);
+  writeFileSync3(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 = path5.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 existsSync6, unlinkSync as unlinkSync2, readFileSync as readFileSync5, openSync, closeSync, statSync } from "fs";
+import path6 from "path";
+import { fileURLToPath } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const id = response.id;
+      if (!id) continue;
+      const entry = _pending.get(id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync6(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync2(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path6.dirname(fileURLToPath(import.meta.url));
+  const { root } = path6.parse(dir);
+  while (dir !== root) {
+    if (existsSync6(path6.join(dir, "package.json"))) return dir;
+    dir = path6.dirname(dir);
+  }
+  return null;
+}
+function getAvailableMemoryGB() {
+  if (process.platform === "darwin") {
+    try {
+      const { execSync: execSync6 } = __require("child_process");
+      const vmstat = execSync6("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 = path6.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync6(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path6.join(path6.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const 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 ?? path6.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path6.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path6.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    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) {
@@ -1288,15 +1828,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") {
@@ -1307,6 +1850,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.");
@@ -1445,6 +2004,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`,
@@ -2315,6 +2881,7 @@ var init_database = __esm({
     init_db_retry();
     init_employees();
     init_database_adapter();
+    init_memory();
     _client = null;
     _resilientClient = null;
     _walCheckpointTimer = null;
@@ -2339,12 +2906,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path6 from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import path8 from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync6(SHARDS_DIR)) {
+  if (!existsSync8(SHARDS_DIR)) {
     mkdirSync2(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -2374,7 +2941,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path6.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path8.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -2385,10 +2952,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync6(path6.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync8(path8.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync6(SHARDS_DIR)) return [];
+  if (!existsSync8(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -2635,7 +3202,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path6.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path8.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -2755,6 +3322,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(
@@ -2771,7 +3400,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({
@@ -2800,7 +3429,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({
@@ -3529,9 +4158,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, unlinkSync as unlinkSync4, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync4 } from "child_process";
-import path8 from "path";
+import path10 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -3575,12 +4204,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path8.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path10.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
     mkdirSync4(CACHE_DIR, { recursive: true });
-    writeFileSync4(
+    writeFileSync5(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -3589,21 +4218,21 @@ function writeActiveAgent(agentId, agentRole) {
 }
 function clearActiveAgent() {
   try {
-    unlinkSync3(getMarkerPath());
+    unlinkSync4(getMarkerPath());
   } catch {
   }
 }
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync4(markerPath, "utf8");
+    const raw = readFileSync6(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 {
@@ -3644,14 +4273,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync4(path8.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync6(path10.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(path8.join(CACHE_DIR, file));
+              unlinkSync4(path10.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -3674,11 +4303,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync3(path8.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync4(path10.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync3(path8.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync4(path10.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -3689,33 +4318,34 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path8.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path10.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
 
 // src/bin/exe-launch-agent.ts
-import os6 from "os";
-import path9 from "path";
-import { existsSync as existsSync8, readFileSync as readFileSync5, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5, readdirSync as readdirSync4 } from "fs";
+import os7 from "os";
+import path11 from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, 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 existsSync5 } from "fs";
-import path5 from "path";
-import os4 from "os";
+import { existsSync as existsSync7 } from "fs";
+import path7 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 ?? path5.join(os4.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path7.join(os5.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path5.join(getKeyDir(), "master.key");
+  return path7.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -3736,9 +4366,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync5(keyPath)) {
+  if (!existsSync7(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;
@@ -3867,6 +4497,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));
@@ -4049,24 +4684,24 @@ function vectorToBlob(vector) {
 }
 
 // src/lib/behaviors-export.ts
-import os5 from "os";
-import path7 from "path";
+import os6 from "os";
+import path9 from "path";
 import {
-  existsSync as existsSync7,
+  existsSync as existsSync9,
   mkdirSync as mkdirSync3,
   readdirSync as readdirSync2,
-  statSync,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  statSync as statSync2,
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
 } 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 = ?)
@@ -4087,20 +4722,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 = path7.join(
-  os5.homedir(),
+var BEHAVIORS_EXPORT_DIR = path9.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 (!existsSync7(BEHAVIORS_EXPORT_DIR)) return;
+  if (!existsSync9(BEHAVIORS_EXPORT_DIR)) return;
   let entries;
   try {
     entries = readdirSync2(BEHAVIORS_EXPORT_DIR);
@@ -4108,11 +4744,11 @@ function sweepStaleBehaviorExports(now = Date.now()) {
     return;
   }
   for (const entry of entries) {
-    const filePath = path7.join(BEHAVIORS_EXPORT_DIR, entry);
+    const filePath = path9.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 {
     }
@@ -4141,10 +4777,10 @@ function renderBehaviorExport(behaviors) {
 }
 function exportFilePath(agentId, projectName, sessionKey) {
   if (!sessionKey) {
-    return path7.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
+    return path9.join(BEHAVIORS_EXPORT_DIR, `${agentId}.md`);
   }
   const safeProject = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return path7.join(
+  return path9.join(
     BEHAVIORS_EXPORT_DIR,
     `${agentId}-${safeProject}-${sessionKey}.md`
   );
@@ -4156,7 +4792,7 @@ async function exportBehaviorsForAgent(agentId, projectName, sessionKey) {
   if (behaviors.length === 0) return null;
   const body = renderBehaviorExport(behaviors);
   const target = exportFilePath(agentId, projectName, sessionKey);
-  writeFileSync3(target, body, "utf-8");
+  writeFileSync4(target, body, "utf-8");
   return target;
 }
 
@@ -4215,7 +4851,7 @@ function parseBasename(basename) {
   return { agent, provider };
 }
 function resolveAgent(argv) {
-  const invokedAs = path9.basename(argv[1] ?? "");
+  const invokedAs = path11.basename(argv[1] ?? "");
   if (invokedAs && invokedAs !== "exe-launch-agent" && !invokedAs.endsWith(".js")) {
     const { agent: agent2, provider } = parseBasename(invokedAs.toLowerCase());
     return { agent: agent2, provider, passthrough: argv.slice(2) };
@@ -4244,20 +4880,20 @@ async function isKnownAgent(agent) {
   }
 }
 function identityPathFor(agent) {
-  const dir = path9.join(os6.homedir(), ".exe-os", "identity");
-  const exactPath = path9.join(dir, `${agent}.md`);
-  if (existsSync8(exactPath)) return exactPath;
+  const dir = path11.join(os7.homedir(), ".exe-os", "identity");
+  const exactPath = path11.join(dir, `${agent}.md`);
+  if (existsSync10(exactPath)) return exactPath;
   try {
     const files = readdirSync4(dir);
     const match = files.find((f) => f.toLowerCase() === `${agent.toLowerCase()}.md`);
-    if (match) return path9.join(dir, match);
+    if (match) return path11.join(dir, match);
   } catch {
   }
   return exactPath;
 }
 function leanMcpConfigFor(agent) {
-  const p = path9.join(os6.homedir(), ".exe-os", "mcp-configs", `${agent}-lean.json`);
-  return existsSync8(p) ? p : null;
+  const p = path11.join(os7.homedir(), ".exe-os", "mcp-configs", `${agent}-lean.json`);
+  return existsSync10(p) ? p : null;
 }
 var _ccHelpOutput = null;
 function getCcHelpOutput() {
@@ -4280,39 +4916,39 @@ function _resetCcHelpCache() {
 function buildLaunchPlan(agent, behaviorsPath, passthrough, _hasAgentFlag, _provider) {
   const args = ["--dangerously-skip-permissions"];
   const idPath = identityPathFor(agent);
-  const ccAgentPath = path9.join(os6.homedir(), ".claude", "agents", `${agent}.md`);
+  const ccAgentPath = path11.join(os7.homedir(), ".claude", "agents", `${agent}.md`);
   let effectiveCcPath = null;
-  if (existsSync8(ccAgentPath)) {
+  if (existsSync10(ccAgentPath)) {
     effectiveCcPath = ccAgentPath;
   } else {
     try {
-      const ccAgentDir = path9.join(os6.homedir(), ".claude", "agents");
+      const ccAgentDir = path11.join(os7.homedir(), ".claude", "agents");
       const ccFiles = readdirSync4(ccAgentDir);
       const ccMatch = ccFiles.find((f) => f.toLowerCase() === `${agent.toLowerCase()}.md`);
-      if (ccMatch) effectiveCcPath = path9.join(ccAgentDir, ccMatch);
+      if (ccMatch) effectiveCcPath = path11.join(ccAgentDir, ccMatch);
     } catch {
     }
   }
-  const effectiveIdPath = existsSync8(idPath) ? idPath : effectiveCcPath;
+  const effectiveIdPath = existsSync10(idPath) ? idPath : effectiveCcPath;
   let identityContent = null;
-  if (effectiveIdPath && existsSync8(effectiveIdPath)) {
+  if (effectiveIdPath && existsSync10(effectiveIdPath)) {
     try {
-      const content = readFileSync5(effectiveIdPath, "utf-8");
+      const content = readFileSync7(effectiveIdPath, "utf-8");
       if (content.trim().length > 0) identityContent = content;
     } catch {
     }
   }
   if (!identityContent) {
     try {
-      const rosterPath = path9.join(os6.homedir(), ".exe-os", "exe-employees.json");
-      if (existsSync8(rosterPath)) {
-        const roster = JSON.parse(readFileSync5(rosterPath, "utf8"));
+      const rosterPath = path11.join(os7.homedir(), ".exe-os", "exe-employees.json");
+      if (existsSync10(rosterPath)) {
+        const roster = JSON.parse(readFileSync7(rosterPath, "utf8"));
         const emp = roster.find((e) => e.name.toLowerCase() === agent.toLowerCase());
         if (emp?.systemPrompt && emp.systemPrompt.trim().length > 20) {
           identityContent = emp.systemPrompt;
           try {
-            const dir = path9.dirname(idPath);
-            if (!existsSync8(dir)) mkdirSync5(dir, { recursive: true });
+            const dir = path11.dirname(idPath);
+            if (!existsSync10(dir)) mkdirSync5(dir, { recursive: true });
             const hasFrontmatter = identityContent.trimStart().startsWith("---");
             const fileContent = hasFrontmatter ? identityContent : `---
 role: ${(emp.role ?? "employee").toLowerCase()}
@@ -4324,7 +4960,7 @@ updated_at: ${(/* @__PURE__ */ new Date()).toISOString()}
 ---
 
 ${identityContent}`;
-            writeFileSync5(idPath, fileContent, "utf-8");
+            writeFileSync6(idPath, fileContent, "utf-8");
             identityContent = fileContent;
             process.stderr.write(`[exe-launch-agent] self-healed missing identity file: ${idPath}
 `);
@@ -4352,15 +4988,15 @@ ${identityContent}`;
       args.push("--system-prompt", getSessionPrompt(identityContent));
     } else {
       try {
-        const tmpPath = path9.join(os6.homedir(), ".exe-os", "session-cache", `${agent}-identity.md`);
-        mkdirSync5(path9.dirname(tmpPath), { recursive: true });
-        writeFileSync5(tmpPath, identityContent, "utf-8");
+        const tmpPath = path11.join(os7.homedir(), ".exe-os", "session-cache", `${agent}-identity.md`);
+        mkdirSync5(path11.dirname(tmpPath), { recursive: true });
+        writeFileSync6(tmpPath, identityContent, "utf-8");
         args.push("--append-system-prompt-file", tmpPath);
       } catch {
       }
     }
   }
-  if (behaviorsPath && existsSync8(behaviorsPath)) {
+  if (behaviorsPath && existsSync10(behaviorsPath)) {
     args.push("--append-system-prompt-file", behaviorsPath);
   }
   const leanMcp = leanMcpConfigFor(agent);
@@ -4481,28 +5117,28 @@ async function main() {
   _resetCcAgentSupportCache();
   const hasAgentFlag = claudeSupportsAgentFlag();
   if (hasAgentFlag) {
-    const ccAgentDir = path9.join(os6.homedir(), ".claude", "agents");
-    const ccAgentFile = path9.join(ccAgentDir, `${agent}.md`);
-    if (!existsSync8(ccAgentFile)) {
+    const ccAgentDir = path11.join(os7.homedir(), ".claude", "agents");
+    const ccAgentFile = path11.join(ccAgentDir, `${agent}.md`);
+    if (!existsSync10(ccAgentFile)) {
       const exeIdentity = identityPathFor(agent);
       let sourceFile = null;
-      if (existsSync8(exeIdentity)) {
+      if (existsSync10(exeIdentity)) {
         sourceFile = exeIdentity;
       } else {
         try {
-          const identityDir = path9.dirname(exeIdentity);
+          const identityDir = path11.dirname(exeIdentity);
           const files = readdirSync4(identityDir);
           const match = files.find((f) => f.toLowerCase() === `${agent.toLowerCase()}.md`);
-          if (match) sourceFile = path9.join(identityDir, match);
+          if (match) sourceFile = path11.join(identityDir, match);
         } catch {
         }
       }
       if (sourceFile) {
         try {
           mkdirSync5(ccAgentDir, { recursive: true });
-          let content = readFileSync5(sourceFile, "utf-8");
+          let content = readFileSync7(sourceFile, "utf-8");
           content = content.replace(/\$\{agent_id\}/g, baseAgentName(agent));
-          writeFileSync5(ccAgentFile, content, "utf-8");
+          writeFileSync6(ccAgentFile, content, "utf-8");
           process.stderr.write(
             `[exe-launch-agent] auto-provisioned ${ccAgentFile} from ${sourceFile}
 `
@@ -4522,7 +5158,7 @@ async function main() {
   const empRole = (() => {
     try {
       const emps = __require("fs").readFileSync(
-        path9.join(os6.homedir(), ".exe-os", "exe-employees.json"),
+        path11.join(os7.homedir(), ".exe-os", "exe-employees.json"),
         "utf-8"
       );
       const found = JSON.parse(emps).find(