@askexenow/exe-os 0.9.16 → 0.9.18

package/dist/hooks/ingest.js

@@ -355,7 +355,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"]
     };
@@ -365,7 +365,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"
     };
@@ -710,9 +710,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;
   }
 });
 
@@ -1300,7 +1300,544 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/lib/daemon-auth.ts
+var daemon_auth_exports = {};
+__export(daemon_auth_exports, {
+  DAEMON_TOKEN_PATH: () => DAEMON_TOKEN_PATH,
+  ensureDaemonToken: () => ensureDaemonToken,
+  readDaemonToken: () => readDaemonToken
+});
+import crypto2 from "crypto";
+import path8 from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync7(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync6(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto2.randomBytes(32).toString("hex");
+  ensurePrivateDirSync(EXE_AI_DIR);
+  writeFileSync6(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 = path8.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import os5 from "os";
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync as existsSync8, unlinkSync as unlinkSync5, readFileSync as readFileSync7, openSync, closeSync, statSync } from "fs";
+import path9 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 (existsSync8(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync7(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync5(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync5(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path9.dirname(fileURLToPath(import.meta.url));
+  const { root } = path9.parse(dir);
+  while (dir !== root) {
+    if (existsSync8(path9.join(dir, "package.json"))) return dir;
+    dir = path9.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 os5.freemem() / (1024 * 1024 * 1024);
+    }
+  }
+  return os5.freemem() / (1024 * 1024 * 1024);
+}
+function spawnDaemon() {
+  const freeGB = getAvailableMemoryGB();
+  const totalGB = os5.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 = path9.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync8(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 = path9.join(path9.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 {
+          unlinkSync5(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync5(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 ?? path9.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path9.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path9.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) {
@@ -1339,15 +1876,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") {
@@ -1358,6 +1898,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.");
@@ -1496,6 +2052,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`,
@@ -2366,6 +2929,7 @@ var init_database = __esm({
     init_db_retry();
     init_employees();
     init_database_adapter();
+    init_memory();
     _client = null;
     _resilientClient = null;
     _walCheckpointTimer = null;
@@ -2378,14 +2942,14 @@ var init_database = __esm({
 
 // src/lib/keychain.ts
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
-import path8 from "path";
-import os5 from "os";
+import { existsSync as existsSync9 } from "fs";
+import path10 from "path";
+import os6 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path8.join(os5.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path10.join(os6.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path8.join(getKeyDir(), "master.key");
+  return path10.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -2406,9 +2970,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync7(keyPath)) {
+  if (!existsSync9(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os5.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os6.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -2502,12 +3066,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path9 from "path";
-import { existsSync as existsSync8, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
+import path11 from "path";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5, readdirSync as readdirSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync8(SHARDS_DIR)) {
+  if (!existsSync10(SHARDS_DIR)) {
     mkdirSync5(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -2537,7 +3101,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path9.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path11.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -2548,10 +3112,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync8(path9.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync10(path11.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync8(SHARDS_DIR)) return [];
+  if (!existsSync10(SHARDS_DIR)) return [];
   return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -2798,7 +3362,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path9.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path11.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -2918,6 +3482,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(
@@ -2934,7 +3560,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({
@@ -2963,7 +3589,7 @@ ${sections.join("\n\n")}
 `;
 }
 async function storeGlobalProcedure(input2) {
-  const id = randomUUID();
+  const id = randomUUID2();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
   await client.execute({
@@ -3067,6 +3693,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));
@@ -3588,7 +4219,7 @@ __export(git_staleness_exports, {
   recordFileRead: () => recordFileRead
 });
 import { execSync as execSync4 } from "child_process";
-import path10 from "path";
+import path12 from "path";
 function getHeadCommit(cwd) {
   try {
     return execSync4("git rev-parse --short HEAD", {
@@ -3601,9 +4232,9 @@ function getHeadCommit(cwd) {
   }
 }
 function normalizeTrackedPath(cwd, filePath) {
-  const resolved = path10.resolve(cwd, filePath);
-  const relative = path10.relative(cwd, resolved);
-  if (!relative || relative.startsWith("..") || path10.isAbsolute(relative)) {
+  const resolved = path12.resolve(cwd, filePath);
+  const relative = path12.relative(cwd, resolved);
+  if (!relative || relative.startsWith("..") || path12.isAbsolute(relative)) {
     return null;
   }
   return relative;
@@ -3722,8 +4353,8 @@ function findContainingChunk(filePath, snippet) {
   try {
     const ext = filePath.split(".").pop()?.toLowerCase();
     if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const { readFileSync: readFileSync8 } = __require("fs");
-    const source = readFileSync8(filePath, "utf8");
+    const { readFileSync: readFileSync9 } = __require("fs");
+    const source = readFileSync9(filePath, "utf8");
     const lines = source.split("\n");
     const lowerSnippet = snippet.toLowerCase().slice(0, 80);
     let matchLine = -1;
@@ -3789,9 +4420,9 @@ function extractBash(input2, response) {
 }
 function extractGrep(input2, response) {
   const pattern = String(input2.pattern ?? "");
-  const path14 = input2.path ? String(input2.path) : "";
+  const path15 = input2.path ? String(input2.path) : "";
   const output = String(response.text ?? response.content ?? JSON.stringify(response).slice(0, MAX_OUTPUT));
-  return `Searched for "${pattern}"${path14 ? ` in ${path14}` : ""}
+  return `Searched for "${pattern}"${path15 ? ` in ${path15}` : ""}
 ${output.slice(0, MAX_OUTPUT)}`;
 }
 function extractGlob(input2, response) {
@@ -3892,7 +4523,7 @@ __export(project_name_exports, {
   getProjectName: () => getProjectName
 });
 import { execSync as execSync5 } from "child_process";
-import path11 from "path";
+import path13 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -3905,7 +4536,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path11.dirname(gitCommonDir);
+      repoRoot = path13.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync5("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -3914,11 +4545,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path11.basename(repoRoot);
+    _cached2 = path13.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path11.basename(dir);
+    _cached2 = path13.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -3936,56 +4567,13 @@ var init_project_name = __esm({
   }
 });
 
-// src/lib/daemon-auth.ts
-var daemon_auth_exports = {};
-__export(daemon_auth_exports, {
-  DAEMON_TOKEN_PATH: () => DAEMON_TOKEN_PATH,
-  ensureDaemonToken: () => ensureDaemonToken,
-  readDaemonToken: () => readDaemonToken
-});
-import crypto2 from "crypto";
-import path12 from "path";
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync6 } from "fs";
-function normalizeToken(token) {
-  if (!token) return null;
-  const trimmed = token.trim();
-  return trimmed.length > 0 ? trimmed : null;
-}
-function readDaemonToken() {
-  try {
-    if (!existsSync9(DAEMON_TOKEN_PATH)) return null;
-    return normalizeToken(readFileSync6(DAEMON_TOKEN_PATH, "utf8"));
-  } catch {
-    return null;
-  }
-}
-function ensureDaemonToken(seed) {
-  const existing = readDaemonToken();
-  if (existing) return existing;
-  const token = normalizeToken(seed) ?? crypto2.randomBytes(32).toString("hex");
-  ensurePrivateDirSync(EXE_AI_DIR);
-  writeFileSync6(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 = path12.join(EXE_AI_DIR, "exed.token");
-  }
-});
-
 // src/adapters/claude/hooks/ingest.ts
 init_config();
 init_config();
-import { spawn } from "child_process";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync10, openSync, closeSync } from "fs";
-import path13 from "path";
-import { fileURLToPath } from "url";
+import { spawn as spawn2 } from "child_process";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync11, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import path14 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/lib/active-agent.ts
 init_config();
@@ -4379,10 +4967,10 @@ if (!loadConfigSync().autoIngestion) {
 if (!process.env.EXE_OS_DIR) {
   process.env.EXE_OS_DIR = EXE_AI_DIR;
 }
-var WORKER_LOG_PATH = path13.join(EXE_AI_DIR, "workers.log");
+var WORKER_LOG_PATH = path14.join(EXE_AI_DIR, "workers.log");
 function openWorkerLog() {
   try {
-    return openSync(WORKER_LOG_PATH, "a");
+    return openSync2(WORKER_LOG_PATH, "a");
   } catch {
     return "ignore";
   }
@@ -4391,13 +4979,13 @@ var ALLOWED_TOOL_RE = /^(Bash|Edit|Write|Read|Glob|Grep|Agent|apply_patch|mcp__.
 var WRITE_TOOL_RE = /^(Bash|Edit|Write|apply_patch)$/;
 var SUMMARY_INTERVAL = 25;
 var MIN_WRITES_FOR_SUMMARY = 3;
-var COUNTER_DIR = path13.join(EXE_AI_DIR, "session-cache");
+var COUNTER_DIR = path14.join(EXE_AI_DIR, "session-cache");
 function getCounterPath(sessionId) {
-  return path13.join(COUNTER_DIR, `counter-${sessionId}.json`);
+  return path14.join(COUNTER_DIR, `counter-${sessionId}.json`);
 }
 function loadCounter(sessionId) {
   try {
-    const raw = readFileSync7(getCounterPath(sessionId), "utf8");
+    const raw = readFileSync8(getCounterPath(sessionId), "utf8");
     return JSON.parse(raw);
   } catch {
     return { total: 0, writes: 0, pipelineWrites: 0, lastSummaryAt: 0, pipelineDetected: false };
@@ -4422,8 +5010,8 @@ process.stdin.on("end", async () => {
   try {
     if (process.env.EXE_DEBUG_HOOKS) {
       try {
-        const debugPath = path13.join(EXE_AI_DIR, "logs", "hook-stdin-ingest.log");
-        mkdirSync6(path13.dirname(debugPath), { recursive: true });
+        const debugPath = path14.join(EXE_AI_DIR, "logs", "hook-stdin-ingest.log");
+        mkdirSync6(path14.dirname(debugPath), { recursive: true });
         const ts = (/* @__PURE__ */ new Date()).toISOString();
         const snippet = input.length > 2e3 ? input.slice(0, 2e3) + "...[truncated]" : input;
         writeFileSync7(debugPath, `[${ts}] ${snippet}
@@ -4511,14 +5099,14 @@ Your output files must start with: exe/output/${agent.agentId}-`
       const classification = classifyError(errorText);
       if (classification === "system" && data.session_id) {
         const fp = errorFingerprint(data.tool_name, errorText);
-        const fpFilePath = path13.join(COUNTER_DIR, `bug-fingerprints-${data.session_id}.json`);
+        const fpFilePath = path14.join(COUNTER_DIR, `bug-fingerprints-${data.session_id}.json`);
         let fpData = {
           seen: {},
           taskCount: 0,
           lastTaskAt: ""
         };
         try {
-          fpData = JSON.parse(readFileSync7(fpFilePath, "utf8"));
+          fpData = JSON.parse(readFileSync8(fpFilePath, "utf8"));
         } catch {
         }
         const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -4536,15 +5124,15 @@ Your output files must start with: exe/output/${agent.agentId}-`
           fpData.seen[fp] = { count: 1, firstAt: now, lastAt: now };
           fpData.taskCount++;
           fpData.lastTaskAt = now;
-          const bugWorkerPath = path13.resolve(
-            path13.dirname(fileURLToPath(import.meta.url)),
+          const bugWorkerPath = path14.resolve(
+            path14.dirname(fileURLToPath2(import.meta.url)),
             "bug-report-worker.js"
           );
-          if (existsSync10(bugWorkerPath) && tryAcquireWorkerSlot()) {
+          if (existsSync11(bugWorkerPath) && tryAcquireWorkerSlot()) {
             const stderrFd2 = openWorkerLog();
-            const projectName = process.cwd().split(path13.sep).pop() ?? "unknown";
+            const projectName = process.cwd().split(path14.sep).pop() ?? "unknown";
             const bugToolInput = data.tool_input ?? {};
-            const bugWorker = spawn(process.execPath, [bugWorkerPath], {
+            const bugWorker = spawn2(process.execPath, [bugWorkerPath], {
               detached: true,
               stdio: ["ignore", "ignore", stderrFd2],
               env: {
@@ -4561,7 +5149,7 @@ Your output files must start with: exe/output/${agent.agentId}-`
             if (bugWorker.pid) registerWorkerPid(bugWorker.pid);
             bugWorker.unref();
             if (typeof stderrFd2 === "number") try {
-              closeSync(stderrFd2);
+              closeSync2(stderrFd2);
             } catch {
             }
           } else {
@@ -4588,13 +5176,13 @@ Your output files must start with: exe/output/${agent.agentId}-`
       }
       const callsSinceLastSummary = counter.total - counter.lastSummaryAt;
       if (callsSinceLastSummary >= SUMMARY_INTERVAL && counter.writes >= MIN_WRITES_FOR_SUMMARY) {
-        const summaryWorkerPath = path13.resolve(
-          path13.dirname(fileURLToPath(import.meta.url)),
+        const summaryWorkerPath = path14.resolve(
+          path14.dirname(fileURLToPath2(import.meta.url)),
           "summary-worker.js"
         );
-        if (existsSync10(summaryWorkerPath) && tryAcquireWorkerSlot()) {
+        if (existsSync11(summaryWorkerPath) && tryAcquireWorkerSlot()) {
           const stderrFd2 = openWorkerLog();
-          const summaryWorker = spawn(process.execPath, [summaryWorkerPath], {
+          const summaryWorker = spawn2(process.execPath, [summaryWorkerPath], {
             detached: true,
             stdio: ["ignore", "ignore", stderrFd2],
             env: {
@@ -4609,7 +5197,7 @@ Your output files must start with: exe/output/${agent.agentId}-`
           if (summaryWorker.pid) registerWorkerPid(summaryWorker.pid);
           summaryWorker.unref();
           if (typeof stderrFd2 === "number") try {
-            closeSync(stderrFd2);
+            closeSync2(stderrFd2);
           } catch {
           }
         } else {
@@ -4638,14 +5226,14 @@ WARNING: You are writing code without running the build pipeline. If this task a
       const bashOutput = typeof data.tool_response === "string" ? data.tool_response : JSON.stringify(data.tool_response ?? "");
       const commitMatch = bashOutput.match(/\[(\S+)\s+([a-f0-9]{7,40})\]\s+(.+)/);
       if (commitMatch) {
-        const commitWorkerPath = path13.resolve(
-          path13.dirname(fileURLToPath(import.meta.url)),
+        const commitWorkerPath = path14.resolve(
+          path14.dirname(fileURLToPath2(import.meta.url)),
           "commit-complete.js"
         );
-        if (existsSync10(commitWorkerPath) && tryAcquireWorkerSlot()) {
+        if (existsSync11(commitWorkerPath) && tryAcquireWorkerSlot()) {
           const stderrFd2 = openWorkerLog();
-          const projectName = process.cwd().split(path13.sep).pop() ?? "unknown";
-          const commitWorker = spawn(process.execPath, [commitWorkerPath], {
+          const projectName = process.cwd().split(path14.sep).pop() ?? "unknown";
+          const commitWorker = spawn2(process.execPath, [commitWorkerPath], {
             detached: true,
             stdio: ["ignore", "ignore", stderrFd2],
             env: {
@@ -4659,7 +5247,7 @@ WARNING: You are writing code without running the build pipeline. If this task a
           if (commitWorker.pid) registerWorkerPid(commitWorker.pid);
           commitWorker.unref();
           if (typeof stderrFd2 === "number") try {
-            closeSync(stderrFd2);
+            closeSync2(stderrFd2);
           } catch {
           }
         }
@@ -4670,8 +5258,8 @@ WARNING: You are writing code without running the build pipeline. If this task a
     }
     let sentViaDaemon = false;
     try {
-      const socketPath = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path13.join(EXE_AI_DIR, "exed.sock");
-      if (existsSync10(socketPath)) {
+      const socketPath = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path14.join(EXE_AI_DIR, "exed.sock");
+      if (existsSync11(socketPath)) {
         const { extractSemanticText: extractSemanticText2 } = await Promise.resolve().then(() => (init_content_extractor(), content_extractor_exports));
         const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
         const { canCoordinate: canCoordinate2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
@@ -4680,9 +5268,9 @@ WARNING: You are writing code without running the build pipeline. If this task a
         if (rawText.length >= 50) {
           let taskId = null;
           try {
-            const cachePath = path13.join(EXE_AI_DIR, "session-cache", `current-task-${agent.agentId}.json`);
-            if (existsSync10(cachePath)) {
-              const cached = JSON.parse(readFileSync7(cachePath, "utf8"));
+            const cachePath = path14.join(EXE_AI_DIR, "session-cache", `current-task-${agent.agentId}.json`);
+            if (existsSync11(cachePath)) {
+              const cached = JSON.parse(readFileSync8(cachePath, "utf8"));
               taskId = cached.taskId ?? null;
             }
           } catch {
@@ -4710,8 +5298,8 @@ WARNING: You are writing code without running the build pipeline. If this task a
             draft: isDraft,
             trajectory: { input: toolInputStr, tool: data.tool_name, output: toolOutputStr, result_type: hasError ? "error" : "success" }
           }) + "\n";
-          const net = await import("net");
-          const sock = net.connect(socketPath);
+          const net2 = await import("net");
+          const sock = net2.connect(socketPath);
           sock.on("error", () => {
           });
           sock.write(payload, () => {
@@ -4728,8 +5316,8 @@ WARNING: You are writing code without running the build pipeline. If this task a
       setTimeout(() => process.exit(0), 10);
       return;
     }
-    const workerPath = path13.resolve(
-      path13.dirname(fileURLToPath(import.meta.url)),
+    const workerPath = path14.resolve(
+      path14.dirname(fileURLToPath2(import.meta.url)),
       "ingest-worker.js"
     );
     if (!tryAcquireWorkerSlot()) {
@@ -4737,7 +5325,7 @@ WARNING: You are writing code without running the build pipeline. If this task a
       process.exit(0);
     }
     const stderrFd = openWorkerLog();
-    const worker = spawn(process.execPath, [workerPath], {
+    const worker = spawn2(process.execPath, [workerPath], {
       detached: true,
       stdio: ["pipe", "ignore", stderrFd],
       env: { ...process.env, AGENT_ID: agent.agentId, AGENT_ROLE: agent.agentRole }
@@ -4747,7 +5335,7 @@ WARNING: You are writing code without running the build pipeline. If this task a
     worker.stdin.end();
     worker.unref();
     if (typeof stderrFd === "number") try {
-      closeSync(stderrFd);
+      closeSync2(stderrFd);
     } catch {
     }
   } catch {