@askexenow/exe-os 0.9.16 → 0.9.18

package/dist/lib/tmux-routing.js

@@ -327,12 +327,25 @@ async function ensurePrivateDir(dirPath) {
   } catch {
   }
 }
+function ensurePrivateDirSync(dirPath) {
+  mkdirSync2(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    chmodSync(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
 async function enforcePrivateFile(filePath) {
   try {
     await chmod(filePath, PRIVATE_FILE_MODE);
   } catch {
   }
 }
+function enforcePrivateFileSync(filePath) {
+  try {
+    if (existsSync2(filePath)) chmodSync(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
 var PRIVATE_DIR_MODE, PRIVATE_FILE_MODE;
 var init_secure_files = __esm({
   "src/lib/secure-files.ts"() {
@@ -343,6 +356,21 @@ var init_secure_files = __esm({
 });
 
 // src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
+  CONFIG_PATH: () => CONFIG_PATH,
+  CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
+  DB_PATH: () => DB_PATH,
+  EXE_AI_DIR: () => EXE_AI_DIR,
+  LEGACY_LANCE_PATH: () => LEGACY_LANCE_PATH,
+  MODELS_DIR: () => MODELS_DIR,
+  loadConfig: () => loadConfig,
+  loadConfigFrom: () => loadConfigFrom,
+  loadConfigSync: () => loadConfigSync,
+  migrateConfig: () => migrateConfig,
+  saveConfig: () => saveConfig
+});
 import { readFile, writeFile } from "fs/promises";
 import { readFileSync as readFileSync2, existsSync as existsSync3, renameSync } from "fs";
 import path2 from "path";
@@ -446,6 +474,46 @@ async function loadConfig() {
     return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
   }
 }
+function loadConfigSync() {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync3(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  }
+  try {
+    const raw = readFileSync2(configPath, "utf-8");
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  }
+}
+async function saveConfig(config) {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  await ensurePrivateDir(dir);
+  const configPath = path2.join(dir, "config.json");
+  await writeFile(configPath, JSON.stringify(config, null, 2) + "\n");
+  await enforcePrivateFile(configPath);
+}
+async function loadConfigFrom(configPath) {
+  const raw = await readFile(configPath, "utf-8");
+  try {
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    return { ...DEFAULT_CONFIG, ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
 var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
 var init_config = __esm({
   "src/lib/config.ts"() {
@@ -582,7 +650,7 @@ var init_agent_config = __esm({
     init_secure_files();
     AGENT_CONFIG_PATH = path3.join(EXE_AI_DIR, "agent-config.json");
     DEFAULT_MODELS = {
-      claude: "claude-opus-4",
+      claude: "claude-opus-4.6",
       codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
       opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
     };
@@ -814,13 +882,22 @@ var init_database_adapter = __esm({
   }
 });
 
+// src/types/memory.ts
+var EMBEDDING_DIM;
+var init_memory = __esm({
+  "src/types/memory.ts"() {
+    "use strict";
+    EMBEDDING_DIM = 1024;
+  }
+});
+
 // src/lib/database.ts
 import { createClient } from "@libsql/client";
 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") {
@@ -838,6 +915,7 @@ var init_database = __esm({
     init_db_retry();
     init_employees();
     init_database_adapter();
+    init_memory();
     _resilientClient = null;
     _daemonClient = null;
     _adapterClient = null;
@@ -1362,15 +1440,20 @@ async function createTaskCore(input) {
     const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
     const resolved = resolveExeSession2();
     if (resolved && input.projectName) {
-      const { getSessionProject: getSessionProject2 } = await Promise.resolve().then(() => (init_session_scope(), session_scope_exports));
-      const sessionProject = getSessionProject2(resolved);
-      if (sessionProject && sessionProject !== input.projectName) {
-        scopeMismatchWarning = `session/project mismatch: session "${resolved}" owns "${sessionProject}" but task targets "${input.projectName}". Routed to default scope.`;
-        process.stderr.write(`[create_task] ${scopeMismatchWarning}
-`);
-        earlySessionScope = null;
-      } else {
+      const isCoordinatorSession = !resolved.includes("-");
+      if (isCoordinatorSession) {
         earlySessionScope = resolved;
+      } else {
+        const { getSessionProject: getSessionProject2 } = await Promise.resolve().then(() => (init_session_scope(), session_scope_exports));
+        const sessionProject = getSessionProject2(resolved);
+        if (sessionProject && sessionProject !== input.projectName) {
+          scopeMismatchWarning = `session/project mismatch: session "${resolved}" owns "${sessionProject}" but task targets "${input.projectName}". Routed to default scope.`;
+          process.stderr.write(`[create_task] ${scopeMismatchWarning}
+`);
+          earlySessionScope = null;
+        } else {
+          earlySessionScope = resolved;
+        }
       }
     } else {
       earlySessionScope = resolved;
@@ -2255,6 +2338,10 @@ async function dispatchTaskToEmployee(input) {
     if (transport.isAlive(sessionName)) {
       const result = sendIntercom(sessionName);
       const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      process.stderr.write(
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+`
+      );
       return { dispatched, session: sessionName, crossProject };
     } else {
       const projectDir = input.projectDir ?? process.cwd();
@@ -2263,11 +2350,15 @@ async function dispatchTaskToEmployee(input) {
       });
       if (result.status === "failed") {
         process.stderr.write(
-          `[dispatch] Failed to spawn ${input.assignedTo}: ${result.error}
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
 `
         );
         return { dispatched: "session_missing" };
       }
+      process.stderr.write(
+        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+`
+      );
       return { dispatched: "spawned", session: result.sessionName, crossProject };
     }
   } catch {
@@ -2277,7 +2368,13 @@ async function dispatchTaskToEmployee(input) {
 function notifyTaskDone() {
   try {
     const key = getSessionKey();
-    if (key && !process.env.VITEST) notifyParentExe(key);
+    if (key && !process.env.VITEST) {
+      notifyParentExe(key);
+      process.stderr.write(
+        `[dispatch-audit] notifyTaskDone \u2192 parent coordinator (session=${key})
+`
+      );
+    }
   } catch {
   }
 }
@@ -2298,16 +2395,557 @@ var init_tasks_notify = __esm({
   }
 });
 
-// src/lib/behaviors.ts
+// src/lib/daemon-auth.ts
 import crypto4 from "crypto";
+import path14 from "path";
+import { existsSync as existsSync12, readFileSync as readFileSync10, 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 (!existsSync12(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync10(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto4.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 = path14.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import os9 from "os";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync13, unlinkSync as unlinkSync4, readFileSync as readFileSync11, openSync, closeSync, statSync } from "fs";
+import path15 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 (existsSync13(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync11(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync4(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync4(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path15.dirname(fileURLToPath(import.meta.url));
+  const { root } = path15.parse(dir);
+  while (dir !== root) {
+    if (existsSync13(path15.join(dir, "package.json"))) return dir;
+    dir = path15.dirname(dir);
+  }
+  return null;
+}
+function getAvailableMemoryGB() {
+  if (process.platform === "darwin") {
+    try {
+      const { execSync: execSync7 } = __require("child_process");
+      const vmstat = execSync7("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 os9.freemem() / (1024 * 1024 * 1024);
+    }
+  }
+  return os9.freemem() / (1024 * 1024 * 1024);
+}
+function spawnDaemon() {
+  const freeGB = getAvailableMemoryGB();
+  const totalGB = os9.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 = path15.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync13(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 = path15.join(path15.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 {
+          unlinkSync4(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock() {
+  try {
+    unlinkSync4(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 delay = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay));
+    if (await connectToSocket()) return true;
+    delay = Math.min(delay * 2, 3e3);
+  }
+  return false;
+}
+function sendRequest(texts, priority) {
+  return sendDaemonRequest({ texts, priority });
+}
+function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID2();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, timeoutMs);
+    _pending.set(id, { resolve, timer });
+    try {
+      _socket.write(JSON.stringify({ id, token, ...payload }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  const response = await sendDaemonRequest({ type: "health" }, 5e3);
+  if (response.health) {
+    return response.health;
+  }
+  return null;
+}
+function killAndRespawnDaemon() {
+  if (!acquireSpawnLock()) {
+    process.stderr.write("[exed-client] Another process is already restarting daemon \u2014 skipping\n");
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    return;
+  }
+  try {
+    process.stderr.write("[exed-client] Killing daemon for restart...\n");
+    if (existsSync13(PID_PATH)) {
+      try {
+        const pid = parseInt(readFileSync11(PID_PATH, "utf8").trim(), 10);
+        if (pid > 0) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
+        }
+      } catch {
+      }
+    }
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    try {
+      unlinkSync4(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync4(SOCKET_PATH);
+    } catch {
+    }
+    spawnDaemon();
+  } finally {
+    releaseSpawnLock();
+  }
+}
+function isDaemonTooYoung() {
+  try {
+    const stat = statSync(PID_PATH);
+    return Date.now() - stat.mtimeMs < MIN_DAEMON_AGE_MS;
+  } catch {
+    return false;
+  }
+}
+async function retryThenRestart(doRequest, label) {
+  const result = await doRequest();
+  if (!result.error) {
+    _consecutiveFailures = 0;
+    return result;
+  }
+  _consecutiveFailures++;
+  for (let i = 0; i < MAX_RETRIES_BEFORE_RESTART; i++) {
+    const delayMs = RETRY_DELAYS_MS[i] ?? 5e3;
+    process.stderr.write(`[exed-client] ${label} failed (${result.error}), retry ${i + 1}/${MAX_RETRIES_BEFORE_RESTART} in ${delayMs}ms
+`);
+    await new Promise((r) => setTimeout(r, delayMs));
+    if (!_connected) {
+      if (!await connectToSocket()) continue;
+    }
+    const retry = await doRequest();
+    if (!retry.error) {
+      _consecutiveFailures = 0;
+      return retry;
+    }
+    _consecutiveFailures++;
+  }
+  if (isDaemonTooYoung()) {
+    process.stderr.write(`[exed-client] ${label}: daemon too young (< ${MIN_DAEMON_AGE_MS / 1e3}s) \u2014 skipping restart
+`);
+    return { error: result.error };
+  }
+  process.stderr.write(`[exed-client] ${label}: ${_consecutiveFailures} consecutive failures \u2014 restarting daemon
+`);
+  killAndRespawnDaemon();
+  const start = Date.now();
+  let delay = 200;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay));
+    if (await connectToSocket()) break;
+    delay = Math.min(delay * 2, 3e3);
+  }
+  if (!_connected) return { error: "Daemon restart failed" };
+  const final = await doRequest();
+  if (!final.error) _consecutiveFailures = 0;
+  return final;
+}
+async function embedViaClient(text, priority = "high") {
+  if (!_connected && !await connectEmbedDaemon()) return null;
+  _requestCount++;
+  if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
+    const health = await pingDaemon();
+    if (!health && !isDaemonTooYoung()) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
+`);
+      killAndRespawnDaemon();
+      const start = Date.now();
+      let d = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, d));
+        if (await connectToSocket()) break;
+        d = Math.min(d * 2, 3e3);
+      }
+      if (!_connected) return null;
+    }
+  }
+  const result = await retryThenRestart(
+    () => sendRequest([text], priority),
+    "Embed"
+  );
+  return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
+}
+function disconnectClient() {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  for (const [id, entry] of _pending) {
+    clearTimeout(entry.timer);
+    _pending.delete(id);
+    entry.resolve({ error: "Client disconnected" });
+  }
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
+var init_exe_daemon_client = __esm({
+  "src/lib/exe-daemon-client.ts"() {
+    "use strict";
+    init_config();
+    init_daemon_auth();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path15.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path15.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path15.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    DAEMON_TOKEN_ENV = "EXE_DAEMON_TOKEN";
+    _socket = null;
+    _connected = false;
+    _buffer = "";
+    _requestCount = 0;
+    _consecutiveFailures = 0;
+    HEALTH_CHECK_INTERVAL = 100;
+    MAX_RETRIES_BEFORE_RESTART = 3;
+    RETRY_DELAYS_MS = [1e3, 3e3, 5e3];
+    MIN_DAEMON_AGE_MS = 3e4;
+    _pending = /* @__PURE__ */ new Map();
+    MAX_BUFFER = 1e7;
+  }
+});
+
+// src/lib/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  disposeEmbedder: () => disposeEmbedder,
+  embed: () => embed,
+  embedDirect: () => embedDirect,
+  getEmbedder: () => getEmbedder
+});
+async function getEmbedder() {
+  const ok = await connectEmbedDaemon();
+  if (!ok) {
+    throw new Error(
+      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
+    );
+  }
+}
+async function embed(text) {
+  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
+  const vector = await embedViaClient(text, priority);
+  if (!vector) {
+    throw new Error(
+      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
+    );
+  }
+  if (vector.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
+    );
+  }
+  return vector;
+}
+async function disposeEmbedder() {
+  disconnectClient();
+}
+async function embedDirect(text) {
+  const llamaCpp = await import("node-llama-cpp");
+  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { existsSync: existsSync15 } = await import("fs");
+  const path18 = await import("path");
+  const modelPath = path18.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync15(modelPath)) {
+    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
+  }
+  const llama = await llamaCpp.getLlama();
+  const model = await llama.loadModel({ modelPath });
+  const context = await model.createEmbeddingContext();
+  try {
+    const embedding = await context.getEmbeddingFor(text);
+    const vector = Array.from(embedding.vector);
+    if (vector.length !== EMBEDDING_DIM) {
+      throw new Error(
+        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
+      );
+    }
+    return vector;
+  } finally {
+    await context.dispose();
+    await model.dispose();
+  }
+}
+var init_embedder = __esm({
+  "src/lib/embedder.ts"() {
+    "use strict";
+    init_memory();
+    init_exe_daemon_client();
+  }
+});
+
+// src/lib/behaviors.ts
+import crypto5 from "crypto";
 async function storeBehavior(opts) {
   const client = getClient();
-  const id = crypto4.randomUUID();
+  const id = crypto5.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
+  let vector = null;
+  try {
+    const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+    const vec = await embed2(opts.content);
+    vector = new Float32Array(vec);
+  } catch {
+  }
   await client.execute({
-    sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
-          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
-    args: [id, opts.agentId, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", opts.content, now, now]
+    sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector)
+          VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?, ?)`,
+    args: [id, opts.agentId, opts.projectName ?? null, opts.domain ?? null, opts.priority ?? "p1", opts.content, now, now, vector ? vector.buffer : null]
   });
   return id;
 }
@@ -2331,7 +2969,7 @@ __export(skill_learning_exports, {
   storeTrajectory: () => storeTrajectory,
   sweepTrajectories: () => sweepTrajectories
 });
-import crypto5 from "crypto";
+import crypto6 from "crypto";
 async function extractTrajectory(taskId, agentId) {
   const client = getClient();
   const result = await client.execute({
@@ -2360,11 +2998,11 @@ async function extractTrajectory(taskId, agentId) {
   return signature;
 }
 function hashSignature(signature) {
-  return crypto5.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+  return crypto6.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
 }
 async function storeTrajectory(opts) {
   const client = getClient();
-  const id = crypto5.randomUUID();
+  const id = crypto6.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const signatureHash = hashSignature(opts.signature);
   await client.execute({
@@ -2629,8 +3267,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path14 from "path";
-import { writeFileSync as writeFileSync6, mkdirSync as mkdirSync5, unlinkSync as unlinkSync4 } from "fs";
+import path16 from "path";
+import { writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, unlinkSync as unlinkSync5 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -2649,14 +3287,14 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path14.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path14.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path16.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path16.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
       mkdirSync5(cacheDir, { recursive: true });
-      writeFileSync6(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+      writeFileSync7(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
     } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled" || input.status === "closed") {
       try {
-        unlinkSync4(cachePath);
+        unlinkSync5(cachePath);
       } catch {
       }
     }
@@ -3098,7 +3736,7 @@ var init_capacity_monitor = __esm({
 // src/lib/tmux-routing.ts
 var tmux_routing_exports = {};
 __export(tmux_routing_exports, {
-  acquireSpawnLock: () => acquireSpawnLock,
+  acquireSpawnLock: () => acquireSpawnLock2,
   employeeSessionName: () => employeeSessionName,
   ensureEmployee: () => ensureEmployee,
   extractRootExe: () => extractRootExe,
@@ -3114,20 +3752,20 @@ __export(tmux_routing_exports, {
   notifyParentExe: () => notifyParentExe,
   parseParentExe: () => parseParentExe,
   registerParentExe: () => registerParentExe,
-  releaseSpawnLock: () => releaseSpawnLock,
+  releaseSpawnLock: () => releaseSpawnLock2,
   resolveExeSession: () => resolveExeSession,
   sendIntercom: () => sendIntercom,
   spawnEmployee: () => spawnEmployee,
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync2, execSync as execSync6 } from "child_process";
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync12, appendFileSync, readdirSync as readdirSync3 } from "fs";
-import path15 from "path";
-import os9 from "os";
-import { fileURLToPath } from "url";
-import { unlinkSync as unlinkSync5 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6, existsSync as existsSync14, appendFileSync, readdirSync as readdirSync3 } from "fs";
+import path17 from "path";
+import os10 from "os";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { unlinkSync as unlinkSync6 } from "fs";
 function spawnLockPath(sessionName) {
-  return path15.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path17.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -3137,14 +3775,14 @@ function isProcessAlive(pid) {
     return false;
   }
 }
-function acquireSpawnLock(sessionName) {
-  if (!existsSync12(SPAWN_LOCK_DIR)) {
+function acquireSpawnLock2(sessionName) {
+  if (!existsSync14(SPAWN_LOCK_DIR)) {
     mkdirSync6(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync12(lockFile)) {
+  if (existsSync14(lockFile)) {
     try {
-      const lock = JSON.parse(readFileSync10(lockFile, "utf8"));
+      const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
       if (isProcessAlive(lock.pid) && age < 6e4) {
         return false;
@@ -3152,25 +3790,25 @@ function acquireSpawnLock(sessionName) {
     } catch {
     }
   }
-  writeFileSync7(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync8(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
-function releaseSpawnLock(sessionName) {
+function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync5(spawnLockPath(sessionName));
+    unlinkSync6(spawnLockPath(sessionName));
   } catch {
   }
 }
 function resolveBehaviorsExporterScript() {
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const scriptPath = path15.join(
-      path15.dirname(thisFile),
+    const thisFile = fileURLToPath2(import.meta.url);
+    const scriptPath = path17.join(
+      path17.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync12(scriptPath) ? scriptPath : null;
+    return existsSync14(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -3236,12 +3874,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync12(SESSION_CACHE)) {
+  if (!existsSync14(SESSION_CACHE)) {
     mkdirSync6(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync7(filePath, JSON.stringify({
+  const filePath = path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  writeFileSync8(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -3249,7 +3887,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync10(path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync12(path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -3257,8 +3895,8 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync10(
-      path15.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+    const data = JSON.parse(readFileSync12(
+      path17.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -3293,10 +3931,10 @@ function isEmployeeAlive(sessionName) {
 }
 function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive = isEmployeeAlive) {
   const base = employeeSessionName(employeeName, exeSession);
-  if (!isAlive(base) && acquireSpawnLock(base)) return 0;
+  if (!isAlive(base) && acquireSpawnLock2(base)) return 0;
   for (let i = 2; i <= maxInstances; i++) {
     const candidate = employeeSessionName(employeeName, exeSession, i);
-    if (!isAlive(candidate) && acquireSpawnLock(candidate)) return i;
+    if (!isAlive(candidate) && acquireSpawnLock2(candidate)) return i;
   }
   return null;
 }
@@ -3328,8 +3966,8 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync12(DEBOUNCE_FILE)) return {};
-    const raw = JSON.parse(readFileSync10(DEBOUNCE_FILE, "utf8"));
+    if (!existsSync14(DEBOUNCE_FILE)) return {};
+    const raw = JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
       if (typeof val === "number") {
@@ -3345,8 +3983,8 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync12(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
-    writeFileSync7(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync14(SESSION_CACHE)) mkdirSync6(SESSION_CACHE, { recursive: true });
+    writeFileSync8(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
@@ -3410,7 +4048,7 @@ function isSessionBusy(sessionName) {
 function isExeSession(sessionName) {
   const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
   const coordinatorName = getCoordinatorName();
-  return matchesBaseWithInstance(coordinatorName) || matchesBaseWithInstance("exe");
+  return matchesBaseWithInstance(coordinatorName);
 }
 function sendIntercom(targetSession) {
   const transport = getTransport();
@@ -3445,8 +4083,8 @@ function sendIntercom(targetSession) {
       try {
         const rawAgent = targetSession.split("-")[0] ?? targetSession;
         const agent = baseAgentName(rawAgent);
-        const markerPath = path15.join(SESSION_CACHE, `current-task-${agent}.json`);
-        if (existsSync12(markerPath)) {
+        const markerPath = path17.join(SESSION_CACHE, `current-task-${agent}.json`);
+        if (existsSync14(markerPath)) {
           logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
           return "debounced";
         }
@@ -3456,8 +4094,8 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path15.join(process.cwd(), "exe", agent);
-      if (existsSync12(taskDir)) {
+      const taskDir = path17.join(process.cwd(), "exe", agent);
+      if (existsSync14(taskDir)) {
         const files = readdirSync3(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
         );
@@ -3624,26 +4262,26 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path15.join(os9.homedir(), ".exe-os", "session-logs");
-  const logFile = path15.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync12(logDir)) {
+  const logDir = path17.join(os10.homedir(), ".exe-os", "session-logs");
+  const logFile = path17.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync14(logDir)) {
     mkdirSync6(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
-    const thisFile = fileURLToPath(import.meta.url);
-    const cleanupScript = path15.join(path15.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync12(cleanupScript)) {
+    const thisFile = fileURLToPath2(import.meta.url);
+    const cleanupScript = path17.join(path17.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync14(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path15.join(os9.homedir(), ".claude.json");
+    const claudeJsonPath = path17.join(os10.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync10(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -3651,17 +4289,17 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync7(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync8(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
-    const settingsDir = path15.join(os9.homedir(), ".claude", "projects");
+    const settingsDir = path17.join(os10.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path15.join(settingsDir, normalizedKey);
-    const settingsPath = path15.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path17.join(settingsDir, normalizedKey);
+    const settingsPath = path17.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync10(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -3690,7 +4328,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       perms.allow = allow;
       settings.permissions = perms;
       mkdirSync6(projSettingsDir, { recursive: true });
-      writeFileSync7(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      writeFileSync8(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
@@ -3705,8 +4343,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath = path15.join(
-      os9.homedir(),
+    const identityPath = path17.join(
+      os10.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -3715,13 +4353,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync12(identityPath)) {
+    } else if (existsSync14(identityPath)) {
       identityFlag = ` --append-system-prompt-file ${identityPath}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path15.basename(spawnCwd),
+      path17.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -3736,16 +4374,16 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path15.join(os9.homedir(), ".exe-os", "session-cache");
+    const ctxDir = path17.join(os10.homedir(), ".exe-os", "session-cache");
     mkdirSync6(ctxDir, { recursive: true });
-    const ctxFile = path15.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxFile = path17.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync7(ctxFile, ctxContent);
+    writeFileSync8(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -3819,14 +4457,14 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     command: spawnCommand
   });
   if (spawnResult.error) {
-    releaseSpawnLock(sessionName);
+    releaseSpawnLock2(sessionName);
     return { sessionName, error: `tmux new-session failed: ${spawnResult.error}` };
   }
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path15.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync7(dispatchInfo, JSON.stringify({
+    const dispatchInfo = path17.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    writeFileSync8(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
       provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
@@ -3864,7 +4502,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
   }
   if (!booted) {
-    releaseSpawnLock(sessionName);
+    releaseSpawnLock2(sessionName);
     const runtimeLabel = useExeAgent ? "exe-agent" : useCodex ? "codex" : "claude";
     return { sessionName, error: `${runtimeLabel} did not boot within 15s` };
   }
@@ -3882,7 +4520,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     pid: 0,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
   });
-  releaseSpawnLock(sessionName);
+  releaseSpawnLock2(sessionName);
   return { sessionName };
 }
 var SPAWN_LOCK_DIR, SESSION_CACHE, BEHAVIORS_EXPORT_TIMEOUT_MS, VALID_SESSION_NAME, VERIFY_PANE_LINES, INTERCOM_DEBOUNCE_MS, CODEX_DEBOUNCE_MS, INTERCOM_LOG2, DEBOUNCE_FILE, DEBOUNCE_CLEANUP_AGE_MS, BUSY_PATTERN;
@@ -3899,22 +4537,22 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path15.join(os9.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path15.join(os9.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path17.join(os10.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path17.join(os10.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
-    INTERCOM_LOG2 = path15.join(os9.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path15.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path17.join(os10.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path17.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
 });
 init_tmux_routing();
 export {
-  acquireSpawnLock,
+  acquireSpawnLock2 as acquireSpawnLock,
   employeeSessionName,
   ensureEmployee,
   extractRootExe,
@@ -3930,7 +4568,7 @@ export {
   notifyParentExe,
   parseParentExe,
   registerParentExe,
-  releaseSpawnLock,
+  releaseSpawnLock2 as releaseSpawnLock,
   resolveExeSession,
   sendIntercom,
   spawnEmployee,