@askexenow/exe-os 0.9.6 → 0.9.8

package/dist/bin/cli.js

@@ -266,6 +266,118 @@ var init_config = __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 readFileSync2, writeFileSync, existsSync as existsSync2, mkdirSync } from "fs";
+import path2 from "path";
+function loadAgentConfig() {
+  if (!existsSync2(AGENT_CONFIG_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync2(AGENT_CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveAgentConfig(config) {
+  const dir = path2.dirname(AGENT_CONFIG_PATH);
+  if (!existsSync2(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+function getAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  const entry = config[agentId];
+  if (entry) return entry;
+  const orgDefault = config["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 config = loadAgentConfig();
+  config[agentId] = { runtime, model };
+  saveAgentConfig(config);
+  return { ok: true };
+}
+function clearAgentRuntime(agentId) {
+  const config = loadAgentConfig();
+  delete config[agentId];
+  saveAgentConfig(config);
+}
+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 = path2.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, {
@@ -281,6 +393,7 @@ __export(employees_exports, {
   getEmployeeByRole: () => getEmployeeByRole,
   getEmployeeNamesByRole: () => getEmployeeNamesByRole,
   hasRole: () => hasRole,
+  hireEmployee: () => hireEmployee,
   isCoordinatorName: () => isCoordinatorName,
   isCoordinatorRole: () => isCoordinatorRole,
   isMultiInstance: () => isMultiInstance,
@@ -293,9 +406,9 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync2, symlinkSync, readlinkSync, readFileSync as readFileSync2, renameSync as renameSync2, unlinkSync, writeFileSync } from "fs";
+import { existsSync as existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
 import { execSync } from "child_process";
-import path2 from "path";
+import path3 from "path";
 import os2 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -332,7 +445,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) {
+  if (!existsSync3(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -343,13 +456,13 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path2.dirname(employeesPath), { recursive: true });
+  await mkdir2(path3.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync2(employeesPath)) return [];
+  if (!existsSync3(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync3(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -391,6 +504,52 @@ function addEmployee(employees, employee) {
   }
   return [...employees, normalized];
 }
+function appendToCoordinatorTeam(employee) {
+  const coordinator = getCoordinatorEmployee(loadEmployeesSync());
+  if (!coordinator) return;
+  const idPath = path3.join(IDENTITY_DIR, `${coordinator.name}.md`);
+  if (!existsSync3(idPath)) return;
+  const content = readFileSync3(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 config = loadAgentConfig2();
+    const name = employee.name.toLowerCase();
+    if (!config[name] && config["default"]) {
+      config[name] = { ...config["default"] };
+      saveAgentConfig2(config);
+    }
+  } catch {
+  }
+  return updated;
+}
 async function normalizeRosterCase(rosterPath) {
   const employees = await loadEmployees(rosterPath);
   let changed = false;
@@ -400,14 +559,14 @@ async function normalizeRosterCase(rosterPath) {
       emp.name = emp.name.toLowerCase();
       changed = true;
       try {
-        const identityDir = path2.join(os2.homedir(), ".exe-os", "identity");
-        const oldPath = path2.join(identityDir, `${oldName}.md`);
-        const newPath = path2.join(identityDir, `${emp.name}.md`);
-        if (existsSync2(oldPath) && !existsSync2(newPath)) {
+        const identityDir = path3.join(os2.homedir(), ".exe-os", "identity");
+        const oldPath = path3.join(identityDir, `${oldName}.md`);
+        const newPath = path3.join(identityDir, `${emp.name}.md`);
+        if (existsSync3(oldPath) && !existsSync3(newPath)) {
           renameSync2(oldPath, newPath);
-        } else if (existsSync2(oldPath) && oldPath !== newPath) {
-          const content = readFileSync2(oldPath, "utf-8");
-          writeFileSync(newPath, content, "utf-8");
+        } else if (existsSync3(oldPath) && oldPath !== newPath) {
+          const content = readFileSync3(oldPath, "utf-8");
+          writeFileSync2(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
             unlinkSync(oldPath);
           }
@@ -437,7 +596,7 @@ function registerBinSymlinks(name) {
     errors.push("Could not find 'exe-os' in PATH");
     return { created, skipped, errors };
   }
-  const binDir = path2.dirname(exeBinPath);
+  const binDir = path3.dirname(exeBinPath);
   let target;
   try {
     target = readlinkSync(exeBinPath);
@@ -447,8 +606,8 @@ function registerBinSymlinks(name) {
   }
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
-    const linkPath = path2.join(binDir, linkName);
-    if (existsSync2(linkPath)) {
+    const linkPath = path3.join(binDir, linkName);
+    if (existsSync3(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -461,42 +620,44 @@ function registerBinSymlinks(name) {
   }
   return { created, skipped, errors };
 }
-var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
+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 = path2.join(EXE_AI_DIR, "exe-employees.json");
+    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"]);
+    IDENTITY_DIR = path3.join(EXE_AI_DIR, "identity");
+    TEAM_SECTION_RE = /^## Team\b.*$/m;
   }
 });
 
 // src/lib/agent-symlinks.ts
 import os3 from "os";
-import path3 from "path";
+import path4 from "path";
 import {
-  existsSync as existsSync3,
+  existsSync as existsSync4,
   lstatSync,
-  mkdirSync,
+  mkdirSync as mkdirSync2,
   readlinkSync as readlinkSync2,
   symlinkSync as symlinkSync2
 } from "fs";
 function claudeAgentsDir(homeDir) {
-  return path3.join(homeDir, ".claude", "agents");
+  return path4.join(homeDir, ".claude", "agents");
 }
 function identitySourcePath(homeDir, agentId) {
-  return path3.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
+  return path4.join(homeDir, ".exe-os", "identity", `${agentId}.md`);
 }
 function claudeAgentLinkPath(homeDir, agentId) {
-  return path3.join(claudeAgentsDir(homeDir), `${agentId}.md`);
+  return path4.join(claudeAgentsDir(homeDir), `${agentId}.md`);
 }
 function ensureAgentSymlink(agentId, homeDir = os3.homedir()) {
   const target = identitySourcePath(homeDir, agentId);
   const link = claudeAgentLinkPath(homeDir, agentId);
-  mkdirSync(claudeAgentsDir(homeDir), { recursive: true });
-  if (existsSync3(link)) {
+  mkdirSync2(claudeAgentsDir(homeDir), { recursive: true });
+  if (existsSync4(link)) {
     let stat2;
     try {
       stat2 = lstatSync(link);
@@ -570,33 +731,33 @@ __export(preferences_exports, {
   loadPreferences: () => loadPreferences,
   savePreferences: () => savePreferences
 });
-import { existsSync as existsSync4, readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
-import path4 from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import path5 from "path";
 import os4 from "os";
 function loadPreferences(homeDir = os4.homedir()) {
-  const configPath = path4.join(homeDir, ".exe-os", "config.json");
-  if (!existsSync4(configPath)) return {};
+  const configPath = path5.join(homeDir, ".exe-os", "config.json");
+  if (!existsSync5(configPath)) return {};
   try {
-    const config = JSON.parse(readFileSync3(configPath, "utf-8"));
+    const config = JSON.parse(readFileSync4(configPath, "utf-8"));
     return config.preferences ?? {};
   } catch {
     return {};
   }
 }
 function savePreferences(prefs, homeDir = os4.homedir()) {
-  const configDir = path4.join(homeDir, ".exe-os");
-  const configPath = path4.join(configDir, "config.json");
-  mkdirSync2(configDir, { recursive: true });
+  const configDir = path5.join(homeDir, ".exe-os");
+  const configPath = path5.join(configDir, "config.json");
+  mkdirSync3(configDir, { recursive: true });
   let config = {};
-  if (existsSync4(configPath)) {
+  if (existsSync5(configPath)) {
     try {
-      config = JSON.parse(readFileSync3(configPath, "utf-8"));
+      config = JSON.parse(readFileSync4(configPath, "utf-8"));
     } catch {
       config = {};
     }
   }
   config.preferences = prefs;
-  writeFileSync2(configPath, JSON.stringify(config, null, 2) + "\n");
+  writeFileSync3(configPath, JSON.stringify(config, null, 2) + "\n");
 }
 var init_preferences = __esm({
   "src/lib/preferences.ts"() {
@@ -618,52 +779,52 @@ __export(installer_exports, {
   setupTmux: () => setupTmux
 });
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3, readdir } from "fs/promises";
-import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, copyFileSync, mkdirSync as mkdirSync3 } from "fs";
-import path5 from "path";
+import { existsSync as existsSync6, readFileSync as readFileSync5, writeFileSync as writeFileSync4, copyFileSync, mkdirSync as mkdirSync4 } from "fs";
+import path6 from "path";
 import os5 from "os";
 import { execSync as execSync2 } from "child_process";
 import { fileURLToPath } from "url";
 function resolvePackageRoot() {
   const thisFile = fileURLToPath(import.meta.url);
-  let dir = path5.dirname(thisFile);
-  const root = path5.parse(dir).root;
+  let dir = path6.dirname(thisFile);
+  const root = path6.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path5.join(dir, "package.json");
-    if (existsSync5(pkgPath)) {
+    const pkgPath = path6.join(dir, "package.json");
+    if (existsSync6(pkgPath)) {
       try {
-        const pkg = JSON.parse(readFileSync4(pkgPath, "utf-8"));
+        const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path5.dirname(dir);
+    dir = path6.dirname(dir);
   }
-  return path5.resolve(path5.dirname(thisFile), "..", "..", "..");
+  return path6.resolve(path6.dirname(thisFile), "..", "..", "..");
 }
 async function copySlashCommands(packageRoot, homeDir = os5.homedir()) {
   let copied = 0;
   let skipped = 0;
-  const skillsBase = path5.join(homeDir, ".claude", "skills");
-  const exeDir = path5.join(packageRoot, "src", "commands", "exe");
-  if (existsSync5(exeDir)) {
+  const skillsBase = path6.join(homeDir, ".claude", "skills");
+  const exeDir = path6.join(packageRoot, "src", "commands", "exe");
+  if (existsSync6(exeDir)) {
     const entries = await readdir(exeDir);
     const mdFiles = entries.filter((f) => f.endsWith(".md"));
     for (const file of mdFiles) {
       const name = file.replace(".md", "");
-      const destDir = path5.join(skillsBase, `exe-${name}`);
+      const destDir = path6.join(skillsBase, `exe-${name}`);
       await mkdir3(destDir, { recursive: true });
-      const srcPath = path5.join(exeDir, file);
-      const destPath = path5.join(destDir, "SKILL.md");
+      const srcPath = path6.join(exeDir, file);
+      const destPath = path6.join(destDir, "SKILL.md");
       const result = await copyAsSkill(srcPath, destPath, `exe-${name}`);
       if (result) copied++;
       else skipped++;
     }
   }
-  const topLevelSrc = path5.join(packageRoot, "src", "commands", "exe.md");
-  if (existsSync5(topLevelSrc)) {
-    const destDir = path5.join(skillsBase, "exe");
+  const topLevelSrc = path6.join(packageRoot, "src", "commands", "exe.md");
+  if (existsSync6(topLevelSrc)) {
+    const destDir = path6.join(skillsBase, "exe");
     await mkdir3(destDir, { recursive: true });
-    const destPath = path5.join(destDir, "SKILL.md");
+    const destPath = path6.join(destDir, "SKILL.md");
     const result = await copyAsSkill(topLevelSrc, destPath, "exe");
     if (result) copied++;
     else skipped++;
@@ -686,7 +847,7 @@ name: ${skillName}
 `);
     }
   }
-  if (existsSync5(destPath)) {
+  if (existsSync6(destPath)) {
     const existing = await readFile3(destPath, "utf-8");
     if (existing === content) return false;
   }
@@ -694,9 +855,9 @@ name: ${skillName}
   return true;
 }
 async function registerMcpServer(packageRoot, homeDir = os5.homedir()) {
-  const claudeJsonPath = path5.join(homeDir, ".claude.json");
+  const claudeJsonPath = path6.join(homeDir, ".claude.json");
   let claudeJson = {};
-  if (existsSync5(claudeJsonPath)) {
+  if (existsSync6(claudeJsonPath)) {
     try {
       claudeJson = JSON.parse(await readFile3(claudeJsonPath, "utf-8"));
     } catch {
@@ -709,7 +870,7 @@ async function registerMcpServer(packageRoot, homeDir = os5.homedir()) {
   const newEntry = {
     type: "stdio",
     command: "node",
-    args: [path5.join(packageRoot, "dist", "mcp", "server.js")],
+    args: [path6.join(packageRoot, "dist", "mcp", "server.js")],
     env: {}
   };
   const currentMem = claudeJson.mcpServers[MCP_LEGACY_KEY];
@@ -717,17 +878,17 @@ async function registerMcpServer(packageRoot, homeDir = os5.homedir()) {
   const memMatches = currentMem && JSON.stringify(currentMem) === JSON.stringify(newEntry);
   const osMatches = currentOs && JSON.stringify(currentOs) === JSON.stringify(newEntry);
   if (memMatches && osMatches) {
-    await cleanSettingsJsonMcp(path5.join(homeDir, ".claude", "settings.json"));
+    await cleanSettingsJsonMcp(path6.join(homeDir, ".claude", "settings.json"));
     return false;
   }
   claudeJson.mcpServers[MCP_LEGACY_KEY] = newEntry;
   claudeJson.mcpServers[MCP_PRIMARY_KEY] = newEntry;
   await writeFile3(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
-  await cleanSettingsJsonMcp(path5.join(homeDir, ".claude", "settings.json"));
+  await cleanSettingsJsonMcp(path6.join(homeDir, ".claude", "settings.json"));
   return true;
 }
 async function cleanSettingsJsonMcp(settingsPath) {
-  if (!existsSync5(settingsPath)) return;
+  if (!existsSync6(settingsPath)) return;
   try {
     const settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
     const servers = settings.mcpServers;
@@ -748,13 +909,13 @@ async function cleanSettingsJsonMcp(settingsPath) {
   }
 }
 async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
-  const settingsPath = path5.join(homeDir, ".claude", "settings.json");
-  const logsDir = path5.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path5.join(logsDir, "hooks.log");
+  const settingsPath = path6.join(homeDir, ".claude", "settings.json");
+  const logsDir = path6.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path6.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir3(logsDir, { recursive: true });
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
       settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
     } catch {
@@ -776,11 +937,11 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
           }
         ]
       },
@@ -792,7 +953,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
             timeout: 1e4
           }
         ]
@@ -805,7 +966,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           }
         ]
       },
@@ -817,7 +978,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
             timeout: 5e3
           }
         ]
@@ -830,7 +991,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -843,7 +1004,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -855,7 +1016,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "subagent-stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -867,7 +1028,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "pre-compact.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "pre-compact.js")}"${logSuffix}`,
             timeout: 1e4
           }
         ]
@@ -880,7 +1041,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "session-end.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "session-end.js")}"${logSuffix}`
           }
         ]
       },
@@ -892,7 +1053,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "notification.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "notification.js")}"${logSuffix}`
           }
         ]
       },
@@ -904,7 +1065,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "post-compact.js")}"${logSuffix}`,
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "post-compact.js")}"${logSuffix}`,
             timeout: 1e4
           }
         ]
@@ -917,7 +1078,7 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path5.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"${logSuffix}`
+            command: `node "${path6.join(packageRoot, "dist", "hooks", "instructions-loaded.js")}"${logSuffix}`
           }
         ]
       },
@@ -1016,13 +1177,13 @@ async function mergeHooks(packageRoot, homeDir = os5.homedir()) {
       allowList.push(tool);
     }
   }
-  await mkdir3(path5.dirname(settingsPath), { recursive: true });
+  await mkdir3(path6.dirname(settingsPath), { recursive: true });
   await writeFile3(settingsPath, JSON.stringify(settings, null, 2) + "\n");
   return { added, skipped };
 }
 async function cleanOldShellFunctions(homeDir = os5.homedir()) {
-  const rosterPath = path5.join(homeDir, ".exe-os", "exe-employees.json");
-  if (!existsSync5(rosterPath)) return 0;
+  const rosterPath = path6.join(homeDir, ".exe-os", "exe-employees.json");
+  if (!existsSync6(rosterPath)) return 0;
   let employees;
   try {
     employees = JSON.parse(await readFile3(rosterPath, "utf-8"));
@@ -1037,13 +1198,13 @@ async function cleanOldShellFunctions(homeDir = os5.homedir()) {
     return { name: n, funcDef, forLoop };
   });
   const rcFiles = [
-    path5.join(homeDir, ".zshrc"),
-    path5.join(homeDir, ".bashrc")
+    path6.join(homeDir, ".zshrc"),
+    path6.join(homeDir, ".bashrc")
   ];
   const REMOVED_MARKER = "# Removed by exe-os \u2014 wrappers now at ~/.exe-os/bin/";
   let totalRemoved = 0;
   for (const rcPath of rcFiles) {
-    if (!existsSync5(rcPath)) continue;
+    if (!existsSync6(rcPath)) continue;
     let content;
     try {
       content = await readFile3(rcPath, "utf-8");
@@ -1147,8 +1308,8 @@ function escapeRegExp(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 async function injectOrchestrationRules(homeDir) {
-  const claudeDir = path5.join(homeDir, ".claude");
-  const claudeMdPath = path5.join(claudeDir, "CLAUDE.md");
+  const claudeDir = path6.join(homeDir, ".claude");
+  const claudeMdPath = path6.join(claudeDir, "CLAUDE.md");
   await mkdir3(claudeDir, { recursive: true });
   let existing = "";
   try {
@@ -1173,16 +1334,16 @@ async function injectOrchestrationRules(homeDir) {
 async function installStatusLine(packageRoot, homeDir = os5.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.ccStatusLine === false) return "opted-out";
-  const claudeDir = path5.join(homeDir, ".claude");
+  const claudeDir = path6.join(homeDir, ".claude");
   await mkdir3(claudeDir, { recursive: true });
-  const assetPath = path5.join(packageRoot, "dist", "assets", "statusline-command.sh");
-  if (!existsSync5(assetPath)) return "asset-missing";
-  const destScript = path5.join(claudeDir, "statusline-command.sh");
+  const assetPath = path6.join(packageRoot, "dist", "assets", "statusline-command.sh");
+  if (!existsSync6(assetPath)) return "asset-missing";
+  const destScript = path6.join(claudeDir, "statusline-command.sh");
   const assetContent = await readFile3(assetPath, "utf-8");
   await writeFile3(destScript, assetContent, { mode: 493 });
-  const settingsPath = path5.join(claudeDir, "settings.json");
+  const settingsPath = path6.join(claudeDir, "settings.json");
   let settings = {};
-  if (existsSync5(settingsPath)) {
+  if (existsSync6(settingsPath)) {
     try {
       settings = JSON.parse(await readFile3(settingsPath, "utf-8"));
     } catch {
@@ -1220,12 +1381,12 @@ async function runInstaller(homeDir) {
 `
   );
   const resolvedHome = homeDir ?? os5.homedir();
-  const exeWorkspace = path5.join(resolvedHome, "exe");
-  if (!existsSync5(exeWorkspace)) {
+  const exeWorkspace = path6.join(resolvedHome, "exe");
+  if (!existsSync6(exeWorkspace)) {
     try {
-      await mkdir3(path5.join(exeWorkspace, "content"), { recursive: true });
-      await mkdir3(path5.join(exeWorkspace, "operations"), { recursive: true });
-      await mkdir3(path5.join(exeWorkspace, "output"), { recursive: true });
+      await mkdir3(path6.join(exeWorkspace, "content"), { recursive: true });
+      await mkdir3(path6.join(exeWorkspace, "operations"), { recursive: true });
+      await mkdir3(path6.join(exeWorkspace, "output"), { recursive: true });
       process.stderr.write(
         `Created ~/exe/ \u2014 your automation workspace for non-code projects
 `
@@ -1261,33 +1422,33 @@ exe-os installed successfully.
 }
 function setupTmux(home) {
   const homeDir = home ?? os5.homedir();
-  const exeDir = path5.join(homeDir, ".exe-os");
-  const exeTmuxConf = path5.join(exeDir, "tmux.conf");
-  const userTmuxConf = path5.join(homeDir, ".tmux.conf");
-  const backupPath = path5.join(homeDir, ".tmux.conf.backup");
+  const exeDir = path6.join(homeDir, ".exe-os");
+  const exeTmuxConf = path6.join(exeDir, "tmux.conf");
+  const userTmuxConf = path6.join(homeDir, ".tmux.conf");
+  const backupPath = path6.join(homeDir, ".tmux.conf.backup");
   const sourceLine = "source-file ~/.exe-os/tmux.conf";
   const pkgRoot = resolvePackageRoot();
-  const assetPath = path5.join(pkgRoot, "dist", "assets", "tmux.conf");
-  if (!existsSync5(assetPath)) {
+  const assetPath = path6.join(pkgRoot, "dist", "assets", "tmux.conf");
+  if (!existsSync6(assetPath)) {
     process.stderr.write(`exe-os: tmux.conf asset not found at ${assetPath} \u2014 skipping tmux setup
 `);
     return;
   }
-  mkdirSync3(exeDir, { recursive: true });
+  mkdirSync4(exeDir, { recursive: true });
   copyFileSync(assetPath, exeTmuxConf);
-  if (existsSync5(userTmuxConf)) {
-    const existing = readFileSync4(userTmuxConf, "utf8");
+  if (existsSync6(userTmuxConf)) {
+    const existing = readFileSync5(userTmuxConf, "utf8");
     if (!existing.includes(sourceLine)) {
-      if (!existsSync5(backupPath)) {
+      if (!existsSync6(backupPath)) {
         copyFileSync(userTmuxConf, backupPath);
         process.stderr.write(`exe-os: backed up existing tmux config to ${backupPath}
 `);
       }
-      writeFileSync3(userTmuxConf, `${sourceLine}
+      writeFileSync4(userTmuxConf, `${sourceLine}
 ${existing}`);
     }
   } else {
-    writeFileSync3(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
+    writeFileSync4(userTmuxConf, `# Exe OS tmux defaults \u2014 remove this line to use your own config
 ${sourceLine}
 `);
   }
@@ -1299,9 +1460,9 @@ ${sourceLine}
 }
 function setupGhostty(home) {
   const homeDir = home ?? os5.homedir();
-  const xdgConfig = path5.join(homeDir, ".config", "ghostty");
-  const macConfig = path5.join(homeDir, "Library", "Application Support", "com.mitchellh.ghostty");
-  const ghosttyInstalled = existsSync5(xdgConfig) || existsSync5(macConfig) || (() => {
+  const xdgConfig = path6.join(homeDir, ".config", "ghostty");
+  const macConfig = path6.join(homeDir, "Library", "Application Support", "com.mitchellh.ghostty");
+  const ghosttyInstalled = existsSync6(xdgConfig) || existsSync6(macConfig) || (() => {
     try {
       execSync2("which ghostty 2>/dev/null");
       return true;
@@ -1313,47 +1474,47 @@ function setupGhostty(home) {
     return;
   }
   const pkgRoot = resolvePackageRoot();
-  const assetPath = path5.join(pkgRoot, "dist", "assets", "ghostty.conf");
-  if (!existsSync5(assetPath)) {
+  const assetPath = path6.join(pkgRoot, "dist", "assets", "ghostty.conf");
+  if (!existsSync6(assetPath)) {
     process.stderr.write("exe-os: ghostty.conf asset not found \u2014 skipping Ghostty setup\n");
     return;
   }
   const configDir = xdgConfig;
-  const configPath = path5.join(configDir, "config");
-  const backupPath = path5.join(configDir, "config.backup");
-  mkdirSync3(configDir, { recursive: true });
+  const configPath = path6.join(configDir, "config");
+  const backupPath = path6.join(configDir, "config.backup");
+  mkdirSync4(configDir, { recursive: true });
   const START_MARKER = "# \u2500\u2500 exe-os:ghostty-start \u2500\u2500";
   const END_MARKER = "# \u2500\u2500 exe-os:ghostty-end \u2500\u2500";
-  const assetContent = readFileSync4(assetPath, "utf8").trim();
+  const assetContent = readFileSync5(assetPath, "utf8").trim();
   const markedSection = `${START_MARKER}
 ${assetContent}
 ${END_MARKER}`;
-  if (existsSync5(configPath)) {
-    const existing = readFileSync4(configPath, "utf8");
+  if (existsSync6(configPath)) {
+    const existing = readFileSync5(configPath, "utf8");
     if (existing.includes(START_MARKER) && existing.includes(END_MARKER)) {
       const before = existing.slice(0, existing.indexOf(START_MARKER));
       const after = existing.slice(existing.indexOf(END_MARKER) + END_MARKER.length);
-      writeFileSync3(configPath, `${before}${markedSection}${after}`);
+      writeFileSync4(configPath, `${before}${markedSection}${after}`);
     } else if (existing.includes("Exe OS")) {
-      if (!existsSync5(backupPath)) {
+      if (!existsSync6(backupPath)) {
         copyFileSync(configPath, backupPath);
         process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
 `);
       }
-      writeFileSync3(configPath, `${markedSection}
+      writeFileSync4(configPath, `${markedSection}
 `);
     } else {
-      if (!existsSync5(backupPath)) {
+      if (!existsSync6(backupPath)) {
         copyFileSync(configPath, backupPath);
         process.stderr.write(`exe-os: backed up existing Ghostty config to ${backupPath}
 `);
       }
-      writeFileSync3(configPath, `${markedSection}
+      writeFileSync4(configPath, `${markedSection}
 
 ${existing}`);
     }
   } else {
-    writeFileSync3(configPath, `${markedSection}
+    writeFileSync4(configPath, `${markedSection}
 `);
   }
   process.stderr.write("exe-os: Ghostty config installed\n");
@@ -1403,14 +1564,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile4, writeFile as writeFile4, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync6 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync7 } from "fs";
+import path7 from "path";
 import os6 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path6.join(os6.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path7.join(os6.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path6.join(getKeyDir(), "master.key");
+  return path7.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -1431,7 +1592,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync6(keyPath)) {
+  if (!existsSync7(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os6.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
@@ -1474,7 +1635,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync6(keyPath)) {
+  if (existsSync7(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -1618,13 +1779,597 @@ var init_db_retry = __esm({
   }
 });
 
+// src/lib/database-adapter.ts
+import os7 from "os";
+import path8 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, args2) {
+  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 < args2.length) {
+      args2[index] = toBoolean(args2[index]);
+    }
+  }
+}
+function coerceUpdateBooleanArgs(sql, args2) {
+  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])) {
+      args2[placeholderIndex - 1] = toBoolean(args2[placeholderIndex - 1]);
+    }
+  }
+}
+function coerceBooleanArgs(sql, args2) {
+  const nextArgs = [...args2];
+  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 ?? path8.join(os7.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path8.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;
+  }
+  if (current.trim()) {
+    parts.push(current.trim());
+  }
+  return parts;
+}
+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";
+    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;
+  }
+});
+
 // src/lib/exe-daemon-client.ts
 import net from "net";
-import os7 from "os";
+import os8 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync7, unlinkSync as unlinkSync2, readFileSync as readFileSync5, openSync, closeSync, statSync } from "fs";
-import path7 from "path";
+import { existsSync as existsSync8, unlinkSync as unlinkSync2, readFileSync as readFileSync6, openSync, closeSync, statSync } from "fs";
+import path9 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -1652,9 +2397,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync7(PID_PATH)) {
+  if (existsSync8(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync5(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -1675,17 +2420,17 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path7.dirname(fileURLToPath3(import.meta.url));
-  const { root } = path7.parse(dir);
+  let dir = path9.dirname(fileURLToPath3(import.meta.url));
+  const { root } = path9.parse(dir);
   while (dir !== root) {
-    if (existsSync7(path7.join(dir, "package.json"))) return dir;
-    dir = path7.dirname(dir);
+    if (existsSync8(path9.join(dir, "package.json"))) return dir;
+    dir = path9.dirname(dir);
   }
   return null;
 }
 function spawnDaemon() {
-  const freeGB = os7.freemem() / (1024 * 1024 * 1024);
-  const totalGB = os7.totalmem() / (1024 * 1024 * 1024);
+  const freeGB = os8.freemem() / (1024 * 1024 * 1024);
+  const totalGB = os8.totalmem() / (1024 * 1024 * 1024);
   if (totalGB <= 8) {
     process.stderr.write(
       `[exed-client] SKIP: ${totalGB.toFixed(0)}GB system \u2014 embedding daemon disabled. Using keyword search only. Minimum 16GB recommended for vector search.
@@ -1705,8 +2450,8 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path7.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync7(daemonPath)) {
+  const daemonPath = path9.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync8(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
@@ -1714,7 +2459,7 @@ function spawnDaemon() {
   const resolvedPath = daemonPath;
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path7.join(path7.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path9.join(path9.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -1865,74 +2610,123 @@ async function pingDaemon() {
   return null;
 }
 function killAndRespawnDaemon() {
-  process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync7(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync5(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 (existsSync8(PID_PATH)) {
+      try {
+        const pid = parseInt(readFileSync6(PID_PATH, "utf8").trim(), 10);
+        if (pid > 0) {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch {
+          }
         }
+      } catch {
       }
+    }
+    if (_socket) {
+      _socket.destroy();
+      _socket = null;
+    }
+    _connected = false;
+    _buffer = "";
+    try {
+      unlinkSync2(PID_PATH);
     } catch {
     }
+    try {
+      unlinkSync2(SOCKET_PATH);
+    } catch {
+    }
+    spawnDaemon();
+  } finally {
+    releaseSpawnLock();
   }
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
-  }
-  _connected = false;
-  _buffer = "";
+}
+function isDaemonTooYoung() {
   try {
-    unlinkSync2(PID_PATH);
+    const stat2 = statSync(PID_PATH);
+    return Date.now() - stat2.mtimeMs < MIN_DAEMON_AGE_MS;
   } catch {
+    return false;
   }
-  try {
-    unlinkSync2(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 };
+  }
+  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);
   }
-  spawnDaemon();
+  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;
 }
 function disconnectClient() {
   if (_socket) {
@@ -1950,14 +2744,14 @@ 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";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path7.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path7.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path7.join(EXE_AI_DIR, "exed-spawn.lock");
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path9.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path9.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path9.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
@@ -1965,7 +2759,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;
   }
@@ -2041,7 +2839,7 @@ __export(db_daemon_client_exports, {
   createDaemonDbClient: () => createDaemonDbClient,
   initDaemonDbClient: () => initDaemonDbClient
 });
-function normalizeStatement(stmt) {
+function normalizeStatement2(stmt) {
   if (typeof stmt === "string") {
     return { sql: stmt, args: [] };
   }
@@ -2065,7 +2863,7 @@ function createDaemonDbClient(fallbackClient) {
       if (!_useDaemon || !isClientConnected()) {
         return fallbackClient.execute(stmt);
       }
-      const { sql, args: args2 } = normalizeStatement(stmt);
+      const { sql, args: args2 } = normalizeStatement2(stmt);
       const response = await sendDaemonRequest({
         type: "db-execute",
         sql,
@@ -2090,7 +2888,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,
@@ -2185,6 +2983,18 @@ __export(database_exports, {
 });
 import { createClient } from "@libsql/client";
 async function initDatabase(config) {
+  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;
@@ -2198,6 +3008,7 @@ async function initDatabase(config) {
   }
   _client = createClient(opts);
   _resilientClient = wrapWithRetry(_client);
+  _adapterClient = _resilientClient;
   _client.execute("PRAGMA busy_timeout = 30000").catch(() => {
   });
   _client.execute("PRAGMA journal_mode = WAL").catch(() => {
@@ -2208,14 +3019,20 @@ async function initDatabase(config) {
     });
   }, 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;
   }
@@ -2225,6 +3042,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 {
@@ -3169,26 +3987,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;
   }
@@ -3290,9 +4118,9 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
-import path8 from "path";
+import path10 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -3303,37 +4131,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path8.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path10.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 = randomUUID2();
-  mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
+  mkdirSync5(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(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) {
-  mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  mkdirSync5(EXE_AI_DIR, { recursive: true });
+  writeFileSync5(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -3359,8 +4187,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 {
@@ -3369,8 +4197,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;
@@ -3404,7 +4232,7 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync5(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
@@ -3468,9 +4296,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path8.join(EXE_AI_DIR, "config.json");
-      if (existsSync8(configPath)) {
-        const raw = JSON.parse(readFileSync6(configPath, "utf8"));
+      const configPath = path10.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;
@@ -3629,9 +4457,9 @@ var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path8.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path8.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path8.join(EXE_AI_DIR, "device-id");
+    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");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -3679,8 +4507,8 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync5, existsSync as existsSync9, mkdirSync as mkdirSync5, unlinkSync as unlinkSync3 } from "fs";
-import path9 from "path";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync10, mkdirSync as mkdirSync6, unlinkSync as unlinkSync3 } from "fs";
+import path11 from "path";
 import { homedir } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -3692,9 +4520,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync9(sp)) {
+  if (existsSync10(sp)) {
     try {
-      const state = readFileSync7(sp);
+      const state = readFileSync8(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -3836,10 +4664,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path9.dirname(sp);
-    if (!existsSync9(dir)) mkdirSync5(dir, { recursive: true });
+    const dir = path11.dirname(sp);
+    if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync5(sp, Buffer.from(state));
+    writeFileSync6(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -3880,7 +4708,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path9.join(homedir(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path11.join(homedir(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -3914,16 +4742,16 @@ __export(cloud_sync_exports, {
   mergeRosterFromRemote: () => mergeRosterFromRemote,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync10, readdirSync, mkdirSync as mkdirSync6, appendFileSync, unlinkSync as unlinkSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync9, writeFileSync as writeFileSync7, existsSync as existsSync11, readdirSync, mkdirSync as mkdirSync7, appendFileSync, unlinkSync as unlinkSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto3 from "crypto";
-import path10 from "path";
+import path12 from "path";
 import { homedir as homedir2 } from "os";
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path10.join(homedir2(), ".exe-os", "workers.log");
+    const logPath = path12.join(homedir2(), ".exe-os", "workers.log");
     appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -3933,18 +4761,18 @@ async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync6(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync7(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts = parseInt(readFileSync8(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts = parseInt(readFileSync9(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync4(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync6(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync7(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -4318,8 +5146,8 @@ async function cloudSync(config) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path10.join(EXE_AI_DIR, "identity");
-    if (existsSync10(idDir)) {
+    const idDir = path12.join(EXE_AI_DIR, "identity");
+    if (existsSync11(idDir)) {
       rosterResult.identities = readdirSync(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -4340,56 +5168,56 @@ async function cloudSync(config) {
 function recordRosterDeletion(name) {
   let deletions = [];
   try {
-    if (existsSync10(ROSTER_DELETIONS_PATH)) {
-      deletions = JSON.parse(readFileSync8(ROSTER_DELETIONS_PATH, "utf-8"));
+    if (existsSync11(ROSTER_DELETIONS_PATH)) {
+      deletions = JSON.parse(readFileSync9(ROSTER_DELETIONS_PATH, "utf-8"));
     }
   } catch {
   }
   if (!deletions.includes(name)) deletions.push(name);
-  writeFileSync6(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
+  writeFileSync7(ROSTER_DELETIONS_PATH, JSON.stringify(deletions));
 }
 function consumeRosterDeletions() {
   try {
-    if (!existsSync10(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync8(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync6(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync11(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync9(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync7(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path10.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path10.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path10.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path12.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path12.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path12.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync10(rosterPath)) {
+  if (existsSync11(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync8(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync9(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync10(identityDir)) {
+  if (existsSync11(identityDir)) {
     for (const file of readdirSync(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync8(path10.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync9(path12.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config;
-  if (existsSync10(configPath)) {
+  if (existsSync11(configPath)) {
     try {
-      config = JSON.parse(readFileSync8(configPath, "utf-8"));
+      config = JSON.parse(readFileSync9(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path10.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync10(agentConfigPath)) {
+  const agentConfigPath = path12.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync11(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync8(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync9(agentConfigPath, "utf-8"));
     } catch {
     }
   }
@@ -4465,23 +5293,23 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path10.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path12.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync10(cfgPath)) {
+  if (existsSync11(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync8(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync9(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path10.dirname(cfgPath);
-  if (!existsSync10(dir)) mkdirSync6(dir, { recursive: true });
-  writeFileSync6(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path12.dirname(cfgPath);
+  if (!existsSync11(dir)) mkdirSync7(dir, { recursive: true });
+  writeFileSync7(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 ?? path10.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path12.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -4502,15 +5330,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync10(identityDir)) mkdirSync6(identityDir, { recursive: true });
-        const idPath = path10.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync11(identityDir)) mkdirSync7(identityDir, { recursive: true });
+        const idPath = path12.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync10(idPath) ? readFileSync8(idPath, "utf-8") : null;
+          localIdentity = existsSync11(idPath) ? readFileSync9(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync6(idPath, remoteIdentity, "utf-8");
+          writeFileSync7(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -4536,16 +5364,16 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path10.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path12.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
-        if (existsSync10(agentConfigPath)) {
+        if (existsSync11(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync8(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync9(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        writeFileSync6(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        writeFileSync7(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       } catch {
       }
     }
@@ -4983,9 +5811,9 @@ var init_cloud_sync = __esm({
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path10.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path12.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
-    ROSTER_DELETIONS_PATH = path10.join(EXE_AI_DIR, "roster-deletions.json");
+    ROSTER_DELETIONS_PATH = path12.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -5291,13 +6119,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path11 from "path";
-import { existsSync as existsSync11, mkdirSync as mkdirSync7, readdirSync as readdirSync2 } from "fs";
+import path13 from "path";
+import { existsSync as existsSync12, mkdirSync as mkdirSync8, readdirSync as readdirSync2 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync11(SHARDS_DIR)) {
-    mkdirSync7(SHARDS_DIR, { recursive: true });
+  if (!existsSync12(SHARDS_DIR)) {
+    mkdirSync8(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
 }
@@ -5317,7 +6145,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path11.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path13.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -5327,10 +6155,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync11(path11.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync12(path13.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync11(SHARDS_DIR)) return [];
+  if (!existsSync12(SHARDS_DIR)) return [];
   return readdirSync2(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -5404,7 +6232,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);
@@ -5516,7 +6360,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path11.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path13.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -6288,12 +7132,12 @@ __export(backfill_conversations_exports, {
 import crypto4 from "crypto";
 import { createReadStream } from "fs";
 import { readdir as readdir2, stat } from "fs/promises";
-import path12 from "path";
+import path14 from "path";
 import { createInterface as createInterface2 } from "readline";
 import { homedir as homedir3 } from "os";
 import { parseArgs } from "util";
 async function findJsonlFiles(sinceDate, projectFilter) {
-  const projectsDir = path12.join(homedir3(), ".claude", "projects");
+  const projectsDir = path14.join(homedir3(), ".claude", "projects");
   const files = [];
   async function walk(dir, depth = 0) {
     if (depth > MAX_WALK_DEPTH) return;
@@ -6304,7 +7148,7 @@ async function findJsonlFiles(sinceDate, projectFilter) {
       return;
     }
     for (const entry of entries) {
-      const full = path12.join(dir, entry.name);
+      const full = path14.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "subagents" || entry.name === "tool-results") continue;
         await walk(full, depth + 1);
@@ -6329,7 +7173,7 @@ async function findJsonlFiles(sinceDate, projectFilter) {
       if (!entry.isDirectory()) continue;
       const decoded = decodeProjectDir(entry.name);
       if (decoded.toLowerCase().includes(projectFilter.toLowerCase())) {
-        await walk(path12.join(projectsDir, entry.name));
+        await walk(path14.join(projectsDir, entry.name));
       }
     }
   } else {
@@ -6346,14 +7190,14 @@ function decodeProjectDir(dirName) {
   return dirName;
 }
 function projectNameFromPath(filePath) {
-  const projectsDir = path12.join(homedir3(), ".claude", "projects");
-  const relative = path12.relative(projectsDir, filePath);
-  const projectDir = relative.split(path12.sep)[0] ?? "unknown";
+  const projectsDir = path14.join(homedir3(), ".claude", "projects");
+  const relative = path14.relative(projectsDir, filePath);
+  const projectDir = relative.split(path14.sep)[0] ?? "unknown";
   return decodeProjectDir(projectDir);
 }
 async function parseConversation(filePath) {
   const conv = {
-    sessionId: path12.basename(filePath, ".jsonl"),
+    sessionId: path14.basename(filePath, ".jsonl"),
     projectName: projectNameFromPath(filePath),
     cwd: void 0,
     startTime: void 0,
@@ -6417,7 +7261,7 @@ async function parseConversation(filePath) {
     }
   }
   if (conv.cwd) {
-    conv.projectName = path12.basename(conv.cwd);
+    conv.projectName = path14.basename(conv.cwd);
     const worktreeMatch = conv.cwd.match(/\.worktrees\/([^/]+)/);
     if (worktreeMatch?.[1]) {
       conv.agentId = worktreeMatch[1];
@@ -7069,9 +7913,9 @@ Unclassified: ${unclassified}
 }
 async function exportBatches(options) {
   const fs8 = await import("fs");
-  const path44 = await import("path");
+  const path45 = await import("path");
   const client = getClient();
-  const outDir = path44.join(process.cwd(), "exe/output/classifications/input");
+  const outDir = path45.join(process.cwd(), "exe/output/classifications/input");
   fs8.mkdirSync(outDir, { recursive: true });
   const countResult = await client.execute({
     sql: "SELECT COUNT(*) as cnt FROM memories WHERE intent IS NULL AND outcome IS NULL AND domain IS NULL",
@@ -7095,7 +7939,7 @@ async function exportBatches(options) {
       const text = String(row.text || "").replace(/\n/g, " ");
       return JSON.stringify({ id: row.id, text });
     });
-    const batchFile = path44.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
+    const batchFile = path45.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
     fs8.writeFileSync(batchFile, lines.join("\n") + "\n");
     exported += batch.rows.length;
     offset += options.batchSize;
@@ -7111,7 +7955,7 @@ async function exportBatches(options) {
 }
 async function importClassifications(importDir) {
   const fs8 = await import("fs");
-  const path44 = await import("path");
+  const path45 = await import("path");
   const client = getClient();
   const files = fs8.readdirSync(importDir).filter((f) => f.endsWith(".jsonl")).sort();
   process.stderr.write(`[backfill-metadata] Found ${files.length} JSONL files to import from ${importDir}
@@ -7119,7 +7963,7 @@ async function importClassifications(importDir) {
   let imported = 0;
   let invalid = 0;
   for (const file of files) {
-    const lines = fs8.readFileSync(path44.join(importDir, file), "utf-8").split("\n").filter(Boolean);
+    const lines = fs8.readFileSync(path45.join(importDir, file), "utf-8").split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -7260,17 +8104,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync12, mkdirSync as mkdirSync8, readFileSync as readFileSync9, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
 import { readdirSync as readdirSync3 } from "fs";
-import path13 from "path";
+import path15 from "path";
 import { createHash as createHash2 } from "crypto";
 function ensureDir() {
-  if (!existsSync12(IDENTITY_DIR)) {
-    mkdirSync8(IDENTITY_DIR, { recursive: true });
+  if (!existsSync13(IDENTITY_DIR2)) {
+    mkdirSync9(IDENTITY_DIR2, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path13.join(IDENTITY_DIR, `${agentId}.md`);
+  return path15.join(IDENTITY_DIR2, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -7311,8 +8155,8 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync12(filePath)) return null;
-  const raw = readFileSync9(filePath, "utf-8");
+  if (!existsSync13(filePath)) return null;
+  const raw = readFileSync10(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -7326,7 +8170,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync7(filePath, content, "utf-8");
+  writeFileSync8(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -7343,7 +8187,7 @@ async function updateIdentity(agentId, content, updatedBy) {
 }
 function listIdentities() {
   ensureDir();
-  const files = readdirSync3(IDENTITY_DIR).filter((f) => f.endsWith(".md"));
+  const files = readdirSync3(IDENTITY_DIR2).filter((f) => f.endsWith(".md"));
   const results = [];
   for (const file of files) {
     const agentId = file.replace(".md", "");
@@ -7376,21 +8220,21 @@ ${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 = path13.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR2 = path15.join(EXE_AI_DIR, "identity");
   }
 });
 
 // src/lib/orchestration-package.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync9, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "fs";
-import os8 from "os";
-import path14 from "path";
+import { copyFileSync as copyFileSync2, existsSync as existsSync14, mkdirSync as mkdirSync10, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import os9 from "os";
+import path16 from "path";
 function ensureObject(value, label) {
   if (value == null || Array.isArray(value) || typeof value !== "object") {
     throw new Error(`${label} must be an object`);
@@ -7449,15 +8293,15 @@ function validateProcedureEntry(value, index) {
   };
 }
 function getRosterPath() {
-  return path14.join(os8.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+  return path16.join(os9.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
 }
 function getBackupPath() {
-  return path14.join(os8.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+  return path16.join(os9.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
 }
 function readRosterFile() {
   const rosterPath = getRosterPath();
-  if (!existsSync13(rosterPath)) return [];
-  const raw = readFileSync10(rosterPath, "utf-8");
+  if (!existsSync14(rosterPath)) return [];
+  const raw = readFileSync11(rosterPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) {
     throw new Error("Roster file must contain a JSON array");
@@ -7469,8 +8313,8 @@ function writeRosterFile(roster) {
     throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
   }
   const rosterPath = getRosterPath();
-  mkdirSync9(path14.dirname(rosterPath), { recursive: true });
-  if (existsSync13(rosterPath)) {
+  mkdirSync10(path16.dirname(rosterPath), { recursive: true });
+  if (existsSync14(rosterPath)) {
     const currentRoster = readRosterFile();
     if (roster.length < currentRoster.length) {
       throw new Error(
@@ -7479,7 +8323,7 @@ function writeRosterFile(roster) {
     }
     copyFileSync2(rosterPath, getBackupPath());
   }
-  writeFileSync8(rosterPath, `${JSON.stringify(roster, null, 2)}
+  writeFileSync9(rosterPath, `${JSON.stringify(roster, null, 2)}
 `, "utf-8");
 }
 function buildImportedRosterEntries(roster, timestamp) {
@@ -7746,8 +8590,8 @@ var exe_export_exports = {};
 __export(exe_export_exports, {
   runExeExport: () => runExeExport
 });
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "fs";
-import path15 from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync10 } from "fs";
+import path17 from "path";
 function printUsage() {
   process.stdout.write("Usage: exe-os export --output <path>\n");
 }
@@ -7768,8 +8612,8 @@ async function runExeExport(argv = process.argv.slice(2)) {
   await initStore();
   try {
     const pkg = await exportOrchestration("cli");
-    mkdirSync10(path15.dirname(outputPath), { recursive: true });
-    writeFileSync9(outputPath, `${JSON.stringify(pkg, null, 2)}
+    mkdirSync11(path17.dirname(outputPath), { recursive: true });
+    writeFileSync10(outputPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
     process.stdout.write(
       `Exported ${pkg.roster.length} roster entries, ${Object.keys(pkg.identities).length} identities, ${pkg.behaviors.length} behaviors, ${pkg.procedures.length} procedures to ${outputPath}
@@ -7805,7 +8649,7 @@ var exe_import_exports = {};
 __export(exe_import_exports, {
   runExeImport: () => runExeImport
 });
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 function printUsage2() {
   process.stdout.write("Usage: exe-os import --from <path> [--merge]\n");
 }
@@ -7828,7 +8672,7 @@ async function runExeImport(argv = process.argv.slice(2)) {
   if (parsed == null) return;
   await initStore();
   try {
-    const raw = readFileSync11(parsed.packagePath, "utf-8");
+    const raw = readFileSync12(parsed.packagePath, "utf-8");
     const pkg = validatePackage(JSON.parse(raw));
     const result = await importOrchestration(pkg, parsed.strategy);
     process.stdout.write(
@@ -7868,14 +8712,14 @@ __export(session_registry_exports, {
   pruneStaleSessions: () => pruneStaleSessions,
   registerSession: () => registerSession
 });
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync10, mkdirSync as mkdirSync11, existsSync as existsSync14 } from "fs";
+import { readFileSync as readFileSync13, writeFileSync as writeFileSync11, mkdirSync as mkdirSync12, existsSync as existsSync15 } from "fs";
 import { execSync as execSync3 } from "child_process";
-import path16 from "path";
-import os9 from "os";
+import path18 from "path";
+import os10 from "os";
 function registerSession(entry) {
-  const dir = path16.dirname(REGISTRY_PATH);
-  if (!existsSync14(dir)) {
-    mkdirSync11(dir, { recursive: true });
+  const dir = path18.dirname(REGISTRY_PATH);
+  if (!existsSync15(dir)) {
+    mkdirSync12(dir, { recursive: true });
   }
   const sessions = listSessions();
   const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
@@ -7884,11 +8728,11 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync10(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync11(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function listSessions() {
   try {
-    const raw = readFileSync12(REGISTRY_PATH, "utf8");
+    const raw = readFileSync13(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -7909,7 +8753,7 @@ function pruneStaleSessions() {
   const alive = sessions.filter((s) => liveSet.has(s.windowName));
   const pruned = sessions.length - alive.length;
   if (pruned > 0) {
-    writeFileSync10(REGISTRY_PATH, JSON.stringify(alive, null, 2));
+    writeFileSync11(REGISTRY_PATH, JSON.stringify(alive, null, 2));
   }
   return pruned;
 }
@@ -7917,7 +8761,7 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path16.join(os9.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path18.join(os10.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
@@ -8154,67 +8998,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 readFileSync13, writeFileSync as writeFileSync11, existsSync as existsSync15, mkdirSync as mkdirSync12 } from "fs";
-import path17 from "path";
-function loadAgentConfig() {
-  if (!existsSync15(AGENT_CONFIG_PATH)) return {};
-  try {
-    return JSON.parse(readFileSync13(AGENT_CONFIG_PATH, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function getAgentRuntime(agentId) {
-  const config = loadAgentConfig();
-  const entry = config[agentId];
-  if (entry) return entry;
-  const orgDefault = config["default"];
-  if (orgDefault) return orgDefault;
-  return { runtime: DEFAULT_RUNTIME, model: DEFAULT_MODELS[DEFAULT_RUNTIME] };
-}
-var AGENT_CONFIG_PATH, DEFAULT_MODELS;
-var init_agent_config = __esm({
-  "src/lib/agent-config.ts"() {
-    "use strict";
-    init_config();
-    init_runtime_table();
-    AGENT_CONFIG_PATH = path17.join(EXE_AI_DIR, "agent-config.json");
-    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, {
@@ -8225,10 +9008,10 @@ __export(intercom_queue_exports, {
   readQueue: () => readQueue
 });
 import { readFileSync as readFileSync14, writeFileSync as writeFileSync12, renameSync as renameSync3, existsSync as existsSync16, mkdirSync as mkdirSync13 } from "fs";
-import path18 from "path";
-import os10 from "os";
+import path19 from "path";
+import os11 from "os";
 function ensureDir2() {
-  const dir = path18.dirname(QUEUE_PATH);
+  const dir = path19.dirname(QUEUE_PATH);
   if (!existsSync16(dir)) mkdirSync13(dir, { recursive: true });
 }
 function readQueue() {
@@ -8334,16 +9117,16 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path18.join(os10.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path19.join(os11.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path18.join(os10.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path19.join(os11.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/plan-limits.ts
 import { readFileSync as readFileSync15, existsSync as existsSync17 } from "fs";
-import path19 from "path";
+import path20 from "path";
 function getLicenseSync() {
   try {
     if (!existsSync17(CACHE_PATH2)) return freeLicense();
@@ -8415,14 +9198,14 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path19.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path20.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/notifications.ts
 import crypto5 from "crypto";
-import path20 from "path";
-import os11 from "os";
+import path21 from "path";
+import os12 from "os";
 import {
   readFileSync as readFileSync16,
   readdirSync as readdirSync4,
@@ -8552,8 +9335,8 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto7 from "crypto";
-import path21 from "path";
-import os12 from "os";
+import path22 from "path";
+import os13 from "os";
 import { execSync as execSync6 } from "child_process";
 import { mkdir as mkdir5, writeFile as writeFile5, appendFile } from "fs/promises";
 import { existsSync as existsSync19, readFileSync as readFileSync17 } from "fs";
@@ -8731,8 +9514,8 @@ ${laneWarning}` : laneWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir5(path21.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir5(path21.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir5(path22.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir5(path22.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -8768,9 +9551,9 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path21.join(os12.homedir(), ".exe-os");
-      const mdPath = path21.join(EXE_OS_DIR, taskFile);
-      const mdDir = path21.dirname(mdPath);
+      const EXE_OS_DIR = path22.join(os13.homedir(), ".exe-os");
+      const mdPath = path22.join(EXE_OS_DIR, taskFile);
+      const mdDir = path22.dirname(mdPath);
       if (!existsSync19(mdDir)) await mkdir5(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
@@ -9071,7 +9854,7 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path21.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path22.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
     if (existsSync19(archPath)) return;
     const template = [
@@ -9106,7 +9889,7 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path21.join(baseDir, ".gitignore");
+  const gitignorePath = path22.join(baseDir, ".gitignore");
   try {
     if (existsSync19(gitignorePath)) {
       const content = readFileSync17(gitignorePath, "utf-8");
@@ -9140,13 +9923,13 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path22 from "path";
+import path23 from "path";
 import { existsSync as existsSync20, readdirSync as readdirSync5, 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;
@@ -9322,11 +10105,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path22.join(EXE_AI_DIR, "session-cache");
+    const cacheDir = path23.join(EXE_AI_DIR, "session-cache");
     if (existsSync20(cacheDir)) {
       for (const f of readdirSync5(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path22.join(cacheDir, f));
+          unlinkSync6(path23.join(cacheDir, f));
         }
       }
     }
@@ -9347,7 +10130,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path23 from "path";
+import path24 from "path";
 import { readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -9364,7 +10147,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path23.join(baseDir, String(ur.task_file));
+        const ubFile = path24.join(baseDir, String(ur.task_file));
         let ubContent = await readFile5(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -9433,7 +10216,7 @@ var init_tasks_chain = __esm({
 
 // src/lib/project-name.ts
 import { execSync as execSync7 } from "child_process";
-import path24 from "path";
+import path25 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
@@ -9446,7 +10229,7 @@ function getProjectName(cwd2) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path24.dirname(gitCommonDir);
+      repoRoot = path25.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync7("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -9455,11 +10238,11 @@ function getProjectName(cwd2) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path24.basename(repoRoot);
+    _cached2 = path25.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path24.basename(dir);
+    _cached2 = path25.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -9932,7 +10715,7 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path25 from "path";
+import path26 from "path";
 import { writeFileSync as writeFileSync13, mkdirSync as mkdirSync14, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
@@ -9952,8 +10735,8 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path25.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path25.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path26.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path26.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
       mkdirSync14(cacheDir, { recursive: true });
       writeFileSync13(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
@@ -10424,12 +11207,12 @@ __export(tmux_routing_exports, {
 });
 import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
 import { readFileSync as readFileSync18, writeFileSync as writeFileSync14, mkdirSync as mkdirSync15, existsSync as existsSync21, appendFileSync as appendFileSync2, readdirSync as readdirSync6 } from "fs";
-import path26 from "path";
-import os13 from "os";
+import path27 from "path";
+import os14 from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { unlinkSync as unlinkSync8 } from "fs";
 function spawnLockPath(sessionName) {
-  return path26.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path27.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -10466,8 +11249,8 @@ function releaseSpawnLock2(sessionName) {
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const scriptPath = path26.join(
-      path26.dirname(thisFile),
+    const scriptPath = path27.join(
+      path27.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
@@ -10542,7 +11325,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
     mkdirSync15(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path26.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  const filePath = path27.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
   writeFileSync14(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
@@ -10551,7 +11334,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync18(path26.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync18(path27.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -10560,7 +11343,7 @@ function getParentExe(sessionKey) {
 function getDispatchedBy(sessionKey) {
   try {
     const data = JSON.parse(readFileSync18(
-      path26.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      path27.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -10571,15 +11354,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);
@@ -10737,7 +11529,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const markerPath = path26.join(SESSION_CACHE, `current-task-${agent}.json`);
+      const markerPath = path27.join(SESSION_CACHE, `current-task-${agent}.json`);
       if (existsSync21(markerPath)) {
         logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker \u2014 will auto-chain)`);
         return "debounced";
@@ -10747,7 +11539,7 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path26.join(process.cwd(), "exe", agent);
+      const taskDir = path27.join(process.cwd(), "exe", agent);
       if (existsSync21(taskDir)) {
         const files = readdirSync6(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
@@ -10881,8 +11673,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 = path26.join(os13.homedir(), ".exe-os", "session-logs");
-  const logFile = path26.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  const logDir = path27.join(os14.homedir(), ".exe-os", "session-logs");
+  const logFile = path27.join(logDir, `${instanceLabel}-${Date.now()}.log`);
   if (!existsSync21(logDir)) {
     mkdirSync15(logDir, { recursive: true });
   }
@@ -10890,14 +11682,14 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const cleanupScript = path26.join(path26.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    const cleanupScript = path27.join(path27.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
     if (existsSync21(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path26.join(os13.homedir(), ".claude.json");
+    const claudeJsonPath = path27.join(os14.homedir(), ".claude.json");
     let claudeJson = {};
     try {
       claudeJson = JSON.parse(readFileSync18(claudeJsonPath, "utf8"));
@@ -10912,10 +11704,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   try {
-    const settingsDir = path26.join(os13.homedir(), ".claude", "projects");
+    const settingsDir = path27.join(os14.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path26.join(settingsDir, normalizedKey);
-    const settingsPath = path26.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path27.join(settingsDir, normalizedKey);
+    const settingsPath = path27.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
       settings = JSON.parse(readFileSync18(settingsPath, "utf8"));
@@ -10962,8 +11754,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath2 = path26.join(
-      os13.homedir(),
+    const identityPath2 = path27.join(
+      os14.homedir(),
       ".exe-os",
       "identity",
       `${employeeName}.md`
@@ -10978,7 +11770,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path26.basename(spawnCwd),
+      path27.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -10993,9 +11785,9 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path26.join(os13.homedir(), ".exe-os", "session-cache");
+    const ctxDir = path27.join(os14.homedir(), ".exe-os", "session-cache");
     mkdirSync15(ctxDir, { recursive: true });
-    const ctxFile = path26.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxFile = path27.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
@@ -11079,7 +11871,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path26.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    const dispatchInfo = path27.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
     writeFileSync14(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
@@ -11154,15 +11946,15 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path26.join(os13.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path26.join(os13.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path27.join(os14.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path27.join(os14.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 = path26.join(os13.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path26.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path27.join(os14.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path27.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -11431,7 +12223,7 @@ __export(active_agent_exports, {
 });
 import { readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync16, unlinkSync as unlinkSync9, readdirSync as readdirSync7 } from "fs";
 import { execSync as execSync9 } from "child_process";
-import path27 from "path";
+import path28 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -11475,7 +12267,7 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path27.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path28.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
@@ -11544,14 +12336,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync19(path27.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync19(path28.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 {
-              unlinkSync9(path27.join(CACHE_DIR, file));
+              unlinkSync9(path28.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -11574,11 +12366,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync9(path27.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync9(path28.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync9(path27.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync9(path28.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -11589,7 +12381,7 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path27.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path28.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -12219,12 +13011,12 @@ __export(exe_rename_exports, {
 });
 import { readFileSync as readFileSync20, writeFileSync as writeFileSync16, renameSync as renameSync4, unlinkSync as unlinkSync10, existsSync as existsSync22 } from "fs";
 import { execSync as execSync10 } from "child_process";
-import path28 from "path";
+import path29 from "path";
 import { homedir as homedir4 } from "os";
 async function renameEmployee(oldName, newName, opts = {}) {
-  const rosterPath = opts.rosterPath ?? path28.join(homedir4(), ".exe-os", "exe-employees.json");
-  const identityDir = opts.identityDir ?? path28.join(homedir4(), ".exe-os", "identity");
-  const agentsDir = opts.agentsDir ?? path28.join(homedir4(), ".claude", "agents");
+  const rosterPath = opts.rosterPath ?? path29.join(homedir4(), ".exe-os", "exe-employees.json");
+  const identityDir = opts.identityDir ?? path29.join(homedir4(), ".exe-os", "identity");
+  const agentsDir = opts.agentsDir ?? path29.join(homedir4(), ".claude", "agents");
   const validation = validateEmployeeName(newName);
   if (!validation.valid) {
     return { success: false, error: validation.error };
@@ -12256,8 +13048,8 @@ async function renameEmployee(oldName, newName, opts = {}) {
         writeFileSync16(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
       }
     });
-    const oldIdentityPath = path28.join(identityDir, `${rosterOldName}.md`);
-    const newIdentityPath = path28.join(identityDir, `${newName}.md`);
+    const oldIdentityPath = path29.join(identityDir, `${rosterOldName}.md`);
+    const newIdentityPath = path29.join(identityDir, `${newName}.md`);
     if (existsSync22(oldIdentityPath)) {
       const content = readFileSync20(oldIdentityPath, "utf-8");
       const updatedContent = content.replace(
@@ -12276,8 +13068,8 @@ async function renameEmployee(oldName, newName, opts = {}) {
         }
       });
     }
-    const oldAgentPath = path28.join(agentsDir, `${rosterOldName}.md`);
-    const newAgentPath = path28.join(agentsDir, `${newName}.md`);
+    const oldAgentPath = path29.join(agentsDir, `${rosterOldName}.md`);
+    const newAgentPath = path29.join(agentsDir, `${newName}.md`);
     if (existsSync22(oldAgentPath)) {
       const agentContent = readFileSync20(oldAgentPath, "utf-8");
       renameSync4(oldAgentPath, newAgentPath);
@@ -12364,9 +13156,9 @@ function removeOldSymlinks(name) {
   try {
     const exeBinPath = findExeBin2();
     if (!exeBinPath) return;
-    const binDir = path28.dirname(exeBinPath);
+    const binDir = path29.dirname(exeBinPath);
     for (const suffix of ["", "-opencode"]) {
-      const linkPath = path28.join(binDir, `${name}${suffix}`);
+      const linkPath = path29.join(binDir, `${name}${suffix}`);
       if (existsSync22(linkPath)) {
         try {
           unlinkSync10(linkPath);
@@ -12415,10 +13207,10 @@ var init_exe_rename = __esm({
 import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync23, unlinkSync as unlinkSync11, renameSync as renameSync5 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
-import path29 from "path";
+import path30 from "path";
 async function downloadModel(opts) {
   const { destDir, onProgress, fetchFn = globalThis.fetch } = opts;
-  const destPath = path29.join(destDir, LOCAL_FILENAME);
+  const destPath = path30.join(destDir, LOCAL_FILENAME);
   const tmpPath = destPath + ".tmp";
   await mkdir6(destDir, { recursive: true });
   if (existsSync23(destPath)) {
@@ -12542,8 +13334,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: existsSync30 } = await import("fs");
-  const path44 = await import("path");
-  const modelPath = path44.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  const path45 = await import("path");
+  const modelPath = path45.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
   if (!existsSync30(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
@@ -13127,17 +13919,17 @@ import {
   readdirSync as readdirSync8,
   unlinkSync as unlinkSync12
 } from "fs";
-import path30 from "path";
+import path31 from "path";
 import { homedir as homedir5 } from "os";
 function generateSessionWrappers(packageRoot, homeDir) {
   const home = homeDir ?? homedir5();
-  const binDir = path30.join(home, ".exe-os", "bin");
-  const rosterPath = path30.join(home, ".exe-os", "exe-employees.json");
+  const binDir = path31.join(home, ".exe-os", "bin");
+  const rosterPath = path31.join(home, ".exe-os", "exe-employees.json");
   mkdirSync17(binDir, { recursive: true });
-  const exeStartDst = path30.join(binDir, "exe-start");
+  const exeStartDst = path31.join(binDir, "exe-start");
   const candidates = [
-    path30.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path30.join(packageRoot, "src", "bin", "exe-start.sh")
+    path31.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path31.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
     if (existsSync24(src)) {
@@ -13158,7 +13950,7 @@ function generateSessionWrappers(packageRoot, homeDir) {
   try {
     for (const f of readdirSync8(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path30.join(binDir, f);
+      const fPath = path31.join(binDir, f);
       try {
         const content = readFileSync21(fPath, "utf8");
         if (content.includes("exe-start")) {
@@ -13175,15 +13967,15 @@ exec "${exeStartDst}" "$0" "$@"
 `;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      const wrapperPath = path30.join(binDir, `${emp.name}${n}`);
+      const wrapperPath = path31.join(binDir, `${emp.name}${n}`);
       writeFileSync17(wrapperPath, wrapperContent);
       chmodSync(wrapperPath, 493);
       created++;
     }
   }
   const codexLauncherCandidates = [
-    path30.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
-    path30.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+    path31.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path31.join(packageRoot, "src", "bin", "exe-start-codex.ts")
   ];
   let codexLauncher = null;
   for (const c of codexLauncherCandidates) {
@@ -13194,7 +13986,7 @@ exec "${exeStartDst}" "$0" "$@"
   }
   if (codexLauncher) {
     for (const emp of employees) {
-      const wrapperPath = path30.join(binDir, `${emp.name}-codex`);
+      const wrapperPath = path31.join(binDir, `${emp.name}-codex`);
       const content = `#!/bin/bash
 exec node "${codexLauncher}" --agent ${emp.name} "$@"
 `;
@@ -13217,12 +14009,12 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path30.join(home, ".zshrc"));
+    profilePaths.push(path31.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path30.join(home, ".bashrc"));
-    profilePaths.push(path30.join(home, ".bash_profile"));
+    profilePaths.push(path31.join(home, ".bashrc"));
+    profilePaths.push(path31.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path30.join(home, ".profile"));
+    profilePaths.push(path31.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
@@ -13258,14 +14050,14 @@ __export(setup_wizard_exports, {
 });
 import crypto11 from "crypto";
 import { existsSync as existsSync25, mkdirSync as mkdirSync18, readFileSync as readFileSync22, writeFileSync as writeFileSync18, unlinkSync as unlinkSync13 } from "fs";
-import os14 from "os";
-import path31 from "path";
+import os15 from "os";
+import path32 from "path";
 import { createInterface as createInterface3 } from "readline";
 function findPackageRoot2() {
-  let dir = path31.dirname(new URL(import.meta.url).pathname);
-  const root = path31.parse(dir).root;
+  let dir = path32.dirname(new URL(import.meta.url).pathname);
+  const root = path32.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path31.join(dir, "package.json");
+    const pkgPath = path32.join(dir, "package.json");
     if (existsSync25(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync22(pkgPath, "utf-8"));
@@ -13273,7 +14065,7 @@ function findPackageRoot2() {
       } catch {
       }
     }
-    dir = path31.dirname(dir);
+    dir = path32.dirname(dir);
   }
   return null;
 }
@@ -13285,7 +14077,7 @@ function loadSetupState() {
   }
 }
 function saveSetupState(state) {
-  mkdirSync18(path31.dirname(SETUP_STATE_PATH), { recursive: true });
+  mkdirSync18(path32.dirname(SETUP_STATE_PATH), { recursive: true });
   writeFileSync18(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
 }
 function clearSetupState() {
@@ -13305,10 +14097,10 @@ function ask2(rl, prompt) {
   });
 }
 function getAvailableMemoryGB() {
-  return os14.freemem() / (1024 * 1024 * 1024);
+  return os15.freemem() / (1024 * 1024 * 1024);
 }
 function getTotalMemoryGB() {
-  return os14.totalmem() / (1024 * 1024 * 1024);
+  return os15.totalmem() / (1024 * 1024 * 1024);
 }
 function isLowMemory() {
   return getAvailableMemoryGB() < 2;
@@ -13319,7 +14111,7 @@ async function validateModel(log) {
   if (totalGB <= 8 || isLowMemory()) {
     log(`System memory: ${totalGB.toFixed(0)}GB total, ${freeGB.toFixed(1)}GB free`);
     log("Skipping in-memory model validation (low memory \u2014 will validate on first use).");
-    const modelPath = path31.join(MODELS_DIR, LOCAL_FILENAME);
+    const modelPath = path32.join(MODELS_DIR, LOCAL_FILENAME);
     if (existsSync25(modelPath)) {
       const { statSync: statSync2 } = await import("fs");
       const size = statSync2(modelPath).size;
@@ -13575,7 +14367,7 @@ async function runSetupWizard(opts = {}) {
       await saveConfig(config);
       log("");
       try {
-        const claudeJsonPath = path31.join(os14.homedir(), ".claude.json");
+        const claudeJsonPath = path32.join(os15.homedir(), ".claude.json");
         let claudeJson = {};
         try {
           claudeJson = JSON.parse(readFileSync22(claudeJsonPath, "utf8"));
@@ -13583,7 +14375,7 @@ async function runSetupWizard(opts = {}) {
         }
         if (!claudeJson.projects) claudeJson.projects = {};
         const projects = claudeJson.projects;
-        for (const dir of [process.cwd(), os14.homedir()]) {
+        for (const dir of [process.cwd(), os15.homedir()]) {
           if (!projects[dir]) projects[dir] = {};
           projects[dir].hasTrustDialogAccepted = true;
         }
@@ -13601,7 +14393,7 @@ async function runSetupWizard(opts = {}) {
       const prefs = { ...existingPrefs };
       log("=== Config Defaults ===");
       log("");
-      const ghosttyDetected = existsSync25(path31.join(os14.homedir(), ".config", "ghostty")) || existsSync25(path31.join(os14.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
+      const ghosttyDetected = existsSync25(path32.join(os15.homedir(), ".config", "ghostty")) || existsSync25(path32.join(os15.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
       if (ghosttyDetected) {
         const ghosttyAnswer = await ask2(rl, "Detected Ghostty terminal. Use exe-os Ghostty defaults? (Y/n) ");
         prefs.ghostty = ghosttyAnswer.toLowerCase() !== "n";
@@ -13745,7 +14537,7 @@ async function runSetupWizard(opts = {}) {
       const cooIdentityContent = getIdentityTemplate("coo");
       if (cooIdentityContent) {
         const cooIdPath = identityPath2(cooName);
-        mkdirSync18(path31.dirname(cooIdPath), { recursive: true });
+        mkdirSync18(path32.dirname(cooIdPath), { recursive: true });
         const replaced = cooIdentityContent.replace(/agent_id:\s*exe/g, `agent_id: ${cooName}`).replace(/\$\{agent_id\}/g, cooName);
         writeFileSync18(cooIdPath, replaced, "utf-8");
       }
@@ -13841,7 +14633,7 @@ async function runSetupWizard(opts = {}) {
       const ctoIdentityContent = getIdentityTemplate("cto");
       if (ctoIdentityContent) {
         const ctoIdPath = identityPath2(ctoName);
-        mkdirSync18(path31.dirname(ctoIdPath), { recursive: true });
+        mkdirSync18(path32.dirname(ctoIdPath), { recursive: true });
         const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
         writeFileSync18(ctoIdPath, replaced, "utf-8");
       }
@@ -13864,7 +14656,7 @@ async function runSetupWizard(opts = {}) {
       const cmoIdentityContent = getIdentityTemplate("cmo");
       if (cmoIdentityContent) {
         const cmoIdPath = identityPath2(cmoName);
-        mkdirSync18(path31.dirname(cmoIdPath), { recursive: true });
+        mkdirSync18(path32.dirname(cmoIdPath), { recursive: true });
         const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
         writeFileSync18(cmoIdPath, replaced, "utf-8");
       }
@@ -13888,7 +14680,7 @@ async function runSetupWizard(opts = {}) {
             log(`Session shortcuts generated (${cooName}1, ${cooName}2, ...)`);
           }
           if (wrapResult.pathConfigured) {
-            const binDir = path31.join(os14.homedir(), ".exe-os", "bin");
+            const binDir = path32.join(os15.homedir(), ".exe-os", "bin");
             process.env.PATH = `${binDir}:${process.env.PATH ?? ""}`;
             pathJustConfigured = true;
           }
@@ -13931,7 +14723,7 @@ async function runSetupWizard(opts = {}) {
     const pkgRoot2 = findPackageRoot2();
     if (pkgRoot2) {
       try {
-        version = JSON.parse(readFileSync22(path31.join(pkgRoot2, "package.json"), "utf-8")).version;
+        version = JSON.parse(readFileSync22(path32.join(pkgRoot2, "package.json"), "utf-8")).version;
       } catch {
       }
     }
@@ -13965,16 +14757,16 @@ var init_setup_wizard = __esm({
     init_config();
     init_keychain();
     init_model_downloader();
-    SETUP_STATE_PATH = path31.join(os14.homedir(), ".exe-os", "setup-state.json");
+    SETUP_STATE_PATH = path32.join(os15.homedir(), ".exe-os", "setup-state.json");
   }
 });
 
 // src/lib/update-check.ts
 import { execSync as execSync11 } from "child_process";
 import { readFileSync as readFileSync23 } from "fs";
-import path32 from "path";
+import path33 from "path";
 function getLocalVersion(packageRoot) {
-  const pkgPath = path32.join(packageRoot, "package.json");
+  const pkgPath = path33.join(packageRoot, "package.json");
   const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
   return pkg.version;
 }
@@ -18499,8 +19291,8 @@ var init_ErrorOverview = __esm({
     "use strict";
     init_Box();
     init_Text();
-    cleanupPath = (path44) => {
-      return path44?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path45) => {
+      return path45?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new StackUtils({
       cwd: cwd(),
@@ -22954,10 +23746,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path33 from "path";
-import os15 from "os";
+import path34 from "path";
+import os16 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path33.resolve(filePath);
+  const resolved = path34.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -22967,7 +23759,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path33.resolve(filePath);
+  const resolved = path34.resolve(filePath);
   const credPatterns = BYPASS_IMMUNE_PATTERNS.filter(
     (p) => typeof p.pattern !== "function" && (p.reason.includes("secrets") || p.reason.includes("Private key") || p.reason.includes("Credential"))
   );
@@ -22982,7 +23774,7 @@ var HOME, BYPASS_IMMUNE_PATTERNS;
 var init_safety_checks = __esm({
   "src/runtime/safety-checks.ts"() {
     "use strict";
-    HOME = os15.homedir();
+    HOME = os16.homedir();
     BYPASS_IMMUNE_PATTERNS = [
       {
         pattern: /\/\.git\/hooks\//,
@@ -22993,11 +23785,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path33.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path34.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path33.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path34.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -23014,7 +23806,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path33.basename(p);
+          const name = path34.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -23041,7 +23833,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path34 from "path";
+import path35 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -23077,7 +23869,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path34.isAbsolute(input.file_path) ? input.file_path : path34.resolve(context.cwd, input.file_path);
+        const filePath = path35.isAbsolute(input.file_path) ? input.file_path : path35.resolve(context.cwd, input.file_path);
         let stat2;
         try {
           stat2 = await fs3.stat(filePath);
@@ -23117,7 +23909,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path35 from "path";
+import path36 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -23133,7 +23925,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path35.join(current, entry.name);
+      const fullPath = path36.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -23167,11 +23959,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path35.isAbsolute(input.path) ? input.path : path35.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path36.isAbsolute(input.path) ? input.path : path36.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path35.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path36.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -23197,7 +23989,7 @@ __export(grep_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path36 from "path";
+import path37 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -23251,7 +24043,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path36.join(dir, entry.name);
+      const fullPath = path37.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -23297,7 +24089,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path36.isAbsolute(input.path) ? input.path : path36.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path37.isAbsolute(input.path) ? input.path : path37.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -23322,7 +24114,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -23350,8 +24142,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path37.isAbsolute(input.file_path) ? input.file_path : path37.resolve(context.cwd, input.file_path);
-        const dir = path37.dirname(filePath);
+        const filePath = path38.isAbsolute(input.file_path) ? input.file_path : path38.resolve(context.cwd, input.file_path);
+        const dir = path38.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -23369,7 +24161,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -23410,7 +24202,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path38.isAbsolute(input.file_path) ? input.file_path : path38.resolve(context.cwd, input.file_path);
+        const filePath = path39.isAbsolute(input.file_path) ? input.file_path : path39.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -23652,7 +24444,7 @@ var init_bash = __esm({
 // src/tui/views/CommandCenter.tsx
 import { useState as useState6, useEffect as useEffect8, useMemo as useMemo4, useCallback as useCallback4, useRef as useRef4 } from "react";
 import TextInput from "ink-text-input";
-import path39 from "path";
+import path40 from "path";
 import { homedir as homedir6 } from "os";
 import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function CommandCenterView({
@@ -23901,7 +24693,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path39.join(homedir6(), p.projectName),
+        projectDir: path40.join(homedir6(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -24905,7 +25697,7 @@ var init_useOrchestrator = __esm({
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path40 from "path";
+import path41 from "path";
 import { homedir as homedir7 } from "os";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function isCoordinatorEntry(entry) {
@@ -24943,7 +25735,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path40.join(homedir7(), p.projectName),
+        projectDir: path41.join(homedir7(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -26861,8 +27653,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path44, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path44}`;
+async function wikiFetch(config, path45, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path45}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
@@ -26895,7 +27687,7 @@ async function wikiFetch(config, path44, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path44}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path45}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -27529,8 +28321,8 @@ function SettingsView({ onBack }) {
       let version = "unknown";
       try {
         const { readFileSync: readFileSync27 } = await import("fs");
-        const { createRequire } = await import("module");
-        const require2 = createRequire(import.meta.url);
+        const { createRequire: createRequire2 } = await import("module");
+        const require2 = createRequire2(import.meta.url);
         const pkgPath = require2.resolve("@askexenow/exe-os/package.json");
         const pkg = JSON.parse(readFileSync27(pkgPath, "utf8"));
         version = pkg.version;
@@ -28340,11 +29132,11 @@ __export(installer_exports2, {
 });
 import { readFile as readFile6, writeFile as writeFile7, mkdir as mkdir7 } from "fs/promises";
 import { existsSync as existsSync27, readFileSync as readFileSync25 } from "fs";
-import path41 from "path";
-import os16 from "os";
-async function registerOpenCodeMcp(packageRoot, homeDir = os16.homedir()) {
-  const configDir = path41.join(homeDir, ".config", "opencode");
-  const configPath = path41.join(configDir, "opencode.json");
+import path42 from "path";
+import os17 from "os";
+async function registerOpenCodeMcp(packageRoot, homeDir = os17.homedir()) {
+  const configDir = path42.join(homeDir, ".config", "opencode");
+  const configPath = path42.join(configDir, "opencode.json");
   await mkdir7(configDir, { recursive: true });
   let config = {};
   if (existsSync27(configPath)) {
@@ -28359,7 +29151,7 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os16.homedir()) {
   }
   const newEntry = {
     type: "local",
-    command: ["node", path41.join(packageRoot, "dist", "mcp", "server.js")],
+    command: ["node", path42.join(packageRoot, "dist", "mcp", "server.js")],
     enabled: true
   };
   const current = config.mcp["exe-os"];
@@ -28373,9 +29165,9 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os16.homedir()) {
   await writeFile7(configPath, JSON.stringify(config, null, 2) + "\n");
   return true;
 }
-async function installOpenCodePlugin(packageRoot, homeDir = os16.homedir()) {
-  const pluginDir = path41.join(homeDir, ".config", "opencode", "plugins");
-  const pluginPath = path41.join(pluginDir, "exe-os.mjs");
+async function installOpenCodePlugin(packageRoot, homeDir = os17.homedir()) {
+  const pluginDir = path42.join(homeDir, ".config", "opencode", "plugins");
+  const pluginPath = path42.join(pluginDir, "exe-os.mjs");
   await mkdir7(pluginDir, { recursive: true });
   const pluginContent = PLUGIN_TEMPLATE.replace(
     /__PACKAGE_ROOT__/g,
@@ -28390,9 +29182,9 @@ async function installOpenCodePlugin(packageRoot, homeDir = os16.homedir()) {
   await writeFile7(pluginPath, pluginContent);
   return true;
 }
-function verifyOpenCodeHooks(homeDir = os16.homedir()) {
-  const configPath = path41.join(homeDir, ".config", "opencode", "opencode.json");
-  const pluginPath = path41.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
+function verifyOpenCodeHooks(homeDir = os17.homedir()) {
+  const configPath = path42.join(homeDir, ".config", "opencode", "opencode.json");
+  const pluginPath = path42.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
   if (!existsSync27(configPath)) return false;
   try {
     const config = JSON.parse(readFileSync25(configPath, "utf-8"));
@@ -28434,13 +29226,13 @@ __export(installer_exports3, {
 });
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
 import { existsSync as existsSync28 } from "fs";
-import path42 from "path";
-import os17 from "os";
-async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
-  const codexDir = path42.join(homeDir, ".codex");
-  const hooksPath = path42.join(codexDir, "hooks.json");
-  const logsDir = path42.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path42.join(logsDir, "hooks.log");
+import path43 from "path";
+import os18 from "os";
+async function mergeCodexHooks(packageRoot, homeDir = os18.homedir()) {
+  const codexDir = path43.join(homeDir, ".codex");
+  const hooksPath = path43.join(codexDir, "hooks.json");
+  const logsDir = path43.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path43.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir8(codexDir, { recursive: true });
   await mkdir8(logsDir, { recursive: true });
@@ -28462,7 +29254,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
             timeout: 30,
             statusMessage: "exe-os: loading memory brief"
           }
@@ -28477,11 +29269,11 @@ async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "ingest.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "error-recall.js")}"${logSuffix}`
           }
         ]
       },
@@ -28493,11 +29285,11 @@ async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           },
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "exe-heartbeat-hook.js")}"${logSuffix}`,
             timeout: 5
           }
         ]
@@ -28510,7 +29302,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -28523,7 +29315,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path42.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path43.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -28554,15 +29346,15 @@ async function mergeCodexHooks(packageRoot, homeDir = os17.homedir()) {
   await writeFile8(hooksPath, JSON.stringify(hooksJson, null, 2) + "\n");
   return { added, skipped };
 }
-function verifyCodexHooks(homeDir = os17.homedir()) {
-  const hooksPath = path42.join(homeDir, ".codex", "hooks.json");
+function verifyCodexHooks(homeDir = os18.homedir()) {
+  const hooksPath = path43.join(homeDir, ".codex", "hooks.json");
   if (!existsSync28(hooksPath)) return false;
   try {
     const hooksJson = JSON.parse(
       __require("fs").readFileSync(hooksPath, "utf-8")
     );
     if (!hooksJson.hooks) return false;
-    const required = ["SessionStart", "PostToolUse", "UserPromptSubmit", "Stop"];
+    const required = ["SessionStart", "PostToolUse", "UserPromptSubmit", "Stop", "PreToolUse"];
     for (const event of required) {
       const groups = hooksJson.hooks[event];
       if (!groups || !groups.some(
@@ -28576,11 +29368,11 @@ function verifyCodexHooks(homeDir = os17.homedir()) {
     return false;
   }
 }
-async function installCodexStatusLine(homeDir = os17.homedir()) {
+async function installCodexStatusLine(homeDir = os18.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.codexStatusLine === false) return "opted-out";
-  const codexDir = path42.join(homeDir, ".codex");
-  const configPath = path42.join(codexDir, "config.toml");
+  const codexDir = path43.join(homeDir, ".codex");
+  const configPath = path43.join(codexDir, "config.toml");
   await mkdir8(codexDir, { recursive: true });
   let content = "";
   if (existsSync28(configPath)) {
@@ -28632,12 +29424,12 @@ var init_installer3 = __esm({
 
 // src/bin/cli.ts
 import { existsSync as existsSync29, readFileSync as readFileSync26, writeFileSync as writeFileSync19, readdirSync as readdirSync9, rmSync } from "fs";
-import path43 from "path";
-import os18 from "os";
+import path44 from "path";
+import os19 from "os";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   try {
-    const pkgPath = path43.join(path43.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkgPath = path44.join(path44.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync26(pkgPath, "utf8"));
     console.log(pkg.version);
   } catch {
@@ -28802,8 +29594,8 @@ ID: ${result.id}`);
   });
   await init_App2().then(() => App_exports);
 } else {
-  const claudeDir = path43.join(os18.homedir(), ".claude");
-  const settingsPath = path43.join(claudeDir, "settings.json");
+  const claudeDir = path44.join(os19.homedir(), ".claude");
+  const settingsPath = path44.join(claudeDir, "settings.json");
   const hasClaudeCode = existsSync29(settingsPath) && (() => {
     try {
       const raw = readFileSync26(settingsPath, "utf8");
@@ -28816,7 +29608,7 @@ ID: ${result.id}`);
     const { DEFAULT_COORDINATOR_TEMPLATE_NAME: DEFAULT_COORDINATOR_TEMPLATE_NAME2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
     let cooName = DEFAULT_COORDINATOR_TEMPLATE_NAME2;
     try {
-      const rosterPath = path43.join(os18.homedir(), ".exe-os", "exe-employees.json");
+      const rosterPath = path44.join(os19.homedir(), ".exe-os", "exe-employees.json");
       if (existsSync29(rosterPath)) {
         const roster = JSON.parse(readFileSync26(rosterPath, "utf8"));
         const coo = roster.find((e) => e.role === "COO");
@@ -28882,9 +29674,9 @@ async function runCodexInstall() {
   }
 }
 async function runClaudeCheck() {
-  const claudeDir = path43.join(os18.homedir(), ".claude");
-  const settingsPath = path43.join(claudeDir, "settings.json");
-  const claudeJsonPath = path43.join(os18.homedir(), ".claude.json");
+  const claudeDir = path44.join(os19.homedir(), ".claude");
+  const settingsPath = path44.join(claudeDir, "settings.json");
+  const claudeJsonPath = path44.join(os19.homedir(), ".claude.json");
   let ok = true;
   if (existsSync29(settingsPath)) {
     let settings;
@@ -28937,7 +29729,7 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m claude.json not found");
     ok = false;
   }
-  const skillsDir = path43.join(claudeDir, "skills");
+  const skillsDir = path44.join(claudeDir, "skills");
   if (existsSync29(skillsDir)) {
     console.log("\x1B[32m\u2713\x1B[0m Slash skills directory exists");
   } else {
@@ -28954,11 +29746,11 @@ async function runClaudeCheck() {
 async function runClaudeUninstall(flags = []) {
   const dryRun = flags.includes("--dry-run");
   const purge = flags.includes("--purge");
-  const homeDir = os18.homedir();
-  const claudeDir = path43.join(homeDir, ".claude");
-  const settingsPath = path43.join(claudeDir, "settings.json");
-  const claudeJsonPath = path43.join(homeDir, ".claude.json");
-  const exeOsDir = path43.join(homeDir, ".exe-os");
+  const homeDir = os19.homedir();
+  const claudeDir = path44.join(homeDir, ".claude");
+  const settingsPath = path44.join(claudeDir, "settings.json");
+  const claudeJsonPath = path44.join(homeDir, ".claude.json");
+  const exeOsDir = path44.join(homeDir, ".exe-os");
   let removed = 0;
   const log = (msg) => console.log(dryRun ? `[dry-run] ${msg}` : msg);
   let settings = {};
@@ -29039,14 +29831,14 @@ async function runClaudeUninstall(flags = []) {
       }
     }
   }
-  const skillsDir = path43.join(claudeDir, "skills");
+  const skillsDir = path44.join(claudeDir, "skills");
   if (existsSync29(skillsDir)) {
     let skillCount = 0;
     try {
       const entries = readdirSync9(skillsDir);
       for (const entry of entries) {
         if (entry.startsWith("exe")) {
-          const fullPath = path43.join(skillsDir, entry);
+          const fullPath = path44.join(skillsDir, entry);
           if (!dryRun) rmSync(fullPath, { recursive: true, force: true });
           skillCount++;
         }
@@ -29058,7 +29850,7 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const claudeMdPath = path43.join(claudeDir, "CLAUDE.md");
+  const claudeMdPath = path44.join(claudeDir, "CLAUDE.md");
   if (existsSync29(claudeMdPath)) {
     const content = readFileSync26(claudeMdPath, "utf8");
     const startMarker = "<!-- exe-os:orchestration-start -->";
@@ -29072,13 +29864,13 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const agentsDir = path43.join(claudeDir, "agents");
+  const agentsDir = path44.join(claudeDir, "agents");
   if (existsSync29(agentsDir)) {
     let agentCount = 0;
     try {
       const entries = readdirSync9(agentsDir).filter((f) => f.endsWith(".md"));
       let knownNames = /* @__PURE__ */ new Set();
-      const rosterPath = path43.join(exeOsDir, "exe-employees.json");
+      const rosterPath = path44.join(exeOsDir, "exe-employees.json");
       if (existsSync29(rosterPath)) {
         try {
           const roster = JSON.parse(readFileSync26(rosterPath, "utf8"));
@@ -29089,7 +29881,7 @@ async function runClaudeUninstall(flags = []) {
       for (const entry of entries) {
         const name = entry.replace(/\.md$/, "");
         if (knownNames.has(name)) {
-          if (!dryRun) rmSync(path43.join(agentsDir, entry), { force: true });
+          if (!dryRun) rmSync(path44.join(agentsDir, entry), { force: true });
           agentCount++;
         }
       }
@@ -29100,13 +29892,13 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const projectsDir = path43.join(claudeDir, "projects");
+  const projectsDir = path44.join(claudeDir, "projects");
   if (existsSync29(projectsDir)) {
     let projectCount = 0;
     try {
       const projects = readdirSync9(projectsDir);
       for (const proj of projects) {
-        const projSettings = path43.join(projectsDir, proj, "settings.json");
+        const projSettings = path44.join(projectsDir, proj, "settings.json");
         if (!existsSync29(projSettings)) continue;
         try {
           const pSettings = JSON.parse(readFileSync26(projSettings, "utf8"));
@@ -29143,9 +29935,9 @@ async function runClaudeUninstall(flags = []) {
     };
     const exeBinPath = findExeBin3();
     if (!exeBinPath) throw new Error("exe-os not found in PATH");
-    const binDir = path43.dirname(exeBinPath);
+    const binDir = path44.dirname(exeBinPath);
     let symlinkCount = 0;
-    const rosterPath = path43.join(exeOsDir, "exe-employees.json");
+    const rosterPath = path44.join(exeOsDir, "exe-employees.json");
     if (existsSync29(rosterPath)) {
       const roster = JSON.parse(readFileSync26(rosterPath, "utf8"));
       const { DEFAULT_COORDINATOR_TEMPLATE_NAME: DEFAULT_COORDINATOR_TEMPLATE_NAME2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
@@ -29153,7 +29945,7 @@ async function runClaudeUninstall(flags = []) {
       for (const emp of roster) {
         if (emp.name === coordinatorName) continue;
         for (const suffix of ["", "-opencode"]) {
-          const linkPath = path43.join(binDir, `${emp.name}${suffix}`);
+          const linkPath = path44.join(binDir, `${emp.name}${suffix}`);
           if (existsSync29(linkPath)) {
             if (!dryRun) rmSync(linkPath, { force: true });
             symlinkCount++;
@@ -29192,7 +29984,7 @@ async function checkForUpdateOnBoot() {
     const config = await loadConfig2();
     if (!config.autoUpdate.checkOnBoot) return;
     const { checkForUpdate: checkForUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
-    const packageRoot = path43.resolve(
+    const packageRoot = path44.resolve(
       new URL("../..", import.meta.url).pathname
     );
     const result = checkForUpdate2(packageRoot);
@@ -29252,7 +30044,7 @@ async function runActivate(key) {
       const idTemplate = getIdentityTemplate(identityKey);
       if (idTemplate) {
         const idPath = identityPath2(name);
-        const dir = path43.dirname(idPath);
+        const dir = path44.dirname(idPath);
         if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
         fs8.writeFileSync(idPath, idTemplate.replace(/^agent_id: \w+/m, `agent_id: ${name}`), "utf-8");
       }