@askexenow/exe-os 0.8.80 → 0.8.82

package/dist/index.js

@@ -25,6 +25,444 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/lib/config.ts
+var config_exports = {};
+__export(config_exports, {
+  CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
+  CONFIG_PATH: () => CONFIG_PATH,
+  CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
+  DB_PATH: () => DB_PATH,
+  EXE_AI_DIR: () => EXE_AI_DIR,
+  LEGACY_LANCE_PATH: () => LEGACY_LANCE_PATH,
+  MODELS_DIR: () => MODELS_DIR,
+  loadConfig: () => loadConfig,
+  loadConfigFrom: () => loadConfigFrom,
+  loadConfigSync: () => loadConfigSync,
+  migrateConfig: () => migrateConfig,
+  saveConfig: () => saveConfig
+});
+import { readFile, writeFile, mkdir, chmod } from "fs/promises";
+import { readFileSync, existsSync, renameSync } from "fs";
+import path2 from "path";
+import os2 from "os";
+function resolveDataDir() {
+  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
+  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
+  const newDir = path2.join(os2.homedir(), ".exe-os");
+  const legacyDir = path2.join(os2.homedir(), ".exe-mem");
+  if (!existsSync(newDir) && existsSync(legacyDir)) {
+    try {
+      renameSync(legacyDir, newDir);
+      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
+`);
+    } catch {
+      return legacyDir;
+    }
+  }
+  return newDir;
+}
+function migrateLegacyConfig(raw) {
+  if ("r2" in raw) {
+    process.stderr.write(
+      "[exe-os] Warning: config.json contains deprecated 'r2' field from v1.0. R2 sync has been replaced in v1.1. The 'r2' field will be ignored.\n"
+    );
+    delete raw.r2;
+  }
+  if ("syncIntervalMs" in raw) {
+    delete raw.syncIntervalMs;
+  }
+  return raw;
+}
+function migrateConfig(raw) {
+  const fromVersion = typeof raw.config_version === "number" ? raw.config_version : 0;
+  let currentVersion = fromVersion;
+  let migrated = false;
+  if (currentVersion > CURRENT_CONFIG_VERSION) {
+    return { config: raw, migrated: false, fromVersion };
+  }
+  for (const migration of CONFIG_MIGRATIONS) {
+    if (currentVersion === migration.from && migration.to <= CURRENT_CONFIG_VERSION) {
+      raw = migration.migrate(raw);
+      currentVersion = migration.to;
+      migrated = true;
+    }
+  }
+  return { config: raw, migrated, fromVersion };
+}
+function normalizeScalingRoadmap(raw) {
+  const defaultAuto = DEFAULT_CONFIG.scalingRoadmap.rerankerAutoTrigger;
+  const userRoadmap = raw.scalingRoadmap ?? {};
+  const userAuto = userRoadmap.rerankerAutoTrigger ?? {};
+  if (userAuto.enabled === void 0 && raw.rerankerEnabled !== void 0) {
+    userAuto.enabled = raw.rerankerEnabled;
+  }
+  raw.scalingRoadmap = {
+    ...userRoadmap,
+    rerankerAutoTrigger: { ...defaultAuto, ...userAuto }
+  };
+}
+function normalizeSessionLifecycle(raw) {
+  const defaultSL = DEFAULT_CONFIG.sessionLifecycle;
+  const userSL = raw.sessionLifecycle ?? {};
+  raw.sessionLifecycle = { ...defaultSL, ...userSL };
+}
+function normalizeAutoUpdate(raw) {
+  const defaultAU = DEFAULT_CONFIG.autoUpdate;
+  const userAU = raw.autoUpdate ?? {};
+  raw.autoUpdate = { ...defaultAU, ...userAU };
+}
+async function loadConfig() {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  await mkdir(dir, { recursive: true });
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  }
+  const raw = await readFile(configPath, "utf-8");
+  try {
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg, migrated, fromVersion } = migrateConfig(parsed);
+    if (migrated) {
+      process.stderr.write(`[exe-os] Config migrated from v${fromVersion} to v${migratedCfg.config_version}
+`);
+      try {
+        await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
+      } catch {
+      }
+    }
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    const config2 = { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
+    if (config2.dbPath.startsWith("~")) {
+      config2.dbPath = config2.dbPath.replace(/^~/, os2.homedir());
+    }
+    return config2;
+  } catch {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  }
+}
+function loadConfigSync() {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  const configPath = path2.join(dir, "config.json");
+  if (!existsSync(configPath)) {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  }
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db"), ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG, dbPath: path2.join(dir, "memories.db") };
+  }
+}
+async function saveConfig(config2) {
+  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
+  await mkdir(dir, { recursive: true });
+  const configPath = path2.join(dir, "config.json");
+  await writeFile(configPath, JSON.stringify(config2, null, 2) + "\n");
+  if (config2.cloud?.apiKey) {
+    await chmod(configPath, 384);
+  }
+}
+async function loadConfigFrom(configPath) {
+  const raw = await readFile(configPath, "utf-8");
+  try {
+    let parsed = JSON.parse(raw);
+    parsed = migrateLegacyConfig(parsed);
+    const { config: migratedCfg } = migrateConfig(parsed);
+    normalizeScalingRoadmap(migratedCfg);
+    normalizeSessionLifecycle(migratedCfg);
+    normalizeAutoUpdate(migratedCfg);
+    return { ...DEFAULT_CONFIG, ...migratedCfg };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
+var init_config = __esm({
+  "src/lib/config.ts"() {
+    "use strict";
+    EXE_AI_DIR = resolveDataDir();
+    DB_PATH = path2.join(EXE_AI_DIR, "memories.db");
+    MODELS_DIR = path2.join(EXE_AI_DIR, "models");
+    CONFIG_PATH = path2.join(EXE_AI_DIR, "config.json");
+    LEGACY_LANCE_PATH = path2.join(EXE_AI_DIR, "local.lance");
+    CURRENT_CONFIG_VERSION = 1;
+    DEFAULT_CONFIG = {
+      config_version: CURRENT_CONFIG_VERSION,
+      dbPath: DB_PATH,
+      modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
+      embeddingDim: 1024,
+      batchSize: 20,
+      flushIntervalMs: 1e4,
+      autoIngestion: true,
+      autoRetrieval: true,
+      searchMode: "hybrid",
+      hookSearchMode: "hybrid",
+      fileGrepEnabled: true,
+      splashEffect: true,
+      consolidationEnabled: true,
+      consolidationIntervalMs: 6 * 60 * 60 * 1e3,
+      consolidationModel: "claude-haiku-4-5-20251001",
+      consolidationMaxCallsPerRun: 20,
+      selfQueryRouter: true,
+      selfQueryModel: "claude-haiku-4-5-20251001",
+      rerankerEnabled: true,
+      scalingRoadmap: {
+        rerankerAutoTrigger: {
+          enabled: true,
+          broadQueryMinCardinality: 5e4,
+          fetchTopK: 150,
+          returnTopK: 5
+        }
+      },
+      graphRagEnabled: true,
+      wikiEnabled: false,
+      wikiUrl: "",
+      wikiApiKey: "",
+      wikiSyncIntervalMs: 30 * 60 * 1e3,
+      wikiWorkspaceMapping: {},
+      wikiAutoUpdate: true,
+      wikiAutoUpdateThreshold: 0.5,
+      wikiAutoUpdateCreateNew: true,
+      skillLearning: true,
+      skillThreshold: 3,
+      skillModel: "claude-haiku-4-5-20251001",
+      exeHeartbeat: {
+        enabled: true,
+        intervalSeconds: 60,
+        staleInProgressThresholdHours: 2
+      },
+      sessionLifecycle: {
+        idleKillEnabled: true,
+        idleKillTicksRequired: 3,
+        idleKillIntercomAckWindowMs: 1e4,
+        maxAutoInstances: 10
+      },
+      autoUpdate: {
+        checkOnBoot: true,
+        autoInstall: false,
+        checkIntervalMs: 24 * 60 * 60 * 1e3
+      }
+    };
+    CONFIG_MIGRATIONS = [
+      {
+        from: 0,
+        to: 1,
+        migrate: (cfg) => {
+          cfg.config_version = 1;
+          return cfg;
+        }
+      }
+    ];
+  }
+});
+
+// src/lib/employees.ts
+var employees_exports = {};
+__export(employees_exports, {
+  COORDINATOR_ROLE: () => COORDINATOR_ROLE,
+  DEFAULT_COORDINATOR_TEMPLATE_NAME: () => DEFAULT_COORDINATOR_TEMPLATE_NAME,
+  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
+  addEmployee: () => addEmployee,
+  canCoordinate: () => canCoordinate,
+  getCoordinatorEmployee: () => getCoordinatorEmployee,
+  getCoordinatorName: () => getCoordinatorName,
+  getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  isCoordinatorName: () => isCoordinatorName,
+  isCoordinatorRole: () => isCoordinatorRole,
+  isMultiInstance: () => isMultiInstance,
+  loadEmployees: () => loadEmployees,
+  loadEmployeesSync: () => loadEmployeesSync,
+  normalizeRole: () => normalizeRole,
+  normalizeRosterCase: () => normalizeRosterCase,
+  registerBinSymlinks: () => registerBinSymlinks,
+  saveEmployees: () => saveEmployees,
+  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 { execSync } from "child_process";
+import path3 from "path";
+import os3 from "os";
+function normalizeRole(role) {
+  return (role ?? "").trim().toLowerCase();
+}
+function isCoordinatorRole(role) {
+  return normalizeRole(role) === normalizeRole(COORDINATOR_ROLE);
+}
+function getCoordinatorEmployee(employees) {
+  return employees.find((e) => isCoordinatorRole(e.role));
+}
+function getCoordinatorName(employees = loadEmployeesSync()) {
+  return getCoordinatorEmployee(employees)?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+}
+function isCoordinatorName(agentName, employees = loadEmployeesSync()) {
+  if (!agentName) return false;
+  return agentName.toLowerCase() === getCoordinatorName(employees).toLowerCase();
+}
+function canCoordinate(agentName, agentRole, employees = loadEmployeesSync()) {
+  return agentName === "default" || isCoordinatorRole(agentRole) || isCoordinatorName(agentName, employees);
+}
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+    };
+  }
+  return { valid: true };
+}
+async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync2(employeesPath)) {
+    return [];
+  }
+  const raw = await readFile2(employeesPath, "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return [];
+  }
+}
+async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
+  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 [];
+  try {
+    return JSON.parse(readFileSync2(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
+function addEmployee(employees, employee) {
+  const normalized = { ...employee, name: employee.name.toLowerCase() };
+  if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
+    throw new Error(`Employee '${normalized.name}' already exists`);
+  }
+  return [...employees, normalized];
+}
+async function normalizeRosterCase(rosterPath) {
+  const employees = await loadEmployees(rosterPath);
+  let changed = false;
+  for (const emp of employees) {
+    if (emp.name !== emp.name.toLowerCase()) {
+      const oldName = emp.name;
+      emp.name = emp.name.toLowerCase();
+      changed = true;
+      try {
+        const identityDir = path3.join(os3.homedir(), ".exe-os", "identity");
+        const oldPath = path3.join(identityDir, `${oldName}.md`);
+        const newPath = path3.join(identityDir, `${emp.name}.md`);
+        if (existsSync2(oldPath) && !existsSync2(newPath)) {
+          renameSync2(oldPath, newPath);
+        } else if (existsSync2(oldPath) && oldPath !== newPath) {
+          const content = readFileSync2(oldPath, "utf-8");
+          writeFileSync(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync(oldPath);
+          }
+        }
+      } catch {
+      }
+    }
+  }
+  if (changed) {
+    await saveEmployees(employees, rosterPath);
+  }
+  return changed;
+}
+function findExeBin() {
+  try {
+    return execSync(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  const exeBinPath = findExeBin();
+  if (!exeBinPath) {
+    errors.push("Could not find 'exe-os' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path3.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path3.join(binDir, linkName);
+    if (existsSync2(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, DEFAULT_COORDINATOR_TEMPLATE_NAME, COORDINATOR_ROLE, MULTI_INSTANCE_ROLES;
+var init_employees = __esm({
+  "src/lib/employees.ts"() {
+    "use strict";
+    init_config();
+    EMPLOYEES_PATH = path3.join(EXE_AI_DIR, "exe-employees.json");
+    DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
+    COORDINATOR_ROLE = "COO";
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+  }
+});
+
 // src/lib/session-registry.ts
 var session_registry_exports = {};
 __export(session_registry_exports, {
@@ -32,13 +470,13 @@ __export(session_registry_exports, {
   pruneStaleSessions: () => pruneStaleSessions,
   registerSession: () => registerSession
 });
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
-import { execSync } from "child_process";
-import path2 from "path";
-import os2 from "os";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, mkdirSync, existsSync as existsSync3 } from "fs";
+import { execSync as execSync2 } from "child_process";
+import path4 from "path";
+import os4 from "os";
 function registerSession(entry) {
-  const dir = path2.dirname(REGISTRY_PATH);
-  if (!existsSync(dir)) {
+  const dir = path4.dirname(REGISTRY_PATH);
+  if (!existsSync3(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   const sessions = listSessions();
@@ -48,11 +486,11 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync2(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function listSessions() {
   try {
-    const raw = readFileSync(REGISTRY_PATH, "utf8");
+    const raw = readFileSync3(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -63,7 +501,7 @@ function pruneStaleSessions() {
   if (sessions.length === 0) return 0;
   let liveSessions = [];
   try {
-    liveSessions = execSync("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+    liveSessions = execSync2("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
       encoding: "utf8"
     }).trim().split("\n").filter(Boolean);
   } catch {
@@ -73,7 +511,7 @@ function pruneStaleSessions() {
   const alive = sessions.filter((s) => liveSet.has(s.windowName));
   const pruned = sessions.length - alive.length;
   if (pruned > 0) {
-    writeFileSync(REGISTRY_PATH, JSON.stringify(alive, null, 2));
+    writeFileSync2(REGISTRY_PATH, JSON.stringify(alive, null, 2));
   }
   return pruned;
 }
@@ -81,18 +519,18 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path2.join(os2.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path4.join(os4.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
 // src/lib/session-key.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function getSessionKey() {
   if (_cached) return _cached;
   let pid = process.ppid;
   for (let i = 0; i < 10; i++) {
     try {
-      const info = execSync2(`ps -p ${pid} -o ppid=,comm=`, {
+      const info = execSync3(`ps -p ${pid} -o ppid=,comm=`, {
         encoding: "utf8",
         timeout: 2e3
       }).trim();
@@ -228,14 +666,14 @@ var init_transport = __esm({
 });
 
 // src/lib/cc-agent-support.ts
-import { execSync as execSync3 } from "child_process";
+import { execSync as execSync4 } from "child_process";
 function _resetCcAgentSupportCache() {
   _cachedSupport = null;
 }
 function claudeSupportsAgentFlag() {
   if (_cachedSupport !== null) return _cachedSupport;
   try {
-    const helpOutput = execSync3("claude --help 2>&1", {
+    const helpOutput = execSync4("claude --help 2>&1", {
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -311,17 +749,17 @@ var init_provider_table = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, renameSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import path3 from "path";
-import os3 from "os";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync3, existsSync as existsSync4, mkdirSync as mkdirSync2 } from "fs";
+import path5 from "path";
+import os5 from "os";
 function ensureDir() {
-  const dir = path3.dirname(QUEUE_PATH);
-  if (!existsSync2(dir)) mkdirSync2(dir, { recursive: true });
+  const dir = path5.dirname(QUEUE_PATH);
+  if (!existsSync4(dir)) mkdirSync2(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync2(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync2(QUEUE_PATH, "utf8"));
+    if (!existsSync4(QUEUE_PATH)) return [];
+    return JSON.parse(readFileSync4(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -329,8 +767,8 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync2(tmp, JSON.stringify(queue, null, 2));
-  renameSync(tmp, QUEUE_PATH);
+  writeFileSync3(tmp, JSON.stringify(queue, null, 2));
+  renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
   const queue = readQueue();
@@ -353,9 +791,9 @@ var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path3.join(os3.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path5.join(os5.homedir(), ".exe-os", "intercom-queue.json");
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path3.join(os3.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path5.join(os5.homedir(), ".exe-os", "intercom.log");
   }
 });
 
@@ -398,7 +836,7 @@ function wrapWithRetry(client) {
         return (sql) => retryOnBusy(() => target.execute(sql), "execute");
       }
       if (prop === "batch") {
-        return (stmts) => retryOnBusy(() => target.batch(stmts), "batch");
+        return (stmts, mode) => retryOnBusy(() => target.batch(stmts, mode), "batch");
       }
       return Reflect.get(target, prop, receiver);
     }
@@ -561,22 +999,24 @@ async function ensureSchema() {
       ON behaviors(agent_id, active);
   `);
   try {
+    const coordinatorName = getCoordinatorName();
     const existing = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = 'exe'",
-      args: []
+      sql: "SELECT COUNT(*) as cnt FROM behaviors WHERE agent_id = ?",
+      args: [coordinatorName]
     });
     if (Number(existing.rows[0]?.cnt) === 0) {
-      await client.executeMultiple(`
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Don''t ask "keep going?" \u2014 just keep executing phases/plans autonomously', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'tool-use', 'Always use create_task MCP tool, never write .md files directly for task creation', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-        INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
-        VALUES
-          (hex(randomblob(16)), 'exe', NULL, 'workflow', 'Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission', 1, '2026-03-25T00:00:00Z', '2026-03-25T00:00:00Z');
-      `);
+      const seededAt = "2026-03-25T00:00:00Z";
+      for (const [domain, content] of [
+        ["workflow", `Don't ask "keep going?" \u2014 just keep executing phases/plans autonomously`],
+        ["tool-use", "Always use create_task MCP tool, never write .md files directly for task creation"],
+        ["workflow", "Auto-start reviewing when idle and reviews are pending \u2014 never ask founder for permission"]
+      ]) {
+        await client.execute({
+          sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, content, active, created_at, updated_at)
+                VALUES (hex(randomblob(16)), ?, NULL, ?, ?, 1, ?, ?)`,
+          args: [coordinatorName, domain, content, seededAt, seededAt]
+        });
+      }
     }
   } catch {
   }
@@ -1268,304 +1708,57 @@ async function ensureSchema() {
     } catch {
     }
   }
-}
-async function disposeDatabase() {
-  if (_client) {
-    _client.close();
-    _client = null;
-    _resilientClient = null;
-  }
-}
-var _client, _resilientClient, initTurso, disposeTurso;
-var init_database = __esm({
-  "src/lib/database.ts"() {
-    "use strict";
-    init_db_retry();
-    _client = null;
-    _resilientClient = null;
-    initTurso = initDatabase;
-    disposeTurso = disposeDatabase;
-  }
-});
-
-// src/lib/config.ts
-var config_exports = {};
-__export(config_exports, {
-  CONFIG_MIGRATIONS: () => CONFIG_MIGRATIONS,
-  CONFIG_PATH: () => CONFIG_PATH,
-  COO_AGENT_NAME: () => COO_AGENT_NAME,
-  CURRENT_CONFIG_VERSION: () => CURRENT_CONFIG_VERSION,
-  DB_PATH: () => DB_PATH,
-  EXE_AI_DIR: () => EXE_AI_DIR,
-  LEGACY_LANCE_PATH: () => LEGACY_LANCE_PATH,
-  MODELS_DIR: () => MODELS_DIR,
-  loadConfig: () => loadConfig,
-  loadConfigFrom: () => loadConfigFrom,
-  loadConfigSync: () => loadConfigSync,
-  migrateConfig: () => migrateConfig,
-  saveConfig: () => saveConfig
-});
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync as readFileSync3, existsSync as existsSync3, renameSync as renameSync2 } from "fs";
-import path4 from "path";
-import os4 from "os";
-function resolveDataDir() {
-  if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
-  if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  const newDir = path4.join(os4.homedir(), ".exe-os");
-  const legacyDir = path4.join(os4.homedir(), ".exe-mem");
-  if (!existsSync3(newDir) && existsSync3(legacyDir)) {
-    try {
-      renameSync2(legacyDir, newDir);
-      process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
-`);
-    } catch {
-      return legacyDir;
-    }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
   }
-  return newDir;
-}
-function migrateLegacyConfig(raw) {
-  if ("r2" in raw) {
-    process.stderr.write(
-      "[exe-os] Warning: config.json contains deprecated 'r2' field from v1.0. R2 sync has been replaced in v1.1. The 'r2' field will be ignored.\n"
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
     );
-    delete raw.r2;
-  }
-  if ("syncIntervalMs" in raw) {
-    delete raw.syncIntervalMs;
-  }
-  return raw;
-}
-function migrateConfig(raw) {
-  const fromVersion = typeof raw.config_version === "number" ? raw.config_version : 0;
-  let currentVersion = fromVersion;
-  let migrated = false;
-  if (currentVersion > CURRENT_CONFIG_VERSION) {
-    return { config: raw, migrated: false, fromVersion };
-  }
-  for (const migration of CONFIG_MIGRATIONS) {
-    if (currentVersion === migration.from && migration.to <= CURRENT_CONFIG_VERSION) {
-      raw = migration.migrate(raw);
-      currentVersion = migration.to;
-      migrated = true;
-    }
-  }
-  return { config: raw, migrated, fromVersion };
-}
-function normalizeScalingRoadmap(raw) {
-  const defaultAuto = DEFAULT_CONFIG.scalingRoadmap.rerankerAutoTrigger;
-  const userRoadmap = raw.scalingRoadmap ?? {};
-  const userAuto = userRoadmap.rerankerAutoTrigger ?? {};
-  if (userAuto.enabled === void 0 && raw.rerankerEnabled !== void 0) {
-    userAuto.enabled = raw.rerankerEnabled;
-  }
-  raw.scalingRoadmap = {
-    ...userRoadmap,
-    rerankerAutoTrigger: { ...defaultAuto, ...userAuto }
-  };
-}
-function normalizeSessionLifecycle(raw) {
-  const defaultSL = DEFAULT_CONFIG.sessionLifecycle;
-  const userSL = raw.sessionLifecycle ?? {};
-  raw.sessionLifecycle = { ...defaultSL, ...userSL };
-}
-function normalizeAutoUpdate(raw) {
-  const defaultAU = DEFAULT_CONFIG.autoUpdate;
-  const userAU = raw.autoUpdate ?? {};
-  raw.autoUpdate = { ...defaultAU, ...userAU };
-}
-async function loadConfig() {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir(dir, { recursive: true });
-  const configPath = path4.join(dir, "config.json");
-  if (!existsSync3(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
+  } catch {
   }
-  const raw = await readFile(configPath, "utf-8");
   try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg, migrated, fromVersion } = migrateConfig(parsed);
-    if (migrated) {
-      process.stderr.write(`[exe-os] Config migrated from v${fromVersion} to v${migratedCfg.config_version}
-`);
-      try {
-        await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
-      } catch {
-      }
-    }
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    const config2 = { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db"), ...migratedCfg };
-    if (config2.dbPath.startsWith("~")) {
-      config2.dbPath = config2.dbPath.replace(/^~/, os4.homedir());
-    }
-    return config2;
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`,
+      args: []
+    });
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
-  }
-}
-function loadConfigSync() {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  const configPath = path4.join(dir, "config.json");
-  if (!existsSync3(configPath)) {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
   }
   try {
-    const raw = readFileSync3(configPath, "utf-8");
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg } = migrateConfig(parsed);
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db"), ...migratedCfg };
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
+    );
   } catch {
-    return { ...DEFAULT_CONFIG, dbPath: path4.join(dir, "memories.db") };
-  }
-}
-async function saveConfig(config2) {
-  const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir(dir, { recursive: true });
-  const configPath = path4.join(dir, "config.json");
-  await writeFile(configPath, JSON.stringify(config2, null, 2) + "\n");
-  if (config2.cloud?.apiKey) {
-    await chmod(configPath, 384);
   }
-}
-async function loadConfigFrom(configPath) {
-  const raw = await readFile(configPath, "utf-8");
   try {
-    let parsed = JSON.parse(raw);
-    parsed = migrateLegacyConfig(parsed);
-    const { config: migratedCfg } = migrateConfig(parsed);
-    normalizeScalingRoadmap(migratedCfg);
-    normalizeSessionLifecycle(migratedCfg);
-    normalizeAutoUpdate(migratedCfg);
-    return { ...DEFAULT_CONFIG, ...migratedCfg };
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN trajectory TEXT`,
+      args: []
+    });
   } catch {
-    return { ...DEFAULT_CONFIG };
   }
 }
-var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, COO_AGENT_NAME, LEGACY_LANCE_PATH, CURRENT_CONFIG_VERSION, DEFAULT_CONFIG, CONFIG_MIGRATIONS;
-var init_config = __esm({
-  "src/lib/config.ts"() {
-    "use strict";
-    EXE_AI_DIR = resolveDataDir();
-    DB_PATH = path4.join(EXE_AI_DIR, "memories.db");
-    MODELS_DIR = path4.join(EXE_AI_DIR, "models");
-    CONFIG_PATH = path4.join(EXE_AI_DIR, "config.json");
-    COO_AGENT_NAME = "exe";
-    LEGACY_LANCE_PATH = path4.join(EXE_AI_DIR, "local.lance");
-    CURRENT_CONFIG_VERSION = 1;
-    DEFAULT_CONFIG = {
-      config_version: CURRENT_CONFIG_VERSION,
-      dbPath: DB_PATH,
-      modelFile: "jina-embeddings-v5-small-q4_k_m.gguf",
-      embeddingDim: 1024,
-      batchSize: 20,
-      flushIntervalMs: 1e4,
-      autoIngestion: true,
-      autoRetrieval: true,
-      searchMode: "hybrid",
-      hookSearchMode: "hybrid",
-      fileGrepEnabled: true,
-      splashEffect: true,
-      consolidationEnabled: true,
-      consolidationIntervalMs: 6 * 60 * 60 * 1e3,
-      consolidationModel: "claude-haiku-4-5-20251001",
-      consolidationMaxCallsPerRun: 20,
-      selfQueryRouter: true,
-      selfQueryModel: "claude-haiku-4-5-20251001",
-      rerankerEnabled: true,
-      scalingRoadmap: {
-        rerankerAutoTrigger: {
-          enabled: true,
-          broadQueryMinCardinality: 5e4,
-          fetchTopK: 150,
-          returnTopK: 5
-        }
-      },
-      graphRagEnabled: true,
-      wikiEnabled: false,
-      wikiUrl: "",
-      wikiApiKey: "",
-      wikiSyncIntervalMs: 30 * 60 * 1e3,
-      wikiWorkspaceMapping: {
-        exe: "Executive",
-        yoshi: "Engineering",
-        mari: "Marketing",
-        tom: "Engineering",
-        sasha: "Production"
-      },
-      wikiAutoUpdate: true,
-      wikiAutoUpdateThreshold: 0.5,
-      wikiAutoUpdateCreateNew: true,
-      skillLearning: true,
-      skillThreshold: 3,
-      skillModel: "claude-haiku-4-5-20251001",
-      exeHeartbeat: {
-        enabled: true,
-        intervalSeconds: 60,
-        staleInProgressThresholdHours: 2
-      },
-      sessionLifecycle: {
-        idleKillEnabled: true,
-        idleKillTicksRequired: 3,
-        idleKillIntercomAckWindowMs: 1e4,
-        maxAutoInstances: 10
-      },
-      autoUpdate: {
-        checkOnBoot: true,
-        autoInstall: false,
-        checkIntervalMs: 24 * 60 * 60 * 1e3
-      }
-    };
-    CONFIG_MIGRATIONS = [
-      {
-        from: 0,
-        to: 1,
-        migrate: (cfg) => {
-          cfg.config_version = 1;
-          return cfg;
-        }
-      }
-    ];
-  }
-});
-
-// src/lib/employees.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync4, renameSync as renameSync3, unlinkSync, writeFileSync as writeFileSync3 } from "fs";
-import { execSync as execSync4 } from "child_process";
-import path5 from "path";
-import os5 from "os";
-function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync4(employeesPath)) return [];
-  try {
-    return JSON.parse(readFileSync4(employeesPath, "utf-8"));
-  } catch {
-    return [];
+async function disposeDatabase() {
+  if (_client) {
+    _client.close();
+    _client = null;
+    _resilientClient = null;
   }
 }
-function getEmployee(employees, name) {
-  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
-}
-function isMultiInstance(agentName, employees) {
-  const roster = employees ?? loadEmployeesSync();
-  const emp = getEmployee(roster, agentName);
-  if (!emp) return false;
-  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
-}
-var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
+var _client, _resilientClient, initTurso, disposeTurso;
+var init_database = __esm({
+  "src/lib/database.ts"() {
     "use strict";
-    init_config();
-    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
-    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+    init_db_retry();
+    init_employees();
+    _client = null;
+    _resilientClient = null;
+    initTurso = initDatabase;
+    disposeTurso = disposeDatabase;
   }
 });
 
@@ -2085,6 +2278,36 @@ async function listTasks(input) {
     tokensWarnedAt: r.tokens_warned_at !== null ? Number(r.tokens_warned_at) : null
   }));
 }
+function isTmuxSessionAlive(identifier) {
+  if (!identifier || identifier === "unknown") return true;
+  try {
+    if (identifier.startsWith("%")) {
+      const output = execSync5("tmux list-panes -a -F '#{pane_id}'", {
+        timeout: 2e3,
+        encoding: "utf8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return output.split("\n").some((l) => l.trim() === identifier);
+    } else {
+      execSync5(`tmux has-session -t ${JSON.stringify(identifier)}`, {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    }
+  } catch {
+    if (identifier.startsWith("%")) return true;
+    try {
+      execSync5("tmux list-sessions", {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return false;
+    } catch {
+      return true;
+    }
+  }
+}
 function checkStaleCompletion(taskContext, taskCreatedAt) {
   if (!taskContext) return null;
   if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
@@ -2147,13 +2370,59 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
     });
     if (claim.rowsAffected === 0) {
       const current = await client.execute({
-        sql: "SELECT status, assigned_tmux FROM tasks WHERE id = ?",
+        sql: "SELECT status, assigned_tmux, assigned_by FROM tasks WHERE id = ?",
         args: [taskId]
       });
       const cur = current.rows[0];
-      const status = cur?.status ?? "unknown";
-      const claimedBy = cur?.assigned_tmux ? ` (claimed by ${cur.assigned_tmux})` : "";
-      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${status}${claimedBy}`);
+      const curStatus = cur?.status ?? "unknown";
+      const claimedBySession = cur?.assigned_tmux ?? "";
+      const assignedBy = cur?.assigned_by ?? "";
+      if (curStatus === "in_progress" && claimedBySession && !isTmuxSessionAlive(claimedBySession)) {
+        process.stderr.write(
+          `[tasks] Auto-releasing dead claim on ${taskId} (was ${claimedBySession})
+`
+        );
+        await client.execute({
+          sql: "UPDATE tasks SET status = 'open', assigned_tmux = NULL, updated_at = ? WHERE id = ?",
+          args: [now, taskId]
+        });
+        const retried = await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ? WHERE id = ? AND status = 'open'`,
+          args: [tmuxSession, now, taskId]
+        });
+        if (retried.rowsAffected > 0) {
+          try {
+            await writeCheckpoint({
+              taskId,
+              step: "reclaimed_dead_session",
+              contextSummary: `Task reclaimed after dead session ${claimedBySession} released.`
+            });
+          } catch {
+          }
+          return { row, taskFile, now, taskId };
+        }
+      }
+      if (curStatus === "in_progress" && input.callerAgentId && (input.callerAgentId === assignedBy || input.callerAgentId === "exe")) {
+        process.stderr.write(
+          `[tasks] Assigner override: ${input.callerAgentId} reclaiming ${taskId}
+`
+        );
+        await client.execute({
+          sql: `UPDATE tasks SET status = 'in_progress', assigned_tmux = ?, updated_at = ? WHERE id = ?`,
+          args: [tmuxSession, now, taskId]
+        });
+        try {
+          await writeCheckpoint({
+            taskId,
+            step: "assigner_override",
+            contextSummary: `Task force-reclaimed by assigner ${input.callerAgentId}.`
+          });
+        } catch {
+        }
+        return { row, taskFile, now, taskId };
+      }
+      const claimedBy = claimedBySession ? ` (claimed by ${claimedBySession})` : "";
+      throw new Error(`${TASK_ALREADY_CLAIMED_PREFIX}: task ${taskId} is ${curStatus}${claimedBy}`);
     }
     try {
       await writeCheckpoint({
@@ -2251,7 +2520,7 @@ var init_tasks_crud = __esm({
     "use strict";
     init_database();
     init_task_scope();
-    DELEGATION_KEYWORDS = /parallel|delegate|wave|tom\d*-exe/i;
+    DELEGATION_KEYWORDS = /parallel|delegate|wave|worktree|multi-instance/i;
     TASK_ALREADY_CLAIMED_PREFIX = "TASK_ALREADY_CLAIMED";
   }
 });
@@ -2608,7 +2877,7 @@ function findSessionForProject(projectName) {
   const sessions = listSessions();
   for (const s of sessions) {
     const proj = s.projectDir.split("/").filter(Boolean).pop();
-    if (proj === projectName && s.agentId === "exe") return s;
+    if (proj === projectName && (s.agentId === "exe" || isCoordinatorName(s.agentId))) return s;
   }
   return null;
 }
@@ -2648,12 +2917,13 @@ var init_session_scope = __esm({
     init_session_registry();
     init_project_name();
     init_tmux_routing();
+    init_employees();
   }
 });
 
 // src/lib/tasks-notify.ts
 async function dispatchTaskToEmployee(input) {
-  if (input.assignedTo === "exe") return { dispatched: "skipped" };
+  if (input.assignedTo === "exe" || isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
   let crossProject = false;
   if (input.projectName) {
     try {
@@ -3158,6 +3428,24 @@ async function updateTask(input) {
       });
     } catch {
     }
+    const assignedAgent = String(row.assigned_to);
+    if (!isCoordinatorName(assignedAgent)) {
+      try {
+        const draftClient = getClient();
+        if (input.status === "done") {
+          await draftClient.execute({
+            sql: `UPDATE memories SET draft = 0 WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        } else if (input.status === "cancelled") {
+          await draftClient.execute({
+            sql: `DELETE FROM memories WHERE agent_id = ? AND draft = 1`,
+            args: [assignedAgent]
+          });
+        }
+      } catch {
+      }
+    }
     try {
       const client = getClient();
       const cascaded = await client.execute({
@@ -3176,8 +3464,8 @@ async function updateTask(input) {
   }
   const isTerminal = input.status === "done" || input.status === "needs_review";
   if (isTerminal) {
-    const isExe = String(row.assigned_to) === "exe";
-    if (!isExe) {
+    const isCoordinator = String(row.assigned_to) === "exe" || isCoordinatorName(String(row.assigned_to));
+    if (!isCoordinator) {
       notifyTaskDone();
     }
     await markTaskNotificationsRead(taskFile);
@@ -3201,7 +3489,7 @@ async function updateTask(input) {
       }
     }
   }
-  if (input.status === "done" && String(row.assigned_to) !== "exe" && !process.env.VITEST) {
+  if (input.status === "done" && String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
     Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
       ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
         taskId,
@@ -3217,7 +3505,7 @@ async function updateTask(input) {
     });
   }
   let nextTask;
-  if (isTerminal && String(row.assigned_to) !== "exe") {
+  if (isTerminal && String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to))) {
     try {
       nextTask = await findNextTask(String(row.assigned_to));
     } catch {
@@ -3244,12 +3532,14 @@ async function updateTask(input) {
 async function deleteTask(taskId, baseDir) {
   const client = getClient();
   const { taskFile, assignedTo, assignedBy, taskSlug } = await deleteTaskCore(taskId, baseDir);
-  const reviewer = assignedBy || "exe";
+  const coordinatorName = getCoordinatorName();
+  const reviewer = assignedBy || coordinatorName;
   const reviewSlug = `review-${assignedTo}-${taskSlug}`;
   const reviewFile = `exe/${reviewer}/${reviewSlug}.md`;
+  const legacyReviewFile = `exe/${coordinatorName}/${reviewSlug}.md`;
   await client.execute({
-    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ?",
-    args: [reviewFile, `exe/exe/${reviewSlug}.md`]
+    sql: "DELETE FROM tasks WHERE task_file = ? OR task_file = ? OR task_file = ?",
+    args: [reviewFile, legacyReviewFile, `exe/exe/${reviewSlug}.md`]
   });
   await markAsReadByTaskFile(taskFile);
   await markAsReadByTaskFile(reviewFile);
@@ -3261,6 +3551,7 @@ var init_tasks = __esm({
     init_config();
     init_notifications();
     init_state_bus();
+    init_employees();
     init_tasks_crud();
     init_tasks_review();
     init_tasks_crud();
@@ -3346,7 +3637,7 @@ function _resetLastRelaunchCache() {
 }
 async function lastResumeCreatedAtMs(agentId) {
   const client = getClient();
-  const cmScope = sessionScopeFilter();
+  const cmScope = sessionScopeFilter(null);
   const result = await client.execute({
     sql: `SELECT MAX(created_at) AS last_created_at
           FROM tasks
@@ -3371,7 +3662,7 @@ async function createOrRefreshResumeTask(agentId, projectDir, openTasks) {
   const client = getClient();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const context = buildResumeContext(agentId, openTasks);
-  const rdScope = sessionScopeFilter();
+  const rdScope = sessionScopeFilter(null);
   const existing = await client.execute({
     sql: `SELECT id FROM tasks
           WHERE assigned_to = ?
@@ -3405,7 +3696,7 @@ async function pollCapacityDead() {
   const transport = getTransport();
   const relaunched = [];
   const registered = listSessions().filter(
-    (s) => s.agentId !== "exe"
+    (s) => s.agentId !== "exe" && !isCoordinatorName(s.agentId)
   );
   if (registered.length === 0) return [];
   let liveSessions;
@@ -3465,7 +3756,7 @@ async function pollCapacityDead() {
         reason: "capacity"
       });
       const client = getClient();
-      const rlScope = sessionScopeFilter();
+      const rlScope = sessionScopeFilter(null);
       const openTasks = await client.execute({
         sql: `SELECT id, title, priority, task_file, status
               FROM tasks
@@ -3519,6 +3810,7 @@ var init_capacity_monitor = __esm({
     init_session_kill_telemetry();
     init_tmux_routing();
     init_task_scope();
+    init_employees();
     CAPACITY_PATTERNS = [
       /conversation is too long/i,
       /maximum context length/i,
@@ -3668,7 +3960,7 @@ function employeeSessionName(employee, exeSession, instance) {
       exeSession = root;
     } else {
       throw new Error(
-        `Invalid exeSession "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name (e.g., "exe1", "work", "yoda1")`
+        `Invalid coordinator session "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name.`
       );
     }
   }
@@ -3688,8 +3980,10 @@ function parseParentExe(sessionName, agentId) {
   return match?.[1] ?? null;
 }
 function extractRootExe(name) {
-  const match = name.match(/(exe\d+)$/);
-  return match?.[1] ?? null;
+  if (!name) return null;
+  if (!name.includes("-")) return name;
+  const parts = name.split("-").filter(Boolean);
+  return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
   if (!existsSync10(SESSION_CACHE)) {
@@ -3834,12 +4128,14 @@ function isSessionBusy(sessionName) {
   return state === "thinking" || state === "tool";
 }
 function isExeSession(sessionName) {
-  return /^exe\d*$/.test(sessionName);
+  const matchesBaseWithInstance = (baseName) => sessionName === baseName || sessionName.startsWith(baseName) && /^\d+$/.test(sessionName.slice(baseName.length));
+  const coordinatorName = getCoordinatorName();
+  return matchesBaseWithInstance(coordinatorName) || matchesBaseWithInstance("exe");
 }
 function sendIntercom(targetSession) {
   const transport = getTransport();
   if (isExeSession(targetSession)) {
-    logIntercom(`SKIP_EXE \u2192 ${targetSession} (exe sessions use prompt-submit hook)`);
+    logIntercom(`SKIP_COORDINATOR \u2192 ${targetSession} (coordinator sessions use prompt-submit hook)`);
     return "skipped_exe";
   }
   if (isDebounced(targetSession)) {
@@ -3891,7 +4187,7 @@ function notifyParentExe(sessionKey) {
   if (result === "failed") {
     const rootExe = resolveExeSession();
     if (rootExe && rootExe !== target) {
-      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root exe ${rootExe}
+      process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root coordinator session ${rootExe}
 `);
       const fallback = sendIntercom(rootExe);
       return fallback !== "failed";
@@ -3901,8 +4197,8 @@ function notifyParentExe(sessionKey) {
   return true;
 }
 function ensureEmployee(employeeName, exeSession, projectDir, opts) {
-  if (employeeName === "exe") {
-    return { status: "failed", sessionName: "", error: "exe is the COO, not a dispatchable employee" };
+  if (employeeName === "exe" || isCoordinatorName(employeeName)) {
+    return { status: "failed", sessionName: "", error: "The COO is not a dispatchable employee" };
   }
   try {
     assertEmployeeLimitSync();
@@ -3911,8 +4207,8 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
       return { status: "failed", sessionName: "", error: err.message };
     }
   }
-  if (/-exe\d*$/.test(employeeName)) {
-    const bare = employeeName.replace(/-exe\d*$/, "").replace(/\d+$/, "");
+  if (employeeName.includes("-")) {
+    const bare = employeeName.split("-")[0].replace(/\d+$/, "");
     return {
       status: "failed",
       sessionName: "",
@@ -3931,7 +4227,7 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
       return {
         status: "failed",
         sessionName: "",
-        error: `Invalid exeSession "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name (e.g., "exe1", "work", "yoda1")`
+        error: `Invalid coordinator session "${exeSession}" \u2014 contains a dash but no recognizable root session. Pass a root session name.`
       };
     }
   }
@@ -4088,8 +4384,8 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
-      `Your parent exe session is ${exeSession}.`,
-      `Your employees (if any) use the -${exeSession} suffix (e.g., tom-${exeSession}).`
+      `Your parent coordinator session is ${exeSession}.`,
+      `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
     writeFileSync6(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
@@ -4193,6 +4489,7 @@ var init_tmux_routing = __esm({
     init_provider_table();
     init_intercom_queue();
     init_plan_limits();
+    init_employees();
     SPAWN_LOCK_DIR = path14.join(os7.homedir(), ".exe-os", "spawn-locks");
     SESSION_CACHE = path14.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
@@ -4386,7 +4683,11 @@ async function ensureShardSchema(client) {
     "ALTER TABLE memories ADD COLUMN source_path TEXT",
     "ALTER TABLE memories ADD COLUMN source_type TEXT DEFAULT 'text'",
     "ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3",
-    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT"
+    "ALTER TABLE memories ADD COLUMN supersedes_id TEXT",
+    // 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"
   ]) {
     try {
       await client.execute(col);
@@ -4516,26 +4817,26 @@ var init_platform_procedures = __esm({
         title: "What is exe-os \u2014 the operating model every agent must understand",
         domain: "architecture",
         priority: "p0",
-        content: "Exe OS is an AI employee operating system. A founder runs 5-10 AI agents as a real org: COO (exe), CTO (yoshi), CMO (mari), engineers (tom), content (sasha). Each agent has identity, expertise, and experience layers \u2014 persistent memory that makes them better over time. All data is local-first, E2EE, owned by the user. The MCP server is the ONLY data interface \u2014 never access the DB directly."
+        content: "Exe OS is an AI employee operating system. A founder runs 5-10 AI agents as a real org: COO, CTO, CMO, engineers, and content production specialists. Each agent has identity, expertise, and experience layers \u2014 persistent memory that makes them better over time. All data is local-first, E2EE, owned by the user. The MCP server is the ONLY data interface \u2014 never access the DB directly."
       },
       {
         title: "Mode 1 \u2014 how exe-os runs inside Claude Code",
         domain: "architecture",
         priority: "p0",
-        content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code. The founder opens CC, runs /exe to boot the COO. exe manages employees in tmux sessions. Each exeN is a separate CC window/project. Employees (yoshi, tom, mari) run in their own tmux panes via create_task auto-spawn. The founder talks to exe; exe orchestrates the team. CC is the shell, exe-os is the brain."
+        content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code. The founder opens CC and boots the COO. The COO manages employees in tmux sessions. Each coordinator session is a separate CC window/project. Employees run in their own tmux panes via create_task auto-spawn. The founder talks to the COO; the COO orchestrates the team. CC is the shell, exe-os is the brain."
       },
       {
-        title: "Sessions explained \u2014 what exeN means and how projects work",
+        title: "Sessions explained \u2014 coordinator session names and projects",
         domain: "architecture",
         priority: "p0",
-        content: "Each exeN (exe1, exe2, exe3) is an isolated project session. exe1 might be exe-os development, exe2 might be exe-wiki. Each session spawns its own employees: exe1\u2192yoshi-exe1\u2192tom-exe1. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
+        content: "Each coordinator session is an isolated project session. One might be exe-os development, another might be exe-wiki. Each session spawns its own employees using {employee}-{coordinatorSession}. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
       },
       // --- Hierarchy and dispatch ---
       {
         title: "Chain of command \u2014 who talks to whom",
         domain: "workflow",
         priority: "p0",
-        content: "Founder \u2192 exe (COO) \u2192 yoshi (CTO) / mari (CMO). Yoshi \u2192 tom (engineer). Mari \u2192 sasha (content). Never skip levels: exe never assigns directly to tom. Tom never reports directly to exe. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
+        content: "Founder -> COO -> CTO/CMO. CTO -> engineers. CMO -> content production. Never skip levels: the COO does not bypass managers for specialist work. Specialists report to their manager. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
       },
       {
         title: "Single dispatch path \u2014 create_task only",
@@ -4545,30 +4846,30 @@ var init_platform_procedures = __esm({
       },
       // --- Session isolation ---
       {
-        title: "Session scoping \u2014 stay in your exe boundary",
+        title: "Session scoping \u2014 stay in your coordinator boundary",
         domain: "security",
         priority: "p0",
-        content: "Session scoping is mandatory. Managers dispatch to workers within their own exe session ONLY. exe1\u2192yoshi-exe1\u2192tom-exe1. exe2\u2192yoshi-exe2\u2192tom2-exe2. Cross-session dispatch is blocked by the system. Verify session names before dispatch. Tasks are scoped to the creating exe session."
+        content: "Session scoping is mandatory. Managers dispatch to workers within their own coordinator session ONLY. Employee sessions use {employee}-{coordinatorSession}. Cross-session dispatch is blocked by the system. Verify session names before dispatch. Tasks are scoped to the creating coordinator session."
       },
       {
         title: "Session isolation \u2014 never touch another session's work",
         domain: "workflow",
         priority: "p0",
-        content: `Sessions are isolated. exeN owns ONLY tasks it dispatched. (1) Never close/update/cancel tasks from another exe session. (2) Never review work from a different session \u2014 report "belongs to exeN" and skip. (3) Ignore other sessions' items in list_tasks results. (4) Employees inherit session: yoshi-exe1 works ONLY on exe1 tasks. Cross-session work is a system violation.`
+        content: "Sessions are isolated. A coordinator session owns ONLY tasks it dispatched. (1) Never close/update/cancel tasks from another coordinator session. (2) Never review work from a different session \u2014 report that it belongs to another session and skip. (3) Ignore other sessions' items in list_tasks results. (4) Employees inherit session: employee sessions work ONLY on their parent coordinator session's tasks. Cross-session work is a system violation."
       },
       // --- Engineering: session scoping in code ---
       {
         title: "Three-dimensional scoping \u2014 session, project, role \u2014 enforced in every query",
         domain: "architecture",
         priority: "p0",
-        content: "Every DB query, notification, review count, and task operation MUST be scoped on 3 dimensions: (1) Session \u2014 filter by session_scope matching current exeN. (2) Project \u2014 filter by project_name. (3) Role \u2014 agents only see data at their hierarchy level. When writing ANY function that touches tasks, reviews, messages, or notifications: always accept a sessionScope parameter and pass it to the SQL WHERE clause. Unscoped queries are bugs. Test by running 2+ exe sessions simultaneously."
+        content: "Every DB query, notification, review count, and task operation MUST be scoped on 3 dimensions: (1) Session \u2014 filter by session_scope matching the current coordinator session. (2) Project \u2014 filter by project_name. (3) Role \u2014 agents only see data at their hierarchy level. When writing ANY function that touches tasks, reviews, messages, or notifications: always accept a sessionScope parameter and pass it to the SQL WHERE clause. Unscoped queries are bugs. Test by running 2+ coordinator sessions simultaneously."
       },
       // --- Hard constraints ---
       {
         title: "What you CANNOT do in exe-os \u2014 hard constraints",
         domain: "security",
         priority: "p0",
-        content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 exe reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
+        content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 the COO reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
       },
       // --- Operations ---
       {
@@ -4808,7 +5109,10 @@ async function writeMemory(record) {
     source_path: record.source_path ?? null,
     source_type: record.source_type ?? null,
     tier: record.tier ?? classifyTier(record),
-    supersedes_id: record.supersedes_id ?? null
+    supersedes_id: record.supersedes_id ?? null,
+    draft: record.draft ? 1 : 0,
+    memory_type: record.memory_type ?? "raw",
+    trajectory: record.trajectory ? JSON.stringify(record.trajectory) : null
   };
   _pendingRecords.push(dbRow);
   orgBus.emit({
@@ -4863,6 +5167,9 @@ async function flushBatch() {
       const sourceType = row.source_type ?? null;
       const tier = row.tier ?? 3;
       const supersedesId = row.supersedes_id ?? null;
+      const draft = row.draft ? 1 : 0;
+      const memoryType = row.memory_type ?? "raw";
+      const trajectory = row.trajectory ?? null;
       return {
         sql: hasVector ? `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
@@ -4870,15 +5177,15 @@ async function flushBatch() {
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, vector32(?), ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)` : `INSERT OR IGNORE INTO memories
               (id, agent_id, agent_role, session_id, timestamp,
                tool_name, project_name,
                has_error, raw_text, vector, version, task_id, importance, status,
                confidence, last_accessed,
                workspace_id, document_id, user_id, char_offset, page_number,
-               source_path, source_type, tier, supersedes_id)
-              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+               source_path, source_type, tier, supersedes_id, draft, memory_type, trajectory)
+              VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
         args: hasVector ? [
           row.id,
           row.agent_id,
@@ -4904,7 +5211,10 @@ async function flushBatch() {
           sourcePath,
           sourceType,
           tier,
-          supersedesId
+          supersedesId,
+          draft,
+          memoryType,
+          trajectory
         ] : [
           row.id,
           row.agent_id,
@@ -4929,7 +5239,10 @@ async function flushBatch() {
           sourcePath,
           sourceType,
           tier,
-          supersedesId
+          supersedesId,
+          draft,
+          memoryType,
+          trajectory
         ]
       };
     };
@@ -4998,6 +5311,8 @@ async function searchMemories(queryVector, agentId, options) {
   const limit = options?.limit ?? 10;
   const statusFilter = options?.includeArchived ? "" : `
                AND COALESCE(status, 'active') = 'active'`;
+  const draftFilter = options?.includeDrafts ? "" : `
+               AND (draft = 0 OR draft IS NULL)`;
   let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
                     tool_name, project_name,
                     has_error, raw_text, vector, importance, status,
@@ -5007,7 +5322,7 @@ async function searchMemories(queryVector, agentId, options) {
                     source_path, source_type
              FROM memories
              WHERE agent_id = ?
-               AND vector IS NOT NULL${statusFilter}
+               AND vector IS NOT NULL${statusFilter}${draftFilter}
                AND COALESCE(confidence, 0.7) >= 0.3`;
   const args = [agentId];
   const scope = buildWikiScopeFilter(options, "");
@@ -5029,6 +5344,10 @@ async function searchMemories(queryVector, agentId, options) {
     sql += ` AND timestamp >= ?`;
     args.push(options.since);
   }
+  if (options?.memoryType) {
+    sql += ` AND memory_type = ?`;
+    args.push(options.memoryType);
+  }
   sql += ` ORDER BY vector_distance_cos(vector, vector32(?))`;
   args.push(vectorToBlob(queryVector));
   sql += ` LIMIT ?`;
@@ -5768,563 +6087,1480 @@ async function pushGatewayEventToCRM(params) {
     console.error("[crm-bridge] Event push failed:", err instanceof Error ? err.message : err);
   }
 }
-var config, disabledLogged;
-var init_crm_bridge = __esm({
-  "src/gateway/crm-bridge.ts"() {
-    "use strict";
-    config = null;
-    disabledLogged = false;
+var config, disabledLogged;
+var init_crm_bridge = __esm({
+  "src/gateway/crm-bridge.ts"() {
+    "use strict";
+    config = null;
+    disabledLogged = false;
+  }
+});
+
+// src/lib/exe-daemon-client.ts
+import net from "net";
+import { spawn } from "child_process";
+import { randomUUID as randomUUID6 } from "crypto";
+import { existsSync as existsSync13, unlinkSync as unlinkSync6, readFileSync as readFileSync10, openSync, closeSync, statSync } from "fs";
+import path17 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function handleData(chunk) {
+  _buffer += chunk.toString();
+  if (_buffer.length > MAX_BUFFER) {
+    _buffer = "";
+    return;
+  }
+  let newlineIdx;
+  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
+    const line = _buffer.slice(0, newlineIdx).trim();
+    _buffer = _buffer.slice(newlineIdx + 1);
+    if (!line) continue;
+    try {
+      const response = JSON.parse(line);
+      const entry = _pending.get(response.id);
+      if (entry) {
+        clearTimeout(entry.timer);
+        _pending.delete(response.id);
+        entry.resolve(response);
+      }
+    } catch {
+    }
+  }
+}
+function cleanupStaleFiles() {
+  if (existsSync13(PID_PATH)) {
+    try {
+      const pid = parseInt(readFileSync10(PID_PATH, "utf8").trim(), 10);
+      if (pid > 0) {
+        try {
+          process.kill(pid, 0);
+          return;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    try {
+      unlinkSync6(PID_PATH);
+    } catch {
+    }
+    try {
+      unlinkSync6(SOCKET_PATH);
+    } catch {
+    }
+  }
+}
+function findPackageRoot() {
+  let dir = path17.dirname(fileURLToPath2(import.meta.url));
+  const { root } = path17.parse(dir);
+  while (dir !== root) {
+    if (existsSync13(path17.join(dir, "package.json"))) return dir;
+    dir = path17.dirname(dir);
+  }
+  return null;
+}
+function spawnDaemon() {
+  const pkgRoot = findPackageRoot();
+  if (!pkgRoot) {
+    process.stderr.write("[exed-client] WARN: cannot find package root\n");
+    return;
+  }
+  const daemonPath = path17.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync13(daemonPath)) {
+    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
+`);
+    return;
+  }
+  const resolvedPath = daemonPath;
+  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
+`);
+  const logPath = path17.join(path17.dirname(SOCKET_PATH), "exed.log");
+  let stderrFd = "ignore";
+  try {
+    stderrFd = openSync(logPath, "a");
+  } catch {
+  }
+  const child = spawn(process.execPath, [resolvedPath], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrFd],
+    env: {
+      ...process.env,
+      TMUX: void 0,
+      // Daemon is global — must not inherit session scope
+      TMUX_PANE: void 0,
+      // Prevents resolveExeSession() from scoping to one session
+      EXE_DAEMON_SOCK: SOCKET_PATH,
+      EXE_DAEMON_PID: PID_PATH
+    }
+  });
+  child.unref();
+  if (typeof stderrFd === "number") {
+    try {
+      closeSync(stderrFd);
+    } catch {
+    }
+  }
+}
+function acquireSpawnLock2() {
+  try {
+    const fd = openSync(SPAWN_LOCK_PATH, "wx");
+    closeSync(fd);
+    return true;
+  } catch {
+    try {
+      const stat = statSync(SPAWN_LOCK_PATH);
+      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
+        try {
+          unlinkSync6(SPAWN_LOCK_PATH);
+        } catch {
+        }
+        try {
+          const fd = openSync(SPAWN_LOCK_PATH, "wx");
+          closeSync(fd);
+          return true;
+        } catch {
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseSpawnLock2() {
+  try {
+    unlinkSync6(SPAWN_LOCK_PATH);
+  } catch {
+  }
+}
+function connectToSocket() {
+  return new Promise((resolve) => {
+    if (_socket && _connected) {
+      resolve(true);
+      return;
+    }
+    const socket = net.createConnection({ path: SOCKET_PATH });
+    const connectTimeout = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, 2e3);
+    socket.on("connect", () => {
+      clearTimeout(connectTimeout);
+      _socket = socket;
+      _connected = true;
+      _buffer = "";
+      socket.on("data", handleData);
+      socket.on("close", () => {
+        _connected = false;
+        _socket = null;
+        for (const [id, entry] of _pending) {
+          clearTimeout(entry.timer);
+          _pending.delete(id);
+          entry.resolve({ error: "Connection closed" });
+        }
+      });
+      socket.on("error", () => {
+        _connected = false;
+        _socket = null;
+      });
+      resolve(true);
+    });
+    socket.on("error", () => {
+      clearTimeout(connectTimeout);
+      resolve(false);
+    });
+  });
+}
+async function connectEmbedDaemon() {
+  if (_socket && _connected) return true;
+  if (await connectToSocket()) return true;
+  if (acquireSpawnLock2()) {
+    try {
+      cleanupStaleFiles();
+      spawnDaemon();
+    } finally {
+      releaseSpawnLock2();
+    }
   }
-});
-
-// src/lib/exe-daemon-client.ts
-import net from "net";
-import { spawn } from "child_process";
-import { randomUUID as randomUUID6 } from "crypto";
-import { existsSync as existsSync13, unlinkSync as unlinkSync6, readFileSync as readFileSync10, openSync, closeSync, statSync } from "fs";
-import path17 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-function handleData(chunk) {
-  _buffer += chunk.toString();
-  if (_buffer.length > MAX_BUFFER) {
-    _buffer = "";
-    return;
+  const start = Date.now();
+  let delay2 = 100;
+  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+    await new Promise((r) => setTimeout(r, delay2));
+    if (await connectToSocket()) return true;
+    delay2 = Math.min(delay2 * 2, 3e3);
   }
-  let newlineIdx;
-  while ((newlineIdx = _buffer.indexOf("\n")) !== -1) {
-    const line = _buffer.slice(0, newlineIdx).trim();
-    _buffer = _buffer.slice(newlineIdx + 1);
-    if (!line) continue;
+  return false;
+}
+function sendRequest(texts, priority) {
+  return new Promise((resolve) => {
+    if (!_socket || !_connected) {
+      resolve({ error: "Not connected" });
+      return;
+    }
+    const id = randomUUID6();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve({ error: "Request timeout" });
+    }, REQUEST_TIMEOUT_MS);
+    _pending.set(id, { resolve, timer });
     try {
-      const response = JSON.parse(line);
-      const entry = _pending.get(response.id);
-      if (entry) {
-        clearTimeout(entry.timer);
-        _pending.delete(response.id);
-        entry.resolve(response);
-      }
+      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
+    } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve({ error: "Write failed" });
+    }
+  });
+}
+async function pingDaemon() {
+  if (!_socket || !_connected) return null;
+  return new Promise((resolve) => {
+    const id = randomUUID6();
+    const timer = setTimeout(() => {
+      _pending.delete(id);
+      resolve(null);
+    }, 5e3);
+    _pending.set(id, {
+      resolve: (data) => {
+        if (data.health) {
+          resolve(data.health);
+        } else {
+          resolve(null);
+        }
+      },
+      timer
+    });
+    try {
+      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
     } catch {
+      clearTimeout(timer);
+      _pending.delete(id);
+      resolve(null);
     }
-  }
+  });
 }
-function cleanupStaleFiles() {
+function killAndRespawnDaemon() {
+  process.stderr.write("[exed-client] Killing daemon for restart...\n");
   if (existsSync13(PID_PATH)) {
     try {
       const pid = parseInt(readFileSync10(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
-          process.kill(pid, 0);
-          return;
+          process.kill(pid, "SIGKILL");
         } catch {
         }
       }
     } catch {
     }
-    try {
-      unlinkSync6(PID_PATH);
-    } catch {
+  }
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  try {
+    unlinkSync6(PID_PATH);
+  } catch {
+  }
+  try {
+    unlinkSync6(SOCKET_PATH);
+  } catch {
+  }
+  spawnDaemon();
+}
+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) {
+      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \u2014 restarting daemon
+`);
+      killAndRespawnDaemon();
+      const start = Date.now();
+      let delay2 = 200;
+      while (Date.now() - start < CONNECT_TIMEOUT_MS) {
+        await new Promise((r) => setTimeout(r, delay2));
+        if (await connectToSocket()) break;
+        delay2 = Math.min(delay2 * 2, 3e3);
+      }
+      if (!_connected) return null;
     }
-    try {
-      unlinkSync6(SOCKET_PATH);
-    } catch {
+  }
+  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;
+}
+function disconnectClient() {
+  if (_socket) {
+    _socket.destroy();
+    _socket = null;
+  }
+  _connected = false;
+  _buffer = "";
+  for (const [id, entry] of _pending) {
+    clearTimeout(entry.timer);
+    _pending.delete(id);
+    entry.resolve({ error: "Client disconnected" });
   }
 }
-function findPackageRoot() {
-  let dir = path17.dirname(fileURLToPath2(import.meta.url));
-  const { root } = path17.parse(dir);
-  while (dir !== root) {
-    if (existsSync13(path17.join(dir, "package.json"))) return dir;
-    dir = path17.dirname(dir);
+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 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 ?? path17.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path17.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path17.join(EXE_AI_DIR, "exed-spawn.lock");
+    SPAWN_LOCK_STALE_MS = 3e4;
+    CONNECT_TIMEOUT_MS = 15e3;
+    REQUEST_TIMEOUT_MS = 3e4;
+    _socket = null;
+    _connected = false;
+    _buffer = "";
+    _requestCount = 0;
+    HEALTH_CHECK_INTERVAL = 100;
+    _pending = /* @__PURE__ */ new Map();
+    MAX_BUFFER = 1e7;
+  }
+});
+
+// src/lib/embedder.ts
+var embedder_exports = {};
+__export(embedder_exports, {
+  disposeEmbedder: () => disposeEmbedder,
+  embed: () => embed,
+  embedDirect: () => embedDirect,
+  getEmbedder: () => getEmbedder
+});
+async function getEmbedder() {
+  const ok = await connectEmbedDaemon();
+  if (!ok) {
+    throw new Error(
+      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
+    );
+  }
+}
+async function embed(text) {
+  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
+  const vector = await embedViaClient(text, priority);
+  if (!vector) {
+    throw new Error(
+      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
+    );
+  }
+  if (vector.length !== EMBEDDING_DIM) {
+    throw new Error(
+      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
+    );
+  }
+  return vector;
+}
+async function disposeEmbedder() {
+  disconnectClient();
+}
+async function embedDirect(text) {
+  const llamaCpp = await import("node-llama-cpp");
+  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const { existsSync: existsSync15 } = await import("fs");
+  const path20 = await import("path");
+  const modelPath = path20.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync15(modelPath)) {
+    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
+  }
+  const llama = await llamaCpp.getLlama();
+  const model = await llama.loadModel({ modelPath });
+  const context = await model.createEmbeddingContext();
+  try {
+    const embedding = await context.getEmbeddingFor(text);
+    const vector = Array.from(embedding.vector);
+    if (vector.length !== EMBEDDING_DIM) {
+      throw new Error(
+        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
+      );
+    }
+    return vector;
+  } finally {
+    await context.dispose();
+    await model.dispose();
   }
-  return null;
 }
-function spawnDaemon() {
-  const pkgRoot = findPackageRoot();
-  if (!pkgRoot) {
-    process.stderr.write("[exed-client] WARN: cannot find package root\n");
-    return;
-  }
-  const daemonPath = path17.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync13(daemonPath)) {
-    process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
-`);
-    return;
+var init_embedder = __esm({
+  "src/lib/embedder.ts"() {
+    "use strict";
+    init_memory();
+    init_exe_daemon_client();
   }
-  const resolvedPath = daemonPath;
-  process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
-`);
-  const logPath = path17.join(path17.dirname(SOCKET_PATH), "exed.log");
-  let stderrFd = "ignore";
+});
+
+// src/lib/wiki-client.ts
+var wiki_client_exports = {};
+__export(wiki_client_exports, {
+  chatInWorkspace: () => chatInWorkspace,
+  createWikiClient: () => createWikiClient,
+  getChatHistory: () => getChatHistory,
+  listDocuments: () => listDocuments,
+  listWorkspaces: () => listWorkspaces
+});
+async function wikiFetch(config2, path20, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path20}`;
+  const headers = {
+    Authorization: `Bearer ${config2.apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS2);
   try {
-    stderrFd = openSync(logPath, "a");
-  } catch {
-  }
-  const child = spawn(process.execPath, [resolvedPath], {
-    detached: true,
-    stdio: ["ignore", "ignore", stderrFd],
-    env: {
-      ...process.env,
-      EXE_DAEMON_SOCK: SOCKET_PATH,
-      EXE_DAEMON_PID: PID_PATH
-    }
-  });
-  child.unref();
-  if (typeof stderrFd === "number") {
+    let response;
     try {
-      closeSync(stderrFd);
+      response = await fetch(url, {
+        method,
+        headers,
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
     } catch {
+      clearTimeout(timeout);
+      const retryController = new AbortController();
+      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS2);
+      try {
+        await new Promise((r) => setTimeout(r, 500));
+        response = await fetch(url, {
+          method,
+          headers,
+          body: body ? JSON.stringify(body) : void 0,
+          signal: retryController.signal
+        });
+      } finally {
+        clearTimeout(retryTimeout);
+      }
+    }
+    if (!response.ok) {
+      throw new Error(`Wiki API ${method} ${path20}: ${response.status} ${response.statusText}`);
     }
+    return response.json();
+  } finally {
+    clearTimeout(timeout);
   }
 }
-function acquireSpawnLock2() {
+async function resolveWikiUrl(configUrl) {
   try {
-    const fd = openSync(SPAWN_LOCK_PATH, "wx");
-    closeSync(fd);
-    return true;
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 3e3);
+    const res = await fetch(`${LOCAL_WIKI_URL}/api/v1/auth`, { signal: controller.signal });
+    clearTimeout(timeout);
+    if (res.ok || res.status === 401 || res.status === 403) {
+      return LOCAL_WIKI_URL;
+    }
   } catch {
+  }
+  if (configUrl && configUrl !== LOCAL_WIKI_URL) {
     try {
-      const stat = statSync(SPAWN_LOCK_PATH);
-      if (Date.now() - stat.mtimeMs > SPAWN_LOCK_STALE_MS) {
-        try {
-          unlinkSync6(SPAWN_LOCK_PATH);
-        } catch {
-        }
-        try {
-          const fd = openSync(SPAWN_LOCK_PATH, "wx");
-          closeSync(fd);
-          return true;
-        } catch {
-        }
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), 3e3);
+      const res = await fetch(`${configUrl}/api/v1/auth`, { signal: controller.signal });
+      clearTimeout(timeout);
+      if (res.ok || res.status === 401 || res.status === 403) {
+        return configUrl;
       }
     } catch {
     }
-    return false;
   }
+  return null;
 }
-function releaseSpawnLock2() {
-  try {
-    unlinkSync6(SPAWN_LOCK_PATH);
-  } catch {
-  }
+async function createWikiClient() {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const config2 = await loadConfig2();
+  const baseUrl = await resolveWikiUrl(config2.wikiUrl);
+  if (!baseUrl) return null;
+  return {
+    baseUrl,
+    apiKey: config2.wikiApiKey
+  };
 }
-function connectToSocket() {
-  return new Promise((resolve) => {
-    if (_socket && _connected) {
-      resolve(true);
+async function listWorkspaces(client) {
+  const data = await wikiFetch(client, "/workspaces");
+  return (data.workspaces ?? []).map((w) => ({
+    slug: w.slug,
+    name: w.name,
+    createdAt: w.createdAt ?? "",
+    threads: w.threads ?? []
+  }));
+}
+async function listDocuments(client, workspaceSlug) {
+  const data = await wikiFetch(
+    client,
+    `/workspace/${encodeURIComponent(workspaceSlug)}`
+  );
+  const docs = Array.isArray(data.workspace) ? data.workspace[0]?.documents ?? [] : [];
+  return docs.map((d) => ({
+    filename: d.filename ?? "untitled",
+    docpath: d.docpath,
+    workspace: workspaceSlug,
+    pinned: d.pinned ?? false
+  }));
+}
+async function chatInWorkspace(client, workspaceSlug, message, mode = "chat") {
+  const data = await wikiFetch(
+    client,
+    `/workspace/${encodeURIComponent(workspaceSlug)}/chat`,
+    "POST",
+    { message, mode }
+  );
+  return {
+    id: data.id ?? "",
+    type: data.type ?? "textResponse",
+    textResponse: data.textResponse ?? "",
+    sources: data.sources ?? [],
+    error: data.error ?? null
+  };
+}
+async function getChatHistory(client, workspaceSlug, limit = 50) {
+  const data = await wikiFetch(
+    client,
+    `/workspace/${encodeURIComponent(workspaceSlug)}/chats?limit=${limit}&orderBy=desc`
+  );
+  return (data.history ?? []).reverse().map((h) => ({
+    role: h.role === "user" ? "user" : "assistant",
+    content: h.content,
+    sentAt: h.sentAt ?? 0
+  }));
+}
+var LOCAL_WIKI_URL, REQUEST_TIMEOUT_MS2;
+var init_wiki_client = __esm({
+  "src/lib/wiki-client.ts"() {
+    "use strict";
+    LOCAL_WIKI_URL = "http://localhost:3001";
+    REQUEST_TIMEOUT_MS2 = 8e3;
+  }
+});
+
+// src/lib/code-chunker.ts
+import ts from "typescript";
+function chunkSourceFile(source, fileName = "file.ts") {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    // setParentNodes
+    fileName.endsWith(".tsx") || fileName.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const chunks = [];
+  const lines = source.split("\n");
+  const importLines = [];
+  function getLineNumber(pos) {
+    return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+  }
+  function getLeadingComment(node) {
+    const fullText = sourceFile.getFullText();
+    const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+    if (!ranges || ranges.length === 0) return void 0;
+    return ranges.map((r) => fullText.slice(r.pos, r.end)).join("\n");
+  }
+  function getNodeText(node) {
+    return node.getText(sourceFile);
+  }
+  function getName(node) {
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+      return node.name?.getText(sourceFile) ?? "(anonymous)";
+    }
+    if (ts.isClassDeclaration(node)) {
+      return node.name?.getText(sourceFile) ?? "(anonymous class)";
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      return node.name.getText(sourceFile);
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      return node.name.getText(sourceFile);
+    }
+    if (ts.isEnumDeclaration(node)) {
+      return node.name.getText(sourceFile);
+    }
+    if (ts.isVariableStatement(node)) {
+      const decls = node.declarationList.declarations;
+      return decls.map((d) => d.name.getText(sourceFile)).join(", ");
+    }
+    if (ts.isExportAssignment(node)) {
+      return "default export";
+    }
+    return "(unknown)";
+  }
+  function visitTopLevel(node) {
+    if (ts.isImportDeclaration(node)) {
+      importLines.push({
+        start: getLineNumber(node.getStart(sourceFile)),
+        end: getLineNumber(node.getEnd())
+      });
       return;
     }
-    const socket = net.createConnection({ path: SOCKET_PATH });
-    const connectTimeout = setTimeout(() => {
-      socket.destroy();
-      resolve(false);
-    }, 2e3);
-    socket.on("connect", () => {
-      clearTimeout(connectTimeout);
-      _socket = socket;
-      _connected = true;
-      _buffer = "";
-      socket.on("data", handleData);
-      socket.on("close", () => {
-        _connected = false;
-        _socket = null;
-        for (const [id, entry] of _pending) {
-          clearTimeout(entry.timer);
-          _pending.delete(id);
-          entry.resolve({ error: "Connection closed" });
-        }
+    if (ts.isFunctionDeclaration(node)) {
+      chunks.push({
+        kind: "function",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
       });
-      socket.on("error", () => {
-        _connected = false;
-        _socket = null;
+      return;
+    }
+    if (ts.isClassDeclaration(node)) {
+      chunks.push({
+        kind: "class",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
       });
-      resolve(true);
-    });
-    socket.on("error", () => {
-      clearTimeout(connectTimeout);
-      resolve(false);
-    });
-  });
-}
-async function connectEmbedDaemon() {
-  if (_socket && _connected) return true;
-  if (await connectToSocket()) return true;
-  if (acquireSpawnLock2()) {
-    try {
-      cleanupStaleFiles();
-      spawnDaemon();
-    } finally {
-      releaseSpawnLock2();
+      return;
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      chunks.push({
+        kind: "type",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      chunks.push({
+        kind: "type",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isEnumDeclaration(node)) {
+      chunks.push({
+        kind: "type",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
     }
-  }
-  const start = Date.now();
-  let delay2 = 100;
-  while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay2));
-    if (await connectToSocket()) return true;
-    delay2 = Math.min(delay2 * 2, 3e3);
-  }
-  return false;
-}
-function sendRequest(texts, priority) {
-  return new Promise((resolve) => {
-    if (!_socket || !_connected) {
-      resolve({ error: "Not connected" });
+    if (ts.isVariableStatement(node)) {
+      const decls = node.declarationList.declarations;
+      const isFnLike = decls.some(
+        (d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))
+      );
+      chunks.push({
+        kind: isFnLike ? "function" : "variable",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
       return;
     }
-    const id = randomUUID6();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve({ error: "Request timeout" });
-    }, REQUEST_TIMEOUT_MS);
-    _pending.set(id, { resolve, timer });
-    try {
-      _socket.write(JSON.stringify({ id, texts, priority }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve({ error: "Write failed" });
+    if (ts.isExportAssignment(node)) {
+      chunks.push({
+        kind: "export",
+        name: "default export",
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
     }
-  });
+    if (ts.isExpressionStatement(node)) {
+      const text = getNodeText(node);
+      if (text.length > 10) {
+        chunks.push({
+          kind: "other",
+          name: text.slice(0, 40).replace(/\n/g, " "),
+          text,
+          startLine: getLineNumber(node.getStart(sourceFile)),
+          endLine: getLineNumber(node.getEnd())
+        });
+      }
+      return;
+    }
+  }
+  sourceFile.statements.forEach(visitTopLevel);
+  if (importLines.length > 0) {
+    const startLine = importLines[0].start;
+    const endLine = importLines[importLines.length - 1].end;
+    const importText = lines.slice(startLine - 1, endLine).join("\n");
+    chunks.unshift({
+      kind: "import",
+      name: `${importLines.length} imports`,
+      text: importText,
+      startLine,
+      endLine
+    });
+  }
+  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks;
 }
-async function pingDaemon() {
-  if (!_socket || !_connected) return null;
-  return new Promise((resolve) => {
-    const id = randomUUID6();
-    const timer = setTimeout(() => {
-      _pending.delete(id);
-      resolve(null);
-    }, 5e3);
-    _pending.set(id, {
-      resolve: (data) => {
-        if (data.health) {
-          resolve(data.health);
-        } else {
-          resolve(null);
-        }
-      },
-      timer
+function isChunkable(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx";
+}
+var init_code_chunker = __esm({
+  "src/lib/code-chunker.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/graph-rag.ts
+var graph_rag_exports = {};
+__export(graph_rag_exports, {
+  EXTRACT_TOOL: () => EXTRACT_TOOL,
+  entityId: () => entityId,
+  extractBatch: () => extractBatch,
+  extractFromCode: () => extractFromCode,
+  extractFromMemory: () => extractFromMemory,
+  mergeEntities: () => mergeEntities,
+  normalizeEntityName: () => normalizeEntityName,
+  registerAlias: () => registerAlias,
+  resolveAlias: () => resolveAlias,
+  storeExtraction: () => storeExtraction
+});
+import crypto7 from "crypto";
+function normalizeEntityName(name) {
+  return name.replace(/\s*\([^)]*\)\s*/g, "").trim().toLowerCase();
+}
+function entityId(name, type) {
+  const normalized = normalizeEntityName(name);
+  return crypto7.createHash("sha256").update(`${normalized}::${type.toLowerCase()}`).digest("hex").slice(0, 16);
+}
+async function resolveAlias(client, name) {
+  const normalized = normalizeEntityName(name);
+  try {
+    const result = await client.execute({
+      sql: "SELECT canonical_entity_id FROM entity_aliases WHERE alias = ?",
+      args: [normalized]
     });
-    try {
-      _socket.write(JSON.stringify({ id, type: "health" }) + "\n");
-    } catch {
-      clearTimeout(timer);
-      _pending.delete(id);
-      resolve(null);
+    if (result.rows.length > 0) {
+      return String(result.rows[0].canonical_entity_id);
     }
+  } catch {
+  }
+  return null;
+}
+async function registerAlias(client, alias, canonicalEntityId) {
+  const normalized = normalizeEntityName(alias);
+  await client.execute({
+    sql: `INSERT OR REPLACE INTO entity_aliases (alias, canonical_entity_id) VALUES (?, ?)`,
+    args: [normalized, canonicalEntityId]
   });
 }
-function killAndRespawnDaemon() {
-  process.stderr.write("[exed-client] Killing daemon for restart...\n");
-  if (existsSync13(PID_PATH)) {
-    try {
-      const pid = parseInt(readFileSync10(PID_PATH, "utf8").trim(), 10);
-      if (pid > 0) {
-        try {
-          process.kill(pid, "SIGKILL");
-        } catch {
-        }
-      }
-    } catch {
-    }
+async function mergeEntities(client, sourceEntityId, targetEntityId) {
+  const sourceResult = await client.execute({
+    sql: "SELECT name FROM entities WHERE id = ?",
+    args: [sourceEntityId]
+  });
+  if (sourceResult.rows.length === 0) {
+    throw new Error(`Source entity ${sourceEntityId} not found`);
   }
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
+  const targetResult = await client.execute({
+    sql: "SELECT id FROM entities WHERE id = ?",
+    args: [targetEntityId]
+  });
+  if (targetResult.rows.length === 0) {
+    throw new Error(`Target entity ${targetEntityId} not found`);
+  }
+  const sourceName = String(sourceResult.rows[0].name);
+  const relsSource = await client.execute({
+    sql: `UPDATE relationships SET source_entity_id = ?
+          WHERE source_entity_id = ?
+          AND NOT EXISTS (
+            SELECT 1 FROM relationships r2
+            WHERE r2.source_entity_id = ? AND r2.target_entity_id = relationships.target_entity_id AND r2.type = relationships.type
+          )`,
+    args: [targetEntityId, sourceEntityId, targetEntityId]
+  });
+  const relsTarget = await client.execute({
+    sql: `UPDATE relationships SET target_entity_id = ?
+          WHERE target_entity_id = ?
+          AND NOT EXISTS (
+            SELECT 1 FROM relationships r2
+            WHERE r2.target_entity_id = ? AND r2.source_entity_id = relationships.source_entity_id AND r2.type = relationships.type
+          )`,
+    args: [targetEntityId, sourceEntityId, targetEntityId]
+  });
+  await client.execute({
+    sql: "DELETE FROM relationships WHERE source_entity_id = ? OR target_entity_id = ?",
+    args: [sourceEntityId, sourceEntityId]
+  });
+  const mems = await client.execute({
+    sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+          SELECT ?, memory_id FROM entity_memories WHERE entity_id = ?`,
+    args: [targetEntityId, sourceEntityId]
+  });
+  await client.execute({
+    sql: "DELETE FROM entity_memories WHERE entity_id = ?",
+    args: [sourceEntityId]
+  });
+  await registerAlias(client, sourceName, targetEntityId);
+  await client.execute({
+    sql: "DELETE FROM entities WHERE id = ?",
+    args: [sourceEntityId]
+  });
+  return {
+    relationshipsMoved: (relsSource.rowsAffected ?? 0) + (relsTarget.rowsAffected ?? 0),
+    memoriesMoved: mems.rowsAffected ?? 0
+  };
+}
+function parseImportPaths(importText) {
+  const paths = [];
+  const fromRegex = /from\s+["']([^"']+)["']/g;
+  let match;
+  while ((match = fromRegex.exec(importText)) !== null) {
+    paths.push(match[1]);
   }
-  _connected = false;
-  _buffer = "";
-  try {
-    unlinkSync6(PID_PATH);
-  } catch {
+  const bareRegex = /^import\s+["']([^"']+)["']/gm;
+  while ((match = bareRegex.exec(importText)) !== null) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
   }
+  return paths;
+}
+function moduleNameFromPath(importPath) {
+  const base = importPath.split("/").pop() ?? importPath;
+  return base.replace(/\.\w+$/, "") || base;
+}
+function extractFromCode(source, filePath) {
+  let chunks;
   try {
-    unlinkSync6(SOCKET_PATH);
+    chunks = chunkSourceFile(source, filePath);
   } catch {
-  }
-  spawnDaemon();
-}
-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) {
-      process.stderr.write(`[exed-client] Periodic health check failed at request ${_requestCount} \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);
+    return { entities: [], relationships: [], hyperedges: [] };
+  }
+  if (chunks.length === 0) {
+    return { entities: [], relationships: [], hyperedges: [] };
+  }
+  const entities = [];
+  const relationships = [];
+  const fileName = filePath.split("/").pop() ?? filePath;
+  entities.push({ name: fileName, type: "file" });
+  for (const chunk of chunks) {
+    if (chunk.kind === "import") {
+      const importPaths = parseImportPaths(chunk.text);
+      for (const importPath of importPaths) {
+        const moduleName = moduleNameFromPath(importPath);
+        entities.push({ name: moduleName, type: "file" });
+        relationships.push({
+          source: fileName,
+          sourceType: "file",
+          target: moduleName,
+          targetType: "file",
+          relationship: "depends_on",
+          confidence: 1,
+          confidenceLabel: "extracted"
+        });
       }
-      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);
+      continue;
     }
-    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"}
-`);
+    if (chunk.kind === "other" || chunk.name === "(unknown)") continue;
+    entities.push({ name: chunk.name, type: "concept" });
+    relationships.push({
+      source: fileName,
+      sourceType: "file",
+      target: chunk.name,
+      targetType: "concept",
+      relationship: "uses",
+      confidence: 1,
+      confidenceLabel: "extracted"
+    });
   }
-  return null;
+  return { entities, relationships, hyperedges: [] };
 }
-function disconnectClient() {
-  if (_socket) {
-    _socket.destroy();
-    _socket = null;
-  }
-  _connected = false;
-  _buffer = "";
-  for (const [id, entry] of _pending) {
-    clearTimeout(entry.timer);
-    _pending.delete(id);
-    entry.resolve({ error: "Client disconnected" });
+async function extractFromMemory(content, agentId, model = "claude-haiku-4-5-20251001", filePath) {
+  if (content.length < 50) {
+    return { entities: [], relationships: [], hyperedges: [] };
   }
-}
-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 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 ?? path17.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path17.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path17.join(EXE_AI_DIR, "exed-spawn.lock");
-    SPAWN_LOCK_STALE_MS = 3e4;
-    CONNECT_TIMEOUT_MS = 15e3;
-    REQUEST_TIMEOUT_MS = 3e4;
-    _socket = null;
-    _connected = false;
-    _buffer = "";
-    _requestCount = 0;
-    HEALTH_CHECK_INTERVAL = 100;
-    _pending = /* @__PURE__ */ new Map();
-    MAX_BUFFER = 1e7;
+  if (filePath && isChunkable(filePath)) {
+    const astResult = extractFromCode(content, filePath);
+    if (astResult.entities.length > 0) {
+      return astResult;
+    }
   }
-});
-
-// src/lib/embedder.ts
-var embedder_exports = {};
-__export(embedder_exports, {
-  disposeEmbedder: () => disposeEmbedder,
-  embed: () => embed,
-  embedDirect: () => embedDirect,
-  getEmbedder: () => getEmbedder
-});
-async function getEmbedder() {
-  const ok = await connectEmbedDaemon();
-  if (!ok) {
-    throw new Error(
-      "Could not connect to embedding daemon. Ensure the model is installed (run /exe-setup)."
+  try {
+    const Anthropic4 = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic4();
+    const response = await client.messages.create({
+      model,
+      max_tokens: 512,
+      system: `Extract entities and relationships from this AI agent work memory. Agent: ${agentId}. Focus on: people, tools, projects, decisions, files, rationale \u2014 and for business contexts: products, companies, suppliers, locations, orders, categories. Only extract what's clearly stated \u2014 don't infer. Use the simplest form of names (e.g., "Lenny" not "Lenny (HYGO)"). When content says "we chose X because Y", extract a rationale entity with rationale_for edge. Business examples: "Lenny supplies organic flour to HYGO" \u2192 (Lenny, supplies, HYGO). "Order #1234 shipped to Auckland" \u2192 (Order #1234, ships_to, Auckland).`,
+      messages: [{ role: "user", content: content.slice(0, 1e3) }],
+      tools: [EXTRACT_TOOL],
+      tool_choice: { type: "tool", name: "extract_entities_and_relationships" }
+    });
+    const toolBlock = response.content.find((b) => b.type === "tool_use");
+    if (toolBlock && toolBlock.type === "tool_use") {
+      const input = toolBlock.input;
+      const rawEntities = input.entities ?? [];
+      const rawRels = input.relationships ?? [];
+      const rawHyperedges = input.hyperedges ?? [];
+      return {
+        entities: rawEntities.map((e) => ({
+          name: e.name ?? "",
+          type: e.type ?? "concept"
+        })).filter((e) => e.name.length > 0),
+        relationships: rawRels.map((r) => ({
+          source: r.source ?? "",
+          sourceType: r.source_type ?? "concept",
+          target: r.target ?? "",
+          targetType: r.target_type ?? "concept",
+          relationship: r.relationship ?? "uses",
+          confidence: Number(r.confidence ?? 1),
+          confidenceLabel: String(r.confidence_label ?? "extracted")
+        })).filter((r) => r.source.length > 0 && r.target.length > 0),
+        hyperedges: rawHyperedges.map((h) => ({
+          label: String(h.label ?? ""),
+          relation: String(h.relation ?? ""),
+          entityNames: h.entity_names ?? [],
+          confidence: Number(h.confidence ?? 1)
+        })).filter((h) => h.label.length > 0 && h.entityNames.length >= 3)
+      };
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[graph-rag] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
     );
   }
+  return { entities: [], relationships: [], hyperedges: [] };
 }
-async function embed(text) {
-  const priority = process.env.EXE_EMBED_PRIORITY === "low" ? "low" : "high";
-  const vector = await embedViaClient(text, priority);
-  if (!vector) {
-    throw new Error(
-      "Embedding failed: daemon unavailable. Run /exe-setup to verify model installation."
-    );
+async function storeExtraction(client, extraction, memoryId, timestamp) {
+  let entitiesStored = 0;
+  let relationshipsStored = 0;
+  for (const e of extraction.entities) {
+    const aliasTarget = await resolveAlias(client, e.name);
+    const id = aliasTarget ?? entityId(e.name, e.type);
+    const normalizedName = normalizeEntityName(e.name);
+    try {
+      const newProps = e.properties ?? {};
+      let mergedPropsJson = JSON.stringify(newProps);
+      if (newProps.provenance) {
+        const existing = await client.execute({
+          sql: "SELECT properties FROM entities WHERE id = ?",
+          args: [aliasTarget ?? id]
+        });
+        const existingProps = existing.rows.length > 0 ? JSON.parse(String(existing.rows[0].properties ?? "{}")) : {};
+        const existingProvenance = Array.isArray(existingProps.provenance) ? existingProps.provenance : existingProps.provenance ? [existingProps.provenance] : [];
+        mergedPropsJson = JSON.stringify({
+          ...existingProps,
+          ...newProps,
+          provenance: [...existingProvenance, newProps.provenance]
+        });
+      }
+      if (aliasTarget) {
+        await client.execute({
+          sql: `UPDATE entities SET last_seen = ?, properties = ? WHERE id = ?`,
+          args: [timestamp, mergedPropsJson, aliasTarget]
+        });
+      } else {
+        await client.execute({
+          sql: `INSERT INTO entities (id, name, type, first_seen, last_seen, properties)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(name, type) DO UPDATE SET last_seen = ?, properties = ?`,
+          args: [id, normalizedName, e.type, timestamp, timestamp, mergedPropsJson, timestamp, mergedPropsJson]
+        });
+      }
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO entity_memories (entity_id, memory_id)
+              VALUES (?, ?)`,
+        args: [id, memoryId]
+      });
+      entitiesStored++;
+    } catch {
+    }
   }
-  if (vector.length !== EMBEDDING_DIM) {
-    throw new Error(
-      `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}. Ensure the correct Jina v5-small Q4_K_M GGUF model is installed.`
-    );
+  for (const r of extraction.relationships) {
+    const sourceAlias = await resolveAlias(client, r.source);
+    const targetAlias = await resolveAlias(client, r.target);
+    const sourceId = sourceAlias ?? entityId(r.source, r.sourceType);
+    const targetId = targetAlias ?? entityId(r.target, r.targetType);
+    const relId = crypto7.randomUUID().slice(0, 16);
+    try {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen)
+              VALUES (?, ?, ?, ?, ?)`,
+        args: [sourceId, r.source, r.sourceType, timestamp, timestamp]
+      });
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen)
+              VALUES (?, ?, ?, ?, ?)`,
+        args: [targetId, r.target, r.targetType, timestamp, timestamp]
+      });
+      const relProps = r.properties ?? {};
+      let relPropsJson = JSON.stringify(relProps);
+      if (relProps.provenance) {
+        const existingRels = await client.execute({
+          sql: "SELECT properties FROM relationships WHERE source_entity_id = ? AND target_entity_id = ? AND type = ?",
+          args: [sourceId, targetId, r.relationship]
+        });
+        const existingRelProps = existingRels.rows.length > 0 ? JSON.parse(String(existingRels.rows[0].properties ?? "{}")) : {};
+        const existingProvenance = Array.isArray(existingRelProps.provenance) ? existingRelProps.provenance : existingRelProps.provenance ? [existingRelProps.provenance] : [];
+        relPropsJson = JSON.stringify({
+          ...existingRelProps,
+          ...relProps,
+          provenance: [...existingProvenance, relProps.provenance]
+        });
+      }
+      await client.execute({
+        sql: `INSERT INTO relationships (id, source_entity_id, target_entity_id, type, weight, timestamp, confidence, confidence_label, properties)
+              VALUES (?, ?, ?, ?, 1.0, ?, ?, ?, ?)
+              ON CONFLICT(source_entity_id, target_entity_id, type)
+              DO UPDATE SET weight = MIN(weight + 0.1, 2.0), timestamp = ?,
+                confidence = MAX(confidence, ?), confidence_label = ?, properties = ?`,
+        args: [
+          relId,
+          sourceId,
+          targetId,
+          r.relationship,
+          timestamp,
+          r.confidence,
+          r.confidenceLabel,
+          relPropsJson,
+          timestamp,
+          r.confidence,
+          r.confidenceLabel,
+          relPropsJson
+        ]
+      });
+      const existingRel = await client.execute({
+        sql: `SELECT id FROM relationships WHERE source_entity_id = ? AND target_entity_id = ? AND type = ?`,
+        args: [sourceId, targetId, r.relationship]
+      });
+      const actualRelId = existingRel.rows[0]?.id ? String(existingRel.rows[0].id) : relId;
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO relationship_memories (relationship_id, memory_id)
+              VALUES (?, ?)`,
+        args: [actualRelId, memoryId]
+      });
+      relationshipsStored++;
+    } catch {
+    }
   }
-  return vector;
-}
-async function disposeEmbedder() {
-  disconnectClient();
+  for (const h of extraction.hyperedges) {
+    const hId = crypto7.randomUUID().slice(0, 16);
+    try {
+      await client.execute({
+        sql: `INSERT OR IGNORE INTO hyperedges (id, label, relation, confidence, timestamp)
+              VALUES (?, ?, ?, ?, ?)`,
+        args: [hId, h.label, h.relation, h.confidence, timestamp]
+      });
+      for (const entityName of h.entityNames) {
+        const eType = extraction.entities.find((e) => e.name === entityName)?.type ?? "concept";
+        const eId = entityId(entityName, eType);
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO entities (id, name, type, first_seen, last_seen)
+                VALUES (?, ?, ?, ?, ?)`,
+          args: [eId, entityName, eType, timestamp, timestamp]
+        });
+        await client.execute({
+          sql: `INSERT OR IGNORE INTO hyperedge_nodes (hyperedge_id, entity_id) VALUES (?, ?)`,
+          args: [hId, eId]
+        });
+      }
+    } catch {
+    }
+  }
+  return { entitiesStored, relationshipsStored };
 }
-async function embedDirect(text) {
-  const llamaCpp = await import("node-llama-cpp");
-  const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync15 } = await import("fs");
-  const path20 = await import("path");
-  const modelPath = path20.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync15(modelPath)) {
-    throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
+async function extractBatch(client, batchSize = 50, model = "claude-haiku-4-5-20251001") {
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, raw_text, tool_name, timestamp, content_hash, graph_extracted_hash
+          FROM memories
+          WHERE (COALESCE(graph_extracted, 0) = 0
+                 OR (content_hash IS NOT NULL AND content_hash != COALESCE(graph_extracted_hash, '')))
+            AND COALESCE(status, 'active') = 'active'
+            AND LENGTH(raw_text) >= 50
+          ORDER BY timestamp DESC
+          LIMIT ?`,
+    args: [batchSize]
+  });
+  if (result.rows.length === 0) {
+    return { processed: 0, entities: 0, relationships: 0 };
   }
-  const llama = await llamaCpp.getLlama();
-  const model = await llama.loadModel({ modelPath });
-  const context = await model.createEmbeddingContext();
-  try {
-    const embedding = await context.getEmbeddingFor(text);
-    const vector = Array.from(embedding.vector);
-    if (vector.length !== EMBEDDING_DIM) {
-      throw new Error(
-        `Embedding dimension mismatch: expected ${EMBEDDING_DIM}, got ${vector.length}.`
+  let totalEntities = 0;
+  let totalRelationships = 0;
+  for (const row of result.rows) {
+    const memoryId = String(row.id);
+    const agentId = String(row.agent_id);
+    const rawContent = String(row.raw_text);
+    const toolName = String(row.tool_name ?? "");
+    const timestamp = String(row.timestamp);
+    let extractionContent = rawContent;
+    let detectedFilePath;
+    if (toolName === "Read") {
+      const pathMatch = rawContent.match(READ_MEMORY_PATH_PATTERN);
+      if (pathMatch) {
+        detectedFilePath = pathMatch[1];
+        extractionContent = rawContent.slice(pathMatch[0].length);
+      }
+    }
+    try {
+      const extraction = await extractFromMemory(extractionContent, agentId, model, detectedFilePath);
+      if (extraction.entities.length > 0 || extraction.relationships.length > 0) {
+        const stored = await storeExtraction(client, extraction, memoryId, timestamp);
+        totalEntities += stored.entitiesStored;
+        totalRelationships += stored.relationshipsStored;
+      }
+      const contentHash = crypto7.createHash("sha256").update(rawContent).digest("hex").slice(0, 32);
+      await client.execute({
+        sql: "UPDATE memories SET graph_extracted = 1, content_hash = ?, graph_extracted_hash = ? WHERE id = ?",
+        args: [contentHash, contentHash, memoryId]
+      });
+    } catch (err) {
+      process.stderr.write(
+        `[graph-rag] Batch extraction failed for ${memoryId}: ${err instanceof Error ? err.message : String(err)}
+`
       );
+      await client.execute({
+        sql: "UPDATE memories SET graph_extracted = 1 WHERE id = ?",
+        args: [memoryId]
+      });
     }
-    return vector;
-  } finally {
-    await context.dispose();
-    await model.dispose();
   }
+  return { processed: result.rows.length, entities: totalEntities, relationships: totalRelationships };
 }
-var init_embedder = __esm({
-  "src/lib/embedder.ts"() {
+var EXTRACT_TOOL, READ_MEMORY_PATH_PATTERN;
+var init_graph_rag = __esm({
+  "src/lib/graph-rag.ts"() {
     "use strict";
-    init_memory();
-    init_exe_daemon_client();
+    init_code_chunker();
+    EXTRACT_TOOL = {
+      name: "extract_entities_and_relationships",
+      description: "Extract entities, relationships, and group connections from a memory record. Include confidence scoring.",
+      input_schema: {
+        type: "object",
+        properties: {
+          entities: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                name: { type: "string", description: "Entity name" },
+                type: { type: "string", enum: ["person", "tool", "project", "decision", "concept", "file", "rationale", "product", "company", "location", "order", "supplier", "category"] }
+              },
+              required: ["name", "type"]
+            }
+          },
+          relationships: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                source: { type: "string" },
+                source_type: { type: "string" },
+                target: { type: "string" },
+                target_type: { type: "string" },
+                relationship: {
+                  type: "string",
+                  enum: [
+                    // Engineering
+                    "implemented",
+                    "superseded_by",
+                    "depends_on",
+                    "blocked_by",
+                    "worked_on",
+                    "uses",
+                    "decided",
+                    "created",
+                    "fixed",
+                    "reviewed",
+                    "rationale_for",
+                    // Business / organizational
+                    "supplies",
+                    "ordered_from",
+                    "reports_to",
+                    "manages",
+                    "located_at",
+                    "ships_to",
+                    "categorized_as",
+                    "priced_at",
+                    "partnered_with",
+                    "contracted_by",
+                    // General purpose
+                    "related_to",
+                    "part_of",
+                    "owns",
+                    "communicates_with"
+                  ]
+                },
+                confidence: { type: "number", description: "0.0-1.0. 1.0=explicitly stated, 0.6-0.9=inferred, 0.1-0.3=ambiguous" },
+                confidence_label: { type: "string", enum: ["extracted", "inferred", "ambiguous"] }
+              },
+              required: ["source", "source_type", "target", "target_type", "relationship", "confidence", "confidence_label"]
+            }
+          },
+          hyperedges: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                label: { type: "string", description: "Group label (e.g., 'auth flow files', 'v1.3 contributors')" },
+                relation: { type: "string", description: "What connects them (e.g., 'part_of', 'contributed_to')" },
+                entity_names: { type: "array", items: { type: "string" }, description: "3+ entity names in this group" },
+                confidence: { type: "number" }
+              },
+              required: ["label", "relation", "entity_names", "confidence"]
+            },
+            description: "Group relationships connecting 3+ entities"
+          }
+        },
+        required: ["entities", "relationships", "hyperedges"]
+      }
+    };
+    READ_MEMORY_PATH_PATTERN = /^Read\s+(\S+\.(?:ts|tsx|js|jsx))\s*\n/;
   }
 });
 
-// src/lib/wiki-client.ts
-var wiki_client_exports = {};
-__export(wiki_client_exports, {
-  chatInWorkspace: () => chatInWorkspace,
-  createWikiClient: () => createWikiClient,
-  getChatHistory: () => getChatHistory,
-  listDocuments: () => listDocuments,
-  listWorkspaces: () => listWorkspaces
+// src/lib/conversation-entity-extractor.ts
+var conversation_entity_extractor_exports = {};
+__export(conversation_entity_extractor_exports, {
+  extractFromConversation: () => extractFromConversation
 });
-async function wikiFetch(config2, path20, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path20}`;
-  const headers = {
-    Authorization: `Bearer ${config2.apiKey}`,
-    "Content-Type": "application/json"
-  };
-  const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS2);
+async function extractFromConversation(msg, agentResponse, agentName, model = "claude-haiku-4-5-20251001") {
+  const text = msg.text ?? "";
+  if (text.length < 20) {
+    return { entities: [], relationships: [], hyperedges: [] };
+  }
+  const senderName = msg.senderName ?? msg.senderId;
+  const prompt = [
+    `Extract entities and relationships from this conversation message.`,
+    `Platform: ${msg.platform} | Sender: ${senderName} | Account: ${msg.accountId ?? "unknown"}`,
+    ``,
+    `Focus on: people (from sender name, mentioned names), companies, products, topics discussed, locations mentioned.`,
+    `Only extract what's clearly stated. For business conversations, capture: customer intent, product interest, service requests.`,
+    ``,
+    `MESSAGE:`,
+    text,
+    agentResponse ? `
+AGENT RESPONSE (${agentName ?? "unknown"}):
+${agentResponse}` : ""
+  ].join("\n");
   try {
-    let response;
-    try {
-      response = await fetch(url, {
-        method,
-        headers,
-        body: body ? JSON.stringify(body) : void 0,
-        signal: controller.signal
-      });
-    } catch {
-      clearTimeout(timeout);
-      const retryController = new AbortController();
-      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS2);
-      try {
-        await new Promise((r) => setTimeout(r, 500));
-        response = await fetch(url, {
-          method,
-          headers,
-          body: body ? JSON.stringify(body) : void 0,
-          signal: retryController.signal
+    const Anthropic4 = (await import("@anthropic-ai/sdk")).default;
+    const client = new Anthropic4();
+    const response = await client.messages.create({
+      model,
+      max_tokens: 512,
+      system: prompt,
+      messages: [{ role: "user", content: "Extract entities and relationships from the message above." }],
+      tools: [EXTRACT_TOOL],
+      tool_choice: { type: "tool", name: "extract_entities_and_relationships" }
+    });
+    const toolBlock = response.content.find((b) => b.type === "tool_use");
+    if (!toolBlock || toolBlock.type !== "tool_use") {
+      return { entities: [], relationships: [], hyperedges: [] };
+    }
+    const input = toolBlock.input;
+    const rawEntities = input.entities ?? [];
+    const rawRels = input.relationships ?? [];
+    const rawHyperedges = input.hyperedges ?? [];
+    const entities = rawEntities.map((e) => ({ name: e.name ?? "", type: e.type ?? "concept" })).filter((e) => e.name.length > 0);
+    const relationships = rawRels.map((r) => ({
+      source: r.source ?? "",
+      sourceType: r.source_type ?? "concept",
+      target: r.target ?? "",
+      targetType: r.target_type ?? "concept",
+      relationship: r.relationship ?? "related_to",
+      confidence: Number(r.confidence ?? 1),
+      confidenceLabel: String(r.confidence_label ?? "extracted")
+    })).filter((r) => r.source.length > 0 && r.target.length > 0);
+    const hyperedges = rawHyperedges.map((h) => ({
+      label: String(h.label ?? ""),
+      relation: String(h.relation ?? ""),
+      entityNames: h.entity_names ?? [],
+      confidence: Number(h.confidence ?? 1)
+    })).filter((h) => h.label.length > 0 && h.entityNames.length >= 3);
+    const senderExists = entities.some(
+      (e) => e.type === "person" && e.name.toLowerCase() === senderName.toLowerCase()
+    );
+    if (!senderExists) {
+      entities.push({ name: senderName, type: "person" });
+    }
+    if (msg.accountId) {
+      const hasCommunicates = relationships.some(
+        (r) => r.relationship === "communicates_with" && r.source.toLowerCase() === senderName.toLowerCase()
+      );
+      if (!hasCommunicates) {
+        relationships.push({
+          source: senderName,
+          sourceType: "person",
+          target: msg.accountId,
+          targetType: "person",
+          relationship: "communicates_with",
+          confidence: 1,
+          confidenceLabel: "extracted"
         });
-      } finally {
-        clearTimeout(retryTimeout);
       }
     }
-    if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path20}: ${response.status} ${response.statusText}`);
+    const provenance = {
+      source: "gateway-conversation",
+      platform: msg.platform,
+      senderId: msg.senderId,
+      senderName: msg.senderName,
+      accountId: msg.accountId,
+      messageId: msg.messageId,
+      timestamp: msg.timestamp,
+      agentName,
+      extractionModel: model,
+      extractedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    for (const entity of entities) {
+      entity.properties = { ...entity.properties ?? {}, provenance };
     }
-    return response.json();
-  } finally {
-    clearTimeout(timeout);
+    for (const rel of relationships) {
+      rel.properties = { ...rel.properties ?? {}, provenance };
+    }
+    return { entities, relationships, hyperedges };
+  } catch (err) {
+    process.stderr.write(
+      `[conversation-entity-extractor] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return { entities: [], relationships: [], hyperedges: [] };
   }
 }
-async function resolveWikiUrl(configUrl) {
+var init_conversation_entity_extractor = __esm({
+  "src/lib/conversation-entity-extractor.ts"() {
+    "use strict";
+    init_graph_rag();
+  }
+});
+
+// src/lib/conversation-wiki-populator.ts
+var conversation_wiki_populator_exports = {};
+__export(conversation_wiki_populator_exports, {
+  populateWikiFromExtraction: () => populateWikiFromExtraction
+});
+async function populateWikiFromExtraction(extraction, msg, agentResponse, agentName) {
+  const { createWikiClient: createWikiClient2, chatInWorkspace: chatInWorkspace2, listWorkspaces: listWorkspaces2 } = await Promise.resolve().then(() => (init_wiki_client(), wiki_client_exports));
+  const client = await createWikiClient2();
+  if (!client) {
+    return { created: 0, updated: 0, skipped: extraction.entities.length };
+  }
+  let availableSlugs;
   try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3e3);
-    const res = await fetch(`${LOCAL_WIKI_URL}/api/v1/auth`, { signal: controller.signal });
-    clearTimeout(timeout);
-    if (res.ok || res.status === 401 || res.status === 403) {
-      return LOCAL_WIKI_URL;
-    }
+    const workspaces = await listWorkspaces2(client);
+    availableSlugs = new Set(workspaces.map((w) => w.slug));
   } catch {
-  }
-  if (configUrl && configUrl !== LOCAL_WIKI_URL) {
+    return { created: 0, updated: 0, skipped: extraction.entities.length };
+  }
+  let created = 0;
+  let updated = 0;
+  let skipped = 0;
+  let apiCalls = 0;
+  const candidates = extraction.entities.filter((e) => {
+    if (!WIKI_ENTITY_TYPES.has(e.type)) {
+      skipped++;
+      return false;
+    }
+    if (e.name.length < MIN_NAME_LENGTH) {
+      skipped++;
+      return false;
+    }
+    if (SKIP_NAMES.has(e.name.toLowerCase())) {
+      skipped++;
+      return false;
+    }
+    return true;
+  });
+  const senderName = msg.senderName ?? msg.senderId;
+  const timestamp = msg.timestamp;
+  const platform = msg.platform;
+  const accountId = msg.accountId ?? "unknown";
+  const messageSummary = (msg.text ?? "").slice(0, 200);
+  const responseSummary = agentResponse ? agentResponse.slice(0, 200) : void 0;
+  for (const entity of candidates) {
+    if (apiCalls >= MAX_WIKI_CALLS) {
+      skipped += candidates.length - (created + updated + (skipped - (extraction.entities.length - candidates.length)));
+      break;
+    }
+    const workspace = WORKSPACE_MAP[entity.type] ?? DEFAULT_WORKSPACE;
+    if (!availableSlugs.has(workspace)) {
+      skipped++;
+      continue;
+    }
     try {
-      const controller = new AbortController();
-      const timeout = setTimeout(() => controller.abort(), 3e3);
-      const res = await fetch(`${configUrl}/api/v1/auth`, { signal: controller.signal });
-      clearTimeout(timeout);
-      if (res.ok || res.status === 401 || res.status === 403) {
-        return configUrl;
-      }
-    } catch {
+      const content = buildWikiContent(
+        entity.name,
+        entity.type,
+        timestamp,
+        platform,
+        accountId,
+        senderName,
+        messageSummary,
+        agentName,
+        responseSummary
+      );
+      await chatInWorkspace2(client, workspace, content, "chat");
+      apiCalls++;
+      updated++;
+    } catch (err) {
+      process.stderr.write(
+        `[wiki-populator] Failed for entity "${entity.name}": ${err instanceof Error ? err.message : String(err)}
+`
+      );
+      skipped++;
     }
   }
-  return null;
-}
-async function createWikiClient() {
-  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const config2 = await loadConfig2();
-  const baseUrl = await resolveWikiUrl(config2.wikiUrl);
-  if (!baseUrl) return null;
-  return {
-    baseUrl,
-    apiKey: config2.wikiApiKey
-  };
-}
-async function listWorkspaces(client) {
-  const data = await wikiFetch(client, "/workspaces");
-  return (data.workspaces ?? []).map((w) => ({
-    slug: w.slug,
-    name: w.name,
-    createdAt: w.createdAt ?? "",
-    threads: w.threads ?? []
-  }));
-}
-async function listDocuments(client, workspaceSlug) {
-  const data = await wikiFetch(
-    client,
-    `/workspace/${encodeURIComponent(workspaceSlug)}`
-  );
-  const docs = Array.isArray(data.workspace) ? data.workspace[0]?.documents ?? [] : [];
-  return docs.map((d) => ({
-    filename: d.filename ?? "untitled",
-    docpath: d.docpath,
-    workspace: workspaceSlug,
-    pinned: d.pinned ?? false
-  }));
-}
-async function chatInWorkspace(client, workspaceSlug, message, mode = "chat") {
-  const data = await wikiFetch(
-    client,
-    `/workspace/${encodeURIComponent(workspaceSlug)}/chat`,
-    "POST",
-    { message, mode }
-  );
-  return {
-    id: data.id ?? "",
-    type: data.type ?? "textResponse",
-    textResponse: data.textResponse ?? "",
-    sources: data.sources ?? [],
-    error: data.error ?? null
-  };
+  return { created, updated, skipped };
 }
-async function getChatHistory(client, workspaceSlug, limit = 50) {
-  const data = await wikiFetch(
-    client,
-    `/workspace/${encodeURIComponent(workspaceSlug)}/chats?limit=${limit}&orderBy=desc`
+function buildWikiContent(entityName, entityType, timestamp, platform, accountId, senderName, messageSummary, agentName, responseSummary) {
+  const lines = [
+    `Update knowledge about ${entityName} (${entityType}):`,
+    ``,
+    `## [${timestamp}] via ${platform}/${accountId}`,
+    `${senderName}: ${messageSummary}`
+  ];
+  if (agentName && responseSummary) {
+    lines.push(`Agent (${agentName}): ${responseSummary}`);
+  }
+  lines.push(
+    ``,
+    `Source: ${platform} | Account: ${accountId} | Timestamp: ${timestamp}`
   );
-  return (data.history ?? []).reverse().map((h) => ({
-    role: h.role === "user" ? "user" : "assistant",
-    content: h.content,
-    sentAt: h.sentAt ?? 0
-  }));
+  return lines.join("\n");
 }
-var LOCAL_WIKI_URL, REQUEST_TIMEOUT_MS2;
-var init_wiki_client = __esm({
-  "src/lib/wiki-client.ts"() {
+var MAX_WIKI_CALLS, WIKI_ENTITY_TYPES, WORKSPACE_MAP, DEFAULT_WORKSPACE, MIN_NAME_LENGTH, SKIP_NAMES;
+var init_conversation_wiki_populator = __esm({
+  "src/lib/conversation-wiki-populator.ts"() {
     "use strict";
-    LOCAL_WIKI_URL = "http://localhost:3001";
-    REQUEST_TIMEOUT_MS2 = 8e3;
+    MAX_WIKI_CALLS = 3;
+    WIKI_ENTITY_TYPES = /* @__PURE__ */ new Set(["person", "company", "product"]);
+    WORKSPACE_MAP = {
+      person: "contacts",
+      company: "companies",
+      product: "products"
+    };
+    DEFAULT_WORKSPACE = "conversations";
+    MIN_NAME_LENGTH = 3;
+    SKIP_NAMES = /* @__PURE__ */ new Set(["unknown", "none", "n/a", "null", "undefined"]);
   }
 });
 
@@ -6399,10 +7635,10 @@ __export(messaging_exports, {
   sendMessage: () => sendMessage,
   setWsClientSend: () => setWsClientSend
 });
-import crypto8 from "crypto";
+import crypto9 from "crypto";
 function generateUlid() {
   const timestamp = Date.now().toString(36).padStart(10, "0");
-  const random = crypto8.randomBytes(10).toString("hex").slice(0, 16);
+  const random = crypto9.randomBytes(10).toString("hex").slice(0, 16);
   return (timestamp + random).toUpperCase();
 }
 function rowToMessage(row) {
@@ -6506,7 +7742,7 @@ async function deliverLocalMessage(messageId) {
   try {
     const exeSession = resolveExeSession();
     if (!exeSession) {
-      throw new Error("No exe session found");
+      throw new Error("No coordinator session found");
     }
     const sessionName = employeeSessionName(targetAgent, exeSession);
     if (!isEmployeeAlive(sessionName)) {
@@ -7859,7 +9095,11 @@ function composeHooks(...pipelines) {
   };
 }
 
+// src/runtime/orchestrator.ts
+init_employees();
+
 // src/lib/task-router.ts
+init_employees();
 import { randomUUID } from "crypto";
 var DEFAULT_BLOOM_CONFIG = {
   complexityToTier: {
@@ -7917,7 +9157,7 @@ async function scoreEmployee(taskVector, agentId, searchFn) {
   return { agentId, score: results.length / 5 };
 }
 async function routeTask(taskDescription, employees, embedFn, searchFn, options) {
-  let specialists = employees.filter((e) => e.name !== "exe");
+  let specialists = employees.filter((e) => !isCoordinatorRole(e.role));
   if (specialists.length === 0) {
     throw new Error(
       "No specialist employees available. Create one with /exe-new-employee."
@@ -7994,7 +9234,7 @@ ${task.context}`,
       await createTaskCore({
         title: task.title,
         assignedTo: targetEmployee.name,
-        assignedBy: "exe",
+        assignedBy: getCoordinatorName(),
         projectName: task.projectName,
         priority: task.priority,
         context: task.context,
@@ -8099,15 +9339,16 @@ ${task.context}`,
     const client = getClient2();
     const autoApproved = [];
     const needsReview = [];
+    const coordinatorName = getCoordinatorName();
     const rScope = sessionScopeFilter();
     const reviews = await client.execute({
       sql: `SELECT id, title, assigned_to, priority, result, task_file FROM tasks
-            WHERE assigned_to = 'exe'
+            WHERE (assigned_to = ? OR assigned_to = 'exe')
               AND status IN ('open', 'in_progress')
               AND task_file LIKE '%review-%'${rScope.sql}
             ORDER BY priority ASC
             LIMIT 20`,
-      args: [...rScope.args]
+      args: [coordinatorName, ...rScope.args]
     });
     for (const row of reviews.rows) {
       const item = {
@@ -9088,11 +10329,11 @@ init_crm_bridge();
 
 // src/lib/pipeline-router.ts
 init_database();
-import crypto7 from "crypto";
+import crypto8 from "crypto";
 async function sinkConversationStore(msg, agentResponse, agentName) {
   try {
     const client = getClient();
-    const id = crypto7.randomUUID();
+    const id = crypto8.randomUUID();
     const mediaJson = msg.media ? JSON.stringify(msg.media) : null;
     await client.execute({
       sql: `INSERT INTO conversations
@@ -9142,7 +10383,7 @@ async function sinkMemory(msg, agentResponse, agentName) {
     ].filter(Boolean).join("\n");
     const vector = await embed2(rawText);
     await writeMemory2({
-      id: crypto7.randomUUID(),
+      id: crypto8.randomUUID(),
       agent_id: agentName ?? "gateway",
       agent_role: "gateway",
       session_id: `gateway-${msg.platform}`,
@@ -9223,9 +10464,37 @@ Agent response: ${agentResponse}` : ""
     return false;
   }
 }
+async function sinkEntityExtraction(msg, agentResponse, agentName) {
+  try {
+    const { extractFromConversation: extractFromConversation2 } = await Promise.resolve().then(() => (init_conversation_entity_extractor(), conversation_entity_extractor_exports));
+    const { storeExtraction: storeExtraction2 } = await Promise.resolve().then(() => (init_graph_rag(), graph_rag_exports));
+    if ((msg.text?.length ?? 0) < 20) return false;
+    if (msg.isHistorical) return false;
+    const extraction = await extractFromConversation2(msg, agentResponse, agentName);
+    if (extraction.entities.length === 0) return false;
+    const client = getClient();
+    const memoryId = `conv:${msg.messageId}`;
+    await storeExtraction2(client, extraction, memoryId, msg.timestamp);
+    Promise.resolve().then(() => (init_conversation_wiki_populator(), conversation_wiki_populator_exports)).then(
+      ({ populateWikiFromExtraction: populateWikiFromExtraction2 }) => populateWikiFromExtraction2(extraction, msg, agentResponse, agentName)
+    ).catch((err) => {
+      process.stderr.write(
+        `[pipeline] wiki-population error: ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    });
+    return true;
+  } catch (err) {
+    process.stderr.write(
+      `[pipeline] entity-extraction-sink error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+    return false;
+  }
+}
 async function ingest(msg, agentResponse, agentName) {
   const errors = [];
-  const [conversationStored, memorySunk, crmSunk, wikiSunk] = await Promise.all([
+  const [conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted] = await Promise.all([
     sinkConversationStore(msg, agentResponse, agentName).catch((e) => {
       errors.push(`conversation: ${e}`);
       return false;
@@ -9241,6 +10510,10 @@ async function ingest(msg, agentResponse, agentName) {
     sinkWiki(msg, agentResponse).catch((e) => {
       errors.push(`wiki: ${e}`);
       return false;
+    }),
+    sinkEntityExtraction(msg, agentResponse, agentName).catch((e) => {
+      errors.push(`entity-extraction: ${e}`);
+      return false;
     })
   ]);
   if (errors.length > 0) {
@@ -9249,7 +10522,7 @@ async function ingest(msg, agentResponse, agentName) {
 `
     );
   }
-  return { conversationStored, memorySunk, crmSunk, wikiSunk, errors };
+  return { conversationStored, memorySunk, crmSunk, wikiSunk, entityExtracted, errors };
 }
 
 // src/gateway/gateway.ts
@@ -9535,7 +10808,7 @@ Your personality:
 - If you don't know something, say so and suggest who might
 
 Your tools:
-- ask_team_memory: Query any employee's memories (yoshi, tom, mari, exe)
+- ask_team_memory: Query any employee's memories by their configured name
 - recall_my_memory: Search your own past conversations with the founder
 - list_tasks: See what's in progress across the org
 - get_session_context: Get context from a specific session
@@ -9676,7 +10949,7 @@ function buildExecAssistantTools() {
         properties: {
           team_member: {
             type: "string",
-            description: "Name of the team member (e.g., 'yoshi', 'mari', 'exe')"
+            description: "Configured name of the team member"
           },
           query: { type: "string", description: "What to search for" },
           project_name: {
@@ -9855,7 +11128,7 @@ function buildExecAssistantTools() {
     },
     {
       name: "close_task",
-      description: "Reviewer-only: finalize a task after review. Only exe/ea can use this.",
+      description: "Reviewer-only: finalize a task after review. Only coordinators/reviewers can use this.",
       input_schema: {
         type: "object",
         properties: {
@@ -10926,7 +12199,7 @@ ${val}` : val;
     }
     if (envelope.receiptMessage) {
       const rcpt = envelope.receiptMessage;
-      for (const ts of rcpt.timestamps) {
+      for (const ts2 of rcpt.timestamps) {
         const normalized2 = {
           messageId: randomUUID10(),
           platform: "signal",
@@ -10941,7 +12214,7 @@ ${val}` : val;
           raw: payload,
           dataCategory: "read_receipt",
           readReceipt: {
-            messageId: String(ts),
+            messageId: String(ts2),
             status: rcpt.type === "read" ? "read" : "delivered",
             timestamp: new Date(
               envelope.timestamp ?? Date.now()
@@ -12602,7 +13875,9 @@ async function executeSendWhatsapp(params) {
 }
 async function executeSendMessage(params) {
   const { sendMessage: sendMessage2 } = await Promise.resolve().then(() => (init_messaging(), messaging_exports));
-  const to = params.to ?? params.recipient;
+  const { getCoordinatorName: getCoordinatorName2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
+  const rawTo = params.to ?? params.recipient;
+  const to = rawTo === "coordinator" ? getCoordinatorName2() : rawTo;
   const content = params.message ?? params.content ?? params.text;
   if (!to || !content)
     throw new Error("send_message requires 'to' and 'message' params");
@@ -12615,9 +13890,11 @@ async function executeSendMessage(params) {
 }
 async function executeCreateTask(params) {
   const { createTask: createTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  const { getCoordinatorName: getCoordinatorName2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
+  const rawAssignedTo = params.assigned_to;
   await createTask2({
     title: params.title ?? "Triggered task",
-    assignedTo: params.assigned_to ?? "exe",
+    assignedTo: !rawAssignedTo || rawAssignedTo === "coordinator" ? getCoordinatorName2() : rawAssignedTo,
     assignedBy: "trigger-engine",
     projectName: params.project ?? "exe-os",
     priority: params.priority ?? "p1",
@@ -12693,10 +13970,11 @@ ${content}` : existingContent + "\n\n" + content,
 }
 async function routeToApproval(action, resolvedParams, triggerName) {
   const { createTask: createTask2 } = await Promise.resolve().then(() => (init_tasks(), tasks_exports));
+  const { getCoordinatorName: getCoordinatorName2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
   const actionSummary = action.type === "send_whatsapp" ? `Send WhatsApp to ${resolvedParams.to ?? resolvedParams.recipient ?? "unknown"}: "${(resolvedParams.message ?? resolvedParams.text ?? "").slice(0, 100)}"` : `${action.type}: ${JSON.stringify(resolvedParams).slice(0, 200)}`;
   await createTask2({
     title: `[Approval Required] ${triggerName}: ${action.type}`,
-    assignedTo: "exe",
+    assignedTo: getCoordinatorName2(),
     assignedBy: "trigger-engine",
     projectName: resolvedParams.project ?? "exe-os",
     priority: "p1",