@askexenow/exe-os 0.9.6 → 0.9.8

package/dist/mcp/server.js

@@ -531,98 +531,132 @@ async function pingDaemon() {
   return null;
 }
 function killAndRespawnDaemon() {
-  process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync2(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
+  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 (existsSync2(PID_PATH)) {
+      try {
+        const pid = parseInt(readFileSync2(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 {
+      unlinkSync(PID_PATH);
     } catch {
     }
+    try {
+      unlinkSync(SOCKET_PATH);
+    } catch {
+    }
+    spawnDaemon();
+  } finally {
+    releaseSpawnLock();
   }
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
-  }
-  _connected = false;
-  _buffer = "";
+}
+function isDaemonTooYoung() {
   try {
-    unlinkSync(PID_PATH);
+    const stat = statSync(PID_PATH);
+    return Date.now() - stat.mtimeMs < MIN_DAEMON_AGE_MS;
   } catch {
+    return false;
   }
-  try {
-    unlinkSync(SOCKET_PATH);
-  } catch {
+}
+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 };
   }
-  spawnDaemon();
+  process.stderr.write(`[exed-client] ${label}: ${_consecutiveFailures} consecutive failures \u2014 restarting daemon
+`);
+  killAndRespawnDaemon();
+  const start = Date.now();
+  let delay2 = 200;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay2));
+    if (await connectToSocket()) break;
+    delay2 = Math.min(delay2 * 2, 3e3);
+  }
+  if (!_connected) return { error: "Daemon restart failed" };
+  const final = await doRequest();
+  if (!final.error) _consecutiveFailures = 0;
+  return final;
 }
 async function embedViaClient(text, priority = "high") {
   if (!_connected && !await connectEmbedDaemon()) return null;
   _requestCount++;
   if (_requestCount % HEALTH_CHECK_INTERVAL === 0) {
     const health = await pingDaemon();
-    if (!health) {
+    if (!health && !isDaemonTooYoung()) {
       process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
 `);
       killAndRespawnDaemon();
       const start = Date.now();
-      let delay2 = 200;
+      let d = 200;
       while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay2));
+        await new Promise((r) => setTimeout(r, d));
         if (await connectToSocket()) break;
-        delay2 = Math.min(delay2 * 2, 3e3);
+        d = Math.min(d * 2, 3e3);
       }
       if (!_connected) return null;
     }
   }
-  const result = await sendRequest([text], priority);
-  if (!result.error && result.vectors?.[0]) return result.vectors[0];
-  if (result.error) {
-    process.stderr.write(`[exed-client] Embed failed (${result.error}) \u2014 attempting restart
-`);
-    killAndRespawnDaemon();
-    const start = Date.now();
-    let delay2 = 200;
-    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay2));
-      if (await connectToSocket()) break;
-      delay2 = Math.min(delay2 * 2, 3e3);
-    }
-    if (!_connected) return null;
-    const retry = await sendRequest([text], priority);
-    if (!retry.error && retry.vectors?.[0]) return retry.vectors[0];
-    process.stderr.write(`[exed-client] Embed retry also failed: ${retry.error ?? "no vector"}
-`);
-  }
-  return null;
+  const result = await retryThenRestart(
+    () => sendRequest([text], priority),
+    "Embed"
+  );
+  return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
 }
 async function embedBatchViaClient(texts, priority = "high") {
   if (!_connected && !await connectEmbedDaemon()) return null;
   _requestCount++;
-  const result = await sendRequest(texts, priority);
-  if (!result.error && result.vectors) return result.vectors;
-  if (result.error) {
-    process.stderr.write(`[exed-client] Batch embed failed (${result.error}) \u2014 attempting restart
-`);
-    killAndRespawnDaemon();
-    const start = Date.now();
-    let delay2 = 200;
-    while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay2));
-      if (await connectToSocket()) break;
-      delay2 = Math.min(delay2 * 2, 3e3);
-    }
-    if (!_connected) return null;
-    const retry = await sendRequest(texts, priority);
-    if (!retry.error && retry.vectors) return retry.vectors;
-    process.stderr.write(`[exed-client] Batch retry also failed: ${retry.error ?? "no vectors"}
-`);
-  }
-  return null;
+  const result = await retryThenRestart(
+    () => sendRequest(texts, priority),
+    "Batch embed"
+  );
+  return !result.error && result.vectors ? result.vectors : null;
 }
 function disconnectClient() {
   if (_socket) {
@@ -640,7 +674,7 @@ function disconnectClient() {
 function isClientConnected() {
   return _connected;
 }
-var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, HEALTH_CHECK_INTERVAL, _pending, MAX_BUFFER;
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _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";
@@ -655,7 +689,11 @@ var init_exe_daemon_client = __esm({
     _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;
   }
@@ -699,8 +737,8 @@ 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: existsSync32 } = await import("fs");
-  const path40 = await import("path");
-  const modelPath = path40.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  const path41 = await import("path");
+  const modelPath = path41.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
   if (!existsSync32(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
@@ -784,6 +822,118 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/runtime-table.ts
+var RUNTIME_TABLE, DEFAULT_RUNTIME;
+var init_runtime_table = __esm({
+  "src/lib/runtime-table.ts"() {
+    "use strict";
+    RUNTIME_TABLE = {
+      codex: {
+        binary: "codex",
+        launchMode: "interactive",
+        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
+        inlineFlag: "--no-alt-screen",
+        apiKeyEnv: "OPENAI_API_KEY",
+        defaultModel: "gpt-5.4"
+      },
+      opencode: {
+        binary: "opencode",
+        launchMode: "exec",
+        autoApproveFlag: "--dangerously-skip-permissions",
+        inlineFlag: "",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        defaultModel: "anthropic/claude-sonnet-4-6"
+      }
+    };
+    DEFAULT_RUNTIME = "claude";
+  }
+});
+
+// src/lib/agent-config.ts
+var agent_config_exports = {};
+__export(agent_config_exports, {
+  AGENT_CONFIG_PATH: () => AGENT_CONFIG_PATH,
+  DEFAULT_MODELS: () => DEFAULT_MODELS,
+  KNOWN_RUNTIMES: () => KNOWN_RUNTIMES,
+  RUNTIME_LABELS: () => RUNTIME_LABELS,
+  clearAgentRuntime: () => clearAgentRuntime,
+  getAgentRuntime: () => getAgentRuntime,
+  loadAgentConfig: () => loadAgentConfig,
+  saveAgentConfig: () => saveAgentConfig,
+  setAgentRuntime: () => setAgentRuntime
+});
+import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
+import path3 from "path";
+function loadAgentConfig() {
+  if (!existsSync3(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync3(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config2) {
+  const dir = path3.dirname(AGENT_CONFIG_PATH);
+  if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+}
+function getAgentRuntime(agentId) {
+  const config2 = loadAgentConfig();
+  const entry = config2[agentId];
+  if (entry) return entry;
+  const orgDefault = config2["default"];
+  if (orgDefault) return orgDefault;
+  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
+}
+function setAgentRuntime(agentId, runtime, model) {
+  const knownModels = KNOWN_RUNTIMES[runtime];
+  if (!knownModels) {
+    return {
+      ok: false,
+      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
+    };
+  }
+  if (!knownModels.includes(model)) {
+    return {
+      ok: false,
+      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
+    };
+  }
+  const config2 = loadAgentConfig();
+  config2[agentId] = { runtime, model };
+  saveAgentConfig(config2);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config2 = loadAgentConfig();
+  delete config2[agentId];
+  saveAgentConfig(config2);
+}
+var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, RUNTIME_LABELS, DEFAULT_MODELS;
+var init_agent_config = __esm({
+  "src/lib/agent-config.ts"() {
+    "use strict";
+    init_config();
+    init_runtime_table();
+    AGENT_CONFIG_PATH = path3.join(EXE_AI_DIR, "agent-config.json");
+    KNOWN_RUNTIMES = {
+      claude: ["claude-opus-4", "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"]
+    };
+    RUNTIME_LABELS = {
+      claude: "Claude Code (Anthropic)",
+      codex: "Codex (OpenAI)",
+      opencode: "OpenCode (open source)"
+    };
+    DEFAULT_MODELS = {
+      claude: "claude-opus-4",
+      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
+      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
+    };
+  }
+});
+
 // src/lib/employees.ts
 var employees_exports = {};
 __export(employees_exports, {
@@ -799,6 +949,7 @@ __export(employees_exports, {
   getEmployeeByRole: () => getEmployeeByRole,
   getEmployeeNamesByRole: () => getEmployeeNamesByRole,
   hasRole: () => hasRole,
+  hireEmployee: () => hireEmployee,
   isCoordinatorName: () => isCoordinatorName,
   isCoordinatorRole: () => isCoordinatorRole,
   isMultiInstance: () => isMultiInstance,
@@ -811,9 +962,9 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
 import { execSync } from "child_process";
-import path3 from "path";
+import path4 from "path";
 import os3 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -850,7 +1001,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync3(employeesPath)) {
+  if (!existsSync4(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -861,13 +1012,13 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path3.dirname(employeesPath), { recursive: true });
+  await mkdir2(path4.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync3(employeesPath)) return [];
+  if (!existsSync4(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync4(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -909,6 +1060,52 @@ function addEmployee(employees, employee) {
   }
   return [...employees, normalized];
 }
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path4.join(IDENTITY_DIR, `${coordinator.name}.md`);
+  if (!existsSync4(idPath)) return;
+  const content = readFileSync4(idPath, "utf-8");
+  if (content.includes(`**${capitalize(employee.name)}`)) return;
+  const teamMatch = content.match(TEAM_SECTION_RE);
+  if (!teamMatch || teamMatch.index === void 0) return;
+  const afterTeam = content.slice(teamMatch.index + teamMatch[0].length);
+  const nextHeading = afterTeam.match(/\n## /);
+  const entry = `
+**${capitalize(employee.name)} (${employee.role}):** Newly hired. Update this description as the role develops.
+`;
+  let updated;
+  if (nextHeading && nextHeading.index !== void 0) {
+    const insertAt = teamMatch.index + teamMatch[0].length + nextHeading.index;
+    updated = content.slice(0, insertAt) + entry + content.slice(insertAt);
+  } else {
+    updated = content.trimEnd() + "\n" + entry;
+  }
+  writeFileSync2(idPath, updated, "utf-8");
+}
+function capitalize(s) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}
+async function hireEmployee(employee) {
+  const employees = await loadEmployees();
+  const updated = addEmployee(employees, employee);
+  await saveEmployees(updated);
+  try {
+    appendToCoordinatorTeam(employee);
+  } catch {
+  }
+  try {
+    const { loadAgentConfig: loadAgentConfig2, saveAgentConfig: saveAgentConfig2 } = await Promise.resolve().then(() => (init_agent_config(), agent_config_exports));
+    const config2 = loadAgentConfig2();
+    const name = employee.name.toLowerCase();
+    if (!config2[name] && config2["default"]) {
+      config2[name] = { ...config2["default"] };
+      saveAgentConfig2(config2);
+    }
+  } catch {
+  }
+  return updated;
+}
 async function normalizeRosterCase(rosterPath) {
   const employees = await loadEmployees(rosterPath);
   let changed = false;
@@ -918,14 +1115,14 @@ async function normalizeRosterCase(rosterPath) {
       emp.name = emp.name.toLowerCase();
       changed = true;
       try {
-        const identityDir = path3.join(os3.homedir(), ".exe-os", "identity");
-        const oldPath = path3.join(identityDir, `${oldName}.md`);
-        const newPath = path3.join(identityDir, `${emp.name}.md`);
-        if (existsSync3(oldPath) && !existsSync3(newPath)) {
+        const identityDir = path4.join(os3.homedir(), ".exe-os", "identity");
+        const oldPath = path4.join(identityDir, `${oldName}.md`);
+        const newPath = path4.join(identityDir, `${emp.name}.md`);
+        if (existsSync4(oldPath) && !existsSync4(newPath)) {
           renameSync2(oldPath, newPath);
-        } else if (existsSync3(oldPath) && oldPath !== newPath) {
-          const content = readFileSync3(oldPath, "utf-8");
-          writeFileSync(newPath, content, "utf-8");
+        } else if (existsSync4(oldPath) && oldPath !== newPath) {
+          const content = readFileSync4(oldPath, "utf-8");
+          writeFileSync2(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
             unlinkSync2(oldPath);
           }
@@ -955,7 +1152,7 @@ function registerBinSymlinks(name) {
     errors.push("Could not find 'exe-os' in PATH");
     return { created, skipped, errors };
   }
-  const binDir = path3.dirname(exeBinPath);
+  const binDir = path4.dirname(exeBinPath);
   let target;
   try {
     target = readlinkSync(exeBinPath);
@@ -965,29 +1162,615 @@ function registerBinSymlinks(name) {
   }
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
-    const linkPath = path3.join(binDir, linkName);
-    if (existsSync3(linkPath)) {
+    const linkPath = path4.join(binDir, linkName);
+    if (existsSync4(linkPath)) {
       skipped.push(linkName);
       continue;
     }
-    try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES, IDENTITY_DIR, TEAM_SECTION_RE;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    IDENTITY_DIR = path4.join(EXE_AI_DIR, "identity");
+    TEAM_SECTION_RE = /^## Team\b.*$/m;
+  }
+});
+
+// src/lib/database-adapter.ts
+import os4 from "os";
+import path5 from "path";
+import { createRequire } from "module";
+import { pathToFileURL } from "url";
+function quotedIdentifier(identifier) {
+  return `"${identifier.replace(/"/g, '""')}"`;
+}
+function unqualifiedTableName(name) {
+  const raw = name.trim().replace(/^"|"$/g, "");
+  const parts = raw.split(".");
+  return parts[parts.length - 1].replace(/^"|"$/g, "").toLowerCase();
+}
+function stripTrailingSemicolon(sql) {
+  return sql.trim().replace(/;+\s*$/u, "");
+}
+function appendClause(sql, clause) {
+  const trimmed = stripTrailingSemicolon(sql);
+  const returningMatch = /\sRETURNING\b[\s\S]*$/iu.exec(trimmed);
+  if (!returningMatch) {
+    return `${trimmed}${clause}`;
+  }
+  const idx = returningMatch.index;
+  return `${trimmed.slice(0, idx)}${clause}${trimmed.slice(idx)}`;
+}
+function normalizeStatement(stmt) {
+  if (typeof stmt === "string") {
+    return { kind: "positional", sql: stmt, args: [] };
+  }
+  const sql = stmt.sql;
+  if (Array.isArray(stmt.args) || stmt.args === void 0) {
+    return { kind: "positional", sql, args: stmt.args ?? [] };
+  }
+  return { kind: "named", sql, args: stmt.args };
+}
+function rewriteBooleanLiterals(sql) {
+  let out = sql;
+  for (const column of BOOLEAN_COLUMN_NAMES) {
+    const scoped = `((?:\\b[a-z_][a-z0-9_]*\\.)?${column})`;
+    out = out.replace(new RegExp(`${scoped}\\s*=\\s*0\\b`, "giu"), "$1 = FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*=\\s*1\\b`, "giu"), "$1 = TRUE");
+    out = out.replace(new RegExp(`${scoped}\\s*!=\\s*0\\b`, "giu"), "$1 != FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*!=\\s*1\\b`, "giu"), "$1 != TRUE");
+    out = out.replace(new RegExp(`${scoped}\\s*<>\\s*0\\b`, "giu"), "$1 <> FALSE");
+    out = out.replace(new RegExp(`${scoped}\\s*<>\\s*1\\b`, "giu"), "$1 <> TRUE");
+  }
+  return out;
+}
+function rewriteInsertOrIgnore(sql) {
+  if (!/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu.test(sql)) {
+    return sql;
+  }
+  const replaced = sql.replace(/^\s*INSERT\s+OR\s+IGNORE\s+INTO\b/iu, "INSERT INTO");
+  return /\bON\s+CONFLICT\b/iu.test(replaced) ? replaced : appendClause(replaced, " ON CONFLICT DO NOTHING");
+}
+function rewriteInsertOrReplace(sql) {
+  const match = /^\s*INSERT\s+OR\s+REPLACE\s+INTO\s+([A-Za-z0-9_."]+)\s*\(([^)]+)\)([\s\S]*)$/iu.exec(sql);
+  if (!match) {
+    return sql;
+  }
+  const rawTable = match[1];
+  const rawColumns = match[2];
+  const remainder = match[3];
+  const tableName = unqualifiedTableName(rawTable);
+  const conflictKeys = UPSERT_KEYS[tableName];
+  if (!conflictKeys?.length) {
+    return sql;
+  }
+  const columns = rawColumns.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
+  const updateColumns = columns.filter((col) => !conflictKeys.includes(col));
+  const conflictTarget = conflictKeys.map(quotedIdentifier).join(", ");
+  const updateClause = updateColumns.length === 0 ? " DO NOTHING" : ` DO UPDATE SET ${updateColumns.map((col) => `${quotedIdentifier(col)} = EXCLUDED.${quotedIdentifier(col)}`).join(", ")}`;
+  return `INSERT INTO ${rawTable} (${rawColumns})${appendClause(remainder, ` ON CONFLICT (${conflictTarget})${updateClause}`)}`;
+}
+function rewriteSql(sql) {
+  let out = sql;
+  out = out.replace(/\bdatetime\(\s*['"]now['"]\s*\)/giu, "CURRENT_TIMESTAMP");
+  out = out.replace(/\bvector32\s*\(\s*\?\s*\)/giu, "?");
+  out = rewriteBooleanLiterals(out);
+  out = rewriteInsertOrReplace(out);
+  out = rewriteInsertOrIgnore(out);
+  return stripTrailingSemicolon(out);
+}
+function toBoolean(value) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "number") return value !== 0;
+  if (typeof value === "bigint") return value !== 0n;
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "false") return false;
+    if (normalized === "1" || normalized === "true") return true;
+  }
+  return Boolean(value);
+}
+function countQuestionMarks(sql, end) {
+  let count = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < end; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === "*" && next === "/") {
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "?") {
+      count += 1;
+    }
+  }
+  return count;
+}
+function findBooleanPlaceholderIndexes(sql) {
+  const indexes = /* @__PURE__ */ new Set();
+  for (const column of BOOLEAN_COLUMN_NAMES) {
+    const pattern = new RegExp(`(?:\\b[a-z_][a-z0-9_]*\\.)?${column}\\s*=\\s*\\?`, "giu");
+    for (const match of sql.matchAll(pattern)) {
+      const matchText = match[0];
+      const qIndex = match.index + matchText.lastIndexOf("?");
+      indexes.add(countQuestionMarks(sql, qIndex + 1));
+    }
+  }
+  return indexes;
+}
+function coerceInsertBooleanArgs(sql, args) {
+  const match = /^\s*INSERT(?:\s+OR\s+(?:IGNORE|REPLACE))?\s+INTO\s+([A-Za-z0-9_."]+)\s*\(([^)]+)\)/iu.exec(sql);
+  if (!match) return;
+  const rawTable = match[1];
+  const rawColumns = match[2];
+  const boolColumns = BOOLEAN_COLUMNS_BY_TABLE[unqualifiedTableName(rawTable)];
+  if (!boolColumns?.size) return;
+  const columns = rawColumns.split(",").map((col) => col.trim().replace(/^"|"$/g, ""));
+  for (const [index, column] of columns.entries()) {
+    if (boolColumns.has(column) && index < args.length) {
+      args[index] = toBoolean(args[index]);
+    }
+  }
+}
+function coerceUpdateBooleanArgs(sql, args) {
+  const match = /^\s*UPDATE\s+([A-Za-z0-9_."]+)\s+SET\s+([\s\S]+?)(?:\s+WHERE\b|$)/iu.exec(sql);
+  if (!match) return;
+  const rawTable = match[1];
+  const setClause = match[2];
+  const boolColumns = BOOLEAN_COLUMNS_BY_TABLE[unqualifiedTableName(rawTable)];
+  if (!boolColumns?.size) return;
+  const assignments = setClause.split(",");
+  let placeholderIndex = 0;
+  for (const assignment of assignments) {
+    if (!assignment.includes("?")) continue;
+    placeholderIndex += 1;
+    const colMatch = /^\s*(?:[A-Za-z_][A-Za-z0-9_]*\.)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*\?/iu.exec(assignment);
+    if (colMatch && boolColumns.has(colMatch[1])) {
+      args[placeholderIndex - 1] = toBoolean(args[placeholderIndex - 1]);
+    }
+  }
+}
+function coerceBooleanArgs(sql, args) {
+  const nextArgs = [...args];
+  coerceInsertBooleanArgs(sql, nextArgs);
+  coerceUpdateBooleanArgs(sql, nextArgs);
+  const placeholderIndexes = findBooleanPlaceholderIndexes(sql);
+  for (const index of placeholderIndexes) {
+    if (index > 0 && index <= nextArgs.length) {
+      nextArgs[index - 1] = toBoolean(nextArgs[index - 1]);
+    }
+  }
+  return nextArgs;
+}
+function convertQuestionMarksToDollarParams(sql) {
+  let out = "";
+  let placeholder = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      out += ch;
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      out += ch;
+      if (ch === "*" && next === "/") {
+        out += next;
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      out += ch + next;
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      out += ch + next;
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      out += ch;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      out += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "?") {
+      placeholder += 1;
+      out += `$${placeholder}`;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+function translateStatementForPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    throw new Error("Named SQL parameters are not supported by the Prisma adapter.");
+  }
+  const rewrittenSql = rewriteSql(normalized.sql);
+  const coercedArgs = coerceBooleanArgs(rewrittenSql, normalized.args);
+  return {
+    sql: convertQuestionMarksToDollarParams(rewrittenSql),
+    args: coercedArgs
+  };
+}
+function shouldBypassPostgres(stmt) {
+  const normalized = normalizeStatement(stmt);
+  if (normalized.kind === "named") {
+    return true;
+  }
+  return IMMEDIATE_FALLBACK_PATTERNS.some((pattern) => pattern.test(normalized.sql));
+}
+function shouldFallbackOnError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return /42P01|42883|42601|does not exist|syntax error|not supported|Named SQL parameters are not supported/iu.test(message);
+}
+function isReadQuery(sql) {
+  const trimmed = sql.trimStart();
+  return /^(SELECT|WITH|SHOW|EXPLAIN|VALUES)\b/iu.test(trimmed) || /\bRETURNING\b/iu.test(trimmed);
+}
+function buildRow(row, columns) {
+  const values = columns.map((column) => row[column]);
+  return Object.assign(values, row);
+}
+function buildResultSet(rows, rowsAffected = 0) {
+  const columns = rows[0] ? Object.keys(rows[0]) : [];
+  const resultRows = rows.map((row) => buildRow(row, columns));
+  return {
+    columns,
+    columnTypes: columns.map(() => ""),
+    rows: resultRows,
+    rowsAffected,
+    lastInsertRowid: void 0,
+    toJSON() {
+      return {
+        columns,
+        columnTypes: columns.map(() => ""),
+        rows,
+        rowsAffected,
+        lastInsertRowid: void 0
+      };
+    }
+  };
+}
+async function loadPrismaClient() {
+  if (!prismaClientPromise) {
+    prismaClientPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const module2 = await import(pathToFileURL(explicitPath).href);
+        const PrismaClient2 = module2.PrismaClient ?? module2.default?.PrismaClient;
+        if (!PrismaClient2) {
+          throw new Error(`No PrismaClient export found at ${explicitPath}`);
+        }
+        return new PrismaClient2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path5.join(os4.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path5.join(exeDbRoot, "package.json"));
+      const prismaEntry = requireFromExeDb.resolve("@prisma/client");
+      const module = await import(pathToFileURL(prismaEntry).href);
+      const PrismaClient = module.PrismaClient ?? module.default?.PrismaClient;
+      if (!PrismaClient) {
+        throw new Error(`No PrismaClient export found in ${prismaEntry}`);
+      }
+      return new PrismaClient();
+    })();
+  }
+  return prismaClientPromise;
+}
+async function ensureCompatibilityViews(prisma) {
+  if (!compatibilityBootstrapPromise) {
+    compatibilityBootstrapPromise = (async () => {
+      for (const mapping of VIEW_MAPPINGS) {
+        const relation = mapping.source.replace(/"/g, "");
+        const rows = await prisma.$queryRawUnsafe(
+          "SELECT to_regclass($1) AS regclass",
+          relation
+        );
+        if (!rows[0]?.regclass) {
+          continue;
+        }
+        await prisma.$executeRawUnsafe(
+          `CREATE OR REPLACE VIEW public.${quotedIdentifier(mapping.view)} AS SELECT * FROM ${mapping.source}`
+        );
+      }
+    })();
+  }
+  return compatibilityBootstrapPromise;
+}
+async function executeOnPrisma(executor, stmt) {
+  const translated = translateStatementForPostgres(stmt);
+  if (isReadQuery(translated.sql)) {
+    const rows = await executor.$queryRawUnsafe(
+      translated.sql,
+      ...translated.args
+    );
+    return buildResultSet(rows, /\bRETURNING\b/iu.test(translated.sql) ? rows.length : 0);
+  }
+  const rowsAffected = await executor.$executeRawUnsafe(translated.sql, ...translated.args);
+  return buildResultSet([], rowsAffected);
+}
+function splitSqlStatements(sql) {
+  const parts = [];
+  let current = "";
+  let inSingle = false;
+  let inDouble = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+  for (let i = 0; i < sql.length; i++) {
+    const ch = sql[i];
+    const next = sql[i + 1];
+    if (inLineComment) {
+      current += ch;
+      if (ch === "\n") inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      current += ch;
+      if (ch === "*" && next === "/") {
+        current += next;
+        inBlockComment = false;
+        i += 1;
+      }
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "-" && next === "-") {
+      current += ch + next;
+      inLineComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === "/" && next === "*") {
+      current += ch + next;
+      inBlockComment = true;
+      i += 1;
+      continue;
+    }
+    if (!inDouble && ch === "'" && sql[i - 1] !== "\\") {
+      inSingle = !inSingle;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && ch === '"' && sql[i - 1] !== "\\") {
+      inDouble = !inDouble;
+      current += ch;
+      continue;
+    }
+    if (!inSingle && !inDouble && ch === ";") {
+      if (current.trim()) {
+        parts.push(current.trim());
+      }
+      current = "";
+      continue;
     }
+    current += ch;
   }
-  return { created, skipped, errors };
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
 }
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
+async function createPrismaDbAdapter(fallbackClient) {
+  const prisma = await loadPrismaClient();
+  await ensureCompatibilityViews(prisma);
+  let closed = false;
+  let adapter;
+  const fallbackExecute = async (stmt, error) => {
+    if (!fallbackClient) {
+      if (error) throw error;
+      throw new Error("No fallback SQLite client is available for this Prisma-routed query.");
+    }
+    if (error) {
+      process.stderr.write(
+        `[database-adapter] Falling back to SQLite: ${error instanceof Error ? error.message : String(error)}
+`
+      );
+    }
+    return fallbackClient.execute(stmt);
+  };
+  adapter = {
+    async execute(stmt) {
+      if (shouldBypassPostgres(stmt)) {
+        return fallbackExecute(stmt);
+      }
+      try {
+        return await executeOnPrisma(prisma, stmt);
+      } catch (error) {
+        if (shouldFallbackOnError(error)) {
+          return fallbackExecute(stmt, error);
+        }
+        throw error;
+      }
+    },
+    async batch(stmts, mode) {
+      if (stmts.some((stmt) => shouldBypassPostgres(stmt))) {
+        if (!fallbackClient) {
+          throw new Error("Cannot batch unsupported SQLite-only statements without a fallback client.");
+        }
+        return fallbackClient.batch(stmts, mode);
+      }
+      try {
+        if (prisma.$transaction) {
+          return await prisma.$transaction(async (tx) => {
+            const results2 = [];
+            for (const stmt of stmts) {
+              results2.push(await executeOnPrisma(tx, stmt));
+            }
+            return results2;
+          });
+        }
+        const results = [];
+        for (const stmt of stmts) {
+          results.push(await executeOnPrisma(prisma, stmt));
+        }
+        return results;
+      } catch (error) {
+        if (fallbackClient && shouldFallbackOnError(error)) {
+          process.stderr.write(
+            `[database-adapter] Falling back batch to SQLite: ${error instanceof Error ? error.message : String(error)}
+`
+          );
+          return fallbackClient.batch(stmts, mode);
+        }
+        throw error;
+      }
+    },
+    async migrate(stmts) {
+      if (fallbackClient) {
+        return fallbackClient.migrate(stmts);
+      }
+      return adapter.batch(stmts, "deferred");
+    },
+    async transaction(mode) {
+      if (!fallbackClient) {
+        throw new Error("Interactive transactions are only supported on the SQLite fallback client.");
+      }
+      return fallbackClient.transaction(mode);
+    },
+    async executeMultiple(sql) {
+      if (fallbackClient && shouldBypassPostgres(sql)) {
+        return fallbackClient.executeMultiple(sql);
+      }
+      for (const statement of splitSqlStatements(sql)) {
+        await adapter.execute(statement);
+      }
+    },
+    async sync() {
+      if (fallbackClient) {
+        return fallbackClient.sync();
+      }
+      return { frame_no: 0, frames_synced: 0 };
+    },
+    close() {
+      closed = true;
+      prismaClientPromise = null;
+      compatibilityBootstrapPromise = null;
+      void prisma.$disconnect?.();
+    },
+    get closed() {
+      return closed;
+    },
+    get protocol() {
+      return "prisma-postgres";
+    }
+  };
+  return adapter;
+}
+var VIEW_MAPPINGS, UPSERT_KEYS, BOOLEAN_COLUMNS_BY_TABLE, BOOLEAN_COLUMN_NAMES, IMMEDIATE_FALLBACK_PATTERNS, prismaClientPromise, compatibilityBootstrapPromise;
+var init_database_adapter = __esm({
+  "src/lib/database-adapter.ts"() {
     "use strict";
-    init_config();
-    EMPLOYEES_PATH = path3.join(EXE_AI_DIR, "exe-employees.json");
-    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
-    COORDINATOR_ROLE = "COO";
-    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    VIEW_MAPPINGS = [
+      { view: "memories", source: "memory.memory_records" },
+      { view: "tasks", source: "memory.tasks" },
+      { view: "behaviors", source: "memory.behaviors" },
+      { view: "entities", source: "memory.entities" },
+      { view: "relationships", source: "memory.relationships" },
+      { view: "entity_memories", source: "memory.entity_memories" },
+      { view: "entity_aliases", source: "memory.entity_aliases" },
+      { view: "notifications", source: "memory.notifications" },
+      { view: "messages", source: "memory.messages" },
+      { view: "users", source: "wiki.users" },
+      { view: "workspaces", source: "wiki.workspaces" },
+      { view: "workspace_users", source: "wiki.workspace_users" },
+      { view: "documents", source: "wiki.workspace_documents" },
+      { view: "chats", source: "wiki.workspace_chats" }
+    ];
+    UPSERT_KEYS = {
+      memories: ["id"],
+      tasks: ["id"],
+      behaviors: ["id"],
+      entities: ["id"],
+      relationships: ["id"],
+      entity_aliases: ["alias"],
+      notifications: ["id"],
+      messages: ["id"],
+      users: ["id"],
+      workspaces: ["id"],
+      workspace_users: ["id"],
+      documents: ["id"],
+      chats: ["id"]
+    };
+    BOOLEAN_COLUMNS_BY_TABLE = {
+      memories: /* @__PURE__ */ new Set(["has_error", "draft"]),
+      behaviors: /* @__PURE__ */ new Set(["active"]),
+      notifications: /* @__PURE__ */ new Set(["read"]),
+      users: /* @__PURE__ */ new Set(["has_personal_memory"])
+    };
+    BOOLEAN_COLUMN_NAMES = new Set(
+      Object.values(BOOLEAN_COLUMNS_BY_TABLE).flatMap((cols) => [...cols])
+    );
+    IMMEDIATE_FALLBACK_PATTERNS = [
+      /\bPRAGMA\b/i,
+      /\bsqlite_master\b/i,
+      /(?:^|[.\s])(?:memories|conversations|entities)_fts\b/i,
+      /\bMATCH\b/i,
+      /\bvector_distance_cos\s*\(/i,
+      /\bjson_extract\s*\(/i,
+      /\bjulianday\s*\(/i,
+      /\bstrftime\s*\(/i,
+      /\blast_insert_rowid\s*\(/i
+    ];
+    prismaClientPromise = null;
+    compatibilityBootstrapPromise = null;
   }
 });
 
@@ -1061,7 +1844,7 @@ __export(db_daemon_client_exports, {
   createDaemonDbClient: () => createDaemonDbClient,
   initDaemonDbClient: () => initDaemonDbClient
 });
-function normalizeStatement(stmt) {
+function normalizeStatement2(stmt) {
   if (typeof stmt === "string") {
     return { sql: stmt, args: [] };
   }
@@ -1085,7 +1868,7 @@ function createDaemonDbClient(fallbackClient) {
       if (!_useDaemon || !isClientConnected()) {
         return fallbackClient.execute(stmt);
       }
-      const { sql, args } = normalizeStatement(stmt);
+      const { sql, args } = normalizeStatement2(stmt);
       const response = await sendDaemonRequest({
         type: "db-execute",
         sql,
@@ -1110,7 +1893,7 @@ function createDaemonDbClient(fallbackClient) {
       if (!_useDaemon || !isClientConnected()) {
         return fallbackClient.batch(stmts, mode);
       }
-      const statements = stmts.map(normalizeStatement);
+      const statements = stmts.map(normalizeStatement2);
       const response = await sendDaemonRequest({
         type: "db-batch",
         statements,
@@ -1205,6 +1988,18 @@ __export(database_exports, {
 });
 import { createClient } from "@libsql/client";
 async function initDatabase(config2) {
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
+  if (_daemonClient) {
+    _daemonClient.close();
+    _daemonClient = null;
+  }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
   if (_client) {
     _client.close();
     _client = null;
@@ -1218,6 +2013,7 @@ async function initDatabase(config2) {
   }
   _client = createClient(opts);
   _resilientClient = wrapWithRetry(_client);
+  _adapterClient = _resilientClient;
   _client.execute("PRAGMA busy_timeout = 30000").catch(() => {
   });
   _client.execute("PRAGMA journal_mode = WAL").catch(() => {
@@ -1228,14 +2024,20 @@ async function initDatabase(config2) {
     });
   }, 3e4);
   _walCheckpointTimer.unref();
+  if (process.env.DATABASE_URL) {
+    _adapterClient = await createPrismaDbAdapter(_resilientClient);
+  }
 }
 function isInitialized() {
-  return _client !== null;
+  return _adapterClient !== null || _client !== null;
 }
 function getClient() {
-  if (!_resilientClient) {
+  if (!_adapterClient) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
+  if (process.env.DATABASE_URL) {
+    return _adapterClient;
+  }
   if (process.env.EXE_IS_DAEMON === "1") {
     return _resilientClient;
   }
@@ -1245,6 +2047,7 @@ function getClient() {
   return _resilientClient;
 }
 async function initDaemonClient() {
+  if (process.env.DATABASE_URL) return;
   if (process.env.EXE_IS_DAEMON === "1") return;
   if (!_resilientClient) return;
   try {
@@ -2189,26 +2992,36 @@ async function ensureSchema() {
   }
 }
 async function disposeDatabase() {
+  if (_walCheckpointTimer) {
+    clearInterval(_walCheckpointTimer);
+    _walCheckpointTimer = null;
+  }
   if (_daemonClient) {
     _daemonClient.close();
     _daemonClient = null;
   }
+  if (_adapterClient && _adapterClient !== _resilientClient) {
+    _adapterClient.close();
+  }
+  _adapterClient = null;
   if (_client) {
     _client.close();
     _client = null;
     _resilientClient = null;
   }
 }
-var _client, _resilientClient, _walCheckpointTimer, _daemonClient, initTurso, disposeTurso;
+var _client, _resilientClient, _walCheckpointTimer, _daemonClient, _adapterClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
     init_db_retry();
     init_employees();
+    init_database_adapter();
     _client = null;
     _resilientClient = null;
     _walCheckpointTimer = null;
     _daemonClient = null;
+    _adapterClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -2224,14 +3037,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync4 } from "fs";
-import path4 from "path";
-import os4 from "os";
+import { existsSync as existsSync5 } from "fs";
+import path6 from "path";
+import os5 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(os4.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path6.join(os5.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path4.join(getKeyDir(), "master.key");
+  return path6.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -2252,9 +3065,9 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync4(keyPath)) {
+  if (!existsSync5(keyPath)) {
     process.stderr.write(
-      `[keychain] Key not found at ${keyPath} (HOME=${os4.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
+      `[keychain] Key not found at ${keyPath} (HOME=${os5.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
     );
     return null;
@@ -2295,7 +3108,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync4(keyPath)) {
+  if (existsSync5(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -2405,13 +3218,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path5 from "path";
-import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
+import path7 from "path";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync5(SHARDS_DIR)) {
-    mkdirSync(SHARDS_DIR, { recursive: true });
+  if (!existsSync6(SHARDS_DIR)) {
+    mkdirSync2(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
 }
@@ -2431,7 +3244,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path5.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path7.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -2441,10 +3254,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync5(path5.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync6(path7.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync5(SHARDS_DIR)) return [];
+  if (!existsSync6(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -2518,7 +3331,23 @@ async function ensureShardSchema(client) {
     // MS-11: draft staging, MS-6a: memory_type, MS-7: trajectory
     "ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0",
     "ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'",
-    "ALTER TABLE memories ADD COLUMN trajectory TEXT"
+    "ALTER TABLE memories ADD COLUMN trajectory TEXT",
+    // Metadata enrichment columns (must match database.ts)
+    "ALTER TABLE memories ADD COLUMN intent TEXT",
+    "ALTER TABLE memories ADD COLUMN outcome TEXT",
+    "ALTER TABLE memories ADD COLUMN domain TEXT",
+    "ALTER TABLE memories ADD COLUMN referenced_entities TEXT",
+    "ALTER TABLE memories ADD COLUMN retrieval_count INTEGER DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN chain_position TEXT",
+    "ALTER TABLE memories ADD COLUMN review_status TEXT",
+    "ALTER TABLE memories ADD COLUMN context_window_pct INTEGER",
+    "ALTER TABLE memories ADD COLUMN file_paths TEXT",
+    "ALTER TABLE memories ADD COLUMN commit_hash TEXT",
+    "ALTER TABLE memories ADD COLUMN duration_ms INTEGER",
+    "ALTER TABLE memories ADD COLUMN token_cost REAL",
+    "ALTER TABLE memories ADD COLUMN audience TEXT",
+    "ALTER TABLE memories ADD COLUMN language_type TEXT",
+    "ALTER TABLE memories ADD COLUMN parent_memory_id TEXT"
   ]) {
     try {
       await client.execute(col);
@@ -2630,7 +3459,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path5.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path7.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -3493,8 +4322,8 @@ __export(reranker_exports, {
   rerankWithContext: () => rerankWithContext,
   rerankWithScores: () => rerankWithScores
 });
-import path6 from "path";
-import { existsSync as existsSync6 } from "fs";
+import path8 from "path";
+import { existsSync as existsSync7 } from "fs";
 function resetIdleTimer() {
   if (_idleTimer) clearTimeout(_idleTimer);
   _idleTimer = setTimeout(() => {
@@ -3505,18 +4334,18 @@ function resetIdleTimer() {
   }
 }
 function isRerankerAvailable() {
-  return existsSync6(path6.join(MODELS_DIR, RERANKER_MODEL_FILE));
+  return existsSync7(path8.join(MODELS_DIR, RERANKER_MODEL_FILE));
 }
 function getRerankerModelPath() {
-  return path6.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  return path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
 }
 async function ensureLoaded() {
   if (_rerankerContext) {
     resetIdleTimer();
     return;
   }
-  const modelPath = path6.join(MODELS_DIR, RERANKER_MODEL_FILE);
-  if (!existsSync6(modelPath)) {
+  const modelPath = path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  if (!existsSync7(modelPath)) {
     throw new Error(
       `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
     );
@@ -3619,7 +4448,7 @@ __export(project_name_exports, {
   getProjectName: () => getProjectName
 });
 import { execSync as execSync2 } from "child_process";
-import path7 from "path";
+import path9 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached && _cachedCwd === dir) return _cached;
@@ -3632,7 +4461,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path7.dirname(gitCommonDir);
+      repoRoot = path9.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync2("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -3641,11 +4470,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached = path7.basename(repoRoot);
+    _cached = path9.basename(repoRoot);
     _cachedCwd = dir;
     return _cached;
   } catch {
-    _cached = path7.basename(dir);
+    _cached = path9.basename(dir);
     _cachedCwd = dir;
     return _cached;
   }
@@ -3669,8 +4498,8 @@ __export(file_grep_exports, {
   grepProjectFiles: () => grepProjectFiles
 });
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync7 } from "fs";
-import path8 from "path";
+import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync8 } from "fs";
+import path10 from "path";
 import crypto from "crypto";
 function hasRipgrep() {
   if (_hasRg === null) {
@@ -3710,7 +4539,7 @@ async function grepProjectFiles(query, projectRoot, options) {
       session_id: "file-grep",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       tool_name: "file_grep",
-      project_name: path8.basename(projectRoot),
+      project_name: path10.basename(projectRoot),
       has_error: false,
       raw_text: `${prefix} ${buildSnippet(hit, projectRoot)}`,
       vector: null,
@@ -3722,7 +4551,7 @@ function getChunkContext(filePath, lineNumber) {
   try {
     const ext = filePath.split(".").pop()?.toLowerCase();
     if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const source = readFileSync4(filePath, "utf8");
+    const source = readFileSync5(filePath, "utf8");
     const lines = source.split("\n");
     for (let i = Math.min(lineNumber - 1, lines.length - 1); i >= 0; i--) {
       const line = lines[i];
@@ -3784,11 +4613,11 @@ function grepWithNodeFs(pattern, projectRoot, patterns) {
   const files = collectFiles(projectRoot, patterns ?? DEFAULT_PATTERNS);
   const hits = [];
   for (const filePath of files.slice(0, MAX_FILES)) {
-    const absPath = path8.join(projectRoot, filePath);
+    const absPath = path10.join(projectRoot, filePath);
     try {
       const stat = statSync2(absPath);
       if (stat.size > MAX_FILE_SIZE) continue;
-      const content = readFileSync4(absPath, "utf8");
+      const content = readFileSync5(absPath, "utf8");
       const lines = content.split("\n");
       const matches = content.match(regex);
       if (!matches || matches.length === 0) continue;
@@ -3811,15 +4640,15 @@ function collectFiles(root, patterns) {
   const files = [];
   function walk(dir, relative) {
     if (files.length >= MAX_FILES) return;
-    const basename = path8.basename(dir);
+    const basename = path10.basename(dir);
     if (EXCLUDE_DIRS.includes(basename)) return;
     try {
       const entries = readdirSync2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= MAX_FILES) return;
-        const rel = path8.join(relative, entry.name);
+        const rel = path10.join(relative, entry.name);
         if (entry.isDirectory()) {
-          walk(path8.join(dir, entry.name), rel);
+          walk(path10.join(dir, entry.name), rel);
         } else if (entry.isFile()) {
           for (const pat of patterns) {
             if (matchGlob(rel, pat)) {
@@ -3851,7 +4680,7 @@ function matchGlob(filePath, pattern) {
   if (slashIdx !== -1) {
     const dir = pattern.slice(0, slashIdx);
     const ext2 = pattern.slice(slashIdx + 1).replace("*", "");
-    const fileDir = path8.dirname(filePath);
+    const fileDir = path10.dirname(filePath);
     return fileDir === dir && filePath.endsWith(ext2);
   }
   const ext = pattern.replace("*", "");
@@ -3859,9 +4688,9 @@ function matchGlob(filePath, pattern) {
 }
 function buildSnippet(hit, projectRoot) {
   try {
-    const absPath = path8.join(projectRoot, hit.filePath);
-    if (!existsSync7(absPath)) return hit.matchLine;
-    const lines = readFileSync4(absPath, "utf8").split("\n");
+    const absPath = path10.join(projectRoot, hit.filePath);
+    if (!existsSync8(absPath)) return hit.matchLine;
+    const lines = readFileSync5(absPath, "utf8").split("\n");
     const start = Math.max(0, hit.lineNumber - 3);
     const end = Math.min(lines.length, hit.lineNumber + 2);
     return lines.slice(start, end).join("\n").slice(0, 500);
@@ -5086,9 +5915,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync5 } from "child_process";
-import path9 from "path";
+import path11 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -5132,12 +5961,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path9.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path11.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
-    mkdirSync2(CACHE_DIR, { recursive: true });
-    writeFileSync2(
+    mkdirSync3(CACHE_DIR, { recursive: true });
+    writeFileSync3(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -5153,7 +5982,7 @@ function clearActiveAgent() {
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync5(markerPath, "utf8");
+    const raw = readFileSync6(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
@@ -5201,14 +6030,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync5(path9.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync6(path11.join(CACHE_DIR, file), "utf8");
         const data = JSON.parse(raw);
         if (!data.agentId) continue;
         if (data.startedAt) {
           const age = Date.now() - new Date(data.startedAt).getTime();
           if (age > STALE_MS) {
             try {
-              unlinkSync3(path9.join(CACHE_DIR, file));
+              unlinkSync3(path11.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -5231,11 +6060,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync3(path9.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync3(path11.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync3(path9.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync3(path11.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -5246,7 +6075,7 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path9.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path11.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -5268,9 +6097,9 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import path10 from "path";
+import path12 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -5281,37 +6110,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path10.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path12.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync8(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
+    if (existsSync9(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync8(DEVICE_ID_PATH)) {
-      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync9(DEVICE_ID_PATH)) {
+      const id2 = readFileSync7(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
   }
   const id = randomUUID3();
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync3(DEVICE_ID_PATH, id, "utf8");
+  mkdirSync4(EXE_AI_DIR, { recursive: true });
+  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync8(LICENSE_PATH)) return null;
-    return readFileSync6(LICENSE_PATH, "utf8").trim();
+    if (!existsSync9(LICENSE_PATH)) return null;
+    return readFileSync7(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync3(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync4(EXE_AI_DIR, { recursive: true });
+  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -5337,8 +6166,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!existsSync9(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -5347,8 +6176,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!existsSync9(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -5382,7 +6211,7 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync3(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -5446,9 +6275,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path10.join(EXE_AI_DIR, "config.json");
-      if (existsSync8(configPath)) {
-        const raw = JSON.parse(readFileSync6(configPath, "utf8"));
+      const configPath = path12.join(EXE_AI_DIR, "config.json");
+      if (existsSync9(configPath)) {
+        const raw = JSON.parse(readFileSync7(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -5607,9 +6436,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path10.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path10.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path10.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path12.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path12.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path12.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -5649,12 +6478,12 @@ __export(plan_limits_exports, {
   countActiveMemories: () => countActiveMemories,
   getLicenseSync: () => getLicenseSync
 });
-import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
-import path11 from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
+import path13 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync9(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync7(CACHE_PATH2, "utf8"));
+    if (!existsSync10(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -5721,8 +6550,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync9(filePath)) {
-      const raw = readFileSync7(filePath, "utf8");
+    if (existsSync10(filePath)) {
+      const raw = readFileSync8(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -5759,19 +6588,19 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path11.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path13.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto4 from "crypto";
-import path14 from "path";
-import os5 from "os";
+import path16 from "path";
+import os6 from "os";
 import {
-  readFileSync as readFileSync8,
+  readFileSync as readFileSync9,
   readdirSync as readdirSync4,
   unlinkSync as unlinkSync4,
-  existsSync as existsSync10,
+  existsSync as existsSync11,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -5816,13 +6645,13 @@ var init_notifications = __esm({
 });
 
 // src/lib/session-registry.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync6, mkdirSync as mkdirSync4, existsSync as existsSync11 } from "fs";
-import path15 from "path";
-import os6 from "os";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, existsSync as existsSync12 } from "fs";
+import path17 from "path";
+import os7 from "os";
 function registerSession(entry) {
-  const dir = path15.dirname(REGISTRY_PATH);
-  if (!existsSync11(dir)) {
-    mkdirSync4(dir, { recursive: true });
+  const dir = path17.dirname(REGISTRY_PATH);
+  if (!existsSync12(dir)) {
+    mkdirSync5(dir, { recursive: true });
   }
   const sessions = listSessions();
   const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
@@ -5831,11 +6660,11 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync6(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync7(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function listSessions() {
   try {
-    const raw = readFileSync9(REGISTRY_PATH, "utf8");
+    const raw = readFileSync10(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -5845,7 +6674,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path15.join(os6.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path17.join(os7.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -6029,101 +6858,6 @@ var init_provider_table = __esm({
   }
 });
 
-// src/lib/runtime-table.ts
-var RUNTIME_TABLE, DEFAULT_RUNTIME;
-var init_runtime_table = __esm({
-  "src/lib/runtime-table.ts"() {
-    "use strict";
-    RUNTIME_TABLE = {
-      codex: {
-        binary: "codex",
-        launchMode: "interactive",
-        autoApproveFlag: "--dangerously-bypass-approvals-and-sandbox",
-        inlineFlag: "--no-alt-screen",
-        apiKeyEnv: "OPENAI_API_KEY",
-        defaultModel: "gpt-5.4"
-      },
-      opencode: {
-        binary: "opencode",
-        launchMode: "exec",
-        autoApproveFlag: "--dangerously-skip-permissions",
-        inlineFlag: "",
-        apiKeyEnv: "ANTHROPIC_API_KEY",
-        defaultModel: "anthropic/claude-sonnet-4-6"
-      }
-    };
-    DEFAULT_RUNTIME = "claude";
-  }
-});
-
-// src/lib/agent-config.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, existsSync as existsSync12, mkdirSync as mkdirSync5 } from "fs";
-import path16 from "path";
-function loadAgentConfig() {
-  if (!existsSync12(AGENT_CONFIG_PATH)) return {};
-  try {
-    return JSON.parse(readFileSync10(AGENT_CONFIG_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function saveAgentConfig(config2) {
-  const dir = path16.dirname(AGENT_CONFIG_PATH);
-  if (!existsSync12(dir)) mkdirSync5(dir, { recursive: true });
-  writeFileSync7(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
-}
-function getAgentRuntime(agentId) {
-  const config2 = loadAgentConfig();
-  const entry = config2[agentId];
-  if (entry) return entry;
-  const orgDefault = config2["default"];
-  if (orgDefault) return orgDefault;
-  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
-}
-function setAgentRuntime(agentId, runtime, model) {
-  const knownModels = KNOWN_RUNTIMES[runtime];
-  if (!knownModels) {
-    return {
-      ok: false,
-      error: `Unknown runtime "${runtime}". Valid: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`
-    };
-  }
-  if (!knownModels.includes(model)) {
-    return {
-      ok: false,
-      error: `Unknown model "${model}" for runtime "${runtime}". Valid: ${knownModels.join(", ")}`
-    };
-  }
-  const config2 = loadAgentConfig();
-  config2[agentId] = { runtime, model };
-  saveAgentConfig(config2);
-  return { ok: true };
-}
-var AGENT_CONFIG_PATH, KNOWN_RUNTIMES, RUNTIME_LABELS, DEFAULT_MODELS;
-var init_agent_config = __esm({
-  "src/lib/agent-config.ts"() {
-    "use strict";
-    init_config();
-    init_runtime_table();
-    AGENT_CONFIG_PATH = path16.join(EXE_AI_DIR, "agent-config.json");
-    KNOWN_RUNTIMES = {
-      claude: ["claude-opus-4", "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"]
-    };
-    RUNTIME_LABELS = {
-      claude: "Claude Code (Anthropic)",
-      codex: "Codex (OpenAI)",
-      opencode: "OpenCode (open source)"
-    };
-    DEFAULT_MODELS = {
-      claude: "claude-opus-4",
-      codex: RUNTIME_TABLE.codex?.defaultModel ?? "gpt-5.4",
-      opencode: RUNTIME_TABLE.opencode?.defaultModel ?? "anthropic/claude-sonnet-4-6"
-    };
-  }
-});
-
 // src/lib/intercom-queue.ts
 var intercom_queue_exports = {};
 __export(intercom_queue_exports, {
@@ -6134,10 +6868,10 @@ __export(intercom_queue_exports, {
   readQueue: () => readQueue
 });
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, renameSync as renameSync3, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
-import path17 from "path";
-import os7 from "os";
+import path18 from "path";
+import os8 from "os";
 function ensureDir() {
-  const dir = path17.dirname(QUEUE_PATH);
+  const dir = path18.dirname(QUEUE_PATH);
   if (!existsSync13(dir)) mkdirSync6(dir, { recursive: true });
 }
 function readQueue() {
@@ -6243,10 +6977,10 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path17.join(os7.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path18.join(os8.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path17.join(os7.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path18.join(os8.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -6625,12 +7359,12 @@ __export(tmux_routing_exports, {
 });
 import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
 import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync14, appendFileSync, readdirSync as readdirSync5 } from "fs";
-import path18 from "path";
-import os8 from "os";
+import path19 from "path";
+import os9 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { unlinkSync as unlinkSync5 } from "fs";
 function spawnLockPath(sessionName) {
-  return path18.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path19.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -6667,8 +7401,8 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const scriptPath = path18.join(
-      path18.dirname(thisFile),
+    const scriptPath = path19.join(
+      path19.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
@@ -6743,7 +7477,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
     mkdirSync7(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  const filePath = path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
   writeFileSync9(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
@@ -6752,7 +7486,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync12(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync12(path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -6761,7 +7495,7 @@ function getParentExe(sessionKey) {
 function getDispatchedBy(sessionKey) {
   try {
     const data = JSON.parse(readFileSync12(
-      path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -6772,15 +7506,24 @@ function getDispatchedBy(sessionKey) {
 function resolveExeSession() {
   const mySession = getMySession();
   if (!mySession) return null;
+  const fromSessionName = extractRootExe(mySession);
   try {
     const key = getSessionKey();
     const parentExe = getParentExe(key);
     if (parentExe) {
-      return extractRootExe(parentExe) ?? parentExe;
+      const fromCache = extractRootExe(parentExe) ?? parentExe;
+      if (fromSessionName && fromCache !== fromSessionName) {
+        process.stderr.write(
+          `[tmux-routing] WARN: cache says "${fromCache}" but session name says "${fromSessionName}". Trusting session name.
+`
+        );
+        return fromSessionName;
+      }
+      return fromCache;
     }
   } catch {
   }
-  return extractRootExe(mySession) ?? mySession;
+  return fromSessionName ?? mySession;
 }
 function isEmployeeAlive(sessionName) {
   return getTransport().isAlive(sessionName);
@@ -6938,7 +7681,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const markerPath = path18.join(SESSION_CACHE, `current-task-${agent}.json`);
+      const markerPath = path19.join(SESSION_CACHE, `current-task-${agent}.json`);
       if (existsSync14(markerPath)) {
         logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker \u2014 will auto-chain)`);
         return "debounced";
@@ -6948,7 +7691,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path18.join(process.cwd(), "exe", agent);
+      const taskDir = path19.join(process.cwd(), "exe", agent);
       if (existsSync14(taskDir)) {
         const files = readdirSync5(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
@@ -7082,8 +7825,8 @@ 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 = path18.join(os8.homedir(), ".exe-os", "session-logs");
-  const logFile = path18.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  const logDir = path19.join(os9.homedir(), ".exe-os", "session-logs");
+  const logFile = path19.join(logDir, `${instanceLabel}-${Date.now()}.log`);
   if (!existsSync14(logDir)) {
     mkdirSync7(logDir, { recursive: true });
   }
@@ -7091,14 +7834,14 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath2(import.meta.url);
-    const cleanupScript = path18.join(path18.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    const cleanupScript = path19.join(path19.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
     if (existsSync14(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path18.join(os8.homedir(), ".claude.json");
+    const claudeJsonPath = path19.join(os9.homedir(), ".claude.json");
     let claudeJson = {};
     try {
       claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
@@ -7113,10 +7856,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   try {
-    const settingsDir = path18.join(os8.homedir(), ".claude", "projects");
+    const settingsDir = path19.join(os9.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path18.join(settingsDir, normalizedKey);
-    const settingsPath = path18.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path19.join(settingsDir, normalizedKey);
+    const settingsPath = path19.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
       settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
@@ -7163,8 +7906,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath2 = path18.join(
-      os8.homedir(),
+    const identityPath2 = path19.join(
+      os9.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -7179,7 +7922,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path18.basename(spawnCwd),
+      path19.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -7194,9 +7937,9 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path18.join(os8.homedir(), ".exe-os", "session-cache");
+    const ctxDir = path19.join(os9.homedir(), ".exe-os", "session-cache");
     mkdirSync7(ctxDir, { recursive: true });
-    const ctxFile = path18.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxFile = path19.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
@@ -7280,7 +8023,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path18.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    const dispatchInfo = path19.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
     writeFileSync9(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
@@ -7355,15 +8098,15 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path18.join(os8.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path18.join(os8.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path19.join(os9.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path19.join(os9.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 = path18.join(os8.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path18.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path19.join(os9.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path19.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -7411,8 +8154,8 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto6 from "crypto";
-import path19 from "path";
-import os9 from "os";
+import path20 from "path";
+import os10 from "os";
 import { execSync as execSync8 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
 import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
@@ -7590,8 +8333,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir4(path19.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path19.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir4(path20.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path20.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -7627,9 +8370,9 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path19.join(os9.homedir(), ".exe-os");
-      const mdPath = path19.join(EXE_OS_DIR, taskFile);
-      const mdDir = path19.dirname(mdPath);
+      const EXE_OS_DIR = path20.join(os10.homedir(), ".exe-os");
+      const mdPath = path20.join(EXE_OS_DIR, taskFile);
+      const mdDir = path20.dirname(mdPath);
       if (!existsSync15(mdDir)) await mkdir4(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
@@ -7930,7 +8673,7 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path19.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path20.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
     if (existsSync15(archPath)) return;
     const template = [
@@ -7965,7 +8708,7 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path19.join(baseDir, ".gitignore");
+  const gitignorePath = path20.join(baseDir, ".gitignore");
   try {
     if (existsSync15(gitignorePath)) {
       const content = readFileSync13(gitignorePath, "utf-8");
@@ -7999,13 +8742,13 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path20 from "path";
+import path21 from "path";
 import { existsSync as existsSync16, readdirSync as readdirSync6, unlinkSync as unlinkSync6 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
   if (sessionScope) {
     const result2 = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review' AND (session_scope = ? OR session_scope IS NULL)",
+      sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review' AND session_scope = ?",
       args: [sessionScope]
     });
     return Number(result2.rows[0]?.cnt) || 0;
@@ -8181,11 +8924,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path20.join(EXE_AI_DIR, "session-cache");
+    const cacheDir = path21.join(EXE_AI_DIR, "session-cache");
     if (existsSync16(cacheDir)) {
       for (const f of readdirSync6(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path20.join(cacheDir, f));
+          unlinkSync6(path21.join(cacheDir, f));
         }
       }
     }
@@ -8206,7 +8949,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path21 from "path";
+import path22 from "path";
 import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -8223,7 +8966,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path21.join(baseDir, String(ur.task_file));
+        const ubFile = path22.join(baseDir, String(ur.task_file));
         let ubContent = await readFile4(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -8777,7 +9520,7 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path22 from "path";
+import path23 from "path";
 import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
@@ -8797,8 +9540,8 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path22.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path22.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path23.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path23.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
       mkdirSync8(cacheDir, { recursive: true });
       writeFileSync10(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
@@ -8969,15 +9712,15 @@ __export(identity_exports, {
 });
 import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
 import { readdirSync as readdirSync7 } from "fs";
-import path23 from "path";
+import path24 from "path";
 import { createHash as createHash2 } from "crypto";
 function ensureDir2() {
-  if (!existsSync17(IDENTITY_DIR)) {
-    mkdirSync9(IDENTITY_DIR, { recursive: true });
+  if (!existsSync17(IDENTITY_DIR2)) {
+    mkdirSync9(IDENTITY_DIR2, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path23.join(IDENTITY_DIR, `${agentId}.md`);
+  return path24.join(IDENTITY_DIR2, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -9050,7 +9793,7 @@ async function updateIdentity(agentId, content, updatedBy) {
 }
 function listIdentities() {
   ensureDir2();
-  const files = readdirSync7(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
+  const files = readdirSync7(IDENTITY_DIR2).filter((f) => f.endsWith(".md"));
   const results = [];
   for (const file of files) {
     const agentId = file.replace(".md", "");
@@ -9083,13 +9826,13 @@ ${teamLines.join("\n")}`);
   }
   return parts.join("\n\n");
 }
-var IDENTITY_DIR;
+var IDENTITY_DIR2;
 var init_identity = __esm({
   "src/lib/identity.ts"() {
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR = path23.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR2 = path24.join(EXE_AI_DIR, "identity");
   }
 });
 
@@ -10202,8 +10945,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path40, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path40}`;
+async function wikiFetch(config2, path41, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path41}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
@@ -10236,7 +10979,7 @@ async function wikiFetch(config2, path40, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path40}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path41}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -10346,12 +11089,12 @@ __export(worker_gate_exports, {
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
 import { readdirSync as readdirSync10, writeFileSync as writeFileSync17, unlinkSync as unlinkSync8, mkdirSync as mkdirSync14, existsSync as existsSync25 } from "fs";
-import path33 from "path";
+import path34 from "path";
 function tryAcquireWorkerSlot() {
   try {
     mkdirSync14(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path33.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    const reservationPath = path34.join(WORKER_PID_DIR, `${reservationId}.pid`);
     writeFileSync17(reservationPath, String(process.pid));
     const files = readdirSync10(WORKER_PID_DIR);
     let alive = 0;
@@ -10369,7 +11112,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path33.join(WORKER_PID_DIR, f));
+          unlinkSync8(path34.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -10393,13 +11136,13 @@ function tryAcquireWorkerSlot() {
 function registerWorkerPid(pid) {
   try {
     mkdirSync14(WORKER_PID_DIR, { recursive: true });
-    writeFileSync17(path33.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    writeFileSync17(path34.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path33.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path34.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
@@ -10439,9 +11182,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path33.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path34.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path33.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path34.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -10465,7 +11208,7 @@ __export(crdt_sync_exports, {
 });
 import * as Y from "yjs";
 import { readFileSync as readFileSync24, writeFileSync as writeFileSync18, existsSync as existsSync28, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9 } from "fs";
-import path36 from "path";
+import path37 from "path";
 import { homedir as homedir5 } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -10621,7 +11364,7 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path36.dirname(sp);
+    const dir = path37.dirname(sp);
     if (!existsSync28(dir)) mkdirSync15(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
     writeFileSync18(sp, Buffer.from(state));
@@ -10665,7 +11408,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path36.join(homedir5(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path37.join(homedir5(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -10677,9 +11420,9 @@ init_store();
 init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { spawn as spawn3 } from "child_process";
+import { spawn as spawn4 } from "child_process";
 import { existsSync as existsSync31, openSync as openSync3, mkdirSync as mkdirSync17, closeSync as closeSync3 } from "fs";
-import path39 from "path";
+import path40 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/mcp/tools/recall-my-memory.ts
@@ -10987,8 +11730,8 @@ init_active_agent();
 init_plan_limits();
 import { z as z4 } from "zod";
 import crypto2 from "crypto";
-import { writeFileSync as writeFileSync4 } from "fs";
-import path12 from "path";
+import { writeFileSync as writeFileSync5 } from "fs";
+import path14 from "path";
 function registerStoreMemory(server2) {
   server2.registerTool(
     "store_memory",
@@ -11056,8 +11799,8 @@ function registerStoreMemory(server2) {
       if (needsBackfill) {
         try {
           const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-          const flagPath = path12.join(exeDir, "session-cache", "needs-backfill");
-          writeFileSync4(flagPath, "1");
+          const flagPath = path14.join(exeDir, "session-cache", "needs-backfill");
+          writeFileSync5(flagPath, "1");
         } catch {
         }
       }
@@ -11081,8 +11824,8 @@ init_active_agent();
 init_employees();
 import { z as z5 } from "zod";
 import crypto3 from "crypto";
-import { writeFileSync as writeFileSync5 } from "fs";
-import path13 from "path";
+import { writeFileSync as writeFileSync6 } from "fs";
+import path15 from "path";
 function registerCommitMemory(server2) {
   server2.registerTool(
     "commit_to_long_term_memory",
@@ -11172,8 +11915,8 @@ function registerCommitMemory(server2) {
       if (needsBackfill) {
         try {
           const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-          const flagPath = path13.join(exeDir, "session-cache", "needs-backfill");
-          writeFileSync5(flagPath, "1");
+          const flagPath = path15.join(exeDir, "session-cache", "needs-backfill");
+          writeFileSync6(flagPath, "1");
         } catch {
         }
       }
@@ -11439,13 +12182,14 @@ Warning: ${task.warning}`;
 // src/mcp/tools/list-tasks.ts
 init_tasks();
 init_project_name();
+init_active_agent();
 import { z as z8 } from "zod";
 function registerListTasks(server2) {
   server2.registerTool(
     "list_tasks",
     {
       title: "List Tasks",
-      description: "Query tasks by assignee, status, project, or priority. Defaults to current project. Pass project_name='all' to see all projects.",
+      description: "Query tasks by assignee, status, project, or priority. Defaults to current project. Pass project_name='all' for all projects. When querying your own tasks, project filter is skipped automatically.",
       inputSchema: {
         assigned_to: z8.string().optional().describe("Filter by employee name"),
         status: z8.enum(["open", "in_progress", "done", "blocked", "cancelled"]).optional().describe("Filter by status"),
@@ -11455,7 +12199,16 @@ function registerListTasks(server2) {
     },
     async ({ assigned_to, status, project_name, priority }) => {
       try {
-        const resolvedProject = project_name === "all" ? void 0 : project_name ?? getProjectName();
+        let resolvedProject;
+        if (project_name === "all") {
+          resolvedProject = void 0;
+        } else if (project_name) {
+          resolvedProject = project_name;
+        } else {
+          const { agentId } = getActiveAgent();
+          const queryingSelf = !assigned_to || assigned_to === agentId;
+          resolvedProject = queryingSelf ? void 0 : getProjectName();
+        }
         const tasks = await listTasks({
           assignedTo: assigned_to,
           status,
@@ -13210,9 +13963,9 @@ import { z as z29 } from "zod";
 // src/automation/trigger-engine.ts
 import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync18, mkdirSync as mkdirSync10 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
-import path24 from "path";
-import os10 from "os";
-var TRIGGERS_PATH = path24.join(os10.homedir(), ".exe-os", "triggers.json");
+import path25 from "path";
+import os11 from "os";
+var TRIGGERS_PATH = path25.join(os11.homedir(), ".exe-os", "triggers.json");
 function loadTriggers(project) {
   if (!existsSync18(TRIGGERS_PATH)) return [];
   try {
@@ -13228,7 +13981,7 @@ function loadTriggers(project) {
   }
 }
 function saveTriggers(triggers) {
-  const dir = path24.dirname(TRIGGERS_PATH);
+  const dir = path25.dirname(TRIGGERS_PATH);
   if (!existsSync18(dir)) mkdirSync10(dir, { recursive: true });
   writeFileSync12(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
 }
@@ -13515,23 +14268,23 @@ import { z as z31 } from "zod";
 
 // src/automation/starter-packs/index.ts
 import { readFileSync as readFileSync17, readdirSync as readdirSync8, existsSync as existsSync19 } from "fs";
-import path25 from "path";
+import path26 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname = path25.dirname(fileURLToPath3(import.meta.url));
+var __dirname = path26.dirname(fileURLToPath3(import.meta.url));
 function listPacks() {
-  const packsDir = path25.join(__dirname, ".");
+  const packsDir = path26.join(__dirname, ".");
   if (!existsSync19(packsDir)) return [];
   return readdirSync8(packsDir, { withFileTypes: true }).filter(
-    (d) => d.isDirectory() && existsSync19(path25.join(packsDir, d.name, "custom-objects.json"))
+    (d) => d.isDirectory() && existsSync19(path26.join(packsDir, d.name, "custom-objects.json"))
   ).map((d) => d.name);
 }
 function loadPack(industry) {
-  const packDir = path25.join(__dirname, industry);
-  const objectsPath = path25.join(packDir, "custom-objects.json");
-  const triggersPath = path25.join(packDir, "triggers.json");
-  const wikiDir = path25.join(packDir, "wiki-seeds");
-  const manifestPath = path25.join(packDir, "pack.json");
-  const identityContextPath = path25.join(packDir, "identity-context.md");
+  const packDir = path26.join(__dirname, industry);
+  const objectsPath = path26.join(packDir, "custom-objects.json");
+  const triggersPath = path26.join(packDir, "triggers.json");
+  const wikiDir = path26.join(packDir, "wiki-seeds");
+  const manifestPath = path26.join(packDir, "pack.json");
+  const identityContextPath = path26.join(packDir, "identity-context.md");
   if (!existsSync19(objectsPath)) return null;
   let customObjects = [];
   try {
@@ -13555,7 +14308,7 @@ function loadPack(industry) {
   if (existsSync19(wikiDir)) {
     const files = readdirSync8(wikiDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync17(path25.join(wikiDir, file), "utf-8");
+      const content = readFileSync17(path26.join(wikiDir, file), "utf-8");
       const titleMatch = content.match(/^#\s+(.+)/m);
       wikiSeeds.push({
         filename: file,
@@ -13633,7 +14386,7 @@ function applyPack(industry, project) {
 // src/lib/client-coo.ts
 init_config();
 import { existsSync as existsSync20, mkdirSync as mkdirSync11, writeFileSync as writeFileSync13 } from "fs";
-import path26 from "path";
+import path27 from "path";
 
 // src/lib/employee-templates.ts
 init_global_procedures();
@@ -13771,10 +14524,10 @@ var ClientCOOClobberError = class extends Error {
 var COO_ROLE = "Chief Operating Officer";
 var FEEDBACK_BEHAVIOR_CONTENT = "Tag exe-os issues with needs_improvement \u2014 this is the feedback loop that surfaces bugs, gaps, and friction to the founder each Monday.";
 async function provisionClientCOO(vars, opts = {}) {
-  const identityDir = opts.identityDir ?? path26.join(EXE_AI_DIR, "identity");
+  const identityDir = opts.identityDir ?? path27.join(EXE_AI_DIR, "identity");
   const rosterPath = opts.employeesPath ?? EMPLOYEES_PATH;
   const storeFeedbackBehavior = opts.storeFeedbackBehavior ?? true;
-  const identityPath2 = path26.join(identityDir, `${vars.agent_name}.md`);
+  const identityPath2 = path27.join(identityDir, `${vars.agent_name}.md`);
   if (existsSync20(identityPath2)) {
     throw new ClientCOOClobberError(vars.agent_name, identityPath2);
   }
@@ -14672,7 +15425,7 @@ function registerUpdateWikiPage(server2) {
 import { z as z37 } from "zod";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import path27 from "path";
+import path28 from "path";
 import { existsSync as existsSync21 } from "fs";
 
 // src/lib/hostinger-api.ts
@@ -14721,9 +15474,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path40, body) {
+  async request(method, path41, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path40}`;
+    const url = `${this.baseUrl}${path41}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -14796,8 +15549,8 @@ async function requestCloudflare(cfApiToken, zoneId, options) {
   }
   return envelope.result;
 }
-function buildUrl(zoneId, path40 = "/dns_records", query) {
-  const normalizedPath = path40.startsWith("/") ? path40 : `/${path40}`;
+function buildUrl(zoneId, path41 = "/dns_records", query) {
+  const normalizedPath = path41.startsWith("/") ? path41 : `/${path41}`;
   const url = new URL(
     `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
   );
@@ -15010,12 +15763,12 @@ async function waitForReady(client, vpsId) {
 }
 async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
   const safeClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, "-");
-  const playbookDir = path27.resolve(process.cwd(), "infrastructure", "ansible");
-  const playbookPath = path27.join(playbookDir, "deploy.yml");
-  const inventoryPath = path27.join(playbookDir, "inventory", "hosts.yml");
-  const clientVarsPath = path27.join(playbookDir, "vars", `${safeClientName}.yml`);
-  const varsDir = path27.join(playbookDir, "vars");
-  if (!path27.resolve(clientVarsPath).startsWith(path27.resolve(varsDir))) {
+  const playbookDir = path28.resolve(process.cwd(), "infrastructure", "ansible");
+  const playbookPath = path28.join(playbookDir, "deploy.yml");
+  const inventoryPath = path28.join(playbookDir, "inventory", "hosts.yml");
+  const clientVarsPath = path28.join(playbookDir, "vars", `${safeClientName}.yml`);
+  const varsDir = path28.join(playbookDir, "vars");
+  if (!path28.resolve(clientVarsPath).startsWith(path28.resolve(varsDir))) {
     throw new Error(`Invalid client name for vars path: ${clientName}`);
   }
   const args = [
@@ -15105,7 +15858,7 @@ function buildInventoryRecord(params) {
 // src/mcp/tools/export-orchestration.ts
 init_active_agent();
 import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
-import path29 from "path";
+import path30 from "path";
 import { z as z38 } from "zod";
 
 // src/lib/orchestration-package.ts
@@ -15114,8 +15867,8 @@ init_identity();
 init_platform_procedures();
 import { randomUUID as randomUUID5 } from "crypto";
 import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
-import os11 from "os";
-import path28 from "path";
+import os12 from "os";
+import path29 from "path";
 var PACKAGE_VERSION = "1.0";
 var ROSTER_FILENAME = "exe-employees.json";
 var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
@@ -15181,10 +15934,10 @@ function validateProcedureEntry(value, index) {
   };
 }
 function getRosterPath() {
-  return path28.join(os11.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+  return path29.join(os12.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
 }
 function getBackupPath() {
-  return path28.join(os11.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+  return path29.join(os12.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
 }
 function readRosterFile() {
   const rosterPath = getRosterPath();
@@ -15201,7 +15954,7 @@ function writeRosterFile(roster) {
     throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
   }
   const rosterPath = getRosterPath();
-  mkdirSync12(path28.dirname(rosterPath), { recursive: true });
+  mkdirSync12(path29.dirname(rosterPath), { recursive: true });
   if (existsSync22(rosterPath)) {
     const currentRoster = readRosterFile();
     if (roster.length < currentRoster.length) {
@@ -15473,7 +16226,7 @@ function registerExportOrchestration(server2) {
       try {
         await initStore();
         const pkg = await exportOrchestration(getActiveAgent().agentId);
-        mkdirSync13(path29.dirname(output_path), { recursive: true });
+        mkdirSync13(path30.dirname(output_path), { recursive: true });
         writeFileSync15(output_path, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
         return {
@@ -15674,17 +16427,17 @@ function registerQueryConversations(server2) {
 // src/mcp/tools/load-skill.ts
 import { z as z41 } from "zod";
 import { readFileSync as readFileSync20, readdirSync as readdirSync9, statSync as statSync3 } from "fs";
-import path30 from "path";
+import path31 from "path";
 import { homedir as homedir2 } from "os";
-var SKILLS_DIR = path30.join(homedir2(), ".claude", "skills");
+var SKILLS_DIR = path31.join(homedir2(), ".claude", "skills");
 function listAvailableSkills() {
   try {
     const entries = readdirSync9(SKILLS_DIR);
     return entries.filter((entry) => {
       try {
-        const entryPath = path30.join(SKILLS_DIR, entry);
+        const entryPath = path31.join(SKILLS_DIR, entry);
         if (!statSync3(entryPath).isDirectory()) return false;
-        const skillFile = path30.join(entryPath, "SKILL.md");
+        const skillFile = path31.join(entryPath, "SKILL.md");
         statSync3(skillFile);
         return true;
       } catch {
@@ -15727,8 +16480,8 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
           }]
         };
       }
-      const sanitized = path30.basename(skill_name);
-      const skillFile = path30.join(SKILLS_DIR, sanitized, "SKILL.md");
+      const sanitized = path31.basename(skill_name);
+      const skillFile = path31.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
         const content = readFileSync20(skillFile, "utf-8");
         return {
@@ -16369,8 +17122,8 @@ init_database();
 import { readdir } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
-import path31 from "path";
-import os12 from "os";
+import path32 from "path";
+import os13 from "os";
 var MODEL_PRICING = {
   // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
   "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
@@ -16418,18 +17171,18 @@ async function getAgentSpend(period = "7d") {
   for (const row of result.rows) {
     sessionAgent.set(row.session_uuid, row.agent_id);
   }
-  const claudeDir = path31.join(os12.homedir(), ".claude", "projects");
+  const claudeDir = path32.join(os13.homedir(), ".claude", "projects");
   let projectDirs = [];
   try {
     const entries = await readdir(claudeDir);
-    projectDirs = entries.map((e) => path31.join(claudeDir, e));
+    projectDirs = entries.map((e) => path32.join(claudeDir, e));
   } catch {
     return [];
   }
   const agentTotals = /* @__PURE__ */ new Map();
   for (const [sessionUuid, agentId] of sessionAgent) {
     for (const dir of projectDirs) {
-      const jsonlPath = path31.join(dir, `${sessionUuid}.jsonl`);
+      const jsonlPath = path32.join(dir, `${sessionUuid}.jsonl`);
       try {
         const usage = await extractSessionUsage(jsonlPath);
         if (usage.input === 0 && usage.output === 0) continue;
@@ -17007,12 +17760,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path40 = await import("path");
-        const os14 = await import("os");
-        const outDir = path40.join(os14.homedir(), ".exe-os", "exports");
+        const path41 = await import("path");
+        const os15 = await import("os");
+        const outDir = path41.join(os15.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path40.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path41.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -17234,9 +17987,9 @@ function registerListAgentSessions(server2) {
 // src/mcp/tools/get-daemon-health.ts
 import { z as z56 } from "zod";
 import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
-import path32 from "path";
+import path33 from "path";
 import { homedir as homedir3 } from "os";
-var PID_PATH2 = path32.join(homedir3(), ".exe-os", "exed.pid");
+var PID_PATH2 = path33.join(homedir3(), ".exe-os", "exed.pid");
 function formatUptime(seconds) {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor(seconds % 3600 / 60);
@@ -17426,8 +18179,8 @@ init_worker_gate();
 init_config();
 import { z as z58 } from "zod";
 import { readdirSync as readdirSync11, existsSync as existsSync26 } from "fs";
-import path34 from "path";
-var WORKER_PID_DIR2 = path34.join(EXE_AI_DIR, "worker-pids");
+import path35 from "path";
+var WORKER_PID_DIR2 = path35.join(EXE_AI_DIR, "worker-pids");
 function countAliveWorkers() {
   let alive = 0;
   let stale = 0;
@@ -17503,7 +18256,7 @@ import { z as z59 } from "zod";
 // src/bin/exe-doctor.ts
 init_store();
 init_database();
-import os13 from "os";
+import os14 from "os";
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
@@ -17523,7 +18276,7 @@ function isMainModule(importMetaUrl) {
 // src/bin/exe-doctor.ts
 import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path35 from "path";
+import path36 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 
 // src/lib/conflict-detector.ts
@@ -17926,7 +18679,7 @@ async function auditOrphanedProjects(client) {
   for (const row of result.rows) {
     const name = row.project_name;
     const count = Number(row.cnt);
-    const exists = existsSync27(path35.join(home, name)) || existsSync27(path35.join(home, "..", name)) || existsSync27(path35.join(process.cwd(), "..", name));
+    const exists = existsSync27(path36.join(home, name)) || existsSync27(path36.join(home, "..", name)) || existsSync27(path36.join(process.cwd(), "..", name));
     if (!exists) {
       orphans.push({ project_name: name, count });
     }
@@ -17934,7 +18687,7 @@ async function auditOrphanedProjects(client) {
   return orphans;
 }
 function auditHookHealth() {
-  const logPath = path35.join(
+  const logPath = path36.join(
     process.env.HOME ?? process.env.USERPROFILE ?? "",
     ".exe-os",
     "logs",
@@ -18020,7 +18773,7 @@ function formatReport(report, flags) {
     }
     lines.push("");
   }
-  const totalMemGB = os13.totalmem() / (1024 * 1024 * 1024);
+  const totalMemGB = os14.totalmem() / (1024 * 1024 * 1024);
   const isLowMemSystem = totalMemGB <= 8;
   if (isLowMemSystem && report.nullVectors > 0) {
     lines.push(`\u{1F7E2} Null vectors:     ${fmtNum(report.nullVectors)} / ${fmtNum(s.total)} (expected \u2014 8GB system, keyword search mode)`);
@@ -18142,7 +18895,7 @@ async function fixNullVectors() {
     }
   }
   const npmRoot = (await import("child_process")).execSync("npm root -g", { encoding: "utf8" }).trim();
-  const backfillPath = path35.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
+  const backfillPath = path36.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
   return new Promise((resolve, reject) => {
     const child = spawn2("node", [backfillPath], { stdio: "inherit" });
     if (child.pid) registerWorkerPid2(child.pid);
@@ -18342,7 +19095,7 @@ import { z as z60 } from "zod";
 init_database();
 import { readFileSync as readFileSync25, writeFileSync as writeFileSync19, existsSync as existsSync29, readdirSync as readdirSync12, mkdirSync as mkdirSync16, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto16 from "crypto";
-import path37 from "path";
+import path38 from "path";
 import { homedir as homedir6 } from "os";
 
 // src/lib/crypto.ts
@@ -18416,7 +19169,7 @@ function sqlSafe(v) {
 }
 function logError(msg) {
   try {
-    const logPath = path37.join(homedir6(), ".exe-os", "workers.log");
+    const logPath = path38.join(homedir6(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -18425,7 +19178,7 @@ function logError(msg) {
 var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
 var FETCH_TIMEOUT_MS4 = 3e4;
 var PUSH_BATCH_SIZE = 5e3;
-var ROSTER_LOCK_PATH = path37.join(EXE_AI_DIR, "roster-merge.lock");
+var ROSTER_LOCK_PATH = path38.join(EXE_AI_DIR, "roster-merge.lock");
 var LOCK_STALE_MS = 3e4;
 async function withRosterLock(fn) {
   try {
@@ -18816,7 +19569,7 @@ async function cloudSync(config2) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path37.join(EXE_AI_DIR, "identity");
+    const idDir = path38.join(EXE_AI_DIR, "identity");
     if (existsSync29(idDir)) {
       rosterResult.identities = readdirSync12(idDir).filter((f) => f.endsWith(".md")).length;
     }
@@ -18835,7 +19588,7 @@ async function cloudSync(config2) {
     roster: rosterResult
   };
 }
-var ROSTER_DELETIONS_PATH = path37.join(EXE_AI_DIR, "roster-deletions.json");
+var ROSTER_DELETIONS_PATH = path38.join(EXE_AI_DIR, "roster-deletions.json");
 function consumeRosterDeletions() {
   try {
     if (!existsSync29(ROSTER_DELETIONS_PATH)) return [];
@@ -18847,9 +19600,9 @@ function consumeRosterDeletions() {
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path37.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path37.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path37.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path38.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path38.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path38.join(EXE_AI_DIR, "config.json");
   let roster = [];
   if (existsSync29(rosterPath)) {
     try {
@@ -18861,7 +19614,7 @@ function buildRosterBlob(paths) {
   if (existsSync29(identityDir)) {
     for (const file of readdirSync12(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync25(path37.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync25(path38.join(identityDir, file), "utf-8");
       } catch {
       }
     }
@@ -18874,7 +19627,7 @@ function buildRosterBlob(paths) {
     }
   }
   let agentConfig;
-  const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
+  const agentConfigPath = path38.join(EXE_AI_DIR, "agent-config.json");
   if (existsSync29(agentConfigPath)) {
     try {
       agentConfig = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
@@ -18953,7 +19706,7 @@ async function cloudPullRoster(config2) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path37.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path38.join(EXE_AI_DIR, "config.json");
   let local = {};
   if (existsSync29(cfgPath)) {
     try {
@@ -18962,14 +19715,14 @@ function mergeConfig(remoteConfig, configPath) {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path37.dirname(cfgPath);
+  const dir = path38.dirname(cfgPath);
   if (!existsSync29(dir)) mkdirSync16(dir, { recursive: true });
   writeFileSync19(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path37.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path38.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -18991,7 +19744,7 @@ async function mergeRosterFromRemote(remote, paths) {
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
         if (!existsSync29(identityDir)) mkdirSync16(identityDir, { recursive: true });
-        const idPath = path37.join(identityDir, `${remoteEmp.name}.md`);
+        const idPath = path38.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
           localIdentity = existsSync29(idPath) ? readFileSync25(idPath, "utf-8") : null;
@@ -19024,7 +19777,7 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path38.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
         if (existsSync29(agentConfigPath)) {
           try {
@@ -19753,15 +20506,515 @@ function registerGetLicenseStatus(server2) {
   );
 }
 
-// src/mcp/tools/people-roster.ts
+// src/mcp/tools/backup-vps.ts
+init_keychain();
 import { z as z64 } from "zod";
 
+// src/lib/vps-backup.ts
+import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
+import { Readable } from "stream";
+import { spawn as spawn3 } from "child_process";
+import {
+  DeleteObjectsCommand,
+  GetObjectCommand,
+  ListObjectsV2Command,
+  PutObjectCommand,
+  S3Client
+} from "@aws-sdk/client-s3";
+import {
+  constants as brotliConstants,
+  brotliCompressSync as brotliCompressSync2,
+  brotliDecompressSync as brotliDecompressSync2
+} from "zlib";
+var ALGORITHM2 = "aes-256-gcm";
+var IV_BYTES = 12;
+var TAG_BYTES = 16;
+var CLIENT_ID_FALLBACK = "default";
+var BACKUP_EXT = ".pgdump.br.enc";
+var BACKUP_PREFIX = "backups/";
+function makeS3Client(opts) {
+  return new S3Client({
+    region: "auto",
+    endpoint: opts.r2Endpoint,
+    credentials: {
+      accessKeyId: opts.r2AccessKeyId,
+      secretAccessKey: opts.r2SecretAccessKey
+    }
+  });
+}
+function parsePostgresClientId(databaseUrl) {
+  try {
+    const parsed = new URL(databaseUrl);
+    const candidate = parsed.pathname.split("/").filter(Boolean).pop() ?? CLIENT_ID_FALLBACK;
+    const name = decodeURIComponent(candidate).trim() || CLIENT_ID_FALLBACK;
+    return name.replace(/[^a-zA-Z0-9._-]/g, "_");
+  } catch {
+    return CLIENT_ID_FALLBACK;
+  }
+}
+function makeBackupTimestamp(date = /* @__PURE__ */ new Date()) {
+  return date.toISOString().replace(/[:.]/g, "-");
+}
+function makeBackupKey(databaseUrl, date = /* @__PURE__ */ new Date()) {
+  const clientId = parsePostgresClientId(databaseUrl);
+  return `${BACKUP_PREFIX}${clientId}/${makeBackupTimestamp(date)}${BACKUP_EXT}`;
+}
+function validateEncryptionKey(encryptionKey) {
+  if (encryptionKey.length !== 32) {
+    throw new Error(`Encryption key must be 32 bytes for AES-256, got ${encryptionKey.length}`);
+  }
+}
+function encryptBlob(input, encryptionKey) {
+  validateEncryptionKey(encryptionKey);
+  const iv = randomBytes(IV_BYTES);
+  const cipher = createCipheriv(ALGORITHM2, encryptionKey, iv);
+  const ciphertext = Buffer.concat([cipher.update(input), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([iv, tag, ciphertext]);
+}
+function decryptBlob(input, encryptionKey) {
+  validateEncryptionKey(encryptionKey);
+  if (input.length < IV_BYTES + TAG_BYTES) {
+    throw new Error("Encrypted backup blob is too short");
+  }
+  const iv = input.subarray(0, IV_BYTES);
+  const tag = input.subarray(IV_BYTES, IV_BYTES + TAG_BYTES);
+  const ciphertext = input.subarray(IV_BYTES + TAG_BYTES);
+  const decipher = createDecipheriv(ALGORITHM2, encryptionKey, iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function compress2(input) {
+  if (input.length === 0) return Buffer.alloc(0);
+  return brotliCompressSync2(input, {
+    params: {
+      [brotliConstants.BROTLI_PARAM_QUALITY]: 4
+    }
+  });
+}
+function decompress2(input) {
+  if (input.length === 0) return Buffer.alloc(0);
+  return brotliDecompressSync2(input);
+}
+async function runProcess(command, args, input) {
+  return new Promise((resolve, reject) => {
+    const child = spawn3(command, args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    const stderrChunks = [];
+    child.stdout.on("data", (chunk) => {
+      stdoutChunks.push(chunk);
+    });
+    child.stderr.on("data", (chunk) => {
+      stderrChunks.push(chunk);
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+    child.on("close", (code) => {
+      if (code !== 0) {
+        const stderr = Buffer.concat(stderrChunks).toString("utf8").trim();
+        reject(new Error(`Command failed: ${command} ${args.join(" ")} (code ${code})${stderr ? `: ${stderr}` : ""}`));
+        return;
+      }
+      resolve(Buffer.concat(stdoutChunks));
+    });
+    if (input) {
+      child.stdin.write(input);
+      child.stdin.end();
+    }
+  });
+}
+async function listBackupObjects(client, bucket, prefix) {
+  const objects = [];
+  let token;
+  do {
+    const command = new ListObjectsV2Command({
+      Bucket: bucket,
+      Prefix: prefix,
+      ContinuationToken: token
+    });
+    const response = await client.send(command);
+    const items = response.Contents ?? [];
+    for (const obj of items) {
+      if (!obj.Key || !obj.LastModified) continue;
+      objects.push({
+        key: obj.Key,
+        size: typeof obj.Size === "number" ? obj.Size : Number(obj.Size ?? 0),
+        lastModified: obj.LastModified
+      });
+    }
+    token = response.IsTruncated ? response.NextContinuationToken : void 0;
+  } while (token);
+  return objects;
+}
+function selectRetentionKeep(keys) {
+  if (keys.length <= 11) {
+    return new Set(keys.map((k) => k.key));
+  }
+  const newest = [...keys].sort((a, b) => b.lastModified.getTime() - a.lastModified.getTime());
+  const keep = /* @__PURE__ */ new Set();
+  const seenDays = /* @__PURE__ */ new Set();
+  const seenWeeks = /* @__PURE__ */ new Set();
+  for (const backup of newest) {
+    if (keep.size >= 11) break;
+    const day = backup.lastModified.toISOString().slice(0, 10);
+    if (seenDays.size < 7 && !seenDays.has(day)) {
+      seenDays.add(day);
+      keep.add(backup.key);
+    }
+  }
+  const dayCount = seenDays.size;
+  if (dayCount >= 7) {
+    for (const backup of newest) {
+      if (keep.has(backup.key) || keep.size >= 11) {
+        continue;
+      }
+      const week = getWeekBucket(backup.lastModified);
+      if (seenWeeks.size < 4 && !seenWeeks.has(week)) {
+        seenWeeks.add(week);
+        keep.add(backup.key);
+      }
+      if (seenWeeks.size >= 4) {
+        break;
+      }
+    }
+  }
+  return keep;
+}
+function getWeekBucket(date) {
+  const start = Date.UTC(date.getUTCFullYear(), 0, 0);
+  const dayOfYear = Math.floor((Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()) - start) / 864e5);
+  const week = Math.floor(dayOfYear / 7) + 1;
+  return `${date.getUTCFullYear()}-W${String(week).padStart(2, "0")}`;
+}
+async function enforceRetentionPolicy(opts, clientId, allObjects) {
+  const s3 = makeS3Client(opts);
+  const prefix = `${BACKUP_PREFIX}${clientId}/`;
+  const relevant = allObjects.filter((o) => o.key.startsWith(prefix));
+  const keep = selectRetentionKeep(relevant);
+  if (keep.size >= relevant.length) {
+    return;
+  }
+  const toDelete = relevant.filter((obj) => !keep.has(obj.key)).map((obj) => ({ Key: obj.key })).filter((entry) => Boolean(entry.Key));
+  const deleteBatches = chunkArray(toDelete, 1e3);
+  for (const batch of deleteBatches) {
+    await s3.send(
+      new DeleteObjectsCommand({
+        Bucket: opts.r2Bucket,
+        Delete: { Objects: batch }
+      })
+    );
+  }
+}
+function chunkArray(items, size) {
+  const chunks = [];
+  for (let i = 0; i < items.length; i += size) {
+    chunks.push(items.slice(i, i + size));
+  }
+  return chunks;
+}
+async function readStreamFully(input) {
+  const stream = normalizeS3Body(input);
+  const chunks = [];
+  return new Promise((resolve, reject) => {
+    stream.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+    stream.on("error", (error) => reject(error));
+  });
+}
+function normalizeS3Body(body) {
+  if (body instanceof Readable) return body;
+  if (body && typeof body === "object" && "getReader" in body) {
+    const reader = body.getReader();
+    const readable = new Readable({ read() {
+    } });
+    (async () => {
+      try {
+        while (true) {
+          const { done, value } = await reader.read();
+          if (done) {
+            readable.push(null);
+            break;
+          }
+          readable.push(Buffer.from(value));
+        }
+      } catch (error) {
+        readable.destroy(error);
+      }
+    })();
+    return readable;
+  }
+  throw new Error("Unsupported S3 object body type");
+}
+async function createBackup(opts) {
+  validateEncryptionKey(opts.encryptionKey);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const key = makeBackupKey(opts.databaseUrl, new Date(timestamp));
+  const client = makeS3Client(opts);
+  const dump = await runProcess("pg_dump", ["--format=custom", opts.databaseUrl]);
+  const compressed = compress2(dump);
+  const encrypted = encryptBlob(compressed, opts.encryptionKey);
+  await client.send(
+    new PutObjectCommand({
+      Bucket: opts.r2Bucket,
+      Key: key,
+      Body: Readable.from(encrypted),
+      ContentType: "application/octet-stream",
+      ContentLength: encrypted.length
+    })
+  );
+  const all = await listBackupObjects(client, opts.r2Bucket, BACKUP_PREFIX);
+  const clientId = parsePostgresClientId(opts.databaseUrl);
+  await enforceRetentionPolicy(
+    {
+      r2Bucket: opts.r2Bucket,
+      r2Endpoint: opts.r2Endpoint,
+      r2AccessKeyId: opts.r2AccessKeyId,
+      r2SecretAccessKey: opts.r2SecretAccessKey
+    },
+    clientId,
+    all
+  );
+  return {
+    key,
+    sizeBytes: encrypted.length,
+    timestamp
+  };
+}
+async function restoreBackup(opts) {
+  validateEncryptionKey(opts.encryptionKey);
+  const client = makeS3Client(opts);
+  const response = await client.send(
+    new GetObjectCommand({
+      Bucket: opts.r2Bucket,
+      Key: opts.backupKey
+    })
+  );
+  if (!response.Body) {
+    throw new Error(`Backup not found in R2: ${opts.backupKey}`);
+  }
+  const encrypted = await readStreamFully(response.Body);
+  const decompressed = decompress2(decryptBlob(encrypted, opts.encryptionKey));
+  await runProcess("pg_restore", ["--clean", "--if-exists", "-d", opts.databaseUrl], decompressed);
+}
+async function listBackups(opts) {
+  const s3 = makeS3Client(opts);
+  const objects = await listBackupObjects(s3, opts.r2Bucket, BACKUP_PREFIX);
+  return objects.filter((obj) => obj.key.endsWith(BACKUP_EXT)).map((obj) => ({
+    key: obj.key,
+    size: obj.size,
+    lastModified: obj.lastModified.toISOString()
+  })).sort((a, b) => b.lastModified.localeCompare(a.lastModified));
+}
+async function backupHealth(opts) {
+  const backups = await listBackups(opts);
+  if (backups.length === 0) {
+    return {
+      lastBackup: null,
+      backupCount: 0,
+      totalSizeBytes: 0,
+      oldestBackup: null
+    };
+  }
+  return {
+    lastBackup: backups[0].lastModified,
+    backupCount: backups.length,
+    totalSizeBytes: backups.reduce((acc, item) => acc + item.size, 0),
+    oldestBackup: backups[backups.length - 1].lastModified
+  };
+}
+
+// src/mcp/tools/backup-vps.ts
+function registerBackupVps(server2) {
+  server2.registerTool(
+    "backup_vps",
+    {
+      title: "VPS Backup",
+      description: "Run VPS Postgres backup/restore workflows and check status.",
+      inputSchema: z64.discriminatedUnion("action", [
+        z64.object({
+          action: z64.literal("backup"),
+          databaseUrl: z64.string().min(1).describe("Postgres DATABASE_URL to dump from"),
+          encryptionKeyB64: z64.string().min(1).max(4096).optional().describe(
+            "Base64 AES-256 key (defaults to local master key if omitted)"
+          ),
+          r2Bucket: z64.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z64.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z64.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z64.string().min(1).describe("R2 secret access key")
+        }),
+        z64.object({
+          action: z64.literal("restore"),
+          databaseUrl: z64.string().min(1).describe("Target Postgres DATABASE_URL for restore"),
+          backupKey: z64.string().min(1).describe("R2 object key to restore from"),
+          encryptionKeyB64: z64.string().min(1).max(4096).optional().describe(
+            "Base64 AES-256 key (defaults to local master key if omitted)"
+          ),
+          r2Bucket: z64.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z64.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z64.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z64.string().min(1).describe("R2 secret access key")
+        }),
+        z64.object({
+          action: z64.literal("list"),
+          r2Bucket: z64.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z64.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z64.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z64.string().min(1).describe("R2 secret access key")
+        }),
+        z64.object({
+          action: z64.literal("health"),
+          r2Bucket: z64.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z64.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z64.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z64.string().min(1).describe("R2 secret access key")
+        })
+      ])
+    },
+    async (input) => {
+      try {
+        switch (input.action) {
+          case "backup": {
+            const encryptionKey = await resolveEncryptionKey(input.encryptionKeyB64);
+            const options = {
+              databaseUrl: input.databaseUrl,
+              encryptionKey,
+              r2Bucket: input.r2Bucket,
+              r2Endpoint: input.r2Endpoint,
+              r2AccessKeyId: input.r2AccessKeyId,
+              r2SecretAccessKey: input.r2SecretAccessKey
+            };
+            const result = await createBackup(options);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Backup complete: ${result.key}
+${result.sizeBytes} bytes
+${result.timestamp}`
+                }
+              ]
+            };
+          }
+          case "restore": {
+            const encryptionKey = await resolveEncryptionKey(input.encryptionKeyB64);
+            const options = {
+              databaseUrl: input.databaseUrl,
+              backupKey: input.backupKey,
+              encryptionKey,
+              r2Bucket: input.r2Bucket,
+              r2Endpoint: input.r2Endpoint,
+              r2AccessKeyId: input.r2AccessKeyId,
+              r2SecretAccessKey: input.r2SecretAccessKey
+            };
+            await restoreBackup(options);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Restore complete from ${input.backupKey}`
+                }
+              ]
+            };
+          }
+          case "list": {
+            const options = {
+              r2Bucket: input.r2Bucket,
+              r2Endpoint: input.r2Endpoint,
+              r2AccessKeyId: input.r2AccessKeyId,
+              r2SecretAccessKey: input.r2SecretAccessKey
+            };
+            const result = await listBackups(options);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: formatBackups(result)
+                }
+              ]
+            };
+          }
+          case "health": {
+            const result = await backupHealth({
+              r2Bucket: input.r2Bucket,
+              r2Endpoint: input.r2Endpoint,
+              r2AccessKeyId: input.r2AccessKeyId,
+              r2SecretAccessKey: input.r2SecretAccessKey
+            });
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: [
+                    `last_backup: ${result.lastBackup ?? "none"}`,
+                    `backup_count: ${result.backupCount}`,
+                    `total_size_bytes: ${result.totalSizeBytes}`,
+                    `oldest_backup: ${result.oldestBackup ?? "none"}`
+                  ].join("\n")
+                }
+              ]
+            };
+          }
+          default:
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: "Unknown backup action"
+                }
+              ],
+              isError: true
+            };
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: error instanceof Error ? error.message : String(error)
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+function formatBackups(backups) {
+  if (backups.length === 0) {
+    return "No backups found.";
+  }
+  const lines = [
+    "# VPS backups",
+    "",
+    "| Key | Size | Last Modified |",
+    "| --- | ----: | ------------- |",
+    ...backups.map((item) => `| ${item.key} | ${item.size.toLocaleString()} | ${item.lastModified} |`)
+  ];
+  return lines.join("\n");
+}
+async function resolveEncryptionKey(providedB64) {
+  if (providedB64) {
+    return Buffer.from(providedB64, "base64");
+  }
+  const masterKey = await getMasterKey();
+  if (!masterKey) {
+    throw new Error("No encryption key provided and no local master key is available.");
+  }
+  return masterKey;
+}
+
+// src/mcp/tools/people-roster.ts
+import { z as z65 } from "zod";
+
 // src/lib/people.ts
 init_config();
 import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
 import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
-import path38 from "path";
-var PEOPLE_PATH = path38.join(EXE_AI_DIR, "people.json");
+import path39 from "path";
+var PEOPLE_PATH = path39.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {
   if (!existsSync30(PEOPLE_PATH)) return [];
   try {
@@ -19772,7 +21025,7 @@ async function loadPeople() {
   }
 }
 async function savePeople(people) {
-  await mkdir5(path38.dirname(PEOPLE_PATH), { recursive: true });
+  await mkdir5(path39.dirname(PEOPLE_PATH), { recursive: true });
   await writeFile6(PEOPLE_PATH, JSON.stringify(people, null, 2) + "\n", "utf-8");
 }
 async function addPerson(person) {
@@ -19802,10 +21055,10 @@ function registerAddPerson(server2) {
       title: "Add Person",
       description: "Add or update a key human in the people roster. Used for co-founders, partners, customers \u2014 anyone agents need to know about.",
       inputSchema: {
-        name: z64.string().describe("Person's name"),
-        role: z64.string().describe("Their role (e.g. co-founder, customer, partner)"),
-        relationship: z64.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
-        notes: z64.string().optional().describe("Additional context about this person")
+        name: z65.string().describe("Person's name"),
+        role: z65.string().describe("Their role (e.g. co-founder, customer, partner)"),
+        relationship: z65.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
+        notes: z65.string().optional().describe("Additional context about this person")
       }
     },
     async ({ name, role, relationship, notes }) => {
@@ -19851,7 +21104,7 @@ function registerGetPerson(server2) {
       title: "Get Person",
       description: "Look up a specific person by name from the people roster.",
       inputSchema: {
-        name: z64.string().describe("Person's name to look up")
+        name: z65.string().describe("Person's name to look up")
       }
     },
     async ({ name }) => {
@@ -19879,7 +21132,7 @@ init_active_agent();
 init_agent_config();
 init_runtime_table();
 init_employees();
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 function registerSetAgentConfig(server2) {
   server2.registerTool(
     "set_agent_config",
@@ -19887,14 +21140,22 @@ function registerSetAgentConfig(server2) {
       title: "Set Agent Config",
       description: "Set or view per-agent runtime + model configuration. Controls which runtime (claude, codex, opencode) and model each agent uses when dispatched. COO-only. Omit runtime/model to view current config for an agent or all agents.",
       inputSchema: {
-        agent_id: z65.string().optional().describe("Agent name, or 'default' for org-wide default. Omit to view all agents."),
-        runtime: z65.string().optional().describe(`Runtime: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`),
-        model: z65.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, anthropic/claude-sonnet-4-6)")
+        agent_id: z66.string().optional().describe("Agent name, or 'default' for org-wide default. Omit to view all agents."),
+        runtime: z66.string().optional().describe(`Runtime: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`),
+        model: z66.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, anthropic/claude-sonnet-4-6)")
       }
     },
     async ({ agent_id, runtime, model }) => {
-      const { agentRole } = getActiveAgent();
-      if (agentRole !== "COO") {
+      const { agentId, agentRole } = getActiveAgent();
+      const isCoordinator = isCoordinatorRole(agentRole) || (() => {
+        try {
+          const emp = getEmployee(loadEmployeesSync(), agentId);
+          return emp ? isCoordinatorRole(emp.role) : false;
+        } catch {
+          return false;
+        }
+      })();
+      if (!isCoordinator) {
         return {
           content: [
             {
@@ -19979,6 +21240,72 @@ function registerSetAgentConfig(server2) {
   );
 }
 
+// src/mcp/tools/list-employees.ts
+init_employees();
+init_agent_config();
+import { z as z67 } from "zod";
+function registerListEmployees(server2) {
+  server2.registerTool(
+    "list_employees",
+    {
+      title: "List Employees",
+      description: "List all AI employees in the organization with their role, runtime, and model configuration. Use to see who's on the team and how they're configured.",
+      inputSchema: {
+        role: z67.string().optional().describe("Filter by role (case-insensitive)")
+      }
+    },
+    async ({ role }) => {
+      try {
+        let employees = loadEmployeesSync();
+        if (role) {
+          const lower = role.toLowerCase();
+          employees = employees.filter(
+            (e) => e.role.toLowerCase().includes(lower)
+          );
+        }
+        if (employees.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: role ? `No employees found with role matching "${role}".` : "No employees in roster."
+              }
+            ]
+          };
+        }
+        const lines = [
+          "Employee Roster",
+          "\u2550".repeat(70),
+          "Name".padEnd(12) + "Role".padEnd(20) + "Runtime".padEnd(16) + "Model",
+          "\u2500".repeat(70)
+        ];
+        for (const emp of employees) {
+          const cfg = getAgentRuntime(emp.name);
+          const rtLabel = RUNTIME_LABELS[cfg.runtime] ?? cfg.runtime;
+          lines.push(
+            emp.name.padEnd(12) + emp.role.padEnd(20) + rtLabel.substring(0, 15).padEnd(16) + cfg.model
+          );
+        }
+        lines.push("\u2500".repeat(70));
+        lines.push(`${employees.length} employee(s)`);
+        return {
+          content: [{ type: "text", text: lines.join("\n") }]
+        };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to list employees: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/lib/telemetry.ts
 var ENABLED = process.env.EXE_TELEMETRY === "1";
 var initialized = false;
@@ -20106,6 +21433,7 @@ registerGetAutoWakeStatus(server);
 registerGetWorkerGate(server);
 registerRunMemoryAudit(server);
 registerCloudSync(server);
+registerBackupVps(server);
 registerGetMemoryCardinality(server);
 registerRunConsolidation(server);
 registerGetLicenseStatus(server);
@@ -20113,12 +21441,19 @@ registerAddPerson(server);
 registerListPeople(server);
 registerGetPerson(server);
 registerSetAgentConfig(server);
+registerListEmployees(server);
 try {
   await initStore();
   process.stderr.write("[exe-os] MCP server starting...\n");
   const transport = new StdioServerTransport();
   await server.connect(transport);
   process.stderr.write("[exe-os] MCP server connected.\n");
+  void initDaemonClient().catch((err) => {
+    process.stderr.write(
+      `[exe-os] Daemon DB routing unavailable (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  });
   void (async () => {
     try {
       const { checkLicense: checkLicense2 } = await Promise.resolve().then(() => (init_license(), license_exports));
@@ -20175,20 +21510,20 @@ try {
 `
       );
       const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path39.resolve(
-        path39.dirname(thisFile),
+      const backfillPath = path40.resolve(
+        path40.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
       if (existsSync31(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path39.join(exeDir, "workers.log");
-        mkdirSync17(path39.dirname(logPath), { recursive: true });
+        const logPath = path40.join(exeDir, "workers.log");
+        mkdirSync17(path40.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
           logFd = openSync3(logPath, "a");
         } catch {
         }
-        const child = spawn3(process.execPath, [backfillPath], {
+        const child = spawn4(process.execPath, [backfillPath], {
           detached: true,
           stdio: ["ignore", "ignore", logFd]
         });