@askexenow/exe-os 0.8.80 → 0.8.82

package/dist/mcp/server.js

@@ -39,7 +39,6 @@ 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,
@@ -195,7 +194,7 @@ async function loadConfigFrom(configPath) {
     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 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";
@@ -203,7 +202,6 @@ var init_config = __esm({
     DB_PATH = path.join(EXE_AI_DIR, "memories.db");
     MODELS_DIR = path.join(EXE_AI_DIR, "models");
     CONFIG_PATH = path.join(EXE_AI_DIR, "config.json");
-    COO_AGENT_NAME = "exe";
     LEGACY_LANCE_PATH = path.join(EXE_AI_DIR, "local.lance");
     CURRENT_CONFIG_VERSION = 1;
     DEFAULT_CONFIG = {
@@ -239,13 +237,7 @@ var init_config = __esm({
       wikiUrl: "",
       wikiApiKey: "",
       wikiSyncIntervalMs: 30 * 60 * 1e3,
-      wikiWorkspaceMapping: {
-        exe: "Executive",
-        yoshi: "Engineering",
-        mari: "Marketing",
-        tom: "Engineering",
-        sasha: "Production"
-      },
+      wikiWorkspaceMapping: {},
       wikiAutoUpdate: true,
       wikiAutoUpdateThreshold: 0.5,
       wikiAutoUpdateCreateNew: true,
@@ -370,6 +362,10 @@ function spawnDaemon() {
     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
     }
@@ -730,7 +726,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);
     }
@@ -746,6 +742,204 @@ var init_db_retry = __esm({
   }
 });
 
+// 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 existsSync3, symlinkSync, readlinkSync, readFileSync as readFileSync3, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync } from "fs";
+import { execSync } from "child_process";
+import path3 from "path";
+import os2 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 (!existsSync3(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 (!existsSync3(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync3(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(os2.homedir(), ".exe-os", "identity");
+        const oldPath = path3.join(identityDir, `${oldName}.md`);
+        const newPath = path3.join(identityDir, `${emp.name}.md`);
+        if (existsSync3(oldPath) && !existsSync3(newPath)) {
+          renameSync2(oldPath, newPath);
+        } else if (existsSync3(oldPath) && oldPath !== newPath) {
+          const content = readFileSync3(oldPath, "utf-8");
+          writeFileSync(newPath, content, "utf-8");
+          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
+            unlinkSync2(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 (existsSync3(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/database.ts
 var database_exports = {};
 __export(database_exports, {
@@ -893,22 +1087,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 {
   }
@@ -1600,6 +1796,39 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN draft INTEGER DEFAULT 0`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_draft ON memories(draft) WHERE draft = 1`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN memory_type TEXT DEFAULT 'raw'`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute(
+      `CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(memory_type)`
+    );
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE memories ADD COLUMN trajectory TEXT`,
+      args: []
+    });
+  } catch {
+  }
 }
 async function disposeDatabase() {
   if (_client) {
@@ -1613,6 +1842,7 @@ var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
     init_db_retry();
+    init_employees();
     _client = null;
     _resilientClient = null;
     initTurso = initDatabase;
@@ -1621,15 +1851,15 @@ var init_database = __esm({
 });
 
 // src/lib/keychain.ts
-import { readFile as readFile2, writeFile as writeFile2, unlink, mkdir as mkdir2, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync3 } from "fs";
-import path3 from "path";
-import os2 from "os";
+import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
+import { existsSync as existsSync4 } from "fs";
+import path4 from "path";
+import os3 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path3.join(os2.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path4.join(os3.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path3.join(getKeyDir(), "master.key");
+  return path4.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -1650,11 +1880,11 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync3(keyPath)) {
+  if (!existsSync4(keyPath)) {
     return null;
   }
   try {
-    const content = await readFile2(keyPath, "utf-8");
+    const content = await readFile3(keyPath, "utf-8");
     return Buffer.from(content.trim(), "base64");
   } catch {
     return null;
@@ -1737,12 +1967,12 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path4 from "path";
-import { existsSync as existsSync4, mkdirSync, readdirSync } from "fs";
+import path5 from "path";
+import { existsSync as existsSync5, mkdirSync, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync4(SHARDS_DIR)) {
+  if (!existsSync5(SHARDS_DIR)) {
     mkdirSync(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
@@ -1763,7 +1993,7 @@ function getShardClient(projectName) {
   }
   const cached = _shards.get(safeName);
   if (cached) return cached;
-  const dbPath = path4.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path5.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -1773,10 +2003,10 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync4(path4.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync5(path5.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync4(SHARDS_DIR)) return [];
+  if (!existsSync5(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -1846,7 +2076,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);
@@ -1958,7 +2192,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path4.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path5.join(EXE_AI_DIR, "shards");
     _shards = /* @__PURE__ */ new Map();
     _encryptionKey = null;
     _shardingEnabled = false;
@@ -1976,26 +2210,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",
@@ -2005,30 +2239,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 ---
       {
@@ -2268,7 +2502,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({
@@ -2323,6 +2560,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,
@@ -2330,15 +2570,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,
@@ -2364,7 +2604,10 @@ async function flushBatch() {
           sourcePath,
           sourceType,
           tier,
-          supersedesId
+          supersedesId,
+          draft,
+          memoryType,
+          trajectory
         ] : [
           row.id,
           row.agent_id,
@@ -2389,7 +2632,10 @@ async function flushBatch() {
           sourcePath,
           sourceType,
           tier,
-          supersedesId
+          supersedesId,
+          draft,
+          memoryType,
+          trajectory
         ]
       };
     };
@@ -2458,6 +2704,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,
@@ -2467,7 +2715,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, "");
@@ -2489,6 +2737,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 ?`;
@@ -2714,7 +2966,7 @@ var init_self_query_router = __esm({
           },
           is_broad_query: {
             type: "boolean",
-            description: "True if the query is exploratory/broad (e.g., 'what has yoshi been working on', 'summarize recent activity'). False if targeted (e.g., 'how did we fix the auth bug')."
+            description: "True if the query is exploratory/broad (e.g., 'what has the CTO been working on', 'summarize recent activity'). False if targeted (e.g., 'how did we fix the auth bug')."
           }
         },
         required: ["semantic_query", "project_filter", "role_filter", "time_filter", "is_broad_query"]
@@ -2729,34 +2981,34 @@ __export(project_name_exports, {
   _resetCache: () => _resetCache,
   getProjectName: () => getProjectName
 });
-import { execSync } from "child_process";
-import path5 from "path";
+import { execSync as execSync2 } from "child_process";
+import path6 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached && _cachedCwd === dir) return _cached;
   try {
     let repoRoot;
     try {
-      const gitCommonDir = execSync("git rev-parse --path-format=absolute --git-common-dir", {
+      const gitCommonDir = execSync2("git rev-parse --path-format=absolute --git-common-dir", {
         cwd: dir,
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path5.dirname(gitCommonDir);
+      repoRoot = path6.dirname(gitCommonDir);
     } catch {
-      repoRoot = execSync("git rev-parse --show-toplevel", {
+      repoRoot = execSync2("git rev-parse --show-toplevel", {
         cwd: dir,
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached = path5.basename(repoRoot);
+    _cached = path6.basename(repoRoot);
     _cachedCwd = dir;
     return _cached;
   } catch {
-    _cached = path5.basename(dir);
+    _cached = path6.basename(dir);
     _cachedCwd = dir;
     return _cached;
   }
@@ -2779,14 +3031,14 @@ var file_grep_exports = {};
 __export(file_grep_exports, {
   grepProjectFiles: () => grepProjectFiles
 });
-import { execSync as execSync2 } from "child_process";
-import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync5 } from "fs";
-import path6 from "path";
+import { execSync as execSync3 } from "child_process";
+import { readFileSync as readFileSync4, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync6 } from "fs";
+import path7 from "path";
 import crypto from "crypto";
 function hasRipgrep() {
   if (_hasRg === null) {
     try {
-      execSync2("rg --version", { stdio: "ignore", timeout: 2e3 });
+      execSync3("rg --version", { stdio: "ignore", timeout: 2e3 });
       _hasRg = true;
     } catch {
       _hasRg = false;
@@ -2821,7 +3073,7 @@ async function grepProjectFiles(query, projectRoot, options) {
       session_id: "file-grep",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       tool_name: "file_grep",
-      project_name: path6.basename(projectRoot),
+      project_name: path7.basename(projectRoot),
       has_error: false,
       raw_text: `${prefix} ${buildSnippet(hit, projectRoot)}`,
       vector: null,
@@ -2833,7 +3085,7 @@ function getChunkContext(filePath, lineNumber) {
   try {
     const ext = filePath.split(".").pop()?.toLowerCase();
     if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const source = readFileSync3(filePath, "utf8");
+    const source = readFileSync4(filePath, "utf8");
     const lines = source.split("\n");
     for (let i = Math.min(lineNumber - 1, lines.length - 1); i >= 0; i--) {
       const line = lines[i];
@@ -2852,7 +3104,7 @@ function grepWithRipgrep(pattern, projectRoot, patterns) {
   const globs = (patterns ?? DEFAULT_PATTERNS).map((p) => `--glob '${p}'`).join(" ");
   const excludes = EXCLUDE_DIRS.map((d) => `--glob '!${d}'`).join(" ");
   const cmd = `rg -i -c --hidden --no-config --no-ignore '${pattern.replace(/'/g, "\\'")}' . ${globs} ${excludes} --max-filesize ${MAX_FILE_SIZE} 2>/dev/null || true`;
-  const output = execSync2(cmd, {
+  const output = execSync3(cmd, {
     cwd: projectRoot,
     encoding: "utf8",
     timeout: 3e3,
@@ -2867,12 +3119,12 @@ function grepWithRipgrep(pattern, projectRoot, patterns) {
     const matchCount = parseInt(line.slice(colonIdx + 1));
     if (isNaN(matchCount) || matchCount === 0) continue;
     try {
-      const firstMatch = execSync2(
+      const firstMatch = execSync3(
         `rg -i -n --hidden '${pattern.replace(/'/g, "\\'")}' '${filePath}' --max-count 1 2>/dev/null | head -1`,
         { cwd: projectRoot, encoding: "utf8", timeout: 1e3 }
       ).trim();
       const lineNum = parseInt(firstMatch.split(":")[0] ?? "1");
-      const totalLines = execSync2(`wc -l < '${filePath}'`, {
+      const totalLines = execSync3(`wc -l < '${filePath}'`, {
         cwd: projectRoot,
         encoding: "utf8",
         timeout: 1e3
@@ -2895,11 +3147,11 @@ function grepWithNodeFs(pattern, projectRoot, patterns) {
   const files = collectFiles(projectRoot, patterns ?? DEFAULT_PATTERNS);
   const hits = [];
   for (const filePath of files.slice(0, MAX_FILES)) {
-    const absPath = path6.join(projectRoot, filePath);
+    const absPath = path7.join(projectRoot, filePath);
     try {
       const stat = statSync2(absPath);
       if (stat.size > MAX_FILE_SIZE) continue;
-      const content = readFileSync3(absPath, "utf8");
+      const content = readFileSync4(absPath, "utf8");
       const lines = content.split("\n");
       const matches = content.match(regex);
       if (!matches || matches.length === 0) continue;
@@ -2922,15 +3174,15 @@ function collectFiles(root, patterns) {
   const files = [];
   function walk(dir, relative) {
     if (files.length >= MAX_FILES) return;
-    const basename = path6.basename(dir);
+    const basename = path7.basename(dir);
     if (EXCLUDE_DIRS.includes(basename)) return;
     try {
       const entries = readdirSync2(dir, { withFileTypes: true });
       for (const entry of entries) {
         if (files.length >= MAX_FILES) return;
-        const rel = path6.join(relative, entry.name);
+        const rel = path7.join(relative, entry.name);
         if (entry.isDirectory()) {
-          walk(path6.join(dir, entry.name), rel);
+          walk(path7.join(dir, entry.name), rel);
         } else if (entry.isFile()) {
           for (const pat of patterns) {
             if (matchGlob(rel, pat)) {
@@ -2962,7 +3214,7 @@ function matchGlob(filePath, pattern) {
   if (slashIdx !== -1) {
     const dir = pattern.slice(0, slashIdx);
     const ext2 = pattern.slice(slashIdx + 1).replace("*", "");
-    const fileDir = path6.dirname(filePath);
+    const fileDir = path7.dirname(filePath);
     return fileDir === dir && filePath.endsWith(ext2);
   }
   const ext = pattern.replace("*", "");
@@ -2970,9 +3222,9 @@ function matchGlob(filePath, pattern) {
 }
 function buildSnippet(hit, projectRoot) {
   try {
-    const absPath = path6.join(projectRoot, hit.filePath);
-    if (!existsSync5(absPath)) return hit.matchLine;
-    const lines = readFileSync3(absPath, "utf8").split("\n");
+    const absPath = path7.join(projectRoot, hit.filePath);
+    if (!existsSync6(absPath)) return hit.matchLine;
+    const lines = readFileSync4(absPath, "utf8").split("\n");
     const start = Math.max(0, hit.lineNumber - 3);
     const end = Math.min(lines.length, hit.lineNumber + 2);
     return lines.slice(start, end).join("\n").slice(0, 500);
@@ -3006,8 +3258,8 @@ __export(reranker_exports, {
   rerank: () => rerank,
   rerankWithScores: () => rerankWithScores
 });
-import path7 from "path";
-import { existsSync as existsSync6 } from "fs";
+import path8 from "path";
+import { existsSync as existsSync7 } from "fs";
 function resetIdleTimer() {
   if (_idleTimer) clearTimeout(_idleTimer);
   _idleTimer = setTimeout(() => {
@@ -3018,18 +3270,18 @@ function resetIdleTimer() {
   }
 }
 function isRerankerAvailable() {
-  return existsSync6(path7.join(MODELS_DIR, RERANKER_MODEL_FILE));
+  return existsSync7(path8.join(MODELS_DIR, RERANKER_MODEL_FILE));
 }
 function getRerankerModelPath() {
-  return path7.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  return path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
 }
 async function ensureLoaded() {
   if (_rerankerContext) {
     resetIdleTimer();
     return;
   }
-  const modelPath = path7.join(MODELS_DIR, RERANKER_MODEL_FILE);
-  if (!existsSync6(modelPath)) {
+  const modelPath = path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  if (!existsSync7(modelPath)) {
     throw new Error(
       `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
     );
@@ -3105,541 +3357,881 @@ var init_reranker = __esm({
   }
 });
 
-// src/lib/session-key.ts
-import { execSync as execSync3 } from "child_process";
-function getSessionKey() {
-  if (_cached2) return _cached2;
-  let pid = process.ppid;
-  for (let i = 0; i < 10; i++) {
+// src/lib/hybrid-search.ts
+var hybrid_search_exports = {};
+__export(hybrid_search_exports, {
+  estimateCardinality: () => estimateCardinality,
+  hybridSearch: () => hybridSearch,
+  lightweightSearch: () => lightweightSearch,
+  rrfMerge: () => rrfMerge,
+  rrfMergeMulti: () => rrfMergeMulti
+});
+async function hybridSearch(queryText, agentId, options) {
+  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+  const config2 = await loadConfig2();
+  if (config2.searchMode === "fts") {
+    return lightweightSearch(queryText, agentId, options);
+  }
+  const limit = options?.limit ?? 10;
+  const trajectoryResults = await trajectoryBypass(queryText, agentId, options, limit);
+  if (trajectoryResults !== null) return trajectoryResults;
+  let effectiveQuery = queryText;
+  let effectiveOptions = { ...options };
+  let _isBroadQuery = false;
+  if (config2.selfQueryRouter && process.env.ANTHROPIC_API_KEY) {
     try {
-      const info = execSync3(`ps -p ${pid} -o ppid=,comm=`, {
-        encoding: "utf8",
-        timeout: 2e3
-      }).trim();
-      const match = info.match(/^\s*(\d+)\s+(.+)$/);
-      if (!match) break;
-      const [, ppid, cmd] = match;
-      if (cmd === "claude" || cmd.endsWith("/claude")) {
-        _cached2 = String(pid);
-        return _cached2;
+      const { routeQuery: routeQuery2 } = await Promise.resolve().then(() => (init_self_query_router(), self_query_router_exports));
+      const routed = await routeQuery2(queryText, config2.selfQueryModel);
+      effectiveQuery = routed.semanticQuery;
+      _isBroadQuery = routed.isBroadQuery;
+      if (routed.projectFilter && !effectiveOptions.projectName) {
+        effectiveOptions.projectName = routed.projectFilter;
+      }
+      if (routed.timeFilter && !effectiveOptions.since) {
+        effectiveOptions.since = routed.timeFilter;
       }
-      pid = parseInt(ppid, 10);
-      if (pid <= 1) break;
     } catch {
-      break;
     }
   }
-  _cached2 = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
-  return _cached2;
-}
-var _cached2;
-var init_session_key = __esm({
-  "src/lib/session-key.ts"() {
-    "use strict";
-    _cached2 = null;
-  }
-});
-
-// src/adapters/claude/session-key.ts
-var init_session_key2 = __esm({
-  "src/adapters/claude/session-key.ts"() {
-    "use strict";
-    init_session_key();
-  }
-});
-
-// src/adapters/claude/active-agent.ts
-var active_agent_exports = {};
-__export(active_agent_exports, {
-  cleanupSessionMarkers: () => cleanupSessionMarkers,
-  clearActiveAgent: () => clearActiveAgent,
-  getActiveAgent: () => getActiveAgent,
-  getAllActiveAgents: () => getAllActiveAgents,
-  writeActiveAgent: () => writeActiveAgent
-});
-import { readFileSync as readFileSync4, writeFileSync, mkdirSync as mkdirSync2, unlinkSync as unlinkSync2, readdirSync as readdirSync3 } from "fs";
-import { execSync as execSync4 } from "child_process";
-import path8 from "path";
-function getMarkerPath() {
-  return path8.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
-}
-function writeActiveAgent(agentId, agentRole) {
-  try {
-    mkdirSync2(CACHE_DIR, { recursive: true });
-    writeFileSync(
-      getMarkerPath(),
-      JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
+  const { getMemoryCardinality: getMemoryCardinality2 } = await Promise.resolve().then(() => (init_store(), store_exports));
+  const cardinality = await getMemoryCardinality2(agentId);
+  const { rerankerAutoTrigger } = config2.scalingRoadmap ?? {};
+  const minCardForBroad = rerankerAutoTrigger?.broadQueryMinCardinality ?? 5e4;
+  const useNarrowPath = cardinality < 1e4;
+  const useBroadPath = cardinality > minCardForBroad || _isBroadQuery && cardinality >= 1e4;
+  const effectiveIsBroad = useBroadPath && !useNarrowPath;
+  if (effectiveIsBroad !== _isBroadQuery) {
+    process.stderr.write(
+      `[hybrid-search] Adaptive routing override: cardinality=${cardinality}, router=${_isBroadQuery ? "broad" : "narrow"} \u2192 ${effectiveIsBroad ? "broad" : "narrow"}
+`
     );
-  } catch {
   }
-}
-function clearActiveAgent() {
+  const broadFetchTopK = config2.scalingRoadmap?.rerankerAutoTrigger?.fetchTopK ?? 150;
+  const fetchLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : Math.max(limit * 3, 30);
+  const fetchOptions = { ...effectiveOptions, limit: fetchLimit, includeSource: false };
+  let queryVector = null;
   try {
-    unlinkSync2(getMarkerPath());
+    const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+    queryVector = await embed2(effectiveQuery);
   } catch {
+    process.stderr.write("[hybrid-search] Embed daemon unavailable \u2014 FTS-only mode\n");
   }
-}
-function getActiveAgent() {
-  try {
-    const markerPath = getMarkerPath();
-    const raw = readFileSync4(markerPath, "utf8");
-    const data = JSON.parse(raw);
-    if (data.agentId) {
-      if (data.startedAt) {
-        const age = Date.now() - new Date(data.startedAt).getTime();
-        if (age > STALE_MS) {
-          try {
-            unlinkSync2(markerPath);
-          } catch {
-          }
-        } else {
-          return {
-            agentId: data.agentId,
-            agentRole: data.agentRole || "employee"
-          };
-        }
-      } else {
-        return {
-          agentId: data.agentId,
-          agentRole: data.agentRole || "employee"
-        };
+  let grepPromise = Promise.resolve([]);
+  if (config2.fileGrepEnabled !== false) {
+    try {
+      const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
+      const projectRoot = process.cwd();
+      const projectName = getProjectName2(projectRoot);
+      if (projectName && projectName !== "tmp") {
+        const { grepProjectFiles: grepProjectFiles2 } = await Promise.resolve().then(() => (init_file_grep(), file_grep_exports));
+        grepPromise = grepProjectFiles2(effectiveQuery, projectRoot, {
+          maxResults: 10
+        }).catch(() => []);
       }
+    } catch {
     }
-  } catch {
   }
-  try {
-    const sessionName = execSync4(
-      "tmux display-message -p '#{session_name}' 2>/dev/null",
-      { encoding: "utf8", timeout: 2e3 }
-    ).trim();
-    const empMatch = sessionName.match(/^([a-zA-Z]+)\d*-exe\d+$/);
-    if (empMatch && empMatch[1] !== "exe") {
-      return { agentId: empMatch[1], agentRole: "employee" };
-    }
-    if (/^exe\d+$/.test(sessionName)) {
-      return { agentId: "exe", agentRole: "COO" };
-    }
-  } catch {
+  const [ftsResults, vectorResults, grepResults] = await Promise.all([
+    lightweightSearch(effectiveQuery, agentId, fetchOptions),
+    queryVector ? searchMemories(queryVector, agentId, fetchOptions) : Promise.resolve([]),
+    grepPromise
+  ]);
+  const lists = [];
+  const weights = [];
+  if (ftsResults.length > 0) {
+    lists.push(ftsResults);
+    weights.push(1);
   }
-  return {
-    agentId: process.env.AGENT_ID || "default",
-    agentRole: process.env.AGENT_ROLE || "employee"
+  if (vectorResults.length > 0) {
+    lists.push(vectorResults);
+    weights.push(1);
+  }
+  if (grepResults.length > 0) {
+    lists.push(grepResults);
+    weights.push(0.5);
+  }
+  if (lists.length === 0) return [];
+  if (lists.length === 1 && !effectiveIsBroad) return lists[0].slice(0, limit);
+  const rrfLimit = effectiveIsBroad ? Math.max(limit * 5, 150) : limit;
+  const merged = lists.length === 1 ? lists[0].slice(0, rrfLimit) : rrfMergeMulti(lists, rrfLimit, RRF_K, weights);
+  const auto = config2.scalingRoadmap?.rerankerAutoTrigger ?? {
+    enabled: config2.rerankerEnabled ?? true,
+    broadQueryMinCardinality: 5e4,
+    fetchTopK: 150,
+    returnTopK: 5
   };
-}
-function getAllActiveAgents() {
-  try {
-    const files = readdirSync3(CACHE_DIR);
-    const sessions = [];
-    for (const file of files) {
-      if (!file.startsWith("active-agent-") || !file.endsWith(".json")) continue;
-      const key = file.slice("active-agent-".length, -".json".length);
-      if (key === "undefined") continue;
+  let rerankedAndBlended = null;
+  if (effectiveIsBroad && auto.enabled) {
+    const cardinality2 = await estimateCardinality(agentId, effectiveOptions);
+    if (cardinality2 > auto.broadQueryMinCardinality) {
       try {
-        const raw = readFileSync4(path8.join(CACHE_DIR, file), "utf8");
-        const data = JSON.parse(raw);
-        if (!data.agentId) continue;
-        if (data.startedAt) {
-          const age = Date.now() - new Date(data.startedAt).getTime();
-          if (age > STALE_MS) {
-            try {
-              unlinkSync2(path8.join(CACHE_DIR, file));
-            } catch {
-            }
-            continue;
+        const { isRerankerAvailable: isRerankerAvailable2, rerank: rerank2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
+        if (isRerankerAvailable2()) {
+          const reranked = await rerank2(effectiveQuery, merged, auto.returnTopK);
+          if (reranked.length > 0) {
+            rerankedAndBlended = rrfMergeMulti(
+              [reranked],
+              auto.returnTopK,
+              RRF_K
+            );
           }
         }
-        sessions.push({
-          agentId: data.agentId,
-          agentRole: data.agentRole || "employee",
-          startedAt: data.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
-          sessionKey: key
-        });
       } catch {
       }
     }
-    return sessions;
-  } catch {
-    return [];
   }
-}
-function cleanupSessionMarkers() {
-  const key = getSessionKey();
-  try {
-    unlinkSync2(path8.join(CACHE_DIR, `active-agent-${key}.json`));
-  } catch {
+  const finalResults = (rerankedAndBlended ?? merged).slice(
+    0,
+    rerankedAndBlended ? auto.returnTopK : limit
+  );
+  if (options?.includeSource && finalResults.length > 0) {
+    await attachDocumentMetadata(finalResults);
   }
-  try {
-    unlinkSync2(path8.join(CACHE_DIR, "active-agent-undefined.json"));
-  } catch {
+  if (finalResults.length > 0) {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const ids = finalResults.map((r) => r.id);
+    const placeholders = ids.map(() => "?").join(",");
+    try {
+      const client = getClient();
+      void client.execute({
+        sql: `UPDATE memories SET last_accessed = ? WHERE id IN (${placeholders})`,
+        args: [now, ...ids]
+      }).catch(() => {
+      });
+    } catch {
+    }
   }
+  return finalResults;
 }
-var CACHE_DIR, STALE_MS;
-var init_active_agent = __esm({
-  "src/adapters/claude/active-agent.ts"() {
-    "use strict";
-    init_config();
-    init_session_key2();
-    CACHE_DIR = path8.join(EXE_AI_DIR, "session-cache");
-    STALE_MS = 24 * 60 * 60 * 1e3;
-  }
-});
-
-// src/lib/employees.ts
-var employees_exports = {};
-__export(employees_exports, {
-  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
-  addEmployee: () => addEmployee,
-  getEmployee: () => getEmployee,
-  getEmployeeByRole: () => getEmployeeByRole,
-  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
-  hasRole: () => hasRole,
-  isMultiInstance: () => isMultiInstance,
-  loadEmployees: () => loadEmployees,
-  loadEmployeesSync: () => loadEmployeesSync,
-  normalizeRosterCase: () => normalizeRosterCase,
-  registerBinSymlinks: () => registerBinSymlinks,
-  saveEmployees: () => saveEmployees,
-  validateEmployeeName: () => validateEmployeeName
-});
-import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync7, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync as unlinkSync3, writeFileSync as writeFileSync2 } from "fs";
-import { execSync as execSync5 } from "child_process";
-import path9 from "path";
-import os3 from "os";
-function validateEmployeeName(name) {
-  if (!name) {
-    return { valid: false, error: "Name is required" };
+async function estimateCardinality(agentId, options) {
+  const client = getClient();
+  let sql = `SELECT COUNT(*) as cnt FROM memories
+             WHERE agent_id = ?
+               AND COALESCE(status, 'active') = 'active'
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args = [agentId];
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args.push(options.projectName);
   }
-  if (name.length > 32) {
-    return { valid: false, error: "Name must be 32 characters or fewer" };
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args.push(options.toolName);
   }
-  if (!/^[a-z][a-z0-9]*$/.test(name)) {
-    return {
-      valid: false,
-      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
-    };
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
   }
-  return { valid: true };
-}
-async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync7(employeesPath)) {
-    return [];
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args.push(options.since);
   }
-  const raw = await readFile3(employeesPath, "utf-8");
   try {
-    return JSON.parse(raw);
+    const result = await client.execute({ sql, args });
+    return Number(result.rows[0]?.cnt) || 0;
   } catch {
-    return [];
+    return 0;
   }
 }
-async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir3(path9.dirname(employeesPath), { recursive: true });
-  await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
+function rrfMerge(listA, listB, limit, k = RRF_K) {
+  return rrfMergeMulti([listA, listB], limit, k);
 }
-function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync7(employeesPath)) return [];
-  try {
-    return JSON.parse(readFileSync5(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 recencyScore(timestamp) {
+  const daysSince = (Date.now() - new Date(timestamp).getTime()) / (1e3 * 60 * 60 * 24);
+  return 1 / (1 + daysSince * 0.01);
 }
-function hasRole(agentName, role) {
-  const employees = loadEmployeesSync();
-  const emp = getEmployee(employees, agentName);
-  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+function normalizedImportance(importance) {
+  return ((importance ?? 5) - 1) / 9;
 }
-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 frecencyBoost(lastAccessed, timestamp) {
+  const accessTime = lastAccessed ? new Date(lastAccessed).getTime() : new Date(timestamp).getTime();
+  const hoursSince = Math.max(0, (Date.now() - accessTime) / (1e3 * 60 * 60));
+  return Math.exp(-0.01 * hoursSince);
 }
-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`);
+function rrfMergeMulti(lists, limit, k = RRF_K, weights) {
+  const scores = /* @__PURE__ */ new Map();
+  for (let listIdx = 0; listIdx < lists.length; listIdx++) {
+    const list = lists[listIdx];
+    const weight = weights?.[listIdx] ?? 1;
+    for (let i = 0; i < list.length; i++) {
+      const rec = list[i];
+      const entry = scores.get(rec.id) ?? { rrfScore: 0, record: rec };
+      entry.rrfScore += weight * (1 / (k + i + 1));
+      scores.set(rec.id, entry);
+    }
   }
-  return [...employees, normalized];
+  const entries = Array.from(scores.values()).map((e) => {
+    const recency = recencyScore(e.record.timestamp);
+    const importance = normalizedImportance(e.record.importance);
+    const confidence = e.record.confidence ?? 0.7;
+    const frecency = frecencyBoost(e.record.last_accessed, e.record.timestamp);
+    const baseScore = e.rrfScore * 0.35 + recency * 0.14 + importance * 0.21 + confidence * 0.3;
+    const finalScore = baseScore * (1 + 0.3 * frecency);
+    return { score: finalScore, record: e.record };
+  });
+  return entries.sort((a, b) => b.score - a.score).slice(0, limit).map((e) => e.record);
 }
-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 = path9.join(os3.homedir(), ".exe-os", "identity");
-        const oldPath = path9.join(identityDir, `${oldName}.md`);
-        const newPath = path9.join(identityDir, `${emp.name}.md`);
-        if (existsSync7(oldPath) && !existsSync7(newPath)) {
-          renameSync2(oldPath, newPath);
-        } else if (existsSync7(oldPath) && oldPath !== newPath) {
-          const content = readFileSync5(oldPath, "utf-8");
-          writeFileSync2(newPath, content, "utf-8");
-          if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
-            unlinkSync3(oldPath);
-          }
-        }
-      } catch {
+async function lightweightSearch(queryText, agentId, options) {
+  const client = getClient();
+  const limit = options?.limit ?? 5;
+  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3);
+  if (terms.length === 0) {
+    return recentRecords(agentId, options, limit);
+  }
+  const prefixTerms = terms.map((t) => `${t}*`);
+  const useAnd = terms.length >= 3;
+  const matchExpr = useAnd ? prefixTerms.join(" AND ") : prefixTerms.join(" OR ");
+  const results = await ftsQuery(client, matchExpr, agentId, options, limit);
+  if (useAnd && results.length < limit) {
+    const orExpr = prefixTerms.join(" OR ");
+    const orResults = await ftsQuery(client, orExpr, agentId, options, limit);
+    const seen = new Set(results.map((r) => r.id));
+    for (const r of orResults) {
+      if (!seen.has(r.id) && results.length < limit) {
+        results.push(r);
+        seen.add(r.id);
       }
     }
   }
-  if (changed) {
-    await saveEmployees(employees, rosterPath);
+  if (options?.includeSource && results.length > 0) {
+    await attachDocumentMetadata(results);
   }
-  return changed;
+  return results;
 }
-function findExeBin() {
-  try {
-    return execSync5(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
-  } catch {
-    return null;
+async function ftsQuery(client, matchExpr, agentId, options, limit) {
+  const statusFilter = options?.includeArchived ? "" : `
+               AND COALESCE(m.status, 'active') = 'active'`;
+  const draftFilter = options?.includeDrafts ? "" : `
+               AND (m.draft = 0 OR m.draft IS NULL)`;
+  let sql = `SELECT m.id, m.agent_id, m.agent_role, m.session_id, m.timestamp,
+                    m.tool_name, m.project_name,
+                    m.has_error, m.raw_text, m.vector, m.task_id,
+                    m.importance, m.status, m.confidence, m.last_accessed,
+                    m.workspace_id, m.document_id, m.user_id,
+                    m.char_offset, m.page_number,
+                    m.source_path, m.source_type
+             FROM memories m
+             JOIN memories_fts fts ON m.rowid = fts.rowid
+             WHERE memories_fts MATCH ?
+               AND m.agent_id = ?${statusFilter}${draftFilter}
+               AND COALESCE(m.confidence, 0.7) >= 0.3`;
+  const args = [matchExpr, agentId];
+  const scope = buildWikiScopeFilter(options, "m.");
+  sql += scope.clause;
+  args.push(...scope.args);
+  if (options?.projectName) {
+    sql += ` AND m.project_name = ?`;
+    args.push(options.projectName);
   }
-}
-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 };
+  if (options?.toolName) {
+    sql += ` AND m.tool_name = ?`;
+    args.push(options.toolName);
   }
-  const binDir = path9.dirname(exeBinPath);
-  let target;
-  try {
-    target = readlinkSync(exeBinPath);
-  } catch {
-    errors.push("Could not read 'exe' symlink");
-    return { created, skipped, errors };
+  if (options?.hasError !== void 0) {
+    sql += ` AND m.has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
   }
-  for (const suffix of ["", "-opencode"]) {
-    const linkName = `${name}${suffix}`;
-    const linkPath = path9.join(binDir, linkName);
-    if (existsSync7(linkPath)) {
-      skipped.push(linkName);
-      continue;
-    }
-    try {
-      symlinkSync(target, linkPath);
-      created.push(linkName);
-    } catch (err) {
-      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
-    }
+  if (options?.since) {
+    sql += ` AND m.timestamp >= ?`;
+    args.push(options.since);
   }
-  return { created, skipped, errors };
+  if (options?.memoryType) {
+    sql += ` AND m.memory_type = ?`;
+    args.push(options.memoryType);
+  }
+  sql += ` ORDER BY rank LIMIT ?`;
+  args.push(limit);
+  const result = await client.execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error === 1,
+    raw_text: row.raw_text,
+    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
+    task_id: row.task_id ?? null,
+    importance: row.importance ?? 5,
+    status: row.status ?? "active",
+    confidence: row.confidence ?? 0.7,
+    last_accessed: row.last_accessed ?? row.timestamp,
+    workspace_id: row.workspace_id ?? null,
+    document_id: row.document_id ?? null,
+    user_id: row.user_id ?? null,
+    char_offset: row.char_offset ?? null,
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null
+  }));
 }
-var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
-var init_employees = __esm({
-  "src/lib/employees.ts"() {
-    "use strict";
-    init_config();
-    EMPLOYEES_PATH = path9.join(EXE_AI_DIR, "exe-employees.json");
-    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
+async function recentRecords(agentId, options, limit) {
+  const client = getClient();
+  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, task_id,
+                    importance, status, confidence, last_accessed,
+                    workspace_id, document_id, user_id,
+                    char_offset, page_number,
+                    source_path, source_type
+             FROM memories
+             WHERE agent_id = ?${statusFilter}${draftFilter}
+               AND COALESCE(confidence, 0.7) >= 0.3`;
+  const args = [agentId];
+  const scope = buildWikiScopeFilter(options, "");
+  sql += scope.clause;
+  args.push(...scope.args);
+  if (options?.projectName) {
+    sql += ` AND project_name = ?`;
+    args.push(options.projectName);
   }
-});
-
-// src/lib/license.ts
-var license_exports = {};
-__export(license_exports, {
-  LICENSE_PUBLIC_KEY_PEM: () => LICENSE_PUBLIC_KEY_PEM,
-  PLAN_LIMITS: () => PLAN_LIMITS,
-  assertVpsLicense: () => assertVpsLicense,
-  checkLicense: () => checkLicense,
-  getCachedLicense: () => getCachedLicense,
-  isFeatureAllowed: () => isFeatureAllowed,
-  loadDeviceId: () => loadDeviceId,
-  loadLicense: () => loadLicense,
-  mirrorLicenseKey: () => mirrorLicenseKey,
-  saveLicense: () => saveLicense,
-  startLicenseRevalidation: () => startLicenseRevalidation,
-  stopLicenseRevalidation: () => stopLicenseRevalidation,
-  validateLicense: () => validateLicense
-});
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
-import { randomUUID as randomUUID3 } from "crypto";
-import path10 from "path";
-import { jwtVerify, importSPKI } from "jose";
-async function fetchRetry(url, init) {
-  try {
-    return await fetch(url, init);
-  } catch {
-    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
-    return fetch(url, { ...init, signal: AbortSignal.timeout(1e4) });
+  if (options?.toolName) {
+    sql += ` AND tool_name = ?`;
+    args.push(options.toolName);
   }
-}
-function loadDeviceId() {
-  const deviceJsonPath = path10.join(EXE_AI_DIR, "device.json");
-  try {
-    if (existsSync8(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
-      if (data.deviceId) return data.deviceId;
-    }
-  } catch {
+  if (options?.hasError !== void 0) {
+    sql += ` AND has_error = ?`;
+    args.push(options.hasError ? 1 : 0);
   }
-  try {
-    if (existsSync8(DEVICE_ID_PATH)) {
-      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
-      if (id2) return id2;
-    }
-  } catch {
+  if (options?.since) {
+    sql += ` AND timestamp >= ?`;
+    args.push(options.since);
   }
-  const id = randomUUID3();
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync3(DEVICE_ID_PATH, id, "utf8");
-  return id;
+  if (options?.memoryType) {
+    sql += ` AND memory_type = ?`;
+    args.push(options.memoryType);
+  }
+  sql += ` ORDER BY timestamp DESC LIMIT ?`;
+  args.push(limit);
+  const result = await client.execute({ sql, args });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    agent_role: row.agent_role,
+    session_id: row.session_id,
+    timestamp: row.timestamp,
+    tool_name: row.tool_name,
+    project_name: row.project_name,
+    has_error: row.has_error === 1,
+    raw_text: row.raw_text,
+    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
+    task_id: row.task_id ?? null,
+    importance: row.importance ?? 5,
+    status: row.status ?? "active",
+    confidence: row.confidence ?? 0.7,
+    last_accessed: row.last_accessed ?? row.timestamp,
+    workspace_id: row.workspace_id ?? null,
+    document_id: row.document_id ?? null,
+    user_id: row.user_id ?? null,
+    char_offset: row.char_offset ?? null,
+    page_number: row.page_number ?? null,
+    source_path: row.source_path ?? null,
+    source_type: row.source_type ?? null
+  }));
 }
-function loadLicense() {
+function detectToolQuery(query) {
+  const lower = query.toLowerCase().trim();
+  for (const tool of KNOWN_TOOLS) {
+    if (lower === tool.toLowerCase()) return tool;
+    if (lower.startsWith(tool.toLowerCase() + " ")) return tool;
+    if (lower.includes(`tool:${tool.toLowerCase()}`)) return tool;
+  }
+  return null;
+}
+async function trajectoryBypass(queryText, agentId, options, limit) {
+  const toolName = detectToolQuery(queryText);
+  if (!toolName) return null;
   try {
-    if (!existsSync8(LICENSE_PATH)) return null;
-    return readFileSync6(LICENSE_PATH, "utf8").trim();
+    const client = getClient();
+    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, task_id,
+                      importance, status, confidence, last_accessed,
+                      workspace_id, document_id, user_id,
+                      char_offset, page_number,
+                      source_path, source_type
+               FROM memories
+               WHERE trajectory IS NOT NULL
+                 AND json_extract(trajectory, '$.tool') = ?
+                 AND agent_id = ?${statusFilter}${draftFilter}`;
+    const args = [toolName, agentId];
+    if (options?.projectName) {
+      sql += ` AND project_name = ?`;
+      args.push(options.projectName);
+    }
+    if (options?.since) {
+      sql += ` AND timestamp >= ?`;
+      args.push(options.since);
+    }
+    sql += ` ORDER BY timestamp DESC LIMIT ?`;
+    args.push(limit);
+    const result = await client.execute({ sql, args });
+    if (result.rows.length < 3) return null;
+    return result.rows.map((row) => ({
+      id: row.id,
+      agent_id: row.agent_id,
+      agent_role: row.agent_role,
+      session_id: row.session_id,
+      timestamp: row.timestamp,
+      tool_name: row.tool_name,
+      project_name: row.project_name,
+      has_error: row.has_error === 1,
+      raw_text: row.raw_text,
+      vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
+      task_id: row.task_id ?? null,
+      importance: row.importance ?? 5,
+      status: row.status ?? "active",
+      confidence: row.confidence ?? 0.7,
+      last_accessed: row.last_accessed ?? row.timestamp,
+      workspace_id: row.workspace_id ?? null,
+      document_id: row.document_id ?? null,
+      user_id: row.user_id ?? null,
+      char_offset: row.char_offset ?? null,
+      page_number: row.page_number ?? null,
+      source_path: row.source_path ?? null,
+      source_type: row.source_type ?? null
+    }));
   } catch {
     return null;
   }
 }
-function saveLicense(apiKey) {
-  mkdirSync3(EXE_AI_DIR, { recursive: true });
-  writeFileSync3(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+var RRF_K, KNOWN_TOOLS;
+var init_hybrid_search = __esm({
+  "src/lib/hybrid-search.ts"() {
+    "use strict";
+    init_store();
+    init_database();
+    RRF_K = 60;
+    KNOWN_TOOLS = /* @__PURE__ */ new Set([
+      "Bash",
+      "Read",
+      "Write",
+      "Edit",
+      "Grep",
+      "Glob",
+      "Agent",
+      "Skill",
+      "WebSearch",
+      "WebFetch"
+    ]);
+  }
+});
+
+// src/lib/session-key.ts
+import { execSync as execSync4 } from "child_process";
+function getSessionKey() {
+  if (_cached2) return _cached2;
+  let pid = process.ppid;
+  for (let i = 0; i < 10; i++) {
+    try {
+      const info = execSync4(`ps -p ${pid} -o ppid=,comm=`, {
+        encoding: "utf8",
+        timeout: 2e3
+      }).trim();
+      const match = info.match(/^\s*(\d+)\s+(.+)$/);
+      if (!match) break;
+      const [, ppid, cmd] = match;
+      if (cmd === "claude" || cmd.endsWith("/claude")) {
+        _cached2 = String(pid);
+        return _cached2;
+      }
+      pid = parseInt(ppid, 10);
+      if (pid <= 1) break;
+    } catch {
+      break;
+    }
+  }
+  _cached2 = process.env.CLAUDE_CODE_SSE_PORT ?? String(process.ppid);
+  return _cached2;
 }
-async function verifyLicenseJwt(token) {
-  try {
-    const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
-    const { payload } = await jwtVerify(token, key, {
-      algorithms: [LICENSE_JWT_ALG]
-    });
-    const plan = payload.plan ?? "free";
-    const email = payload.sub ?? "";
-    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
-    return {
-      valid: true,
-      plan,
-      email,
-      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
-      deviceLimit: limits.devices,
-      employeeLimit: limits.employees,
-      memoryLimit: limits.memories
-    };
-  } catch {
-    return null;
+var _cached2;
+var init_session_key = __esm({
+  "src/lib/session-key.ts"() {
+    "use strict";
+    _cached2 = null;
+  }
+});
+
+// src/adapters/claude/session-key.ts
+var init_session_key2 = __esm({
+  "src/adapters/claude/session-key.ts"() {
+    "use strict";
+    init_session_key();
   }
+});
+
+// src/adapters/claude/active-agent.ts
+var active_agent_exports = {};
+__export(active_agent_exports, {
+  cleanupSessionMarkers: () => cleanupSessionMarkers,
+  clearActiveAgent: () => clearActiveAgent,
+  getActiveAgent: () => getActiveAgent,
+  getAllActiveAgents: () => getAllActiveAgents,
+  resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
+  writeActiveAgent: () => writeActiveAgent
+});
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
+import { execSync as execSync5 } from "child_process";
+import path9 from "path";
+function isNameWithOptionalInstance(candidate, baseName) {
+  if (candidate === baseName) return true;
+  if (!candidate.startsWith(baseName)) return false;
+  return /^\d+$/.test(candidate.slice(baseName.length));
 }
-async function getCachedLicense() {
-  try {
-    if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
-    if (!raw.token || typeof raw.token !== "string") return null;
-    return await verifyLicenseJwt(raw.token);
-  } catch {
-    return null;
+function resolveEmployeeFromSessionPrefix(prefix, employees) {
+  const sorted = [...employees].sort((a, b) => b.name.length - a.name.length);
+  for (const employee of sorted) {
+    if (isNameWithOptionalInstance(prefix, employee.name)) {
+      return { agentId: employee.name, agentRole: employee.role };
+    }
   }
+  return null;
 }
-function readCachedToken() {
-  try {
-    if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
-    return typeof raw.token === "string" ? raw.token : null;
-  } catch {
-    return null;
+function resolveActiveAgentFromTmuxSession(sessionName) {
+  const employees = loadEmployeesSync();
+  const coordinator = getCoordinatorEmployee(employees);
+  const coordinatorName = coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME;
+  if (isNameWithOptionalInstance(sessionName, coordinatorName)) {
+    return {
+      agentId: coordinatorName,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (isNameWithOptionalInstance(sessionName, DEFAULT_COORDINATOR_TEMPLATE_NAME)) {
+    return {
+      agentId: coordinator?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME,
+      agentRole: coordinator?.role ?? "COO"
+    };
+  }
+  if (sessionName.includes("-")) {
+    const prefix = sessionName.split("-")[0] ?? "";
+    const employee = resolveEmployeeFromSessionPrefix(prefix, employees);
+    if (employee) return employee;
+    const legacy = prefix.match(/^([a-zA-Z]+)\d*$/);
+    if (legacy?.[1] && legacy[1] !== DEFAULT_COORDINATOR_TEMPLATE_NAME) {
+      const emp = getEmployee(employees, legacy[1]);
+      return { agentId: emp?.name ?? legacy[1], agentRole: emp?.role ?? "employee" };
+    }
   }
+  return null;
 }
-function getRawCachedPlan() {
+function getMarkerPath() {
+  return path9.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+}
+function writeActiveAgent(agentId, agentRole) {
   try {
-    const token = readCachedToken();
-    if (!token) return null;
-    const parts = token.split(".");
-    if (parts.length !== 3) return null;
-    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
-    const plan = payload.plan ?? "free";
-    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
-    process.stderr.write(
-      `[license] WARN: using unverified cached plan (API unreachable, JWT expired). Plan: ${plan}
-`
+    mkdirSync2(CACHE_DIR, { recursive: true });
+    writeFileSync2(
+      getMarkerPath(),
+      JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
-    return {
-      valid: true,
-      plan,
-      email: payload.sub ?? "",
-      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
-      deviceLimit: limits.devices,
-      employeeLimit: limits.employees,
-      memoryLimit: limits.memories
-    };
   } catch {
-    return null;
   }
 }
-function cacheResponse(token) {
+function clearActiveAgent() {
   try {
-    writeFileSync3(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    unlinkSync3(getMarkerPath());
   } catch {
   }
 }
-async function validateLicense(apiKey, deviceId) {
-  const did = deviceId ?? loadDeviceId();
+function getActiveAgent() {
   try {
-    const res = await fetchRetry(`${API_BASE}/auth/activate`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ apiKey, deviceId: did }),
-      signal: AbortSignal.timeout(1e4)
-    });
-    if (res.ok) {
-      const data = await res.json();
-      if (data.error === "device_limit_exceeded") {
-        const cached2 = await getCachedLicense();
-        if (cached2) return cached2;
-        const raw2 = getRawCachedPlan();
-        if (raw2) return { ...raw2, valid: false };
-        return { ...FREE_LICENSE, valid: false, plan: "free" };
-      }
-      if (data.token) {
-        cacheResponse(data.token);
-        const verified = await verifyLicenseJwt(data.token);
-        if (verified) return verified;
+    const markerPath = getMarkerPath();
+    const raw = readFileSync5(markerPath, "utf8");
+    const data = JSON.parse(raw);
+    if (data.agentId) {
+      if (data.startedAt) {
+        const age = Date.now() - new Date(data.startedAt).getTime();
+        if (age > STALE_MS) {
+          try {
+            unlinkSync3(markerPath);
+          } catch {
+          }
+        } else {
+          return {
+            agentId: data.agentId,
+            agentRole: data.agentRole || "employee"
+          };
+        }
+      } else {
+        return {
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee"
+        };
       }
-      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
-      return {
-        valid: data.valid,
-        plan: data.plan,
-        email: data.email,
-        expiresAt: data.expiresAt,
-        deviceLimit: limits.devices,
-        employeeLimit: limits.employees,
-        memoryLimit: limits.memories
-      };
     }
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    const raw = getRawCachedPlan();
-    if (raw) return raw;
-    return { ...FREE_LICENSE, valid: false, plan: "free" };
   } catch {
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    const rawFallback = getRawCachedPlan();
-    if (rawFallback) return rawFallback;
-    return { ...FREE_LICENSE, valid: false, error: "offline" };
   }
-}
-function getCacheAgeMs() {
   try {
-    const { statSync: statSync4 } = __require("fs");
-    const s = statSync4(CACHE_PATH);
-    return Date.now() - s.mtimeMs;
+    const sessionName = execSync5(
+      "tmux display-message -p '#{session_name}' 2>/dev/null",
+      { encoding: "utf8", timeout: 2e3 }
+    ).trim();
+    const resolved = resolveActiveAgentFromTmuxSession(sessionName);
+    if (resolved) return resolved;
+  } catch {
+  }
+  return {
+    agentId: process.env.AGENT_ID || "default",
+    agentRole: process.env.AGENT_ROLE || "employee"
+  };
+}
+function getAllActiveAgents() {
+  try {
+    const files = readdirSync3(CACHE_DIR);
+    const sessions = [];
+    for (const file of files) {
+      if (!file.startsWith("active-agent-") || !file.endsWith(".json")) continue;
+      const key = file.slice("active-agent-".length, -".json".length);
+      if (key === "undefined") continue;
+      try {
+        const raw = readFileSync5(path9.join(CACHE_DIR, file), "utf8");
+        const data = JSON.parse(raw);
+        if (!data.agentId) continue;
+        if (data.startedAt) {
+          const age = Date.now() - new Date(data.startedAt).getTime();
+          if (age > STALE_MS) {
+            try {
+              unlinkSync3(path9.join(CACHE_DIR, file));
+            } catch {
+            }
+            continue;
+          }
+        }
+        sessions.push({
+          agentId: data.agentId,
+          agentRole: data.agentRole || "employee",
+          startedAt: data.startedAt || (/* @__PURE__ */ new Date()).toISOString(),
+          sessionKey: key
+        });
+      } catch {
+      }
+    }
+    return sessions;
+  } catch {
+    return [];
+  }
+}
+function cleanupSessionMarkers() {
+  const key = getSessionKey();
+  try {
+    unlinkSync3(path9.join(CACHE_DIR, `active-agent-${key}.json`));
+  } catch {
+  }
+  try {
+    unlinkSync3(path9.join(CACHE_DIR, "active-agent-undefined.json"));
+  } catch {
+  }
+}
+var CACHE_DIR, STALE_MS;
+var init_active_agent = __esm({
+  "src/adapters/claude/active-agent.ts"() {
+    "use strict";
+    init_config();
+    init_session_key2();
+    init_employees();
+    CACHE_DIR = path9.join(EXE_AI_DIR, "session-cache");
+    STALE_MS = 24 * 60 * 60 * 1e3;
+  }
+});
+
+// src/lib/license.ts
+var license_exports = {};
+__export(license_exports, {
+  LICENSE_PUBLIC_KEY_PEM: () => LICENSE_PUBLIC_KEY_PEM,
+  PLAN_LIMITS: () => PLAN_LIMITS,
+  assertVpsLicense: () => assertVpsLicense,
+  checkLicense: () => checkLicense,
+  getCachedLicense: () => getCachedLicense,
+  isFeatureAllowed: () => isFeatureAllowed,
+  loadDeviceId: () => loadDeviceId,
+  loadLicense: () => loadLicense,
+  mirrorLicenseKey: () => mirrorLicenseKey,
+  saveLicense: () => saveLicense,
+  startLicenseRevalidation: () => startLicenseRevalidation,
+  stopLicenseRevalidation: () => stopLicenseRevalidation,
+  validateLicense: () => validateLicense
+});
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { randomUUID as randomUUID3 } from "crypto";
+import path10 from "path";
+import { jwtVerify, importSPKI } from "jose";
+async function fetchRetry(url, init) {
+  try {
+    return await fetch(url, init);
+  } catch {
+    await new Promise((r) => setTimeout(r, RETRY_DELAY_MS));
+    return fetch(url, { ...init, signal: AbortSignal.timeout(1e4) });
+  }
+}
+function loadDeviceId() {
+  const deviceJsonPath = path10.join(EXE_AI_DIR, "device.json");
+  try {
+    if (existsSync8(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
+      if (data.deviceId) return data.deviceId;
+    }
+  } catch {
+  }
+  try {
+    if (existsSync8(DEVICE_ID_PATH)) {
+      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
+      if (id2) return id2;
+    }
+  } catch {
+  }
+  const id = randomUUID3();
+  mkdirSync3(EXE_AI_DIR, { recursive: true });
+  writeFileSync3(DEVICE_ID_PATH, id, "utf8");
+  return id;
+}
+function loadLicense() {
+  try {
+    if (!existsSync8(LICENSE_PATH)) return null;
+    return readFileSync6(LICENSE_PATH, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+function saveLicense(apiKey) {
+  mkdirSync3(EXE_AI_DIR, { recursive: true });
+  writeFileSync3(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+}
+async function verifyLicenseJwt(token) {
+  try {
+    const key = await importSPKI(LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG);
+    const { payload } = await jwtVerify(token, key, {
+      algorithms: [LICENSE_JWT_ALG]
+    });
+    const plan = payload.plan ?? "free";
+    const email = payload.sub ?? "";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email,
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return null;
+  }
+}
+async function getCachedLicense() {
+  try {
+    if (!existsSync8(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    if (!raw.token || typeof raw.token !== "string") return null;
+    return await verifyLicenseJwt(raw.token);
+  } catch {
+    return null;
+  }
+}
+function readCachedToken() {
+  try {
+    if (!existsSync8(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
+    return typeof raw.token === "string" ? raw.token : null;
+  } catch {
+    return null;
+  }
+}
+function getRawCachedPlan() {
+  try {
+    const token = readCachedToken();
+    if (!token) return null;
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = JSON.parse(Buffer.from(parts[1], "base64url").toString());
+    const plan = payload.plan ?? "free";
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    process.stderr.write(
+      `[license] WARN: using unverified cached plan (API unreachable, JWT expired). Plan: ${plan}
+`
+    );
+    return {
+      valid: true,
+      plan,
+      email: payload.sub ?? "",
+      expiresAt: payload.exp ? new Date(payload.exp * 1e3).toISOString() : null,
+      deviceLimit: limits.devices,
+      employeeLimit: limits.employees,
+      memoryLimit: limits.memories
+    };
+  } catch {
+    return null;
+  }
+}
+function cacheResponse(token) {
+  try {
+    writeFileSync3(CACHE_PATH, JSON.stringify({ token }), "utf8");
+  } catch {
+  }
+}
+async function validateLicense(apiKey, deviceId) {
+  const did = deviceId ?? loadDeviceId();
+  try {
+    const res = await fetchRetry(`${API_BASE}/auth/activate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey, deviceId: did }),
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (res.ok) {
+      const data = await res.json();
+      if (data.error === "device_limit_exceeded") {
+        const cached2 = await getCachedLicense();
+        if (cached2) return cached2;
+        const raw2 = getRawCachedPlan();
+        if (raw2) return { ...raw2, valid: false };
+        return { ...FREE_LICENSE, valid: false, plan: "free" };
+      }
+      if (data.token) {
+        cacheResponse(data.token);
+        const verified = await verifyLicenseJwt(data.token);
+        if (verified) return verified;
+      }
+      const limits = PLAN_LIMITS[data.plan] ?? PLAN_LIMITS.free;
+      return {
+        valid: data.valid,
+        plan: data.plan,
+        email: data.email,
+        expiresAt: data.expiresAt,
+        deviceLimit: limits.devices,
+        employeeLimit: limits.employees,
+        memoryLimit: limits.memories
+      };
+    }
+    const cached = await getCachedLicense();
+    if (cached) return cached;
+    const raw = getRawCachedPlan();
+    if (raw) return raw;
+    return { ...FREE_LICENSE, valid: false, plan: "free" };
+  } catch {
+    const cached = await getCachedLicense();
+    if (cached) return cached;
+    const rawFallback = getRawCachedPlan();
+    if (rawFallback) return rawFallback;
+    return { ...FREE_LICENSE, valid: false, error: "offline" };
+  }
+}
+function getCacheAgeMs() {
+  try {
+    const { statSync: statSync4 } = __require("fs");
+    const s = statSync4(CACHE_PATH);
+    return Date.now() - s.mtimeMs;
   } catch {
     return Infinity;
   }
@@ -4390,7 +4982,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
@@ -4415,7 +5007,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 = ?
@@ -4449,7 +5041,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;
@@ -4509,7 +5101,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
@@ -4563,6 +5155,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,
@@ -4712,7 +5305,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.`
       );
     }
   }
@@ -4732,8 +5325,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 (!existsSync13(SESSION_CACHE)) {
@@ -4878,12 +5473,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)) {
@@ -4935,7 +5532,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";
@@ -4945,8 +5542,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();
@@ -4955,8 +5552,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: "",
@@ -4975,7 +5572,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.`
       };
     }
   }
@@ -5132,8 +5729,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");
     writeFileSync8(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
@@ -5237,6 +5834,7 @@ var init_tmux_routing = __esm({
     init_provider_table();
     init_intercom_queue();
     init_plan_limits();
+    init_employees();
     SPAWN_LOCK_DIR = path17.join(os7.homedir(), ".exe-os", "spawn-locks");
     SESSION_CACHE = path17.join(os7.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
@@ -5275,11 +5873,27 @@ var init_task_scope = __esm({
 });
 
 // src/lib/tasks-crud.ts
-import crypto6 from "crypto";
-import path18 from "path";
-import { execSync as execSync8 } from "child_process";
-import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
+var tasks_crud_exports = {};
+__export(tasks_crud_exports, {
+  TASK_ALREADY_CLAIMED_PREFIX: () => TASK_ALREADY_CLAIMED_PREFIX,
+  checkStaleCompletion: () => checkStaleCompletion,
+  createTaskCore: () => createTaskCore,
+  deleteTaskCore: () => deleteTaskCore,
+  ensureArchitectureDoc: () => ensureArchitectureDoc,
+  ensureGitignoreExe: () => ensureGitignoreExe,
+  extractParentFromContext: () => extractParentFromContext,
+  isTmuxSessionAlive: () => isTmuxSessionAlive,
+  listTasks: () => listTasks,
+  resolveTask: () => resolveTask,
+  slugify: () => slugify,
+  updateTaskStatus: () => updateTaskStatus,
+  writeCheckpoint: () => writeCheckpoint
+});
+import crypto6 from "crypto";
+import path18 from "path";
+import { execSync as execSync8 } from "child_process";
+import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
+import { existsSync as existsSync14, readFileSync as readFileSync12 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -5519,6 +6133,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 = execSync8("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 {
+      execSync8(`tmux has-session -t ${JSON.stringify(identifier)}`, {
+        timeout: 2e3,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return true;
+    }
+  } catch {
+    if (identifier.startsWith("%")) return true;
+    try {
+      execSync8("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;
@@ -5581,13 +6225,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({
@@ -5685,7 +6375,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";
   }
 });
@@ -6000,7 +6690,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;
 }
@@ -6040,12 +6730,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 {
@@ -6516,6 +7207,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({
@@ -6534,8 +7243,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);
@@ -6559,7 +7268,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,
@@ -6575,7 +7284,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 {
@@ -6602,12 +7311,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);
@@ -6619,6 +7330,7 @@ var init_tasks = __esm({
     init_config();
     init_notifications();
     init_state_bus();
+    init_employees();
     init_tasks_crud();
     init_tasks_review();
     init_tasks_crud();
@@ -6733,7 +7445,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)) {
@@ -7065,8 +7777,8 @@ async function runConsolidation(client, options) {
     if (clustersProcessed >= options.maxCalls) break;
     if (cluster.memories.length < 3) continue;
     try {
-      const isExe = cluster.agentId === "exe";
-      if (isExe) {
+      const isCoordinator = cluster.agentId === "exe" || isCoordinatorName(cluster.agentId);
+      if (isCoordinator) {
         const synthesis = await consolidateCluster(cluster, options.model);
         if (!synthesis.trim()) continue;
         const result = await storeConsolidation(client, cluster, synthesis, options.embedFn);
@@ -7095,7 +7807,7 @@ async function runConsolidation(client, options) {
         if (dedupCount === 0) continue;
       }
       clustersProcessed++;
-      memoriesConsolidated += isExe ? cluster.memories.length : 0;
+      memoriesConsolidated += isCoordinator ? cluster.memories.length : 0;
     } catch (err) {
       process.stderr.write(
         `[consolidation] Cluster failed (${cluster.projectName}/${cluster.dateRange}): ${err instanceof Error ? err.message : String(err)}
@@ -7182,10 +7894,153 @@ var init_consolidation = __esm({
   "src/lib/consolidation.ts"() {
     "use strict";
     init_store();
+    init_employees();
     WIKI_FETCH_TIMEOUT_MS = 1e4;
   }
 });
 
+// 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, path30, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path30}`;
+  const headers = {
+    Authorization: `Bearer ${config2.apiKey}`,
+    "Content-Type": "application/json"
+  };
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS2);
+  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
+        });
+      } finally {
+        clearTimeout(retryTimeout);
+      }
+    }
+    if (!response.ok) {
+      throw new Error(`Wiki API ${method} ${path30}: ${response.status} ${response.statusText}`);
+    }
+    return response.json();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function resolveWikiUrl(configUrl) {
+  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;
+    }
+  } catch {
+  }
+  if (configUrl && configUrl !== LOCAL_WIKI_URL) {
+    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 {
+    }
+  }
+  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
+  };
+}
+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/worker-gate.ts
 var worker_gate_exports = {};
 __export(worker_gate_exports, {
@@ -7271,404 +8126,46 @@ function tryAcquireBackfillLock() {
           }
         }
       } catch {
-      }
-    }
-    writeFileSync13(BACKFILL_LOCK, String(process.pid));
-    return true;
-  } catch {
-    return true;
-  }
-}
-function releaseBackfillLock() {
-  try {
-    unlinkSync8(BACKFILL_LOCK);
-  } catch {
-  }
-}
-var WORKER_PID_DIR, MAX_CONCURRENT_WORKERS, BACKFILL_LOCK;
-var init_worker_gate = __esm({
-  "src/lib/worker-gate.ts"() {
-    "use strict";
-    init_config();
-    WORKER_PID_DIR = path28.join(EXE_AI_DIR, "worker-pids");
-    MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path28.join(WORKER_PID_DIR, "backfill.lock");
-  }
-});
-
-// src/mcp/server.ts
-init_embedder();
-init_store();
-init_database();
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { spawn as spawn2 } from "child_process";
-import { existsSync as existsSync22, openSync as openSync2, mkdirSync as mkdirSync12, closeSync as closeSync2 } from "fs";
-import path29 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-
-// src/mcp/tools/recall-my-memory.ts
-import { z } from "zod";
-
-// src/lib/hybrid-search.ts
-init_store();
-init_database();
-var RRF_K = 60;
-async function hybridSearch(queryText, agentId, options) {
-  const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const config2 = await loadConfig2();
-  if (config2.searchMode === "fts") {
-    return lightweightSearch(queryText, agentId, options);
-  }
-  const limit = options?.limit ?? 10;
-  let effectiveQuery = queryText;
-  let effectiveOptions = { ...options };
-  let _isBroadQuery = false;
-  if (config2.selfQueryRouter && process.env.ANTHROPIC_API_KEY) {
-    try {
-      const { routeQuery: routeQuery2 } = await Promise.resolve().then(() => (init_self_query_router(), self_query_router_exports));
-      const routed = await routeQuery2(queryText, config2.selfQueryModel);
-      effectiveQuery = routed.semanticQuery;
-      _isBroadQuery = routed.isBroadQuery;
-      if (routed.projectFilter && !effectiveOptions.projectName) {
-        effectiveOptions.projectName = routed.projectFilter;
-      }
-      if (routed.timeFilter && !effectiveOptions.since) {
-        effectiveOptions.since = routed.timeFilter;
-      }
-    } catch {
-    }
-  }
-  const { getMemoryCardinality: getMemoryCardinality2 } = await Promise.resolve().then(() => (init_store(), store_exports));
-  const cardinality = await getMemoryCardinality2(agentId);
-  const { rerankerAutoTrigger } = config2.scalingRoadmap ?? {};
-  const minCardForBroad = rerankerAutoTrigger?.broadQueryMinCardinality ?? 5e4;
-  const useNarrowPath = cardinality < 1e4;
-  const useBroadPath = cardinality > minCardForBroad || _isBroadQuery && cardinality >= 1e4;
-  const effectiveIsBroad = useBroadPath && !useNarrowPath;
-  if (effectiveIsBroad !== _isBroadQuery) {
-    process.stderr.write(
-      `[hybrid-search] Adaptive routing override: cardinality=${cardinality}, router=${_isBroadQuery ? "broad" : "narrow"} \u2192 ${effectiveIsBroad ? "broad" : "narrow"}
-`
-    );
-  }
-  const broadFetchTopK = config2.scalingRoadmap?.rerankerAutoTrigger?.fetchTopK ?? 150;
-  const fetchLimit = effectiveIsBroad ? Math.max(limit * 5, broadFetchTopK) : Math.max(limit * 3, 30);
-  const fetchOptions = { ...effectiveOptions, limit: fetchLimit, includeSource: false };
-  let queryVector = null;
-  try {
-    const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
-    queryVector = await embed2(effectiveQuery);
-  } catch {
-    process.stderr.write("[hybrid-search] Embed daemon unavailable \u2014 FTS-only mode\n");
-  }
-  let grepPromise = Promise.resolve([]);
-  if (config2.fileGrepEnabled !== false) {
-    try {
-      const { getProjectName: getProjectName2 } = await Promise.resolve().then(() => (init_project_name(), project_name_exports));
-      const projectRoot = process.cwd();
-      const projectName = getProjectName2(projectRoot);
-      if (projectName && projectName !== "tmp") {
-        const { grepProjectFiles: grepProjectFiles2 } = await Promise.resolve().then(() => (init_file_grep(), file_grep_exports));
-        grepPromise = grepProjectFiles2(effectiveQuery, projectRoot, {
-          maxResults: 10
-        }).catch(() => []);
-      }
-    } catch {
-    }
-  }
-  const [ftsResults, vectorResults, grepResults] = await Promise.all([
-    lightweightSearch(effectiveQuery, agentId, fetchOptions),
-    queryVector ? searchMemories(queryVector, agentId, fetchOptions) : Promise.resolve([]),
-    grepPromise
-  ]);
-  const lists = [];
-  const weights = [];
-  if (ftsResults.length > 0) {
-    lists.push(ftsResults);
-    weights.push(1);
-  }
-  if (vectorResults.length > 0) {
-    lists.push(vectorResults);
-    weights.push(1);
-  }
-  if (grepResults.length > 0) {
-    lists.push(grepResults);
-    weights.push(0.5);
-  }
-  if (lists.length === 0) return [];
-  if (lists.length === 1 && !effectiveIsBroad) return lists[0].slice(0, limit);
-  const rrfLimit = effectiveIsBroad ? Math.max(limit * 5, 150) : limit;
-  const merged = lists.length === 1 ? lists[0].slice(0, rrfLimit) : rrfMergeMulti(lists, rrfLimit, RRF_K, weights);
-  const auto = config2.scalingRoadmap?.rerankerAutoTrigger ?? {
-    enabled: config2.rerankerEnabled ?? true,
-    broadQueryMinCardinality: 5e4,
-    fetchTopK: 150,
-    returnTopK: 5
-  };
-  let rerankedAndBlended = null;
-  if (effectiveIsBroad && auto.enabled) {
-    const cardinality2 = await estimateCardinality(agentId, effectiveOptions);
-    if (cardinality2 > auto.broadQueryMinCardinality) {
-      try {
-        const { isRerankerAvailable: isRerankerAvailable2, rerank: rerank2 } = await Promise.resolve().then(() => (init_reranker(), reranker_exports));
-        if (isRerankerAvailable2()) {
-          const reranked = await rerank2(effectiveQuery, merged, auto.returnTopK);
-          if (reranked.length > 0) {
-            rerankedAndBlended = rrfMergeMulti(
-              [reranked],
-              auto.returnTopK,
-              RRF_K
-            );
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  const finalResults = (rerankedAndBlended ?? merged).slice(
-    0,
-    rerankedAndBlended ? auto.returnTopK : limit
-  );
-  if (options?.includeSource && finalResults.length > 0) {
-    await attachDocumentMetadata(finalResults);
-  }
-  if (finalResults.length > 0) {
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const ids = finalResults.map((r) => r.id);
-    const placeholders = ids.map(() => "?").join(",");
-    try {
-      const client = getClient();
-      void client.execute({
-        sql: `UPDATE memories SET last_accessed = ? WHERE id IN (${placeholders})`,
-        args: [now, ...ids]
-      }).catch(() => {
-      });
-    } catch {
-    }
-  }
-  return finalResults;
-}
-async function estimateCardinality(agentId, options) {
-  const client = getClient();
-  let sql = `SELECT COUNT(*) as cnt FROM memories
-             WHERE agent_id = ?
-               AND COALESCE(status, 'active') = 'active'
-               AND COALESCE(confidence, 0.7) >= 0.3`;
-  const args = [agentId];
-  if (options?.projectName) {
-    sql += ` AND project_name = ?`;
-    args.push(options.projectName);
-  }
-  if (options?.toolName) {
-    sql += ` AND tool_name = ?`;
-    args.push(options.toolName);
-  }
-  if (options?.hasError !== void 0) {
-    sql += ` AND has_error = ?`;
-    args.push(options.hasError ? 1 : 0);
-  }
-  if (options?.since) {
-    sql += ` AND timestamp >= ?`;
-    args.push(options.since);
-  }
-  try {
-    const result = await client.execute({ sql, args });
-    return Number(result.rows[0]?.cnt) || 0;
-  } catch {
-    return 0;
-  }
-}
-function recencyScore(timestamp) {
-  const daysSince = (Date.now() - new Date(timestamp).getTime()) / (1e3 * 60 * 60 * 24);
-  return 1 / (1 + daysSince * 0.01);
-}
-function normalizedImportance(importance) {
-  return ((importance ?? 5) - 1) / 9;
-}
-function frecencyBoost(lastAccessed, timestamp) {
-  const accessTime = lastAccessed ? new Date(lastAccessed).getTime() : new Date(timestamp).getTime();
-  const hoursSince = Math.max(0, (Date.now() - accessTime) / (1e3 * 60 * 60));
-  return Math.exp(-0.01 * hoursSince);
-}
-function rrfMergeMulti(lists, limit, k = RRF_K, weights) {
-  const scores = /* @__PURE__ */ new Map();
-  for (let listIdx = 0; listIdx < lists.length; listIdx++) {
-    const list = lists[listIdx];
-    const weight = weights?.[listIdx] ?? 1;
-    for (let i = 0; i < list.length; i++) {
-      const rec = list[i];
-      const entry = scores.get(rec.id) ?? { rrfScore: 0, record: rec };
-      entry.rrfScore += weight * (1 / (k + i + 1));
-      scores.set(rec.id, entry);
-    }
-  }
-  const entries = Array.from(scores.values()).map((e) => {
-    const recency = recencyScore(e.record.timestamp);
-    const importance = normalizedImportance(e.record.importance);
-    const confidence = e.record.confidence ?? 0.7;
-    const frecency = frecencyBoost(e.record.last_accessed, e.record.timestamp);
-    const baseScore = e.rrfScore * 0.35 + recency * 0.14 + importance * 0.21 + confidence * 0.3;
-    const finalScore = baseScore * (1 + 0.3 * frecency);
-    return { score: finalScore, record: e.record };
-  });
-  return entries.sort((a, b) => b.score - a.score).slice(0, limit).map((e) => e.record);
-}
-async function lightweightSearch(queryText, agentId, options) {
-  const client = getClient();
-  const limit = options?.limit ?? 5;
-  const terms = queryText.toLowerCase().split(/\s+/).filter((t) => t.length >= 3).map((t) => t.replace(/[^a-z0-9_]/g, "")).filter((t) => t.length >= 3);
-  if (terms.length === 0) {
-    return recentRecords(agentId, options, limit);
-  }
-  const prefixTerms = terms.map((t) => `${t}*`);
-  const useAnd = terms.length >= 3;
-  const matchExpr = useAnd ? prefixTerms.join(" AND ") : prefixTerms.join(" OR ");
-  const results = await ftsQuery(client, matchExpr, agentId, options, limit);
-  if (useAnd && results.length < limit) {
-    const orExpr = prefixTerms.join(" OR ");
-    const orResults = await ftsQuery(client, orExpr, agentId, options, limit);
-    const seen = new Set(results.map((r) => r.id));
-    for (const r of orResults) {
-      if (!seen.has(r.id) && results.length < limit) {
-        results.push(r);
-        seen.add(r.id);
-      }
-    }
-  }
-  if (options?.includeSource && results.length > 0) {
-    await attachDocumentMetadata(results);
-  }
-  return results;
-}
-async function ftsQuery(client, matchExpr, agentId, options, limit) {
-  const statusFilter = options?.includeArchived ? "" : `
-               AND COALESCE(m.status, 'active') = 'active'`;
-  let sql = `SELECT m.id, m.agent_id, m.agent_role, m.session_id, m.timestamp,
-                    m.tool_name, m.project_name,
-                    m.has_error, m.raw_text, m.vector, m.task_id,
-                    m.importance, m.status, m.confidence, m.last_accessed,
-                    m.workspace_id, m.document_id, m.user_id,
-                    m.char_offset, m.page_number,
-                    m.source_path, m.source_type
-             FROM memories m
-             JOIN memories_fts fts ON m.rowid = fts.rowid
-             WHERE memories_fts MATCH ?
-               AND m.agent_id = ?${statusFilter}
-               AND COALESCE(m.confidence, 0.7) >= 0.3`;
-  const args = [matchExpr, agentId];
-  const scope = buildWikiScopeFilter(options, "m.");
-  sql += scope.clause;
-  args.push(...scope.args);
-  if (options?.projectName) {
-    sql += ` AND m.project_name = ?`;
-    args.push(options.projectName);
-  }
-  if (options?.toolName) {
-    sql += ` AND m.tool_name = ?`;
-    args.push(options.toolName);
-  }
-  if (options?.hasError !== void 0) {
-    sql += ` AND m.has_error = ?`;
-    args.push(options.hasError ? 1 : 0);
-  }
-  if (options?.since) {
-    sql += ` AND m.timestamp >= ?`;
-    args.push(options.since);
-  }
-  sql += ` ORDER BY rank LIMIT ?`;
-  args.push(limit);
-  const result = await client.execute({ sql, args });
-  return result.rows.map((row) => ({
-    id: row.id,
-    agent_id: row.agent_id,
-    agent_role: row.agent_role,
-    session_id: row.session_id,
-    timestamp: row.timestamp,
-    tool_name: row.tool_name,
-    project_name: row.project_name,
-    has_error: row.has_error === 1,
-    raw_text: row.raw_text,
-    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
-    task_id: row.task_id ?? null,
-    importance: row.importance ?? 5,
-    status: row.status ?? "active",
-    confidence: row.confidence ?? 0.7,
-    last_accessed: row.last_accessed ?? row.timestamp,
-    workspace_id: row.workspace_id ?? null,
-    document_id: row.document_id ?? null,
-    user_id: row.user_id ?? null,
-    char_offset: row.char_offset ?? null,
-    page_number: row.page_number ?? null,
-    source_path: row.source_path ?? null,
-    source_type: row.source_type ?? null
-  }));
-}
-async function recentRecords(agentId, options, limit) {
-  const client = getClient();
-  const statusFilter = options?.includeArchived ? "" : `
-               AND COALESCE(status, 'active') = 'active'`;
-  let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
-                    tool_name, project_name,
-                    has_error, raw_text, vector, task_id,
-                    importance, status, confidence, last_accessed,
-                    workspace_id, document_id, user_id,
-                    char_offset, page_number,
-                    source_path, source_type
-             FROM memories
-             WHERE agent_id = ?${statusFilter}
-               AND COALESCE(confidence, 0.7) >= 0.3`;
-  const args = [agentId];
-  const scope = buildWikiScopeFilter(options, "");
-  sql += scope.clause;
-  args.push(...scope.args);
-  if (options?.projectName) {
-    sql += ` AND project_name = ?`;
-    args.push(options.projectName);
-  }
-  if (options?.toolName) {
-    sql += ` AND tool_name = ?`;
-    args.push(options.toolName);
-  }
-  if (options?.hasError !== void 0) {
-    sql += ` AND has_error = ?`;
-    args.push(options.hasError ? 1 : 0);
-  }
-  if (options?.since) {
-    sql += ` AND timestamp >= ?`;
-    args.push(options.since);
-  }
-  sql += ` ORDER BY timestamp DESC LIMIT ?`;
-  args.push(limit);
-  const result = await client.execute({ sql, args });
-  return result.rows.map((row) => ({
-    id: row.id,
-    agent_id: row.agent_id,
-    agent_role: row.agent_role,
-    session_id: row.session_id,
-    timestamp: row.timestamp,
-    tool_name: row.tool_name,
-    project_name: row.project_name,
-    has_error: row.has_error === 1,
-    raw_text: row.raw_text,
-    vector: row.vector == null ? [] : Array.isArray(row.vector) ? row.vector : Array.from(row.vector),
-    task_id: row.task_id ?? null,
-    importance: row.importance ?? 5,
-    status: row.status ?? "active",
-    confidence: row.confidence ?? 0.7,
-    last_accessed: row.last_accessed ?? row.timestamp,
-    workspace_id: row.workspace_id ?? null,
-    document_id: row.document_id ?? null,
-    user_id: row.user_id ?? null,
-    char_offset: row.char_offset ?? null,
-    page_number: row.page_number ?? null,
-    source_path: row.source_path ?? null,
-    source_type: row.source_type ?? null
-  }));
+      }
+    }
+    writeFileSync13(BACKFILL_LOCK, String(process.pid));
+    return true;
+  } catch {
+    return true;
+  }
+}
+function releaseBackfillLock() {
+  try {
+    unlinkSync8(BACKFILL_LOCK);
+  } catch {
+  }
 }
+var WORKER_PID_DIR, MAX_CONCURRENT_WORKERS, BACKFILL_LOCK;
+var init_worker_gate = __esm({
+  "src/lib/worker-gate.ts"() {
+    "use strict";
+    init_config();
+    WORKER_PID_DIR = path28.join(EXE_AI_DIR, "worker-pids");
+    MAX_CONCURRENT_WORKERS = 3;
+    BACKFILL_LOCK = path28.join(WORKER_PID_DIR, "backfill.lock");
+  }
+});
+
+// src/mcp/server.ts
+init_embedder();
+init_store();
+init_database();
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync22, openSync as openSync2, mkdirSync as mkdirSync12, closeSync as closeSync2 } from "fs";
+import path29 from "path";
+import { fileURLToPath as fileURLToPath4 } from "url";
 
 // src/mcp/tools/recall-my-memory.ts
+init_hybrid_search();
 init_active_agent();
+import { z } from "zod";
 function formatSourceLine(record) {
   const doc = record.document_metadata;
   if (!doc) return "";
@@ -7727,6 +8224,7 @@ function registerRecallMyMemory(server2) {
           includeArchived: include_archived,
           workspaceId: workspace_id,
           includeSource: include_source,
+          includeDrafts: true,
           ...user_id !== void 0 ? { userId: user_id } : {}
         };
         const results = await hybridSearch(query, agentId, searchOptions);
@@ -7774,7 +8272,21 @@ ${formatted}`
 }
 
 // src/mcp/tools/ask-team-memory.ts
+init_hybrid_search();
+init_active_agent();
+init_employees();
 import { z as z2 } from "zod";
+function canSeeRaw(queryingRole, targetRole) {
+  if (queryingRole === "COO") return true;
+  if (queryingRole === "CTO" && [
+    "Principal Engineer",
+    "Staff Code Reviewer",
+    "Content Production Specialist",
+    "CMO"
+  ].includes(targetRole))
+    return true;
+  return false;
+}
 function registerAskTeamMemory(server2) {
   server2.registerTool(
     "ask_team_memory",
@@ -7783,7 +8295,7 @@ function registerAskTeamMemory(server2) {
       description: "Search another employee's memories. Use this to find what a team member worked on, learned, or solved.",
       inputSchema: {
         team_member: z2.string().describe(
-          "Name of the team member to query (e.g., 'yoshi', 'mari', 'gen')"
+          "Name of the team member to query"
         ),
         query: z2.string().describe("What to search for"),
         project_name: z2.string().optional().describe("Filter by project name"),
@@ -7791,16 +8303,28 @@ function registerAskTeamMemory(server2) {
         since: z2.string().optional().describe("ISO 8601 timestamp \u2014 only return memories at or after this time"),
         include_archived: z2.boolean().optional().default(false).describe(
           "Include deprecated (archived) memories alongside active ones. Default false."
+        ),
+        include_raw: z2.boolean().optional().default(false).describe(
+          "Include raw technical memories (default: ADR summaries only for cross-agent reads)"
         )
       }
     },
-    async ({ team_member, query, project_name, limit, since, include_archived }) => {
+    async ({ team_member, query, project_name, limit, since, include_archived, include_raw }) => {
       try {
+        const { agentId: queryingAgentId, agentRole: queryingAgentRole } = getActiveAgent();
+        const employees = loadEmployeesSync();
+        const targetEmployee = getEmployee(employees, team_member);
+        const queryingRole = queryingAgentRole ?? employees.find((e) => e.name === queryingAgentId)?.role ?? "";
+        const targetRole = targetEmployee?.role ?? "";
+        const hasRawAccess = canSeeRaw(queryingRole, targetRole);
+        const effectiveIncludeRaw = include_raw && hasRawAccess;
         const results = await hybridSearch(query, team_member, {
           projectName: project_name,
           limit,
           since,
-          includeArchived: include_archived
+          includeArchived: include_archived,
+          includeDrafts: false,
+          memoryType: effectiveIncludeRaw ? void 0 : "adr"
         });
         if (results.length === 0) {
           return {
@@ -8015,6 +8539,7 @@ init_embedder();
 init_store();
 init_plan_limits();
 init_active_agent();
+init_employees();
 import { z as z5 } from "zod";
 import crypto3 from "crypto";
 import { writeFileSync as writeFileSync5 } from "fs";
@@ -8067,6 +8592,7 @@ function registerCommitMemory(server2) {
       }
       const memoryId = crypto3.randomUUID();
       await assertMemoryLimit();
+      const memoryType = canCoordinate(agentId, agentRole) ? "adr" : "raw";
       await writeMemory({
         id: memoryId,
         agent_id: agentId,
@@ -8080,7 +8606,8 @@ function registerCommitMemory(server2) {
         vector,
         importance: importanceOverride ?? 9,
         status: "active",
-        supersedes_id: supersedes_id ?? null
+        supersedes_id: supersedes_id ?? null,
+        memory_type: memoryType
       });
       await flushBatch();
       if (supersedes_id) {
@@ -8259,10 +8786,10 @@ function registerQueryRelationships(server2) {
     "query_relationships",
     {
       title: "Query Relationships",
-      description: "Query the knowledge graph for entity relationships, decision chains, and connections between concepts, people, and projects. Use this to answer relational questions like 'How did our auth strategy evolve?' or 'What did yoshi work on this week?'",
+      description: "Query the knowledge graph for entity relationships, decision chains, and connections between concepts, people, and projects. Use this to answer relational questions like 'How did our auth strategy evolve?' or 'What did the CTO work on this week?'",
       inputSchema: {
         query: z6.string().optional().describe("What relationships to find (natural language)"),
-        entity_name: z6.string().optional().describe("Specific entity to explore (e.g., 'yoshi', 'exe-os', 'Jina v3')"),
+        entity_name: z6.string().optional().describe("Specific entity to explore (for example an agent, project, or vendor name)"),
         relationship_type: z6.string().optional().describe("Filter by relationship type (e.g., 'implemented', 'depends_on', 'worked_on')"),
         max_depth: z6.number().default(2).describe("How many hops to traverse (default: 2)")
       }
@@ -8527,6 +9054,7 @@ ${lines.join("\n")}`
 init_tasks();
 init_database();
 init_tasks_crud();
+init_employees();
 import { z as z9 } from "zod";
 function registerUpdateTask(server2) {
   server2.registerTool(
@@ -8546,7 +9074,7 @@ function registerUpdateTask(server2) {
         try {
           const { getActiveAgent: getActiveAgent2 } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
           const agent = getActiveAgent2();
-          if (agent.agentId !== "exe" && agent.agentId !== "default") {
+          if (!canCoordinate(agent.agentId, agent.agentRole)) {
             let isOwnReview = false;
             try {
               const client = getClient();
@@ -8573,7 +9101,7 @@ function registerUpdateTask(server2) {
           if (assignedBy === "system" && taskFile.includes("review-")) {
             const { getActiveAgent: getActiveAgent2 } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
             const agent = getActiveAgent2();
-            if (agent.agentId !== assignedTo && agent.agentId !== "exe" && agent.agentId !== "default") {
+            if (agent.agentId !== assignedTo && !canCoordinate(agent.agentId, agent.agentRole)) {
               process.stderr.write(
                 `[update_task] BLOCKED: ${agent.agentId} tried to close review "${String(row.title)}" assigned to ${assignedTo}
 `
@@ -8596,13 +9124,20 @@ function registerUpdateTask(server2) {
           };
         }
       }
+      let callerAgentId;
+      try {
+        const { getActiveAgent: getAgent } = await Promise.resolve().then(() => (init_active_agent(), active_agent_exports));
+        callerAgentId = getAgent().agentId;
+      } catch {
+      }
       let task;
       try {
         task = await updateTask({
           taskId: task_id,
           status,
           result,
-          baseDir: process.cwd()
+          baseDir: process.cwd(),
+          callerAgentId
         });
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -8651,8 +9186,9 @@ All tasks complete. No more open tasks in your queue.`;
 init_tasks();
 init_active_agent();
 init_tmux_routing();
+init_employees();
 import { z as z10 } from "zod";
-var CLOSE_TASK_ALLOWED_ROLES = /* @__PURE__ */ new Set(["COO", "CTO"]);
+var CLOSE_TASK_ALLOWED_ROLES = /* @__PURE__ */ new Set(["CTO"]);
 function registerCloseTask(server2) {
   server2.registerTool(
     "close_task",
@@ -8667,12 +9203,13 @@ function registerCloseTask(server2) {
     },
     async ({ task_id, result, status }) => {
       const agent = getActiveAgent();
-      if (agent.agentId && agent.agentId !== "default" && !CLOSE_TASK_ALLOWED_ROLES.has(agent.agentRole ?? "")) {
+      const canClose = canCoordinate(agent.agentId, agent.agentRole) || CLOSE_TASK_ALLOWED_ROLES.has(agent.agentRole ?? "");
+      if (agent.agentId && !canClose) {
         return {
           content: [
             {
               type: "text",
-              text: `close_task is for reviewers only (exe). Use update_task with status "done" and your result summary to complete your work. This triggers a review task for exe.`
+              text: `close_task is for reviewers and coordinators only. Use update_task with status "done" and your result summary to complete your work. This triggers a review task for the coordinator.`
             }
           ],
           isError: true
@@ -8691,7 +9228,7 @@ function registerCloseTask(server2) {
           return {
             content: [{
               type: "text",
-              text: `\u26A0\uFE0F Session scope mismatch: this task belongs to ${taskScope}, but you are ${mySession}. Reviews should be processed by the exe session that dispatched the task. Switch to ${taskScope} to review this task.`
+              text: `\u26A0\uFE0F Session scope mismatch: this task belongs to ${taskScope}, but you are ${mySession}. Reviews should be processed by the coordinator session that dispatched the task. Switch to ${taskScope} to review this task.`
             }],
             isError: true
           };
@@ -8738,6 +9275,7 @@ All tasks complete. No more open tasks in your queue.`;
 // src/mcp/tools/get-task.ts
 init_tasks();
 init_database();
+init_employees();
 import { z as z11 } from "zod";
 function registerGetTask(server2) {
   server2.registerTool(
@@ -8817,13 +9355,13 @@ function registerGetTask(server2) {
         } catch {
         }
       }
-      if (String(row.assigned_to) !== "exe" && !String(row.title).startsWith("Review:") && String(row.status) !== "done" && String(row.status) !== "cancelled") {
+      if (String(row.assigned_to) !== "exe" && !isCoordinatorName(String(row.assigned_to)) && !String(row.title).startsWith("Review:") && String(row.status) !== "done" && String(row.status) !== "cancelled") {
         lines.push(
           "",
           "## MANDATORY: When done",
           "",
           'You MUST call update_task with status "done" and a result summary when finished.',
-          "If you skip this, exe will never know you're done and your work won't be reviewed.",
+          "If you skip this, your reviewer will not know you're done and your work won't be reviewed.",
           "Do NOT let a failed commit or any error prevent you from calling update_task(done)."
         );
       }
@@ -8887,7 +9425,7 @@ function registerResumeEmployee(server2) {
       title: "Resume Employee",
       description: "Create or refresh a RESUME task after an employee hits context capacity. Dedupes against any existing active RESUME for the same agent so repeated capacity hits never produce duplicate rows. Preferred over raw create_task for the context-full handler.",
       inputSchema: {
-        agent_id: z13.string().describe("Employee name to resume (e.g. 'yoshi')"),
+        agent_id: z13.string().describe("Employee name to resume"),
         project_name: z13.string().describe("Project name \u2014 used to namespace the task")
       }
     },
@@ -8895,9 +9433,9 @@ function registerResumeEmployee(server2) {
       const client = getClient();
       const reScope = sessionScopeFilter();
       const openTasks = await client.execute({
-        sql: `SELECT id, title, priority, task_file, status
+        sql: `SELECT id, title, priority, task_file, status, assigned_tmux
               FROM tasks
-              WHERE assigned_to = ? AND status IN ('open', 'in_progress')${reScope.sql}
+              WHERE assigned_to = ? AND status IN ('open', 'in_progress', 'blocked')${reScope.sql}
               ORDER BY
                 CASE priority WHEN 'p0' THEN 0 WHEN 'p1' THEN 1 WHEN 'p2' THEN 2 ELSE 3 END,
                 created_at ASC
@@ -8914,6 +9452,25 @@ function registerResumeEmployee(server2) {
           ]
         };
       }
+      try {
+        const { isTmuxSessionAlive: isTmuxSessionAlive2 } = await Promise.resolve().then(() => (init_tasks_crud(), tasks_crud_exports));
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        for (const row of openTasks.rows) {
+          const status = String(row.status);
+          const assignedTmux = row.assigned_tmux != null ? String(row.assigned_tmux) : null;
+          if (status === "in_progress" && assignedTmux && !isTmuxSessionAlive2(assignedTmux)) {
+            await client.execute({
+              sql: "UPDATE tasks SET status = 'open', assigned_tmux = NULL, updated_at = ? WHERE id = ?",
+              args: [now, String(row.id)]
+            });
+            process.stderr.write(
+              `[resume_employee] Released dead claim on "${String(row.title)}" (was ${assignedTmux})
+`
+            );
+          }
+        }
+      } catch {
+      }
       const { created, taskId } = await createOrRefreshResumeTask(
         agent_id,
         process.cwd(),
@@ -9002,7 +9559,7 @@ function registerSendMessage(server2) {
       title: "Send Message",
       description: "Send a structured message to another agent. Messages are queued and delivered via intercom. NOTE: messages are fire-and-forget \u2014 do NOT use for actionable work dispatch. Use create_task instead to assign work to employees.",
       inputSchema: {
-        target_agent: z15.string().describe("Recipient agent name (e.g., 'yoshi', 'tom', 'exe')"),
+        target_agent: z15.string().describe("Recipient agent name"),
         content: z15.string().describe("Message content"),
         target_project: z15.string().optional().describe("Project context (optional)"),
         priority: z15.enum(["normal", "urgent"]).default("normal").describe("Message priority (default: normal)"),
@@ -9408,12 +9965,13 @@ ${identity.body}`
 // src/mcp/tools/update-identity.ts
 import { z as z21 } from "zod";
 init_active_agent();
+init_employees();
 function registerUpdateIdentity(server2) {
   server2.registerTool(
     "update_identity",
     {
       title: "Update Identity",
-      description: "Write an agent's exe.md identity. RESTRICTED: only exe or founder sessions can use this. Agents cannot rewrite their own identity. Content should be markdown with YAML frontmatter.",
+      description: "Write an agent's exe.md identity. RESTRICTED: only coordinator or founder sessions can use this. Agents cannot rewrite their own identity. Content should be markdown with YAML frontmatter.",
       inputSchema: {
         agent_id: z21.string().describe("Target agent whose identity to write"),
         content: z21.string().describe(
@@ -9423,12 +9981,12 @@ function registerUpdateIdentity(server2) {
     },
     async ({ agent_id, content }) => {
       const caller = getActiveAgent();
-      const allowed = caller.agentId === "default" || caller.agentRole === "COO";
+      const allowed = canCoordinate(caller.agentId, caller.agentRole);
       if (!allowed) {
         return {
           content: [{
             type: "text",
-            text: `Permission denied. Only exe or founder sessions can update identities. You are "${caller.agentId}". Agents cannot rewrite their own identity \u2014 this is an architectural constraint, not a bug.`
+            text: `Permission denied. Only coordinator or founder sessions can update identities. You are "${caller.agentId}". Agents cannot rewrite their own identity \u2014 this is an architectural constraint, not a bug.`
           }],
           isError: true
         };
@@ -9459,25 +10017,26 @@ function registerUpdateIdentity(server2) {
 init_behaviors();
 init_active_agent();
 init_database();
+init_employees();
 import { z as z22 } from "zod";
 function registerDeactivateBehavior(server2) {
   server2.registerTool(
     "deactivate_behavior",
     {
       title: "Deactivate Behavior",
-      description: "Soft-delete a behavior by setting active = 0. RESTRICTED: only exe or founder sessions can use this. Use list_behaviors to find the behavior ID first.",
+      description: "Soft-delete a behavior by setting active = 0. RESTRICTED: only coordinator or founder sessions can use this. Use list_behaviors to find the behavior ID first.",
       inputSchema: {
         behavior_id: z22.string().describe("UUID of the behavior to deactivate")
       }
     },
     async ({ behavior_id }) => {
       const caller = getActiveAgent();
-      const allowed = caller.agentId === "default" || caller.agentRole === "COO";
+      const allowed = canCoordinate(caller.agentId, caller.agentRole);
       if (!allowed) {
         return {
           content: [{
             type: "text",
-            text: `Permission denied. Only exe or founder sessions can deactivate behaviors. You are "${caller.agentId}".`
+            text: `Permission denied. Only the coordinator or founder sessions can deactivate behaviors. You are "${caller.agentId}".`
           }],
           isError: true
         };
@@ -9971,7 +10530,7 @@ function registerAcknowledgeMessages(server2) {
     },
     async () => {
       const agent = getActiveAgent();
-      const agentId = agent.agentId || "exe";
+      const agentId = agent.agentId || "default";
       const client = getClient();
       const result = await client.execute({
         sql: `UPDATE messages SET status = 'acknowledged', processed_at = datetime('now')
@@ -12307,13 +12866,14 @@ Consolidated summaries stored as tier-1 (importance=9) memories.`
 // src/mcp/tools/store-global-procedure.ts
 init_global_procedures();
 init_active_agent();
+init_employees();
 import { z as z41 } from "zod";
 function registerStoreGlobalProcedure(server2) {
   server2.registerTool(
     "store_global_procedure",
     {
       title: "Store Global Procedure",
-      description: "Create an organization-wide procedure (Layer 0) that supersedes identity, expertise, and experience. Use for hard rules that every employee must follow. RESTRICTED: only exe or founder sessions.",
+      description: "Create an organization-wide procedure (Layer 0) that supersedes identity, expertise, and experience. Use for hard rules that every employee must follow. RESTRICTED: only coordinator or founder sessions.",
       inputSchema: {
         title: z41.string().describe("Short title for the procedure"),
         content: z41.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
@@ -12323,12 +12883,12 @@ function registerStoreGlobalProcedure(server2) {
     },
     async ({ title, content, priority, domain }) => {
       const caller = getActiveAgent();
-      const allowed = caller.agentId === "default" || caller.agentRole === "COO";
+      const allowed = canCoordinate(caller.agentId, caller.agentRole);
       if (!allowed) {
         return {
           content: [{
             type: "text",
-            text: `Permission denied. Only exe or founder sessions can create global procedures. You are "${caller.agentId}".`
+            text: `Permission denied. Only the coordinator or founder sessions can create global procedures. You are "${caller.agentId}".`
           }],
           isError: true
         };
@@ -12395,25 +12955,26 @@ ${lines.join("\n\n")}`
 init_global_procedures();
 init_active_agent();
 init_database();
+init_employees();
 import { z as z42 } from "zod";
 function registerDeactivateGlobalProcedure(server2) {
   server2.registerTool(
     "deactivate_global_procedure",
     {
       title: "Deactivate Global Procedure",
-      description: "Soft-delete a global procedure by setting active = 0. RESTRICTED: only exe or founder sessions. Use list_global_procedures to find the procedure ID first.",
+      description: "Soft-delete a global procedure by setting active = 0. RESTRICTED: only coordinator or founder sessions. Use list_global_procedures to find the procedure ID first.",
       inputSchema: {
         procedure_id: z42.string().describe("UUID of the global procedure to deactivate")
       }
     },
     async ({ procedure_id }) => {
       const caller = getActiveAgent();
-      const allowed = caller.agentId === "default" || caller.agentRole === "COO";
+      const allowed = canCoordinate(caller.agentId, caller.agentRole);
       if (!allowed) {
         return {
           content: [{
             type: "text",
-            text: `Permission denied. Only exe or founder sessions can deactivate global procedures. You are "${caller.agentId}".`
+            text: `Permission denied. Only coordinator or founder sessions can deactivate global procedures. You are "${caller.agentId}".`
           }],
           isError: true
         };
@@ -12457,6 +13018,392 @@ Content: ${row.content}`
   );
 }
 
+// src/mcp/tools/search-everything.ts
+import { z as z43 } from "zod";
+
+// src/lib/unified-search.ts
+var DEFAULT_LIMIT = 10;
+var MAX_SNIPPET = 500;
+var ALL_SOURCES = ["memory", "conversations", "wiki"];
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+async function searchMemories2(query, agentId, limit) {
+  const { hybridSearch: hybridSearch2 } = await Promise.resolve().then(() => (init_hybrid_search(), hybrid_search_exports));
+  const results = await hybridSearch2(query, agentId, { limit });
+  return results.map((r, i) => ({
+    source: "memory",
+    score: 1 - i / Math.max(results.length, 1),
+    // rank-based score
+    timestamp: r.timestamp,
+    snippet: truncate(r.raw_text, MAX_SNIPPET),
+    entityLinks: [],
+    metadata: {
+      id: r.id,
+      tool_name: r.tool_name,
+      project_name: r.project_name,
+      agent_id: r.agent_id,
+      has_error: r.has_error
+    }
+  }));
+}
+async function searchConversations(query, limit) {
+  try {
+    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const client = getClient2();
+    const result = await client.execute({
+      sql: `SELECT c.id, c.platform, c.sender_id, c.sender_name,
+                   c.content_text, c.agent_response, c.agent_name, c.timestamp
+            FROM conversations c
+            WHERE c.rowid IN (SELECT rowid FROM conversations_fts WHERE conversations_fts MATCH ?)
+            ORDER BY c.timestamp DESC
+            LIMIT ?`,
+      args: [query, limit]
+    });
+    return result.rows.map((row, i) => ({
+      source: "conversations",
+      score: 1 - i / Math.max(result.rows.length, 1),
+      timestamp: row.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+      snippet: truncate(
+        (row.content_text ?? "") + (row.agent_response ? ` \u2192 ${row.agent_response}` : ""),
+        MAX_SNIPPET
+      ),
+      entityLinks: [],
+      metadata: {
+        id: row.id,
+        platform: row.platform,
+        sender_id: row.sender_id,
+        sender_name: row.sender_name,
+        agent_name: row.agent_name
+      }
+    }));
+  } catch {
+    return [];
+  }
+}
+async function searchWiki(query, limit) {
+  try {
+    const { createWikiClient: createWikiClient2, chatInWorkspace: chatInWorkspace2, listWorkspaces: listWorkspaces2 } = await Promise.resolve().then(() => (init_wiki_client(), wiki_client_exports));
+    const client = await createWikiClient2();
+    if (!client) return [];
+    const workspaces = await listWorkspaces2(client);
+    if (workspaces.length === 0) return [];
+    const results = [];
+    const wsToQuery = workspaces.slice(0, 3);
+    for (const ws of wsToQuery) {
+      if (results.length >= limit) break;
+      try {
+        const response = await chatInWorkspace2(client, ws.slug, query, "query");
+        if (response.textResponse && !response.error) {
+          results.push({
+            source: "wiki",
+            score: 0.8,
+            // wiki query mode relevance is implicit
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            snippet: truncate(response.textResponse, MAX_SNIPPET),
+            entityLinks: [],
+            metadata: {
+              workspace: ws.slug,
+              workspace_name: ws.name,
+              sources: response.sources.map((s) => s.title)
+            }
+          });
+        }
+      } catch {
+      }
+    }
+    return results.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+async function enrichWithEntities(results) {
+  try {
+    const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+    const client = getClient2();
+    const memoryIds = results.filter((r) => r.source === "memory" && r.metadata.id).map((r) => r.metadata.id);
+    if (memoryIds.length === 0) return;
+    const placeholders = memoryIds.map(() => "?").join(",");
+    const entityResult = await client.execute({
+      sql: `SELECT em.memory_id, e.name, e.entity_type
+            FROM entity_memories em
+            JOIN entities e ON e.id = em.entity_id
+            WHERE em.memory_id IN (${placeholders})`,
+      args: memoryIds
+    });
+    const entityMap = /* @__PURE__ */ new Map();
+    for (const row of entityResult.rows) {
+      const mid = row.memory_id;
+      if (!entityMap.has(mid)) entityMap.set(mid, []);
+      entityMap.get(mid).push({
+        name: row.name,
+        type: row.entity_type
+      });
+    }
+    for (const r of results) {
+      if (r.source === "memory" && r.metadata.id) {
+        r.entityLinks = entityMap.get(r.metadata.id) ?? [];
+      }
+    }
+  } catch {
+  }
+}
+async function unifiedSearch(query, agentId, opts) {
+  const limit = opts?.limit ?? DEFAULT_LIMIT;
+  const sources = opts?.sources ?? ALL_SOURCES;
+  const perSourceLimit = Math.max(Math.ceil(limit * 1.5), 5);
+  const promises = [];
+  if (sources.includes("memory")) {
+    promises.push(searchMemories2(query, agentId, perSourceLimit));
+  }
+  if (sources.includes("conversations")) {
+    promises.push(searchConversations(query, perSourceLimit));
+  }
+  if (sources.includes("wiki")) {
+    promises.push(searchWiki(query, perSourceLimit));
+  }
+  const allResults = (await Promise.all(promises)).flat();
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = allResults.filter((r) => {
+    const key = r.snippet.slice(0, 100);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+  deduped.sort((a, b) => b.score - a.score);
+  const trimmed = deduped.slice(0, limit);
+  await enrichWithEntities(trimmed);
+  return trimmed;
+}
+
+// src/mcp/tools/search-everything.ts
+init_active_agent();
+function registerSearchEverything(server2) {
+  server2.registerTool(
+    "search_everything",
+    {
+      title: "Search Everything",
+      description: "Search across all data stores \u2014 memories, conversations, and wiki \u2014 in one query. Returns merged results sorted by relevance with entity links.",
+      inputSchema: {
+        query: z43.string().describe("What to search for across all data stores"),
+        sources: z43.array(z43.enum(["memory", "conversations", "wiki"])).optional().describe(
+          "Which sources to search (default: all). Options: memory, conversations, wiki"
+        ),
+        limit: z43.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results to return (default 10, max 50)")
+      }
+    },
+    async (params) => {
+      try {
+        const { agentId } = getActiveAgent();
+        const sources = params.sources;
+        const results = await unifiedSearch(params.query, agentId, {
+          limit: params.limit,
+          sources
+        });
+        if (results.length === 0) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: "No results found across any data store."
+              }
+            ]
+          };
+        }
+        const formatted = results.map((r) => {
+          const entityStr = r.entityLinks.length > 0 ? ` [entities: ${r.entityLinks.map((e) => `${e.name} (${e.type})`).join(", ")}]` : "";
+          return `[${r.source}] (${(r.score * 100).toFixed(0)}%) ${r.timestamp}
+${r.snippet}${entityStr}`;
+        });
+        const sourceSummary = [...new Set(results.map((r) => r.source))].join(
+          ", "
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${results.length} results across ${sourceSummary}:
+
+${formatted.join("\n\n---\n\n")}`
+            }
+          ]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error searching: ${msg}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/store-decision.ts
+init_embedder();
+init_store();
+init_active_agent();
+init_database();
+init_plan_limits();
+import { z as z44 } from "zod";
+import crypto14 from "crypto";
+function registerStoreDecision(server2) {
+  server2.registerTool(
+    "store_decision",
+    {
+      title: "Store Decision",
+      description: "Store an authoritative decision keyed by domain. Use this when a decision is made that should be canonical \u2014 future lookups via get_decision return the latest decision for that domain. Supports supersession chains.",
+      inputSchema: {
+        domain: z44.string().describe(
+          "Domain key, e.g. 'auth-strategy', 'db-migration-approach', 'api-versioning'"
+        ),
+        decision: z44.string().describe("The decision text \u2014 what was decided"),
+        rationale: z44.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
+        supersedes: z44.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
+        project_name: z44.string().optional().describe("Project name")
+      }
+    },
+    async ({ domain, decision, rationale, supersedes, project_name }) => {
+      const { agentId, agentRole } = getActiveAgent();
+      try {
+        await assertMemoryLimit();
+      } catch (err) {
+        if (err instanceof PlanLimitError) {
+          return {
+            content: [{ type: "text", text: err.message }],
+            isError: true
+          };
+        }
+      }
+      const parts = [`[decision:${domain}] ${decision}`];
+      if (rationale) parts.push(`Rationale: ${rationale}`);
+      const rawText = parts.join("\n\n");
+      let vector;
+      try {
+        vector = await embed(rawText);
+      } catch {
+        vector = null;
+      }
+      const memoryId = crypto14.randomUUID();
+      if (supersedes) {
+        try {
+          const client = getClient();
+          await client.execute({
+            sql: "UPDATE memories SET status = 'archived' WHERE id = ? AND memory_type = 'decision'",
+            args: [supersedes]
+          });
+        } catch {
+        }
+      }
+      await writeMemory({
+        id: memoryId,
+        agent_id: agentId,
+        agent_role: agentRole,
+        session_id: process.env.SESSION_ID ?? "manual",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        tool_name: "store_decision",
+        project_name: project_name ?? "unknown",
+        has_error: false,
+        raw_text: rawText,
+        vector,
+        source_path: domain,
+        memory_type: "decision",
+        supersedes_id: supersedes ?? null,
+        tier: 1,
+        importance: 8
+      });
+      await flushBatch();
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Decision stored for domain "${domain}". ID: ${memoryId}${supersedes ? `
+Supersedes: ${supersedes}` : ""}`
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/get-decision.ts
+init_database();
+import { z as z45 } from "zod";
+function registerGetDecision(server2) {
+  server2.registerTool(
+    "get_decision",
+    {
+      title: "Get Decision",
+      description: "Retrieve the latest authoritative decision for a domain. Returns the current active decision and the supersession history.",
+      inputSchema: {
+        domain: z45.string().describe(
+          "Domain key to look up, e.g. 'auth-strategy', 'db-migration-approach'"
+        )
+      }
+    },
+    async ({ domain }) => {
+      const client = getClient();
+      const result = await client.execute({
+        sql: `SELECT id, agent_id, timestamp, raw_text, status, supersedes_id, project_name
+              FROM memories
+              WHERE memory_type = 'decision' AND source_path = ?
+              ORDER BY timestamp DESC`,
+        args: [domain]
+      });
+      if (result.rows.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No decisions found for domain "${domain}".`
+            }
+          ]
+        };
+      }
+      const decisions = result.rows.map((r) => ({
+        id: String(r.id),
+        agent_id: String(r.agent_id),
+        timestamp: String(r.timestamp),
+        raw_text: String(r.raw_text),
+        status: String(r.status ?? "active"),
+        supersedes_id: r.supersedes_id ? String(r.supersedes_id) : null,
+        project_name: String(r.project_name)
+      }));
+      const current = decisions.find((d) => d.status === "active") ?? decisions[0];
+      const history = decisions.filter((d) => d.id !== current.id);
+      const lines = [];
+      lines.push(`## Current Decision: ${domain}`);
+      lines.push(`ID: ${current.id}`);
+      lines.push(`By: ${current.agent_id} | ${current.timestamp}`);
+      lines.push(`Project: ${current.project_name}`);
+      lines.push(`Status: ${current.status}`);
+      lines.push("");
+      lines.push(current.raw_text);
+      if (history.length > 0) {
+        lines.push("");
+        lines.push(`## Supersession History (${history.length} prior)`);
+        for (const h of history) {
+          lines.push("");
+          lines.push(`---`);
+          lines.push(`ID: ${h.id} | ${h.timestamp} | ${h.status}`);
+          lines.push(`By: ${h.agent_id}`);
+          if (h.supersedes_id) lines.push(`Supersedes: ${h.supersedes_id}`);
+          lines.push(h.raw_text);
+        }
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }]
+      };
+    }
+  );
+}
+
 // src/lib/telemetry.ts
 var ENABLED = process.env.EXE_TELEMETRY === "1";
 var initialized = false;
@@ -12519,6 +13466,8 @@ var server = new McpServer({
   version: "1.3.0"
 });
 var _backfillTimer = null;
+var _ppidWatchdog = null;
+var _shuttingDown = false;
 instrumentServer(server);
 registerRecallMyMemory(server);
 registerAskTeamMemory(server);
@@ -12564,6 +13513,9 @@ registerConsolidateMemories(server);
 registerStoreGlobalProcedure(server);
 registerListGlobalProcedures(server);
 registerDeactivateGlobalProcedure(server);
+registerSearchEverything(server);
+registerStoreDecision(server);
+registerGetDecision(server);
 try {
   await initStore();
   process.stderr.write("[exe-os] MCP server starting...\n");
@@ -12579,6 +13531,31 @@ try {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   process.stderr.write("[exe-os] MCP server connected.\n");
+  process.stdin.on("end", () => {
+    process.stderr.write("[exe-os] stdin closed \u2014 parent process died. Exiting.\n");
+    void shutdown("stdin_end");
+  });
+  process.stdin.on("close", () => {
+    process.stderr.write("[exe-os] stdin pipe closed. Exiting.\n");
+    void shutdown("stdin_close");
+  });
+  process.stdout.on("error", (err) => {
+    if (err.code === "EPIPE") {
+      process.stderr.write("[exe-os] stdout EPIPE \u2014 client disconnected. Exiting.\n");
+      void shutdown("epipe");
+    }
+  });
+  const originalPpid = process.ppid;
+  _ppidWatchdog = setInterval(() => {
+    if (process.ppid !== originalPpid) {
+      process.stderr.write(
+        `[exe-os] Parent PID changed (${originalPpid} \u2192 ${process.ppid}). Orphaned \u2014 exiting.
+`
+      );
+      void shutdown("ppid_changed");
+    }
+  }, 3e4);
+  _ppidWatchdog.unref();
   const BACKFILL_CHECK_MS = 5 * 60 * 1e3;
   _backfillTimer = setInterval(async () => {
     try {
@@ -12638,14 +13615,31 @@ try {
   );
   process.exit(1);
 }
-async function shutdown() {
+async function shutdown(reason = "signal") {
+  if (_shuttingDown) return;
+  _shuttingDown = true;
+  process.stderr.write(`[exe-os] Shutdown initiated (reason: ${reason})
+`);
   if (_backfillTimer) clearInterval(_backfillTimer);
-  await disposeStore();
-  await disposeEmbedder();
+  if (_ppidWatchdog) clearInterval(_ppidWatchdog);
+  const hardExit = setTimeout(() => {
+    process.stderr.write("[exe-os] Shutdown timeout (5s) \u2014 forcing exit.\n");
+    process.exit(1);
+  }, 5e3);
+  hardExit.unref();
+  try {
+    await disposeStore();
+    await disposeEmbedder();
+  } catch (err) {
+    process.stderr.write(
+      `[exe-os] Shutdown cleanup error: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
   process.exit(0);
 }
-process.on("SIGINT", () => void shutdown());
-process.on("SIGTERM", () => void shutdown());
+process.on("SIGINT", () => void shutdown("SIGINT"));
+process.on("SIGTERM", () => void shutdown("SIGTERM"));
 process.on("uncaughtException", (err) => {
   process.stderr.write(
     `[exe-os] uncaughtException (non-fatal): ${err.message}