@askexenow/exe-os 0.9.8 → 0.9.10

package/dist/mcp/server.js

@@ -34,6 +34,44 @@ var init_memory = __esm({
   }
 });
 
+// src/lib/secure-files.ts
+import { chmodSync, existsSync, mkdirSync } from "fs";
+import { chmod, mkdir } from "fs/promises";
+async function ensurePrivateDir(dirPath) {
+  await mkdir(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    await chmod(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
+function ensurePrivateDirSync(dirPath) {
+  mkdirSync(dirPath, { recursive: true, mode: PRIVATE_DIR_MODE });
+  try {
+    chmodSync(dirPath, PRIVATE_DIR_MODE);
+  } catch {
+  }
+}
+async function enforcePrivateFile(filePath) {
+  try {
+    await chmod(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
+function enforcePrivateFileSync(filePath) {
+  try {
+    if (existsSync(filePath)) chmodSync(filePath, PRIVATE_FILE_MODE);
+  } catch {
+  }
+}
+var PRIVATE_DIR_MODE, PRIVATE_FILE_MODE;
+var init_secure_files = __esm({
+  "src/lib/secure-files.ts"() {
+    "use strict";
+    PRIVATE_DIR_MODE = 448;
+    PRIVATE_FILE_MODE = 384;
+  }
+});
+
 // src/lib/config.ts
 var config_exports = {};
 __export(config_exports, {
@@ -50,8 +88,8 @@ __export(config_exports, {
   migrateConfig: () => migrateConfig,
   saveConfig: () => saveConfig
 });
-import { readFile, writeFile, mkdir, chmod } from "fs/promises";
-import { readFileSync, existsSync, renameSync } from "fs";
+import { readFile, writeFile } from "fs/promises";
+import { readFileSync, existsSync as existsSync2, renameSync } from "fs";
 import path from "path";
 import os from "os";
 function resolveDataDir() {
@@ -59,7 +97,7 @@ function resolveDataDir() {
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
   const newDir = path.join(os.homedir(), ".exe-os");
   const legacyDir = path.join(os.homedir(), ".exe-mem");
-  if (!existsSync(newDir) && existsSync(legacyDir)) {
+  if (!existsSync2(newDir) && existsSync2(legacyDir)) {
     try {
       renameSync(legacyDir, newDir);
       process.stderr.write(`[exe-os] Migrated data directory: ~/.exe-mem \u2192 ~/.exe-os
@@ -122,9 +160,9 @@ function normalizeAutoUpdate(raw) {
 }
 async function loadConfig() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir(dir, { recursive: true });
+  await ensurePrivateDir(dir);
   const configPath = path.join(dir, "config.json");
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   const raw = await readFile(configPath, "utf-8");
@@ -137,6 +175,7 @@ async function loadConfig() {
 `);
       try {
         await writeFile(configPath, JSON.stringify(migratedCfg, null, 2) + "\n");
+        await enforcePrivateFile(configPath);
       } catch {
       }
     }
@@ -155,7 +194,7 @@ async function loadConfig() {
 function loadConfigSync() {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
   const configPath = path.join(dir, "config.json");
-  if (!existsSync(configPath)) {
+  if (!existsSync2(configPath)) {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
   try {
@@ -173,12 +212,10 @@ function loadConfigSync() {
 }
 async function saveConfig(config2) {
   const dir = process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? EXE_AI_DIR;
-  await mkdir(dir, { recursive: true });
+  await ensurePrivateDir(dir);
   const configPath = path.join(dir, "config.json");
   await writeFile(configPath, JSON.stringify(config2, null, 2) + "\n");
-  if (config2.cloud?.apiKey) {
-    await chmod(configPath, 384);
-  }
+  await enforcePrivateFile(configPath);
 }
 async function loadConfigFrom(configPath) {
   const raw = await readFile(configPath, "utf-8");
@@ -198,6 +235,7 @@ var EXE_AI_DIR, DB_PATH, MODELS_DIR, CONFIG_PATH, LEGACY_LANCE_PATH, CURRENT_CON
 var init_config = __esm({
   "src/lib/config.ts"() {
     "use strict";
+    init_secure_files();
     EXE_AI_DIR = resolveDataDir();
     DB_PATH = path.join(EXE_AI_DIR, "memories.db");
     MODELS_DIR = path.join(EXE_AI_DIR, "models");
@@ -274,6 +312,43 @@ var init_config = __esm({
   }
 });
 
+// src/lib/daemon-auth.ts
+import crypto2 from "crypto";
+import path2 from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
+function normalizeToken(token) {
+  if (!token) return null;
+  const trimmed = token.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+function readDaemonToken() {
+  try {
+    if (!existsSync3(DAEMON_TOKEN_PATH)) return null;
+    return normalizeToken(readFileSync2(DAEMON_TOKEN_PATH, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function ensureDaemonToken(seed) {
+  const existing = readDaemonToken();
+  if (existing) return existing;
+  const token = normalizeToken(seed) ?? crypto2.randomBytes(32).toString("hex");
+  ensurePrivateDirSync(EXE_AI_DIR);
+  writeFileSync(DAEMON_TOKEN_PATH, `${token}
+`, "utf8");
+  enforcePrivateFileSync(DAEMON_TOKEN_PATH);
+  return token;
+}
+var DAEMON_TOKEN_PATH;
+var init_daemon_auth = __esm({
+  "src/lib/daemon-auth.ts"() {
+    "use strict";
+    init_config();
+    init_secure_files();
+    DAEMON_TOKEN_PATH = path2.join(EXE_AI_DIR, "exed.token");
+  }
+});
+
 // src/lib/exe-daemon-client.ts
 var exe_daemon_client_exports = {};
 __export(exe_daemon_client_exports, {
@@ -283,14 +358,15 @@ __export(exe_daemon_client_exports, {
   embedViaClient: () => embedViaClient,
   isClientConnected: () => isClientConnected,
   pingDaemon: () => pingDaemon,
-  sendDaemonRequest: () => sendDaemonRequest
+  sendDaemonRequest: () => sendDaemonRequest,
+  sendIngestRequest: () => sendIngestRequest
 });
 import net from "net";
 import os2 from "os";
 import { spawn } from "child_process";
 import { randomUUID } from "crypto";
-import { existsSync as existsSync2, unlinkSync, readFileSync as readFileSync2, openSync, closeSync, statSync } from "fs";
-import path2 from "path";
+import { existsSync as existsSync4, unlinkSync, readFileSync as readFileSync3, openSync, closeSync, statSync } from "fs";
+import path3 from "path";
 import { fileURLToPath } from "url";
 function handleData(chunk) {
   _buffer += chunk.toString();
@@ -318,9 +394,9 @@ function handleData(chunk) {
   }
 }
 function cleanupStaleFiles() {
-  if (existsSync2(PID_PATH)) {
+  if (existsSync4(PID_PATH)) {
     try {
-      const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
+      const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
       if (pid > 0) {
         try {
           process.kill(pid, 0);
@@ -341,11 +417,11 @@ function cleanupStaleFiles() {
   }
 }
 function findPackageRoot() {
-  let dir = path2.dirname(fileURLToPath(import.meta.url));
-  const { root } = path2.parse(dir);
+  let dir = path3.dirname(fileURLToPath(import.meta.url));
+  const { root } = path3.parse(dir);
   while (dir !== root) {
-    if (existsSync2(path2.join(dir, "package.json"))) return dir;
-    dir = path2.dirname(dir);
+    if (existsSync4(path3.join(dir, "package.json"))) return dir;
+    dir = path3.dirname(dir);
   }
   return null;
 }
@@ -371,16 +447,17 @@ function spawnDaemon() {
     process.stderr.write("[exed-client] WARN: cannot find package root\n");
     return;
   }
-  const daemonPath = path2.join(pkgRoot, "dist", "lib", "exe-daemon.js");
-  if (!existsSync2(daemonPath)) {
+  const daemonPath = path3.join(pkgRoot, "dist", "lib", "exe-daemon.js");
+  if (!existsSync4(daemonPath)) {
     process.stderr.write(`[exed-client] WARN: daemon script not found at ${daemonPath}
 `);
     return;
   }
   const resolvedPath = daemonPath;
+  const daemonToken = ensureDaemonToken(process.env[DAEMON_TOKEN_ENV] ?? null);
   process.stderr.write(`[exed-client] Spawning daemon: ${resolvedPath}
 `);
-  const logPath = path2.join(path2.dirname(SOCKET_PATH), "exed.log");
+  const logPath = path3.join(path3.dirname(SOCKET_PATH), "exed.log");
   let stderrFd = "ignore";
   try {
     stderrFd = openSync(logPath, "a");
@@ -398,7 +475,8 @@ function spawnDaemon() {
       TMUX_PANE: void 0,
       // Prevents resolveExeSession() from scoping to one session
       EXE_DAEMON_SOCK: SOCKET_PATH,
-      EXE_DAEMON_PID: PID_PATH
+      EXE_DAEMON_PID: PID_PATH,
+      [DAEMON_TOKEN_ENV]: daemonToken
     }
   });
   child.unref();
@@ -508,13 +586,14 @@ function sendDaemonRequest(payload, timeoutMs = REQUEST_TIMEOUT_MS) {
       return;
     }
     const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
     const timer = setTimeout(() => {
       _pending.delete(id);
       resolve({ error: "Request timeout" });
     }, timeoutMs);
     _pending.set(id, { resolve, timer });
     try {
-      _socket.write(JSON.stringify({ id, ...payload }) + "\n");
+      _socket.write(JSON.stringify({ id, token, ...payload }) + "\n");
     } catch {
       clearTimeout(timer);
       _pending.delete(id);
@@ -543,9 +622,9 @@ function killAndRespawnDaemon() {
   }
   try {
     process.stderr.write("[exed-client] Killing daemon for restart...\n");
-    if (existsSync2(PID_PATH)) {
+    if (existsSync4(PID_PATH)) {
       try {
-        const pid = parseInt(readFileSync2(PID_PATH, "utf8").trim(), 10);
+        const pid = parseInt(readFileSync3(PID_PATH, "utf8").trim(), 10);
         if (pid > 0) {
           try {
             process.kill(pid, "SIGKILL");
@@ -674,17 +753,30 @@ function disconnectClient() {
 function isClientConnected() {
   return _connected;
 }
-var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
+function sendIngestRequest(payload) {
+  if (!_socket || !_connected) return false;
+  try {
+    const id = randomUUID();
+    const token = process.env[DAEMON_TOKEN_ENV] ?? readDaemonToken();
+    _socket.write(JSON.stringify({ id, token, type: "ingest", ...payload }) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SOCKET_PATH, PID_PATH, SPAWN_LOCK_PATH, SPAWN_LOCK_STALE_MS, CONNECT_TIMEOUT_MS, REQUEST_TIMEOUT_MS, DAEMON_TOKEN_ENV, _socket, _connected, _buffer, _requestCount, _consecutiveFailures, HEALTH_CHECK_INTERVAL, MAX_RETRIES_BEFORE_RESTART, RETRY_DELAYS_MS, MIN_DAEMON_AGE_MS, _pending, MAX_BUFFER;
 var init_exe_daemon_client = __esm({
   "src/lib/exe-daemon-client.ts"() {
     "use strict";
     init_config();
-    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path2.join(EXE_AI_DIR, "exed.sock");
-    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path2.join(EXE_AI_DIR, "exed.pid");
-    SPAWN_LOCK_PATH = path2.join(EXE_AI_DIR, "exed-spawn.lock");
+    init_daemon_auth();
+    SOCKET_PATH = process.env.EXE_DAEMON_SOCK ?? process.env.EXE_EMBED_SOCK ?? path3.join(EXE_AI_DIR, "exed.sock");
+    PID_PATH = process.env.EXE_DAEMON_PID ?? process.env.EXE_EMBED_PID ?? path3.join(EXE_AI_DIR, "exed.pid");
+    SPAWN_LOCK_PATH = path3.join(EXE_AI_DIR, "exed-spawn.lock");
     SPAWN_LOCK_STALE_MS = 3e4;
     CONNECT_TIMEOUT_MS = 15e3;
     REQUEST_TIMEOUT_MS = 3e4;
+    DAEMON_TOKEN_ENV = "EXE_DAEMON_TOKEN";
     _socket = null;
     _connected = false;
     _buffer = "";
@@ -736,10 +828,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync32 } = await import("fs");
-  const path41 = await import("path");
-  const modelPath = path41.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync32(modelPath)) {
+  const { existsSync: existsSync34 } = await import("fs");
+  const path45 = await import("path");
+  const modelPath = path45.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync34(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -862,20 +954,21 @@ __export(agent_config_exports, {
   saveAgentConfig: () => saveAgentConfig,
   setAgentRuntime: () => setAgentRuntime
 });
-import { readFileSync as readFileSync3, writeFileSync, existsSync as existsSync3, mkdirSync } from "fs";
-import path3 from "path";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
+import path4 from "path";
 function loadAgentConfig() {
-  if (!existsSync3(AGENT_CONFIG_PATH)) return {};
+  if (!existsSync5(AGENT_CONFIG_PATH)) return {};
   try {
-    return JSON.parse(readFileSync3(AGENT_CONFIG_PATH, "utf-8"));
+    return JSON.parse(readFileSync4(AGENT_CONFIG_PATH, "utf-8"));
   } catch {
     return {};
   }
 }
 function saveAgentConfig(config2) {
-  const dir = path3.dirname(AGENT_CONFIG_PATH);
-  if (!existsSync3(dir)) mkdirSync(dir, { recursive: true });
-  writeFileSync(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  const dir = path4.dirname(AGENT_CONFIG_PATH);
+  ensurePrivateDirSync(dir);
+  writeFileSync2(AGENT_CONFIG_PATH, JSON.stringify(config2, null, 2) + "\n", "utf-8");
+  enforcePrivateFileSync(AGENT_CONFIG_PATH);
 }
 function getAgentRuntime(agentId) {
   const config2 = loadAgentConfig();
@@ -915,7 +1008,8 @@ var init_agent_config = __esm({
     "use strict";
     init_config();
     init_runtime_table();
-    AGENT_CONFIG_PATH = path3.join(EXE_AI_DIR, "agent-config.json");
+    init_secure_files();
+    AGENT_CONFIG_PATH = path4.join(EXE_AI_DIR, "agent-config.json");
     KNOWN_RUNTIMES = {
       claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-4.5"],
       codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
@@ -962,9 +1056,9 @@ __export(employees_exports, {
   validateEmployeeName: () => validateEmployeeName
 });
 import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { existsSync as existsSync4, symlinkSync, readlinkSync, readFileSync as readFileSync4, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { existsSync as existsSync6, symlinkSync, readlinkSync, readFileSync as readFileSync5, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync3 } from "fs";
 import { execSync } from "child_process";
-import path4 from "path";
+import path5 from "path";
 import os3 from "os";
 function normalizeRole(role) {
   return (role ?? "").trim().toLowerCase();
@@ -1001,7 +1095,7 @@ function validateEmployeeName(name) {
   return { valid: true };
 }
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync4(employeesPath)) {
+  if (!existsSync6(employeesPath)) {
     return [];
   }
   const raw = await readFile2(employeesPath, "utf-8");
@@ -1012,13 +1106,13 @@ async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   }
 }
 async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
-  await mkdir2(path4.dirname(employeesPath), { recursive: true });
+  await mkdir2(path5.dirname(employeesPath), { recursive: true });
   await writeFile2(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
 function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
-  if (!existsSync4(employeesPath)) return [];
+  if (!existsSync6(employeesPath)) return [];
   try {
-    return JSON.parse(readFileSync4(employeesPath, "utf-8"));
+    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
   } catch {
     return [];
   }
@@ -1063,9 +1157,9 @@ function addEmployee(employees, employee) {
 function appendToCoordinatorTeam(employee) {
   const coordinator = getCoordinatorEmployee(loadEmployeesSync());
   if (!coordinator) return;
-  const idPath = path4.join(IDENTITY_DIR, `${coordinator.name}.md`);
-  if (!existsSync4(idPath)) return;
-  const content = readFileSync4(idPath, "utf-8");
+  const idPath = path5.join(IDENTITY_DIR, `${coordinator.name}.md`);
+  if (!existsSync6(idPath)) return;
+  const content = readFileSync5(idPath, "utf-8");
   if (content.includes(`**${capitalize(employee.name)}`)) return;
   const teamMatch = content.match(TEAM_SECTION_RE);
   if (!teamMatch || teamMatch.index === void 0) return;
@@ -1081,7 +1175,7 @@ function appendToCoordinatorTeam(employee) {
   } else {
     updated = content.trimEnd() + "\n" + entry;
   }
-  writeFileSync2(idPath, updated, "utf-8");
+  writeFileSync3(idPath, updated, "utf-8");
 }
 function capitalize(s) {
   return s.charAt(0).toUpperCase() + s.slice(1);
@@ -1115,14 +1209,14 @@ async function normalizeRosterCase(rosterPath) {
       emp.name = emp.name.toLowerCase();
       changed = true;
       try {
-        const identityDir = path4.join(os3.homedir(), ".exe-os", "identity");
-        const oldPath = path4.join(identityDir, `${oldName}.md`);
-        const newPath = path4.join(identityDir, `${emp.name}.md`);
-        if (existsSync4(oldPath) && !existsSync4(newPath)) {
+        const identityDir = path5.join(os3.homedir(), ".exe-os", "identity");
+        const oldPath = path5.join(identityDir, `${oldName}.md`);
+        const newPath = path5.join(identityDir, `${emp.name}.md`);
+        if (existsSync6(oldPath) && !existsSync6(newPath)) {
           renameSync2(oldPath, newPath);
-        } else if (existsSync4(oldPath) && oldPath !== newPath) {
-          const content = readFileSync4(oldPath, "utf-8");
-          writeFileSync2(newPath, content, "utf-8");
+        } else if (existsSync6(oldPath) && oldPath !== newPath) {
+          const content = readFileSync5(oldPath, "utf-8");
+          writeFileSync3(newPath, content, "utf-8");
           if (oldPath.toLowerCase() !== newPath.toLowerCase()) {
             unlinkSync2(oldPath);
           }
@@ -1152,7 +1246,7 @@ function registerBinSymlinks(name) {
     errors.push("Could not find 'exe-os' in PATH");
     return { created, skipped, errors };
   }
-  const binDir = path4.dirname(exeBinPath);
+  const binDir = path5.dirname(exeBinPath);
   let target;
   try {
     target = readlinkSync(exeBinPath);
@@ -1162,8 +1256,8 @@ function registerBinSymlinks(name) {
   }
   for (const suffix of ["", "-opencode"]) {
     const linkName = `${name}${suffix}`;
-    const linkPath = path4.join(binDir, linkName);
-    if (existsSync4(linkPath)) {
+    const linkPath = path5.join(binDir, linkName);
+    if (existsSync6(linkPath)) {
       skipped.push(linkName);
       continue;
     }
@@ -1181,18 +1275,18 @@ var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
-    EMPLOYEES_PATH = path4.join(EXE_AI_DIR, "exe-employees.json");
+    EMPLOYEES_PATH = path5.join(EXE_AI_DIR, "exe-employees.json");
     DEFAULT_COORDINATOR_TEMPLATE_NAME = "exe";
     COORDINATOR_ROLE = "COO";
     MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
-    IDENTITY_DIR = path4.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR = path5.join(EXE_AI_DIR, "identity");
     TEAM_SECTION_RE = /^## Team\b.*$/m;
   }
 });
 
 // src/lib/database-adapter.ts
 import os4 from "os";
-import path5 from "path";
+import path6 from "path";
 import { createRequire } from "module";
 import { pathToFileURL } from "url";
 function quotedIdentifier(identifier) {
@@ -1503,8 +1597,8 @@ async function loadPrismaClient() {
         }
         return new PrismaClient2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path5.join(os4.homedir(), "exe-db");
-      const requireFromExeDb = createRequire(path5.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path6.join(os4.homedir(), "exe-db");
+      const requireFromExeDb = createRequire(path6.join(exeDbRoot, "package.json"));
       const prismaEntry = requireFromExeDb.resolve("@prisma/client");
       const module = await import(pathToFileURL(prismaEntry).href);
       const PrismaClient = module.PrismaClient ?? module.default?.PrismaClient;
@@ -2344,6 +2438,7 @@ async function ensureSchema() {
       project     TEXT NOT NULL,
       summary     TEXT NOT NULL,
       task_file   TEXT,
+      session_scope TEXT,
       read        INTEGER NOT NULL DEFAULT 0,
       created_at  TEXT NOT NULL
     );
@@ -2352,7 +2447,7 @@ async function ensureSchema() {
       ON notifications(read);
 
     CREATE INDEX IF NOT EXISTS idx_notifications_agent
-      ON notifications(agent_id);
+      ON notifications(agent_id, session_scope);
 
     CREATE INDEX IF NOT EXISTS idx_notifications_task_file
       ON notifications(task_file);
@@ -2390,6 +2485,7 @@ async function ensureSchema() {
       target_agent    TEXT NOT NULL,
       target_project  TEXT,
       target_device   TEXT NOT NULL DEFAULT 'local',
+      session_scope   TEXT,
       content         TEXT NOT NULL,
       priority        TEXT DEFAULT 'normal',
       status          TEXT DEFAULT 'pending',
@@ -2403,10 +2499,31 @@ async function ensureSchema() {
     );
 
     CREATE INDEX IF NOT EXISTS idx_messages_target
-      ON messages(target_agent, status);
+      ON messages(target_agent, session_scope, status);
 
     CREATE INDEX IF NOT EXISTS idx_messages_conversation_order
-      ON messages(target_agent, from_agent, server_seq);
+      ON messages(target_agent, session_scope, from_agent, server_seq);
+  `);
+  try {
+    await client.execute({
+      sql: `ALTER TABLE notifications ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  try {
+    await client.execute({
+      sql: `ALTER TABLE messages ADD COLUMN session_scope TEXT`,
+      args: []
+    });
+  } catch {
+  }
+  await client.executeMultiple(`
+    CREATE INDEX IF NOT EXISTS idx_notifications_agent_scope_read
+      ON notifications(agent_id, session_scope, read, created_at);
+
+    CREATE INDEX IF NOT EXISTS idx_messages_target_scope_status
+      ON messages(target_agent, session_scope, status, created_at);
   `);
   try {
     await client.execute({
@@ -2990,6 +3107,13 @@ async function ensureSchema() {
     } catch {
     }
   }
+  try {
+    await client.execute({
+      sql: `UPDATE tasks SET status = 'closed' WHERE status = 'done' AND result IS NOT NULL`,
+      args: []
+    });
+  } catch {
+  }
 }
 async function disposeDatabase() {
   if (_walCheckpointTimer) {
@@ -3037,14 +3161,14 @@ __export(keychain_exports, {
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync5 } from "fs";
-import path6 from "path";
+import { existsSync as existsSync7 } from "fs";
+import path7 from "path";
 import os5 from "os";
 function getKeyDir() {
-  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path6.join(os5.homedir(), ".exe-os");
+  return process.env.EXE_OS_DIR ?? process.env.EXE_MEM_DIR ?? path7.join(os5.homedir(), ".exe-os");
 }
 function getKeyPath() {
-  return path6.join(getKeyDir(), "master.key");
+  return path7.join(getKeyDir(), "master.key");
 }
 async function tryKeytar() {
   try {
@@ -3065,7 +3189,7 @@ async function getMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (!existsSync5(keyPath)) {
+  if (!existsSync7(keyPath)) {
     process.stderr.write(
       `[keychain] Key not found at ${keyPath} (HOME=${os5.homedir()}, EXE_OS_DIR=${process.env.EXE_OS_DIR ?? "unset"})
 `
@@ -3108,7 +3232,7 @@ async function deleteMasterKey() {
     }
   }
   const keyPath = getKeyPath();
-  if (existsSync5(keyPath)) {
+  if (existsSync7(keyPath)) {
     await unlink(keyPath);
   }
 }
@@ -3210,6 +3334,7 @@ var shard_manager_exports = {};
 __export(shard_manager_exports, {
   disposeShards: () => disposeShards,
   ensureShardSchema: () => ensureShardSchema,
+  getOpenShardCount: () => getOpenShardCount,
   getReadyShardClient: () => getReadyShardClient,
   getShardClient: () => getShardClient,
   getShardsDir: () => getShardsDir,
@@ -3218,15 +3343,18 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path7 from "path";
-import { existsSync as existsSync6, mkdirSync as mkdirSync2, readdirSync } from "fs";
+import path8 from "path";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readdirSync } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync6(SHARDS_DIR)) {
+  if (!existsSync8(SHARDS_DIR)) {
     mkdirSync2(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
+  if (_evictionTimer) clearInterval(_evictionTimer);
+  _evictionTimer = setInterval(evictIdleShards, EVICTION_INTERVAL_MS);
+  _evictionTimer.unref();
 }
 function isShardingEnabled() {
   return _shardingEnabled;
@@ -3243,21 +3371,28 @@ function getShardClient(projectName) {
     throw new Error(`Invalid project name for shard: "${projectName}"`);
   }
   const cached = _shards.get(safeName);
-  if (cached) return cached;
-  const dbPath = path7.join(SHARDS_DIR, `${safeName}.db`);
+  if (cached) {
+    _shardLastAccess.set(safeName, Date.now());
+    return cached;
+  }
+  while (_shards.size >= MAX_OPEN_SHARDS) {
+    evictLRU();
+  }
+  const dbPath = path8.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
   });
   _shards.set(safeName, client);
+  _shardLastAccess.set(safeName, Date.now());
   return client;
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync6(path7.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync8(path8.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync6(SHARDS_DIR)) return [];
+  if (!existsSync8(SHARDS_DIR)) return [];
   return readdirSync(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
@@ -3309,6 +3444,8 @@ async function ensureShardSchema(client) {
   for (const col of [
     "ALTER TABLE memories ADD COLUMN task_id TEXT",
     "ALTER TABLE memories ADD COLUMN consolidated INTEGER NOT NULL DEFAULT 0",
+    "ALTER TABLE memories ADD COLUMN author_device_id TEXT",
+    "ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'business'",
     "ALTER TABLE memories ADD COLUMN importance INTEGER DEFAULT 5",
     "ALTER TABLE memories ADD COLUMN status TEXT DEFAULT 'active'",
     "ALTER TABLE memories ADD COLUMN wiki_synced INTEGER DEFAULT 0",
@@ -3446,21 +3583,69 @@ async function getReadyShardClient(projectName) {
   await ensureShardSchema(client);
   return client;
 }
+function evictLRU() {
+  let oldest = null;
+  let oldestTime = Infinity;
+  for (const [name, time] of _shardLastAccess) {
+    if (time < oldestTime) {
+      oldestTime = time;
+      oldest = name;
+    }
+  }
+  if (oldest) {
+    const client = _shards.get(oldest);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(oldest);
+    _shardLastAccess.delete(oldest);
+  }
+}
+function evictIdleShards() {
+  const now = Date.now();
+  const toEvict = [];
+  for (const [name, lastAccess] of _shardLastAccess) {
+    if (now - lastAccess > SHARD_IDLE_MS) {
+      toEvict.push(name);
+    }
+  }
+  for (const name of toEvict) {
+    const client = _shards.get(name);
+    if (client) {
+      client.close();
+    }
+    _shards.delete(name);
+    _shardLastAccess.delete(name);
+  }
+}
+function getOpenShardCount() {
+  return _shards.size;
+}
 function disposeShards() {
+  if (_evictionTimer) {
+    clearInterval(_evictionTimer);
+    _evictionTimer = null;
+  }
   for (const [, client] of _shards) {
     client.close();
   }
   _shards.clear();
+  _shardLastAccess.clear();
   _shardingEnabled = false;
   _encryptionKey = null;
 }
-var SHARDS_DIR, _shards, _encryptionKey, _shardingEnabled;
+var SHARDS_DIR, SHARD_IDLE_MS, MAX_OPEN_SHARDS, EVICTION_INTERVAL_MS, _shards, _shardLastAccess, _evictionTimer, _encryptionKey, _shardingEnabled;
 var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path7.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path8.join(EXE_AI_DIR, "shards");
+    SHARD_IDLE_MS = 5 * 60 * 1e3;
+    MAX_OPEN_SHARDS = 10;
+    EVICTION_INTERVAL_MS = 60 * 1e3;
     _shards = /* @__PURE__ */ new Map();
+    _shardLastAccess = /* @__PURE__ */ new Map();
+    _evictionTimer = null;
     _encryptionKey = null;
     _shardingEnabled = false;
   }
@@ -4322,8 +4507,8 @@ __export(reranker_exports, {
   rerankWithContext: () => rerankWithContext,
   rerankWithScores: () => rerankWithScores
 });
-import path8 from "path";
-import { existsSync as existsSync7 } from "fs";
+import path9 from "path";
+import { existsSync as existsSync9 } from "fs";
 function resetIdleTimer() {
   if (_idleTimer) clearTimeout(_idleTimer);
   _idleTimer = setTimeout(() => {
@@ -4334,18 +4519,18 @@ function resetIdleTimer() {
   }
 }
 function isRerankerAvailable() {
-  return existsSync7(path8.join(MODELS_DIR, RERANKER_MODEL_FILE));
+  return existsSync9(path9.join(MODELS_DIR, RERANKER_MODEL_FILE));
 }
 function getRerankerModelPath() {
-  return path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  return path9.join(MODELS_DIR, RERANKER_MODEL_FILE);
 }
 async function ensureLoaded() {
   if (_rerankerContext) {
     resetIdleTimer();
     return;
   }
-  const modelPath = path8.join(MODELS_DIR, RERANKER_MODEL_FILE);
-  if (!existsSync7(modelPath)) {
+  const modelPath = path9.join(MODELS_DIR, RERANKER_MODEL_FILE);
+  if (!existsSync9(modelPath)) {
     throw new Error(
       `Reranker model not found at ${modelPath}. Run /exe-setup to download it.`
     );
@@ -4448,7 +4633,7 @@ __export(project_name_exports, {
   getProjectName: () => getProjectName
 });
 import { execSync as execSync2 } from "child_process";
-import path9 from "path";
+import path10 from "path";
 function getProjectName(cwd) {
   const dir = cwd ?? process.cwd();
   if (_cached && _cachedCwd === dir) return _cached;
@@ -4461,7 +4646,7 @@ function getProjectName(cwd) {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path9.dirname(gitCommonDir);
+      repoRoot = path10.dirname(gitCommonDir);
     } catch {
       repoRoot = execSync2("git rev-parse --show-toplevel", {
         cwd: dir,
@@ -4470,11 +4655,11 @@ function getProjectName(cwd) {
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached = path9.basename(repoRoot);
+    _cached = path10.basename(repoRoot);
     _cachedCwd = dir;
     return _cached;
   } catch {
-    _cached = path9.basename(dir);
+    _cached = path10.basename(dir);
     _cachedCwd = dir;
     return _cached;
   }
@@ -4498,9 +4683,9 @@ __export(file_grep_exports, {
   grepProjectFiles: () => grepProjectFiles
 });
 import { execSync as execSync3 } from "child_process";
-import { readFileSync as readFileSync5, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync8 } from "fs";
-import path10 from "path";
-import crypto from "crypto";
+import { readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync2, existsSync as existsSync10 } from "fs";
+import path11 from "path";
+import crypto3 from "crypto";
 function hasRipgrep() {
   if (_hasRg === null) {
     try {
@@ -4533,13 +4718,13 @@ async function grepProjectFiles(query, projectRoot, options) {
     const chunkCtx = getChunkContext(hit.filePath, hit.lineNumber);
     const prefix = chunkCtx ? `[file: ${hit.filePath}:${hit.lineNumber} in ${chunkCtx}]` : `[file: ${hit.filePath}:${hit.lineNumber}]`;
     return {
-      id: crypto.createHash("sha256").update(`${hit.filePath}:${hit.lineNumber}`).digest("hex").slice(0, 36),
+      id: crypto3.createHash("sha256").update(`${hit.filePath}:${hit.lineNumber}`).digest("hex").slice(0, 36),
       agent_id: "project",
       agent_role: "file",
       session_id: "file-grep",
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       tool_name: "file_grep",
-      project_name: path10.basename(projectRoot),
+      project_name: path11.basename(projectRoot),
       has_error: false,
       raw_text: `${prefix} ${buildSnippet(hit, projectRoot)}`,
       vector: null,
@@ -4551,7 +4736,7 @@ function getChunkContext(filePath, lineNumber) {
   try {
     const ext = filePath.split(".").pop()?.toLowerCase();
     if (ext !== "ts" && ext !== "tsx" && ext !== "js" && ext !== "jsx") return "";
-    const source = readFileSync5(filePath, "utf8");
+    const source = readFileSync6(filePath, "utf8");
     const lines = source.split("\n");
     for (let i = Math.min(lineNumber - 1, lines.length - 1); i >= 0; i--) {
       const line = lines[i];
@@ -4613,11 +4798,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 = path10.join(projectRoot, filePath);
+    const absPath = path11.join(projectRoot, filePath);
     try {
       const stat = statSync2(absPath);
       if (stat.size > MAX_FILE_SIZE) continue;
-      const content = readFileSync5(absPath, "utf8");
+      const content = readFileSync6(absPath, "utf8");
       const lines = content.split("\n");
       const matches = content.match(regex);
       if (!matches || matches.length === 0) continue;
@@ -4640,15 +4825,15 @@ function collectFiles(root, patterns) {
   const files = [];
   function walk(dir, relative) {
     if (files.length >= MAX_FILES) return;
-    const basename = path10.basename(dir);
+    const basename = path11.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 = path10.join(relative, entry.name);
+        const rel = path11.join(relative, entry.name);
         if (entry.isDirectory()) {
-          walk(path10.join(dir, entry.name), rel);
+          walk(path11.join(dir, entry.name), rel);
         } else if (entry.isFile()) {
           for (const pat of patterns) {
             if (matchGlob(rel, pat)) {
@@ -4680,7 +4865,7 @@ function matchGlob(filePath, pattern) {
   if (slashIdx !== -1) {
     const dir = pattern.slice(0, slashIdx);
     const ext2 = pattern.slice(slashIdx + 1).replace("*", "");
-    const fileDir = path10.dirname(filePath);
+    const fileDir = path11.dirname(filePath);
     return fileDir === dir && filePath.endsWith(ext2);
   }
   const ext = pattern.replace("*", "");
@@ -4688,9 +4873,9 @@ function matchGlob(filePath, pattern) {
 }
 function buildSnippet(hit, projectRoot) {
   try {
-    const absPath = path10.join(projectRoot, hit.filePath);
-    if (!existsSync8(absPath)) return hit.matchLine;
-    const lines = readFileSync5(absPath, "utf8").split("\n");
+    const absPath = path11.join(projectRoot, hit.filePath);
+    if (!existsSync10(absPath)) return hit.matchLine;
+    const lines = readFileSync6(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);
@@ -5915,9 +6100,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync3, unlinkSync as unlinkSync3, readdirSync as readdirSync3 } from "fs";
 import { execSync as execSync5 } from "child_process";
-import path11 from "path";
+import path12 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -5961,12 +6146,12 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path11.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path12.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
     mkdirSync3(CACHE_DIR, { recursive: true });
-    writeFileSync3(
+    writeFileSync4(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
     );
@@ -5982,7 +6167,7 @@ function clearActiveAgent() {
 function getActiveAgent() {
   try {
     const markerPath = getMarkerPath();
-    const raw = readFileSync6(markerPath, "utf8");
+    const raw = readFileSync7(markerPath, "utf8");
     const data = JSON.parse(raw);
     if (data.agentId) {
       if (data.startedAt) {
@@ -6030,14 +6215,14 @@ function getAllActiveAgents() {
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync6(path11.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync7(path12.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(path11.join(CACHE_DIR, file));
+              unlinkSync3(path12.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -6060,11 +6245,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync3(path11.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync3(path12.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync3(path11.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync3(path12.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -6075,7 +6260,7 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path11.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path12.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -6097,9 +6282,12 @@ __export(license_exports, {
   stopLicenseRevalidation: () => stopLicenseRevalidation,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync4, existsSync as existsSync9, mkdirSync as mkdirSync4 } from "fs";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync5, existsSync as existsSync11, mkdirSync as mkdirSync4 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
-import path12 from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } from "url";
+import os6 from "os";
+import path13 from "path";
 import { jwtVerify, importSPKI } from "jose";
 async function fetchRetry(url, init) {
   try {
@@ -6110,37 +6298,37 @@ async function fetchRetry(url, init) {
   }
 }
 function loadDeviceId() {
-  const deviceJsonPath = path12.join(EXE_AI_DIR, "device.json");
+  const deviceJsonPath = path13.join(EXE_AI_DIR, "device.json");
   try {
-    if (existsSync9(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync7(deviceJsonPath, "utf8"));
+    if (existsSync11(deviceJsonPath)) {
+      const data = JSON.parse(readFileSync8(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
-    if (existsSync9(DEVICE_ID_PATH)) {
-      const id2 = readFileSync7(DEVICE_ID_PATH, "utf8").trim();
+    if (existsSync11(DEVICE_ID_PATH)) {
+      const id2 = readFileSync8(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
   }
   const id = randomUUID3();
   mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(DEVICE_ID_PATH, id, "utf8");
+  writeFileSync5(DEVICE_ID_PATH, id, "utf8");
   return id;
 }
 function loadLicense() {
   try {
-    if (!existsSync9(LICENSE_PATH)) return null;
-    return readFileSync7(LICENSE_PATH, "utf8").trim();
+    if (!existsSync11(LICENSE_PATH)) return null;
+    return readFileSync8(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
 }
 function saveLicense(apiKey) {
   mkdirSync4(EXE_AI_DIR, { recursive: true });
-  writeFileSync4(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
+  writeFileSync5(LICENSE_PATH, apiKey.trim(), { encoding: "utf8", mode: 384 });
 }
 async function verifyLicenseJwt(token) {
   try {
@@ -6166,8 +6354,8 @@ async function verifyLicenseJwt(token) {
 }
 async function getCachedLicense() {
   try {
-    if (!existsSync9(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
+    if (!existsSync11(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -6176,8 +6364,8 @@ async function getCachedLicense() {
 }
 function readCachedToken() {
   try {
-    if (!existsSync9(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync7(CACHE_PATH, "utf8"));
+    if (!existsSync11(CACHE_PATH)) return null;
+    const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -6211,57 +6399,131 @@ function getRawCachedPlan() {
 }
 function cacheResponse(token) {
   try {
-    writeFileSync4(CACHE_PATH, JSON.stringify({ token }), "utf8");
+    writeFileSync5(CACHE_PATH, JSON.stringify({ token }), "utf8");
   } catch {
   }
 }
-async function validateLicense(apiKey, deviceId) {
-  const did = deviceId ?? loadDeviceId();
+function loadPrismaForLicense() {
+  if (_prismaFailed) return null;
+  const dbUrl = process.env.DATABASE_URL;
+  if (!dbUrl) {
+    const exeDbRoot = process.env.EXE_DB_ROOT ?? path13.join(os6.homedir(), "exe-db");
+    if (!existsSync11(path13.join(exeDbRoot, "package.json"))) {
+      _prismaFailed = true;
+      return null;
+    }
+  }
+  if (!_prismaPromise) {
+    _prismaPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod2 = await import(pathToFileURL2(explicitPath).href);
+        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
+        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path13.join(os6.homedir(), "exe-db");
+      const req = createRequire2(path13.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL2(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+      return new Ctor();
+    })().catch((err) => {
+      _prismaFailed = true;
+      _prismaPromise = null;
+      throw err;
+    });
+  }
+  return _prismaPromise;
+}
+async function validateViaPostgres(apiKey) {
+  const loader = loadPrismaForLicense();
+  if (!loader) return null;
+  try {
+    const prisma = await loader;
+    const rows = await prisma.$queryRawUnsafe(
+      `SELECT plan, email, status, device_limit, employee_limit, memory_limit, expires_at
+       FROM billing.licenses WHERE key = $1 LIMIT 1`,
+      apiKey
+    );
+    if (!rows || rows.length === 0) return null;
+    const row = rows[0];
+    if (row.status !== "active") return null;
+    if (row.expires_at && new Date(row.expires_at) < /* @__PURE__ */ new Date()) return null;
+    const plan = row.plan;
+    const limits = PLAN_LIMITS[plan] ?? PLAN_LIMITS.free;
+    return {
+      valid: true,
+      plan,
+      email: row.email,
+      expiresAt: row.expires_at ? new Date(row.expires_at).toISOString() : null,
+      deviceLimit: row.device_limit ?? limits.devices,
+      employeeLimit: row.employee_limit ?? limits.employees,
+      memoryLimit: row.memory_limit ?? limits.memories
+    };
+  } catch {
+    return null;
+  }
+}
+async function validateViaCFWorker(apiKey, deviceId) {
   try {
     const res = await fetchRetry(`${API_BASE}/auth/activate`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ apiKey, deviceId: did }),
+      body: JSON.stringify({ apiKey, deviceId }),
       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
-      };
+    if (!res.ok) return null;
+    const data = await res.json();
+    if (data.error === "device_limit_exceeded") return null;
+    if (!data.valid) return null;
+    if (data.token) {
+      cacheResponse(data.token);
+      const verified = await verifyLicenseJwt(data.token);
+      if (verified) return verified;
     }
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    const raw = getRawCachedPlan();
-    if (raw) return raw;
-    return { ...FREE_LICENSE, valid: false, plan: "free" };
+    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
+    };
   } catch {
-    const cached = await getCachedLicense();
-    if (cached) return cached;
-    const rawFallback = getRawCachedPlan();
-    if (rawFallback) return rawFallback;
-    return { ...FREE_LICENSE, valid: false, error: "offline" };
+    return null;
   }
 }
+async function validateLicense(apiKey, deviceId) {
+  const did = deviceId ?? loadDeviceId();
+  const pgResult = await validateViaPostgres(apiKey);
+  if (pgResult) {
+    try {
+      writeFileSync5(CACHE_PATH, JSON.stringify({ pgLicense: pgResult, ts: Date.now() }), "utf8");
+    } catch {
+    }
+    return pgResult;
+  }
+  const cfResult = await validateViaCFWorker(apiKey, did);
+  if (cfResult) return cfResult;
+  const cached = await getCachedLicense();
+  if (cached) return cached;
+  try {
+    if (existsSync11(CACHE_PATH)) {
+      const raw = JSON.parse(readFileSync8(CACHE_PATH, "utf8"));
+      if (raw.pgLicense && raw.ts && Date.now() - raw.ts < 7 * 24 * 60 * 60 * 1e3) {
+        return raw.pgLicense;
+      }
+    }
+  } catch {
+  }
+  const rawFallback = getRawCachedPlan();
+  if (rawFallback) return rawFallback;
+  return { ...FREE_LICENSE, valid: false };
+}
 function getCacheAgeMs() {
   try {
     const { statSync: statSync4 } = __require("fs");
@@ -6275,9 +6537,9 @@ async function checkLicense() {
   let key = loadLicense();
   if (!key) {
     try {
-      const configPath = path12.join(EXE_AI_DIR, "config.json");
-      if (existsSync9(configPath)) {
-        const raw = JSON.parse(readFileSync7(configPath, "utf8"));
+      const configPath = path13.join(EXE_AI_DIR, "config.json");
+      if (existsSync11(configPath)) {
+        const raw = JSON.parse(readFileSync8(configPath, "utf8"));
         const cloud = raw.cloud;
         if (cloud?.apiKey) {
           key = cloud.apiKey;
@@ -6431,14 +6693,14 @@ function stopLicenseRevalidation() {
     _revalTimer = null;
   }
 }
-var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, CACHE_MAX_AGE_MS, _revalTimer;
+var LICENSE_PATH, CACHE_PATH, DEVICE_ID_PATH, API_BASE, RETRY_DELAY_MS, LICENSE_PUBLIC_KEY_PEM, LICENSE_JWT_ALG, PLAN_LIMITS, FREE_LICENSE, _prismaPromise, _prismaFailed, CACHE_MAX_AGE_MS, _revalTimer;
 var init_license = __esm({
   "src/lib/license.ts"() {
     "use strict";
     init_config();
-    LICENSE_PATH = path12.join(EXE_AI_DIR, "license.key");
-    CACHE_PATH = path12.join(EXE_AI_DIR, "license-cache.json");
-    DEVICE_ID_PATH = path12.join(EXE_AI_DIR, "device-id");
+    LICENSE_PATH = path13.join(EXE_AI_DIR, "license.key");
+    CACHE_PATH = path13.join(EXE_AI_DIR, "license-cache.json");
+    DEVICE_ID_PATH = path13.join(EXE_AI_DIR, "device-id");
     API_BASE = "https://askexe.com/cloud";
     RETRY_DELAY_MS = 500;
     LICENSE_PUBLIC_KEY_PEM = `-----BEGIN PUBLIC KEY-----
@@ -6462,6 +6724,8 @@ MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAEeHztAMOpR/ZMh+rWuOASjEZ54CGY
       employeeLimit: 1,
       memoryLimit: 5e3
     };
+    _prismaPromise = null;
+    _prismaFailed = false;
     CACHE_MAX_AGE_MS = 36e5;
     _revalTimer = null;
   }
@@ -6478,12 +6742,12 @@ __export(plan_limits_exports, {
   countActiveMemories: () => countActiveMemories,
   getLicenseSync: () => getLicenseSync
 });
-import { readFileSync as readFileSync8, existsSync as existsSync10 } from "fs";
-import path13 from "path";
+import { readFileSync as readFileSync9, existsSync as existsSync12 } from "fs";
+import path14 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync10(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync8(CACHE_PATH2, "utf8"));
+    if (!existsSync12(CACHE_PATH2)) return freeLicense();
+    const raw = JSON.parse(readFileSync9(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -6550,8 +6814,8 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync10(filePath)) {
-      const raw = readFileSync8(filePath, "utf8");
+    if (existsSync12(filePath)) {
+      const raw = readFileSync9(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -6588,69 +6852,17 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path13.join(EXE_AI_DIR, "license-cache.json");
-  }
-});
-
-// src/lib/notifications.ts
-import crypto4 from "crypto";
-import path16 from "path";
-import os6 from "os";
-import {
-  readFileSync as readFileSync9,
-  readdirSync as readdirSync4,
-  unlinkSync as unlinkSync4,
-  existsSync as existsSync11,
-  rmdirSync
-} from "fs";
-async function writeNotification(notification) {
-  try {
-    const client = getClient();
-    const id = crypto4.randomUUID();
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    await client.execute({
-      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, read, created_at)
-            VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?)`,
-      args: [
-        id,
-        notification.agentId,
-        notification.agentRole,
-        notification.event,
-        notification.project,
-        notification.summary,
-        notification.taskFile ?? null,
-        now
-      ]
-    });
-  } catch (err) {
-    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
-`);
-  }
-}
-async function markAsReadByTaskFile(taskFile) {
-  try {
-    const client = getClient();
-    await client.execute({
-      sql: "UPDATE notifications SET read = 1 WHERE task_file = ? AND read = 0",
-      args: [taskFile]
-    });
-  } catch {
-  }
-}
-var init_notifications = __esm({
-  "src/lib/notifications.ts"() {
-    "use strict";
-    init_database();
+    CACHE_PATH2 = path14.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
 // src/lib/session-registry.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync7, mkdirSync as mkdirSync5, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, mkdirSync as mkdirSync5, existsSync as existsSync13 } from "fs";
 import path17 from "path";
 import os7 from "os";
 function registerSession(entry) {
   const dir = path17.dirname(REGISTRY_PATH);
-  if (!existsSync12(dir)) {
+  if (!existsSync13(dir)) {
     mkdirSync5(dir, { recursive: true });
   }
   const sessions = listSessions();
@@ -6660,7 +6872,7 @@ function registerSession(entry) {
   } else {
     sessions.push(entry);
   }
-  writeFileSync7(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
+  writeFileSync8(REGISTRY_PATH, JSON.stringify(sessions, null, 2));
 }
 function listSessions() {
   try {
@@ -6867,16 +7079,16 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, renameSync as renameSync3, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync9, renameSync as renameSync3, existsSync as existsSync14, mkdirSync as mkdirSync6 } from "fs";
 import path18 from "path";
 import os8 from "os";
 function ensureDir() {
   const dir = path18.dirname(QUEUE_PATH);
-  if (!existsSync13(dir)) mkdirSync6(dir, { recursive: true });
+  if (!existsSync14(dir)) mkdirSync6(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync13(QUEUE_PATH)) return [];
+    if (!existsSync14(QUEUE_PATH)) return [];
     return JSON.parse(readFileSync11(QUEUE_PATH, "utf8"));
   } catch {
     return [];
@@ -6885,7 +7097,7 @@ function readQueue() {
 function writeQueue(queue) {
   ensureDir();
   const tmp = `${QUEUE_PATH}.tmp`;
-  writeFileSync8(tmp, JSON.stringify(queue, null, 2));
+  writeFileSync9(tmp, JSON.stringify(queue, null, 2));
   renameSync3(tmp, QUEUE_PATH);
 }
 function queueIntercom(targetSession, reason) {
@@ -6985,7 +7197,7 @@ var init_intercom_queue = __esm({
 });
 
 // src/lib/session-kill-telemetry.ts
-import crypto5 from "crypto";
+import crypto6 from "crypto";
 async function recordSessionKill(input) {
   try {
     const client = getClient();
@@ -6995,7 +7207,7 @@ async function recordSessionKill(input) {
                ticks_idle, estimated_tokens_saved)
             VALUES (?, ?, ?, ?, ?, ?, ?)`,
       args: [
-        crypto5.randomUUID(),
+        crypto6.randomUUID(),
         input.sessionName,
         input.agentId,
         (/* @__PURE__ */ new Date()).toISOString(),
@@ -7348,6 +7560,7 @@ __export(tmux_routing_exports, {
   isEmployeeAlive: () => isEmployeeAlive,
   isExeSession: () => isExeSession,
   isSessionBusy: () => isSessionBusy,
+  notifyCoordinatorTaskCompletion: () => notifyCoordinatorTaskCompletion,
   notifyParentExe: () => notifyParentExe,
   parseParentExe: () => parseParentExe,
   registerParentExe: () => registerParentExe,
@@ -7358,11 +7571,11 @@ __export(tmux_routing_exports, {
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
 import { execFileSync as execFileSync2, execSync as execSync7 } from "child_process";
-import { readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7, existsSync as existsSync14, appendFileSync, readdirSync as readdirSync5 } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync10, mkdirSync as mkdirSync7, existsSync as existsSync15, appendFileSync, readdirSync as readdirSync4 } from "fs";
 import path19 from "path";
 import os9 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import { unlinkSync as unlinkSync5 } from "fs";
+import { unlinkSync as unlinkSync4 } from "fs";
 function spawnLockPath(sessionName) {
   return path19.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
@@ -7375,11 +7588,11 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync14(SPAWN_LOCK_DIR)) {
+  if (!existsSync15(SPAWN_LOCK_DIR)) {
     mkdirSync7(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync14(lockFile)) {
+  if (existsSync15(lockFile)) {
     try {
       const lock = JSON.parse(readFileSync12(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
@@ -7389,12 +7602,12 @@ function acquireSpawnLock2(sessionName) {
     } catch {
     }
   }
-  writeFileSync9(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
+  writeFileSync10(lockFile, JSON.stringify({ pid: process.pid, timestamp: Date.now() }));
   return true;
 }
 function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync5(spawnLockPath(sessionName));
+    unlinkSync4(spawnLockPath(sessionName));
   } catch {
   }
 }
@@ -7407,7 +7620,7 @@ function resolveBehaviorsExporterScript() {
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync14(scriptPath) ? scriptPath : null;
+    return existsSync15(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -7473,12 +7686,12 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync14(SESSION_CACHE)) {
+  if (!existsSync15(SESSION_CACHE)) {
     mkdirSync7(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
   const filePath = path19.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
-  writeFileSync9(filePath, JSON.stringify({
+  writeFileSync10(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
     registeredAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -7565,7 +7778,7 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync14(DEBOUNCE_FILE)) return {};
+    if (!existsSync15(DEBOUNCE_FILE)) return {};
     const raw = JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
@@ -7582,8 +7795,8 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync14(SESSION_CACHE)) mkdirSync7(SESSION_CACHE, { recursive: true });
-    writeFileSync9(DEBOUNCE_FILE, JSON.stringify(state));
+    if (!existsSync15(SESSION_CACHE)) mkdirSync7(SESSION_CACHE, { recursive: true });
+    writeFileSync10(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
 }
@@ -7682,7 +7895,7 @@ function sendIntercom(targetSession) {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
       const markerPath = path19.join(SESSION_CACHE, `current-task-${agent}.json`);
-      if (existsSync14(markerPath)) {
+      if (existsSync15(markerPath)) {
         logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker \u2014 will auto-chain)`);
         return "debounced";
       }
@@ -7692,8 +7905,8 @@ function sendIntercom(targetSession) {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
       const taskDir = path19.join(process.cwd(), "exe", agent);
-      if (existsSync14(taskDir)) {
-        const files = readdirSync5(taskDir).filter(
+      if (existsSync15(taskDir)) {
+        const files = readdirSync4(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
         );
         if (files.length === 0) {
@@ -7752,6 +7965,21 @@ function notifyParentExe(sessionKey) {
   }
   return true;
 }
+function notifyCoordinatorTaskCompletion(coordinatorSession, agentName, taskTitle) {
+  const transport = getTransport();
+  try {
+    const sessions = transport.listSessions();
+    if (!sessions.includes(coordinatorSession)) return false;
+    execSync7(
+      `tmux send-keys -t ${JSON.stringify(coordinatorSession)} '/exe-intercom' Enter`,
+      { timeout: 3e3 }
+    );
+    logIntercom(`COMPLETION \u2192 ${coordinatorSession} (${agentName} completed "${taskTitle.slice(0, 50)}")`);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function ensureEmployee(employeeName, exeSession, projectDir, opts) {
   if (isCoordinatorName(employeeName)) {
     return { status: "failed", sessionName: "", error: "The COO is not a dispatchable employee" };
@@ -7827,7 +8055,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
   const logDir = path19.join(os9.homedir(), ".exe-os", "session-logs");
   const logFile = path19.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync14(logDir)) {
+  if (!existsSync15(logDir)) {
     mkdirSync7(logDir, { recursive: true });
   }
   transport.kill(sessionName);
@@ -7835,7 +8063,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   try {
     const thisFile = fileURLToPath2(import.meta.url);
     const cleanupScript = path19.join(path19.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync14(cleanupScript)) {
+    if (existsSync15(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
@@ -7852,7 +8080,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const trustDir = opts?.cwd ?? projectDir;
     if (!projects[trustDir]) projects[trustDir] = {};
     projects[trustDir].hasTrustDialogAccepted = true;
-    writeFileSync9(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
+    writeFileSync10(claudeJsonPath, JSON.stringify(claudeJson, null, 2) + "\n");
   } catch {
   }
   try {
@@ -7891,7 +8119,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       perms.allow = allow;
       settings.permissions = perms;
       mkdirSync7(projSettingsDir, { recursive: true });
-      writeFileSync9(settingsPath, JSON.stringify(settings, null, 2) + "\n");
+      writeFileSync10(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
   }
@@ -7916,7 +8144,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync14(identityPath2)) {
+    } else if (existsSync15(identityPath2)) {
       identityFlag = ` --append-system-prompt-file ${identityPath2}`;
       legacyFallbackWarned = true;
     }
@@ -7946,7 +8174,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
       `Your parent coordinator session is ${exeSession}.`,
       `Your employees (if any) use the -${exeSession} suffix.`
     ].join("\n");
-    writeFileSync9(ctxFile, ctxContent);
+    writeFileSync10(ctxFile, ctxContent);
     sessionContextFlag = ` --append-system-prompt-file ${ctxFile}`;
   } catch {
   }
@@ -8024,7 +8252,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   try {
     const mySession = getMySession();
     const dispatchInfo = path19.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
-    writeFileSync9(dispatchInfo, JSON.stringify({
+    writeFileSync10(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
       provider: useBinSymlink ? ccProvider : useExeAgent ? opts.provider : useCodex ? "openai" : useOpencode ? "opencode" : "anthropic",
@@ -8129,6 +8357,15 @@ function sessionScopeFilter(sessionScope, tableAlias) {
     args: [scope]
   };
 }
+function strictSessionScopeFilter(sessionScope, tableAlias) {
+  const scope = sessionScope !== void 0 ? sessionScope : getCurrentSessionScope();
+  if (!scope) return { sql: "", args: [] };
+  const col = tableAlias ? `${tableAlias}.session_scope` : "session_scope";
+  return {
+    sql: ` AND ${col} = ?`,
+    args: [scope]
+  };
+}
 var init_task_scope = __esm({
   "src/lib/task-scope.ts"() {
     "use strict";
@@ -8136,6 +8373,125 @@ var init_task_scope = __esm({
   }
 });
 
+// src/lib/notifications.ts
+import crypto7 from "crypto";
+import path20 from "path";
+import os10 from "os";
+import {
+  readFileSync as readFileSync13,
+  readdirSync as readdirSync5,
+  unlinkSync as unlinkSync5,
+  existsSync as existsSync16,
+  rmdirSync
+} from "fs";
+async function writeNotification(notification) {
+  try {
+    const client = getClient();
+    const id = crypto7.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const sessionScope = notification.sessionScope === void 0 ? getCurrentSessionScope() : notification.sessionScope;
+    await client.execute({
+      sql: `INSERT INTO notifications (id, agent_id, agent_role, event, project, summary, task_file, session_scope, read, created_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, 0, ?)`,
+      args: [
+        id,
+        notification.agentId,
+        notification.agentRole,
+        notification.event,
+        notification.project,
+        notification.summary,
+        notification.taskFile ?? null,
+        sessionScope,
+        now
+      ]
+    });
+  } catch (err) {
+    process.stderr.write(`[notifications] WRITE FAILED: ${err instanceof Error ? err.message : String(err)}
+`);
+  }
+}
+async function markAsReadByTaskFile(taskFile, sessionScope) {
+  try {
+    const client = getClient();
+    const scope = strictSessionScopeFilter(sessionScope);
+    await client.execute({
+      sql: `UPDATE notifications SET read = 1
+            WHERE task_file = ? AND read = 0${scope.sql}`,
+      args: [taskFile, ...scope.args]
+    });
+  } catch {
+  }
+}
+var init_notifications = __esm({
+  "src/lib/notifications.ts"() {
+    "use strict";
+    init_database();
+    init_task_scope();
+  }
+});
+
+// src/lib/session-scope.ts
+var session_scope_exports = {};
+__export(session_scope_exports, {
+  assertSessionScope: () => assertSessionScope,
+  findSessionForProject: () => findSessionForProject,
+  getSessionProject: () => getSessionProject
+});
+function getSessionProject(sessionName) {
+  const sessions = listSessions();
+  const entry = sessions.find((s) => s.windowName === sessionName);
+  if (!entry) return null;
+  const parts = entry.projectDir.split("/").filter(Boolean);
+  return parts[parts.length - 1] ?? null;
+}
+function findSessionForProject(projectName) {
+  const sessions = listSessions();
+  for (const s of sessions) {
+    const proj = s.projectDir.split("/").filter(Boolean).pop();
+    if (proj === projectName && isCoordinatorName(s.agentId)) return s;
+  }
+  return null;
+}
+function assertSessionScope(actionType, targetProject) {
+  try {
+    const currentProject = getProjectName();
+    const exeSession = resolveExeSession();
+    if (!exeSession) {
+      return { allowed: true, reason: "no_session" };
+    }
+    if (currentProject === targetProject) {
+      return {
+        allowed: true,
+        reason: "same_session",
+        currentProject,
+        targetProject
+      };
+    }
+    process.stderr.write(
+      `[session-scope] BLOCKED cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
+`
+    );
+    return {
+      allowed: false,
+      reason: "cross_session_denied",
+      currentProject,
+      targetProject,
+      targetSession: findSessionForProject(targetProject)?.windowName
+    };
+  } catch {
+    return { allowed: true, reason: "no_session" };
+  }
+}
+var init_session_scope = __esm({
+  "src/lib/session-scope.ts"() {
+    "use strict";
+    init_session_registry();
+    init_project_name();
+    init_tmux_routing();
+    init_employees();
+  }
+});
+
 // src/lib/tasks-crud.ts
 var tasks_crud_exports = {};
 __export(tasks_crud_exports, {
@@ -8153,12 +8509,12 @@ __export(tasks_crud_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import crypto6 from "crypto";
-import path20 from "path";
-import os10 from "os";
+import crypto8 from "crypto";
+import path21 from "path";
+import os11 from "os";
 import { execSync as execSync8 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync15, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -8274,13 +8630,28 @@ async function resolveTask(client, identifier, scopeSession) {
 }
 async function createTaskCore(input) {
   const client = getClient();
-  const id = crypto6.randomUUID();
+  const id = crypto8.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const slug = slugify(input.title);
   let earlySessionScope = null;
+  let scopeMismatchWarning;
   try {
     const { resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
-    earlySessionScope = resolveExeSession2();
+    const resolved = resolveExeSession2();
+    if (resolved && input.projectName) {
+      const { getSessionProject: getSessionProject2 } = await Promise.resolve().then(() => (init_session_scope(), session_scope_exports));
+      const sessionProject = getSessionProject2(resolved);
+      if (sessionProject && sessionProject !== input.projectName) {
+        scopeMismatchWarning = `session/project mismatch: session "${resolved}" owns "${sessionProject}" but task targets "${input.projectName}". Routed to default scope.`;
+        process.stderr.write(`[create_task] ${scopeMismatchWarning}
+`);
+        earlySessionScope = null;
+      } else {
+        earlySessionScope = resolved;
+      }
+    } else {
+      earlySessionScope = resolved;
+    }
   } catch {
   }
   const scope = earlySessionScope ?? "default";
@@ -8331,10 +8702,14 @@ async function createTaskCore(input) {
 ${laneWarning}` : laneWarning;
     }
   }
+  if (scopeMismatchWarning) {
+    warning = warning ? `${warning}
+${scopeMismatchWarning}` : scopeMismatchWarning;
+  }
   if (input.baseDir) {
     try {
-      await mkdir4(path20.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir4(path20.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir4(path21.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir4(path21.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -8370,13 +8745,19 @@ ${laneWarning}` : laneWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path20.join(os10.homedir(), ".exe-os");
-      const mdPath = path20.join(EXE_OS_DIR, taskFile);
-      const mdDir = path20.dirname(mdPath);
-      if (!existsSync15(mdDir)) await mkdir4(mdDir, { recursive: true });
+      const EXE_OS_DIR = path21.join(os11.homedir(), ".exe-os");
+      const mdPath = path21.join(EXE_OS_DIR, taskFile);
+      const mdDir = path21.dirname(mdPath);
+      if (!existsSync17(mdDir)) await mkdir4(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
 
+## MANDATORY: When done
+
+You MUST call update_task with status "done" and a result summary when finished.
+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).
+
 **ID:** ${id}
 **Status:** ${initialStatus}
 **Priority:** ${input.priority}
@@ -8390,12 +8771,6 @@ ${laneWarning}` : laneWarning;
 ## Context
 
 ${input.context}
-
-## MANDATORY: When done
-
-You MUST call update_task with status "done" and a result summary when finished.
-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).
 `;
       await writeFile4(mdPath, mdContent, "utf-8");
     } catch (err) {
@@ -8644,7 +9019,7 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
     await client.execute("PRAGMA wal_checkpoint(PASSIVE)");
   } catch {
   }
-  if (input.status === "done" || input.status === "cancelled") {
+  if (input.status === "done" || input.status === "cancelled" || input.status === "closed") {
     try {
       const { clearQueueForAgent: clearQueueForAgent2 } = await Promise.resolve().then(() => (init_intercom_queue(), intercom_queue_exports));
       clearQueueForAgent2(String(row.assigned_to));
@@ -8673,9 +9048,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path20.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path21.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync15(archPath)) return;
+    if (existsSync17(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -8708,10 +9083,10 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path20.join(baseDir, ".gitignore");
+  const gitignorePath = path21.join(baseDir, ".gitignore");
   try {
-    if (existsSync15(gitignorePath)) {
-      const content = readFileSync13(gitignorePath, "utf-8");
+    if (existsSync17(gitignorePath)) {
+      const content = readFileSync14(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -8742,58 +9117,42 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/tasks-review.ts
-import path21 from "path";
-import { existsSync as existsSync16, readdirSync as readdirSync6, unlinkSync as unlinkSync6 } from "fs";
+import path22 from "path";
+import { existsSync as existsSync18, readdirSync as readdirSync6, unlinkSync as unlinkSync6 } from "fs";
 async function countPendingReviews(sessionScope) {
   const client = getClient();
-  if (sessionScope) {
-    const result2 = await client.execute({
-      sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review' AND session_scope = ?",
-      args: [sessionScope]
-    });
-    return Number(result2.rows[0]?.cnt) || 0;
-  }
+  const scope = strictSessionScopeFilter(
+    sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
+  );
   const result = await client.execute({
-    sql: "SELECT COUNT(*) as cnt FROM tasks WHERE status = 'needs_review'",
-    args: []
+    sql: `SELECT COUNT(*) as cnt FROM tasks
+          WHERE status = 'needs_review'${scope.sql}`,
+    args: [...scope.args]
   });
   return Number(result.rows[0]?.cnt) || 0;
 }
 async function countNewPendingReviewsSince(sinceIso, sessionScope) {
   const client = getClient();
-  if (sessionScope) {
-    const result2 = await client.execute({
-      sql: `SELECT COUNT(*) as cnt FROM tasks
-            WHERE status = 'needs_review' AND updated_at > ?
-              AND session_scope = ?`,
-      args: [sinceIso, sessionScope]
-    });
-    return Number(result2.rows[0]?.cnt) || 0;
-  }
+  const scope = strictSessionScopeFilter(
+    sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
+  );
   const result = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM tasks
-          WHERE status = 'needs_review' AND updated_at > ?`,
-    args: [sinceIso]
+          WHERE status = 'needs_review' AND updated_at > ?${scope.sql}`,
+    args: [sinceIso, ...scope.args]
   });
   return Number(result.rows[0]?.cnt) || 0;
 }
 async function listPendingReviews(limit, sessionScope) {
   const client = getClient();
-  if (sessionScope) {
-    const result2 = await client.execute({
-      sql: `SELECT title, assigned_to, project_name, updated_at FROM tasks
-            WHERE status = 'needs_review'
-              AND session_scope = ?
-            ORDER BY updated_at ASC LIMIT ?`,
-      args: [sessionScope, limit]
-    });
-    return result2.rows;
-  }
+  const scope = strictSessionScopeFilter(
+    sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
+  );
   const result = await client.execute({
     sql: `SELECT title, assigned_to, project_name, updated_at FROM tasks
-          WHERE status = 'needs_review'
+          WHERE status = 'needs_review'${scope.sql}
           ORDER BY updated_at ASC LIMIT ?`,
-    args: [limit]
+    args: [...scope.args, limit]
   });
   return result.rows;
 }
@@ -8805,7 +9164,7 @@ async function cleanupOrphanedReviews() {
           WHERE status IN ('open', 'needs_review', 'in_progress')
           AND assigned_by = 'system'
           AND title LIKE 'Review:%'
-          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled'))`,
+          AND parent_task_id IN (SELECT id FROM tasks WHERE status IN ('done', 'cancelled', 'closed'))`,
     args: [now]
   });
   const r1b = await client.execute({
@@ -8924,11 +9283,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path21.join(EXE_AI_DIR, "session-cache");
-    if (existsSync16(cacheDir)) {
+    const cacheDir = path22.join(EXE_AI_DIR, "session-cache");
+    if (existsSync18(cacheDir)) {
       for (const f of readdirSync6(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path21.join(cacheDir, f));
+          unlinkSync6(path22.join(cacheDir, f));
         }
       }
     }
@@ -8945,11 +9304,12 @@ var init_tasks_review = __esm({
     init_tmux_routing();
     init_session_key();
     init_state_bus();
+    init_task_scope();
   }
 });
 
 // src/lib/tasks-chain.ts
-import path22 from "path";
+import path23 from "path";
 import { readFile as readFile4, writeFile as writeFile5 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -8966,7 +9326,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path22.join(baseDir, String(ur.task_file));
+        const ubFile = path23.join(baseDir, String(ur.task_file));
         let ubContent = await readFile4(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -9001,7 +9361,7 @@ async function checkSubtaskCompletion(parentTaskId, projectName) {
   const scScope = sessionScopeFilter();
   const remaining = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM tasks
-          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled')${scScope.sql}`,
+          WHERE parent_task_id = ? AND status NOT IN ('done', 'cancelled', 'closed')${scScope.sql}`,
     args: [parentTaskId, ...scScope.args]
   });
   const cnt = Number(remaining.rows[0]?.cnt ?? 1);
@@ -9033,68 +9393,6 @@ var init_tasks_chain = __esm({
   }
 });
 
-// src/lib/session-scope.ts
-var session_scope_exports = {};
-__export(session_scope_exports, {
-  assertSessionScope: () => assertSessionScope,
-  findSessionForProject: () => findSessionForProject,
-  getSessionProject: () => getSessionProject
-});
-function getSessionProject(sessionName) {
-  const sessions = listSessions();
-  const entry = sessions.find((s) => s.windowName === sessionName);
-  if (!entry) return null;
-  const parts = entry.projectDir.split("/").filter(Boolean);
-  return parts[parts.length - 1] ?? null;
-}
-function findSessionForProject(projectName) {
-  const sessions = listSessions();
-  for (const s of sessions) {
-    const proj = s.projectDir.split("/").filter(Boolean).pop();
-    if (proj === projectName && isCoordinatorName(s.agentId)) return s;
-  }
-  return null;
-}
-function assertSessionScope(actionType, targetProject) {
-  try {
-    const currentProject = getProjectName();
-    const exeSession = resolveExeSession();
-    if (!exeSession) {
-      return { allowed: true, reason: "no_session" };
-    }
-    if (currentProject === targetProject) {
-      return {
-        allowed: true,
-        reason: "same_session",
-        currentProject,
-        targetProject
-      };
-    }
-    process.stderr.write(
-      `[session-scope] BLOCKED cross-project ${actionType}: session project="${currentProject}" \u2260 target project="${targetProject}"
-`
-    );
-    return {
-      allowed: false,
-      reason: "cross_session_denied",
-      currentProject,
-      targetProject,
-      targetSession: findSessionForProject(targetProject)?.windowName
-    };
-  } catch {
-    return { allowed: true, reason: "no_session" };
-  }
-}
-var init_session_scope = __esm({
-  "src/lib/session-scope.ts"() {
-    "use strict";
-    init_session_registry();
-    init_project_name();
-    init_tmux_routing();
-    init_employees();
-  }
-});
-
 // src/lib/tasks-notify.ts
 async function dispatchTaskToEmployee(input) {
   if (isCoordinatorName(input.assignedTo)) return { dispatched: "skipped" };
@@ -9162,10 +9460,10 @@ var init_tasks_notify = __esm({
 });
 
 // src/lib/behaviors.ts
-import crypto7 from "crypto";
+import crypto9 from "crypto";
 async function storeBehavior(opts) {
   const client = getClient();
-  const id = crypto7.randomUUID();
+  const id = crypto9.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await client.execute({
     sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
@@ -9222,7 +9520,7 @@ __export(skill_learning_exports, {
   storeTrajectory: () => storeTrajectory,
   sweepTrajectories: () => sweepTrajectories
 });
-import crypto8 from "crypto";
+import crypto10 from "crypto";
 async function extractTrajectory(taskId, agentId) {
   const client = getClient();
   const result = await client.execute({
@@ -9251,11 +9549,11 @@ async function extractTrajectory(taskId, agentId) {
   return signature;
 }
 function hashSignature(signature) {
-  return crypto8.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+  return crypto10.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
 }
 async function storeTrajectory(opts) {
   const client = getClient();
-  const id = crypto8.randomUUID();
+  const id = crypto10.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const signatureHash = hashSignature(opts.signature);
   await client.execute({
@@ -9520,8 +9818,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path23 from "path";
-import { writeFileSync as writeFileSync10, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7 } from "fs";
+import path24 from "path";
+import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync8, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -9540,12 +9838,12 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path23.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path23.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path24.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path24.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
       mkdirSync8(cacheDir, { recursive: true });
-      writeFileSync10(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
-    } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled") {
+      writeFileSync11(cachePath, JSON.stringify({ taskId, title: String(row.title) }));
+    } else if (input.status === "done" || input.status === "blocked" || input.status === "cancelled" || input.status === "closed") {
       try {
         unlinkSync7(cachePath);
       } catch {
@@ -9553,10 +9851,10 @@ async function updateTask(input) {
     }
   } catch {
   }
-  if (input.status === "done") {
+  if (input.status === "done" || input.status === "closed") {
     await cleanupReviewFile(row, taskFile, input.baseDir);
   }
-  if (input.status === "done" || input.status === "cancelled") {
+  if (input.status === "done" || input.status === "cancelled" || input.status === "closed") {
     try {
       const client = getClient();
       const taskTitle = String(row.title);
@@ -9572,7 +9870,7 @@ async function updateTask(input) {
     if (!isCoordinatorName(assignedAgent)) {
       try {
         const draftClient = getClient();
-        if (input.status === "done") {
+        if (input.status === "done" || input.status === "closed") {
           await draftClient.execute({
             sql: `UPDATE memories SET draft = 0 WHERE agent_id = ? AND draft = 1`,
             args: [assignedAgent]
@@ -9589,7 +9887,7 @@ async function updateTask(input) {
     try {
       const client = getClient();
       const cascaded = await client.execute({
-        sql: `UPDATE tasks SET status = 'done', updated_at = ?
+        sql: `UPDATE tasks SET status = 'closed', updated_at = ?
               WHERE parent_task_id = ? AND status = 'needs_review'`,
         args: [now, taskId]
       });
@@ -9602,14 +9900,14 @@ async function updateTask(input) {
     } catch {
     }
   }
-  const isTerminal = input.status === "done" || input.status === "needs_review";
+  const isTerminal = input.status === "done" || input.status === "needs_review" || input.status === "closed";
   if (isTerminal) {
     const isCoordinator = isCoordinatorName(String(row.assigned_to));
     if (!isCoordinator) {
       notifyTaskDone();
     }
     await markTaskNotificationsRead(taskFile);
-    if (input.status === "done") {
+    if (input.status === "done" || input.status === "closed") {
       try {
         await cascadeUnblock(taskId, input.baseDir, now);
       } catch {
@@ -9629,7 +9927,7 @@ async function updateTask(input) {
       }
     }
   }
-  if (input.status === "done" && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
+  if ((input.status === "done" || input.status === "closed") && !isCoordinatorName(String(row.assigned_to)) && !process.env.VITEST) {
     Promise.resolve().then(() => (init_skill_learning(), skill_learning_exports)).then(
       ({ captureAndLearn: captureAndLearn2 }) => captureAndLearn2({
         taskId,
@@ -9710,17 +10008,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync17, mkdirSync as mkdirSync9, readFileSync as readFileSync14, writeFileSync as writeFileSync11 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync9, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "fs";
 import { readdirSync as readdirSync7 } from "fs";
-import path24 from "path";
+import path25 from "path";
 import { createHash as createHash2 } from "crypto";
 function ensureDir2() {
-  if (!existsSync17(IDENTITY_DIR2)) {
+  if (!existsSync19(IDENTITY_DIR2)) {
     mkdirSync9(IDENTITY_DIR2, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path24.join(IDENTITY_DIR2, `${agentId}.md`);
+  return path25.join(IDENTITY_DIR2, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -9761,8 +10059,8 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync17(filePath)) return null;
-  const raw = readFileSync14(filePath, "utf-8");
+  if (!existsSync19(filePath)) return null;
+  const raw = readFileSync15(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -9776,7 +10074,7 @@ async function updateIdentity(agentId, content, updatedBy) {
   ensureDir2();
   const filePath = identityPath(agentId);
   const hash = contentHash(content);
-  writeFileSync11(filePath, content, "utf-8");
+  writeFileSync12(filePath, content, "utf-8");
   try {
     const client = getClient();
     await client.execute({
@@ -9832,7 +10130,7 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR2 = path24.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR2 = path25.join(EXE_AI_DIR, "identity");
   }
 });
 
@@ -10378,10 +10676,10 @@ ${PLAN_MODE_COMPAT}
 });
 
 // src/lib/messaging.ts
-import crypto9 from "crypto";
+import crypto11 from "crypto";
 function generateUlid() {
   const timestamp = Date.now().toString(36).padStart(10, "0");
-  const random = crypto9.randomBytes(10).toString("hex").slice(0, 16);
+  const random = crypto11.randomBytes(10).toString("hex").slice(0, 16);
   return (timestamp + random).toUpperCase();
 }
 function rowToMessage(row) {
@@ -10392,6 +10690,7 @@ function rowToMessage(row) {
     targetAgent: row.target_agent,
     targetProject: row.target_project ?? null,
     targetDevice: row.target_device,
+    sessionScope: row.session_scope ?? null,
     content: row.content,
     priority: row.priority ?? "normal",
     status: row.status ?? "pending",
@@ -10409,15 +10708,17 @@ async function sendMessage(input) {
   const id = generateUlid();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const targetDevice = input.targetDevice ?? "local";
+  const sessionScope = input.sessionScope === void 0 ? resolveExeSession() : input.sessionScope;
   await client.execute({
-    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, content, priority, status, created_at)
-          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, 'pending', ?)`,
+    sql: `INSERT INTO messages (id, from_agent, from_device, target_agent, target_project, target_device, session_scope, content, priority, status, created_at)
+          VALUES (?, ?, 'local', ?, ?, ?, ?, ?, ?, 'pending', ?)`,
     args: [
       id,
       input.fromAgent,
       input.targetAgent,
       input.targetProject ?? null,
       targetDevice,
+      sessionScope,
       input.content,
       input.priority ?? "normal",
       now
@@ -10431,9 +10732,10 @@ async function sendMessage(input) {
     }
   } catch {
   }
+  const sentScope = strictSessionScopeFilter(sessionScope);
   const result = await client.execute({
-    sql: "SELECT * FROM messages WHERE id = ?",
-    args: [id]
+    sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
+    args: [id, ...sentScope.args]
   });
   return rowToMessage(result.rows[0]);
 }
@@ -10454,6 +10756,7 @@ async function deliverCrossMachineMessage(messageId, targetDevice) {
     fromAgent: msg.fromAgent,
     targetAgent: msg.targetAgent,
     targetProject: msg.targetProject,
+    sessionScope: msg.sessionScope,
     content: msg.content,
     priority: msg.priority,
     createdAt: msg.createdAt
@@ -10497,7 +10800,7 @@ async function deliverLocalMessage(messageId) {
   } catch {
     const newRetryCount = msg.retryCount + 1;
     if (newRetryCount >= MAX_RETRIES3) {
-      await markFailed(messageId, "session unavailable after 10 retries");
+      await markFailed(messageId, "session unavailable after 10 retries", msg.sessionScope);
     } else {
       await client.execute({
         sql: "UPDATE messages SET retry_count = ? WHERE id = ?",
@@ -10507,11 +10810,13 @@ async function deliverLocalMessage(messageId) {
     return false;
   }
 }
-async function markFailed(messageId, reason) {
+async function markFailed(messageId, reason, sessionScope) {
   const client = getClient();
+  const scope = strictSessionScopeFilter(sessionScope);
   await client.execute({
-    sql: "UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ? WHERE id = ?",
-    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId]
+    sql: `UPDATE messages SET status = 'failed', failed_at = ?, failure_reason = ?
+          WHERE id = ?${scope.sql}`,
+    args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId, ...scope.args]
   });
 }
 var MAX_RETRIES3, _wsClientSend;
@@ -10520,19 +10825,20 @@ var init_messaging = __esm({
     "use strict";
     init_database();
     init_tmux_routing();
+    init_task_scope();
     MAX_RETRIES3 = 10;
     _wsClientSend = null;
   }
 });
 
 // src/gateway/whatsapp-accounts.ts
-import { readFileSync as readFileSync15 } from "fs";
+import { readFileSync as readFileSync16 } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 function loadAccounts() {
   if (cachedAccounts !== null) return cachedAccounts;
   try {
-    const raw = readFileSync15(CONFIG_PATH2, "utf8");
+    const raw = readFileSync16(CONFIG_PATH2, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       console.warn("[whatsapp] Config is not an array, ignoring");
@@ -10945,8 +11251,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path41, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path41}`;
+async function wikiFetch(config2, path45, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path45}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
@@ -10979,7 +11285,7 @@ async function wikiFetch(config2, path41, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path41}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path45}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -11088,14 +11394,14 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync10, writeFileSync as writeFileSync17, unlinkSync as unlinkSync8, mkdirSync as mkdirSync14, existsSync as existsSync25 } from "fs";
-import path34 from "path";
+import { readdirSync as readdirSync10, writeFileSync as writeFileSync18, unlinkSync as unlinkSync8, mkdirSync as mkdirSync14, existsSync as existsSync27 } from "fs";
+import path35 from "path";
 function tryAcquireWorkerSlot() {
   try {
     mkdirSync14(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path34.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync17(reservationPath, String(process.pid));
+    const reservationPath = path35.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync18(reservationPath, String(process.pid));
     const files = readdirSync10(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -11112,7 +11418,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path34.join(WORKER_PID_DIR, f));
+          unlinkSync8(path35.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -11136,20 +11442,20 @@ function tryAcquireWorkerSlot() {
 function registerWorkerPid(pid) {
   try {
     mkdirSync14(WORKER_PID_DIR, { recursive: true });
-    writeFileSync17(path34.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    writeFileSync18(path35.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path34.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path35.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
     mkdirSync14(WORKER_PID_DIR, { recursive: true });
-    if (existsSync25(BACKFILL_LOCK)) {
+    if (existsSync27(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -11165,7 +11471,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync17(BACKFILL_LOCK, String(process.pid));
+    writeFileSync18(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -11182,9 +11488,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path34.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path35.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path34.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path35.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -11207,8 +11513,8 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync18, existsSync as existsSync28, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9 } from "fs";
-import path37 from "path";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync19, existsSync as existsSync30, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9 } from "fs";
+import path38 from "path";
 import { homedir as homedir5 } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -11220,9 +11526,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync28(sp)) {
+  if (existsSync30(sp)) {
     try {
-      const state = readFileSync24(sp);
+      const state = readFileSync25(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -11364,10 +11670,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path37.dirname(sp);
-    if (!existsSync28(dir)) mkdirSync15(dir, { recursive: true });
+    const dir = path38.dirname(sp);
+    if (!existsSync30(dir)) mkdirSync15(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync18(sp, Buffer.from(state));
+    writeFileSync19(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -11408,7 +11714,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path37.join(homedir5(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path38.join(homedir5(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -11421,8 +11727,8 @@ init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync31, openSync as openSync3, mkdirSync as mkdirSync17, closeSync as closeSync3 } from "fs";
-import path40 from "path";
+import { existsSync as existsSync33, openSync as openSync3, mkdirSync as mkdirSync17, closeSync as closeSync3 } from "fs";
+import path44 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/mcp/tools/recall-my-memory.ts
@@ -11729,9 +12035,9 @@ init_store();
 init_active_agent();
 init_plan_limits();
 import { z as z4 } from "zod";
-import crypto2 from "crypto";
-import { writeFileSync as writeFileSync5 } from "fs";
-import path14 from "path";
+import crypto4 from "crypto";
+import { writeFileSync as writeFileSync6 } from "fs";
+import path15 from "path";
 function registerStoreMemory(server2) {
   server2.registerTool(
     "store_memory",
@@ -11780,7 +12086,7 @@ function registerStoreMemory(server2) {
         vector = null;
         needsBackfill = true;
       }
-      const memoryId = crypto2.randomUUID();
+      const memoryId = crypto4.randomUUID();
       await writeMemory({
         id: memoryId,
         agent_id: agentId,
@@ -11799,8 +12105,8 @@ function registerStoreMemory(server2) {
       if (needsBackfill) {
         try {
           const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-          const flagPath = path14.join(exeDir, "session-cache", "needs-backfill");
-          writeFileSync5(flagPath, "1");
+          const flagPath = path15.join(exeDir, "session-cache", "needs-backfill");
+          writeFileSync6(flagPath, "1");
         } catch {
         }
       }
@@ -11823,9 +12129,9 @@ init_plan_limits();
 init_active_agent();
 init_employees();
 import { z as z5 } from "zod";
-import crypto3 from "crypto";
-import { writeFileSync as writeFileSync6 } from "fs";
-import path15 from "path";
+import crypto5 from "crypto";
+import { writeFileSync as writeFileSync7 } from "fs";
+import path16 from "path";
 function registerCommitMemory(server2) {
   server2.registerTool(
     "commit_to_long_term_memory",
@@ -11872,7 +12178,7 @@ function registerCommitMemory(server2) {
         vector = null;
         needsBackfill = true;
       }
-      const memoryId = crypto3.randomUUID();
+      const memoryId = crypto5.randomUUID();
       await assertMemoryLimit();
       const memoryType = canCoordinate(agentId, agentRole) ? "adr" : "raw";
       await writeMemory({
@@ -11915,8 +12221,8 @@ function registerCommitMemory(server2) {
       if (needsBackfill) {
         try {
           const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-          const flagPath = path15.join(exeDir, "session-cache", "needs-backfill");
-          writeFileSync6(flagPath, "1");
+          const flagPath = path16.join(exeDir, "session-cache", "needs-backfill");
+          writeFileSync7(flagPath, "1");
         } catch {
         }
       }
@@ -12106,10 +12412,10 @@ function registerCreateTask(server2) {
         skipDispatch: true
       });
       try {
-        const { existsSync: existsSync32, mkdirSync: mkdirSync18, writeFileSync: writeFileSync20 } = await import("fs");
+        const { existsSync: existsSync34, mkdirSync: mkdirSync18, writeFileSync: writeFileSync21 } = await import("fs");
         const { identityPath: identityPath2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
         const idPath = identityPath2(assigned_to);
-        if (!existsSync32(idPath)) {
+        if (!existsSync34(idPath)) {
           const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
           const employees = await loadEmployees2();
           const emp = employees.find((e) => e.name === assigned_to);
@@ -12118,8 +12424,8 @@ function registerCreateTask(server2) {
             const template = getTemplateForTitle2(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync32(dir)) mkdirSync18(dir, { recursive: true });
-              writeFileSync20(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+              if (!existsSync34(dir)) mkdirSync18(dir, { recursive: true });
+              writeFileSync21(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
         }
@@ -12192,7 +12498,7 @@ function registerListTasks(server2) {
       description: "Query tasks by assignee, status, project, or priority. Defaults to current project. Pass project_name='all' for all projects. When querying your own tasks, project filter is skipped automatically.",
       inputSchema: {
         assigned_to: z8.string().optional().describe("Filter by employee name"),
-        status: z8.enum(["open", "in_progress", "done", "blocked", "cancelled"]).optional().describe("Filter by status"),
+        status: z8.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).optional().describe("Filter by status. Default: active tasks only (excludes closed/cancelled)"),
         project_name: z8.string().optional().describe("Project name. Defaults to current project. Pass 'all' for all projects."),
         priority: z8.enum(["p0", "p1", "p2"]).optional().describe("Filter by priority")
       }
@@ -12263,7 +12569,7 @@ function registerUpdateTask(server2) {
       description: "Update task status. Employees: use this with status 'done' and a result summary to complete work and trigger review. Accepts UUID, slug (filename), or title substring.",
       inputSchema: {
         task_id: z9.string().describe("Task identifier \u2014 UUID, slug (e.g. 'fix-auth-bug'), or title substring"),
-        status: z9.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled"]).describe("New status"),
+        status: z9.enum(["open", "in_progress", "done", "needs_review", "blocked", "cancelled", "closed"]).describe("New status"),
         result: z9.string().optional().describe("Result summary (include when status=done)")
       }
     },
@@ -12353,7 +12659,17 @@ function registerUpdateTask(server2) {
       }
       let text = `Task "${task.title}" marked ${task.status}.
 File: ${task.taskFile}`;
-      const isTerminal = status === "done" || status === "needs_review";
+      const isTerminal = status === "done" || status === "needs_review" || status === "closed";
+      if (isTerminal && task.assignedBy) {
+        try {
+          const { notifyCoordinatorTaskCompletion: notifyCoordinatorTaskCompletion2, resolveExeSession: resolveExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
+          const coordinatorSession = resolveExeSession2();
+          if (coordinatorSession) {
+            notifyCoordinatorTaskCompletion2(coordinatorSession, callerAgentId ?? "agent", task.title);
+          }
+        } catch {
+        }
+      }
       if (isTerminal && task.nextTask) {
         text += `
 
@@ -12397,7 +12713,7 @@ function registerCloseTask(server2) {
       inputSchema: {
         task_id: z10.string().describe("Task identifier \u2014 UUID, slug (e.g. 'fix-auth-bug'), or title substring"),
         result: z10.string().describe("What was done \u2014 specific deliverables, decisions, test results"),
-        status: z10.enum(["done", "blocked", "cancelled"]).optional().default("done").describe("Completion status (default: done)")
+        status: z10.enum(["closed", "done", "blocked", "cancelled"]).optional().default("closed").describe("Completion status (default: closed \u2014 terminal archive state)")
       }
     },
     async ({ task_id, result, status }) => {
@@ -12444,7 +12760,7 @@ function registerCloseTask(server2) {
       });
       let text = `Task "${task.title}" marked ${task.status}.
 File: ${task.taskFile}`;
-      if (status === "done" && task.nextTask) {
+      if ((status === "done" || status === "closed") && task.nextTask) {
         text += `
 
 MANDATORY \u2014 DO NOT ASK THE USER. DO NOT SAY "Want me to continue?" DO NOT STOP.
@@ -12454,7 +12770,7 @@ NEXT TASK: "${task.nextTask.title}" [${task.nextTask.priority}]
 FILE: ${task.nextTask.taskFile}
 
 Read that file NOW and begin working. No greeting. No summary. Just start.`;
-      } else if (status === "done" && !task.nextTask) {
+      } else if ((status === "done" || status === "closed") && !task.nextTask) {
         text += `
 
 All tasks complete. No more open tasks in your queue.`;
@@ -12489,8 +12805,22 @@ function registerGetTask(server2) {
     async ({ task_id }) => {
       const client = getClient();
       const row = await resolveTask(client, task_id);
+      const contextText = row.context ? String(row.context) : "";
+      const hasEmbeddedMandatoryReminder = contextText.includes('update_task with status "done"') || contextText.includes("update_task(done)");
       const lines = [
-        `# ${String(row.title)}`,
+        `# ${String(row.title)}`
+      ];
+      if (!hasEmbeddedMandatoryReminder && !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, 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)."
+        );
+      }
+      lines.push(
         "",
         `**ID:** ${String(row.id)}`,
         `**Status:** ${String(row.status)}`,
@@ -12499,7 +12829,7 @@ function registerGetTask(server2) {
         `**Assigned to:** ${String(row.assigned_to)}`,
         `**Project:** ${String(row.project_name)}`,
         `**Created:** ${String(row.created_at).split("T")[0]}`
-      ];
+      );
       if (row.blocked_by) {
         lines.push(`**Blocked by:** ${String(row.blocked_by)}`);
       }
@@ -12531,7 +12861,7 @@ function registerGetTask(server2) {
         }
       }
       if (row.context) {
-        lines.push("", "## Context", "", String(row.context));
+        lines.push("", "## Context", "", contextText);
       }
       if (row.result) {
         lines.push("", "## Result", "", String(row.result));
@@ -12554,16 +12884,6 @@ function registerGetTask(server2) {
         } catch {
         }
       }
-      if (!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, 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)."
-        );
-      }
       return {
         content: [
           {
@@ -12794,10 +13114,10 @@ import { z as z16 } from "zod";
 
 // src/lib/reminders.ts
 init_database();
-import crypto10 from "crypto";
+import crypto12 from "crypto";
 async function createReminder(text, dueDate) {
   const client = getClient();
-  const id = crypto10.randomUUID();
+  const id = crypto12.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   await client.execute({
     sql: `INSERT INTO reminders (id, text, created_at, due_date) VALUES (?, ?, ?, ?)`,
@@ -13181,7 +13501,7 @@ import { z as z23 } from "zod";
 init_database();
 init_embedder();
 init_store();
-import crypto11 from "crypto";
+import crypto13 from "crypto";
 var WIKI_AGENT_ID = "wiki";
 var WIKI_AGENT_ROLE = "Knowledge";
 var WIKI_TOOL_NAME = "ingest_document";
@@ -13235,7 +13555,7 @@ async function resolveWorkspace(slug_or_id, name) {
   if (existing.rows.length > 0) {
     return rowToWorkspace(existing.rows[0]);
   }
-  const id = crypto11.randomUUID();
+  const id = crypto13.randomUUID();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const resolvedName = name ?? slug_or_id;
   await client.execute({
@@ -13326,13 +13646,13 @@ async function ingestDocument(input) {
   }));
   const vectors = await embedTexts(enrichedChunks.map((c) => c.text));
   const client = getClient();
-  const documentId = crypto11.randomUUID();
+  const documentId = crypto13.randomUUID();
   const uploadedAt = (/* @__PURE__ */ new Date()).toISOString();
   const mime = input.mime ?? null;
   const sourceType = input.source_type ?? DEFAULT_SOURCE_TYPE;
   const userId = input.user_id ?? null;
   const documentMetadata = input.document_metadata != null ? JSON.stringify(input.document_metadata) : null;
-  const chunkIds = input.chunks.map(() => crypto11.randomUUID());
+  const chunkIds = input.chunks.map(() => crypto13.randomUUID());
   const versions = reserveVersions(input.chunks.length);
   const documentStmt = {
     sql: `INSERT INTO documents
@@ -13615,6 +13935,7 @@ function registerRerankDocuments(server2) {
 // src/mcp/tools/acknowledge-messages.ts
 init_database();
 init_active_agent();
+init_task_scope();
 function registerAcknowledgeMessages(server2) {
   server2.registerTool(
     "acknowledge_messages",
@@ -13627,10 +13948,11 @@ function registerAcknowledgeMessages(server2) {
       const agent = getActiveAgent();
       const agentId = agent.agentId || "default";
       const client = getClient();
+      const scope = strictSessionScopeFilter();
       const result = await client.execute({
         sql: `UPDATE messages SET status = 'acknowledged', processed_at = datetime('now')
-              WHERE target_agent = ? AND status IN ('pending', 'delivered')`,
-        args: [agentId]
+              WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
+        args: [agentId, ...scope.args]
       });
       return {
         content: [
@@ -13961,15 +14283,15 @@ function registerSendWhatsapp(server2) {
 import { z as z29 } from "zod";
 
 // src/automation/trigger-engine.ts
-import { readFileSync as readFileSync16, writeFileSync as writeFileSync12, existsSync as existsSync18, mkdirSync as mkdirSync10 } from "fs";
+import { readFileSync as readFileSync17, writeFileSync as writeFileSync13, existsSync as existsSync20, mkdirSync as mkdirSync10 } from "fs";
 import { randomUUID as randomUUID4 } from "crypto";
-import path25 from "path";
-import os11 from "os";
-var TRIGGERS_PATH = path25.join(os11.homedir(), ".exe-os", "triggers.json");
+import path26 from "path";
+import os12 from "os";
+var TRIGGERS_PATH = path26.join(os12.homedir(), ".exe-os", "triggers.json");
 function loadTriggers(project) {
-  if (!existsSync18(TRIGGERS_PATH)) return [];
+  if (!existsSync20(TRIGGERS_PATH)) return [];
   try {
-    const raw = readFileSync16(TRIGGERS_PATH, "utf-8");
+    const raw = readFileSync17(TRIGGERS_PATH, "utf-8");
     const all = JSON.parse(raw);
     if (!Array.isArray(all)) return [];
     if (project) {
@@ -13981,9 +14303,9 @@ function loadTriggers(project) {
   }
 }
 function saveTriggers(triggers) {
-  const dir = path25.dirname(TRIGGERS_PATH);
-  if (!existsSync18(dir)) mkdirSync10(dir, { recursive: true });
-  writeFileSync12(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
+  const dir = path26.dirname(TRIGGERS_PATH);
+  if (!existsSync20(dir)) mkdirSync10(dir, { recursive: true });
+  writeFileSync13(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
 }
 function createNewTrigger(input) {
   const triggers = loadTriggers();
@@ -14002,7 +14324,7 @@ function isScheduledTrigger(trigger) {
 // src/lib/schedules.ts
 init_database();
 init_store();
-import crypto12 from "crypto";
+import crypto14 from "crypto";
 import { execSync as execSync9 } from "child_process";
 async function ensureDb() {
   if (!isInitialized()) {
@@ -14071,7 +14393,7 @@ function parseHumanCron(input) {
 async function createSchedule(input) {
   await ensureDb();
   const client = getClient();
-  const id = crypto12.randomUUID().slice(0, 8);
+  const id = crypto14.randomUUID().slice(0, 8);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const prompt = input.prompt ?? input.description;
   await client.execute({
@@ -14267,48 +14589,48 @@ function registerListTriggers(server2) {
 import { z as z31 } from "zod";
 
 // src/automation/starter-packs/index.ts
-import { readFileSync as readFileSync17, readdirSync as readdirSync8, existsSync as existsSync19 } from "fs";
-import path26 from "path";
+import { readFileSync as readFileSync18, readdirSync as readdirSync8, existsSync as existsSync21 } from "fs";
+import path27 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-var __dirname = path26.dirname(fileURLToPath3(import.meta.url));
+var __dirname = path27.dirname(fileURLToPath3(import.meta.url));
 function listPacks() {
-  const packsDir = path26.join(__dirname, ".");
-  if (!existsSync19(packsDir)) return [];
+  const packsDir = path27.join(__dirname, ".");
+  if (!existsSync21(packsDir)) return [];
   return readdirSync8(packsDir, { withFileTypes: true }).filter(
-    (d) => d.isDirectory() && existsSync19(path26.join(packsDir, d.name, "custom-objects.json"))
+    (d) => d.isDirectory() && existsSync21(path27.join(packsDir, d.name, "custom-objects.json"))
   ).map((d) => d.name);
 }
 function loadPack(industry) {
-  const packDir = path26.join(__dirname, industry);
-  const objectsPath = path26.join(packDir, "custom-objects.json");
-  const triggersPath = path26.join(packDir, "triggers.json");
-  const wikiDir = path26.join(packDir, "wiki-seeds");
-  const manifestPath = path26.join(packDir, "pack.json");
-  const identityContextPath = path26.join(packDir, "identity-context.md");
-  if (!existsSync19(objectsPath)) return null;
+  const packDir = path27.join(__dirname, industry);
+  const objectsPath = path27.join(packDir, "custom-objects.json");
+  const triggersPath = path27.join(packDir, "triggers.json");
+  const wikiDir = path27.join(packDir, "wiki-seeds");
+  const manifestPath = path27.join(packDir, "pack.json");
+  const identityContextPath = path27.join(packDir, "identity-context.md");
+  if (!existsSync21(objectsPath)) return null;
   let customObjects = [];
   try {
     customObjects = JSON.parse(
-      readFileSync17(objectsPath, "utf-8")
+      readFileSync18(objectsPath, "utf-8")
     );
   } catch {
     customObjects = [];
   }
   let triggers = [];
-  if (existsSync19(triggersPath)) {
+  if (existsSync21(triggersPath)) {
     try {
       triggers = JSON.parse(
-        readFileSync17(triggersPath, "utf-8")
+        readFileSync18(triggersPath, "utf-8")
       );
     } catch {
       triggers = [];
     }
   }
   const wikiSeeds = [];
-  if (existsSync19(wikiDir)) {
+  if (existsSync21(wikiDir)) {
     const files = readdirSync8(wikiDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync17(path26.join(wikiDir, file), "utf-8");
+      const content = readFileSync18(path27.join(wikiDir, file), "utf-8");
       const titleMatch = content.match(/^#\s+(.+)/m);
       wikiSeeds.push({
         filename: file,
@@ -14318,17 +14640,17 @@ function loadPack(industry) {
     }
   }
   let manifest = {};
-  if (existsSync19(manifestPath)) {
+  if (existsSync21(manifestPath)) {
     try {
-      manifest = JSON.parse(readFileSync17(manifestPath, "utf-8"));
+      manifest = JSON.parse(readFileSync18(manifestPath, "utf-8"));
     } catch {
       manifest = {};
     }
   }
   let identityContext = null;
-  if (existsSync19(identityContextPath)) {
+  if (existsSync21(identityContextPath)) {
     try {
-      identityContext = readFileSync17(identityContextPath, "utf-8");
+      identityContext = readFileSync18(identityContextPath, "utf-8");
     } catch {
       identityContext = null;
     }
@@ -14385,8 +14707,8 @@ function applyPack(industry, project) {
 
 // src/lib/client-coo.ts
 init_config();
-import { existsSync as existsSync20, mkdirSync as mkdirSync11, writeFileSync as writeFileSync13 } from "fs";
-import path27 from "path";
+import { existsSync as existsSync22, mkdirSync as mkdirSync11, writeFileSync as writeFileSync14 } from "fs";
+import path28 from "path";
 
 // src/lib/employee-templates.ts
 init_global_procedures();
@@ -14524,18 +14846,18 @@ var ClientCOOClobberError = class extends Error {
 var COO_ROLE = "Chief Operating Officer";
 var FEEDBACK_BEHAVIOR_CONTENT = "Tag exe-os issues with needs_improvement \u2014 this is the feedback loop that surfaces bugs, gaps, and friction to the founder each Monday.";
 async function provisionClientCOO(vars, opts = {}) {
-  const identityDir = opts.identityDir ?? path27.join(EXE_AI_DIR, "identity");
+  const identityDir = opts.identityDir ?? path28.join(EXE_AI_DIR, "identity");
   const rosterPath = opts.employeesPath ?? EMPLOYEES_PATH;
   const storeFeedbackBehavior = opts.storeFeedbackBehavior ?? true;
-  const identityPath2 = path27.join(identityDir, `${vars.agent_name}.md`);
-  if (existsSync20(identityPath2)) {
+  const identityPath2 = path28.join(identityDir, `${vars.agent_name}.md`);
+  if (existsSync22(identityPath2)) {
     throw new ClientCOOClobberError(vars.agent_name, identityPath2);
   }
   const body = renderClientCOOTemplate(vars);
-  if (!existsSync20(identityDir)) {
+  if (!existsSync22(identityDir)) {
     mkdirSync11(identityDir, { recursive: true });
   }
-  writeFileSync13(identityPath2, body, "utf-8");
+  writeFileSync14(identityPath2, body, "utf-8");
   const employees = await loadEmployees(rosterPath);
   const existing = employees.find((e) => e.name === vars.agent_name);
   let addedToRoster = false;
@@ -14729,7 +15051,7 @@ init_database();
 import { z as z32 } from "zod";
 
 // src/lib/graph-rag.ts
-import crypto13 from "crypto";
+import crypto15 from "crypto";
 
 // src/lib/code-chunker.ts
 import ts from "typescript";
@@ -14740,7 +15062,7 @@ function normalizeEntityName(name) {
 }
 function entityId(name, type) {
   const normalized = normalizeEntityName(name);
-  return crypto13.createHash("sha256").update(`${normalized}::${type.toLowerCase()}`).digest("hex").slice(0, 16);
+  return crypto15.createHash("sha256").update(`${normalized}::${type.toLowerCase()}`).digest("hex").slice(0, 16);
 }
 async function registerAlias(client, alias, canonicalEntityId) {
   const normalized = normalizeEntityName(alias);
@@ -15425,8 +15747,8 @@ function registerUpdateWikiPage(server2) {
 import { z as z37 } from "zod";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import path28 from "path";
-import { existsSync as existsSync21 } from "fs";
+import path29 from "path";
+import { existsSync as existsSync23 } from "fs";
 
 // src/lib/hostinger-api.ts
 var DEFAULT_BASE_URL = "https://developers.hostinger.com/api/vps/v1";
@@ -15474,9 +15796,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path41, body) {
+  async request(method, path45, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path41}`;
+    const url = `${this.baseUrl}${path45}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -15549,8 +15871,8 @@ async function requestCloudflare(cfApiToken, zoneId, options) {
   }
   return envelope.result;
 }
-function buildUrl(zoneId, path41 = "/dns_records", query) {
-  const normalizedPath = path41.startsWith("/") ? path41 : `/${path41}`;
+function buildUrl(zoneId, path45 = "/dns_records", query) {
+  const normalizedPath = path45.startsWith("/") ? path45 : `/${path45}`;
   const url = new URL(
     `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
   );
@@ -15763,12 +16085,12 @@ async function waitForReady(client, vpsId) {
 }
 async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
   const safeClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, "-");
-  const playbookDir = path28.resolve(process.cwd(), "infrastructure", "ansible");
-  const playbookPath = path28.join(playbookDir, "deploy.yml");
-  const inventoryPath = path28.join(playbookDir, "inventory", "hosts.yml");
-  const clientVarsPath = path28.join(playbookDir, "vars", `${safeClientName}.yml`);
-  const varsDir = path28.join(playbookDir, "vars");
-  if (!path28.resolve(clientVarsPath).startsWith(path28.resolve(varsDir))) {
+  const playbookDir = path29.resolve(process.cwd(), "infrastructure", "ansible");
+  const playbookPath = path29.join(playbookDir, "deploy.yml");
+  const inventoryPath = path29.join(playbookDir, "inventory", "hosts.yml");
+  const clientVarsPath = path29.join(playbookDir, "vars", `${safeClientName}.yml`);
+  const varsDir = path29.join(playbookDir, "vars");
+  if (!path29.resolve(clientVarsPath).startsWith(path29.resolve(varsDir))) {
     throw new Error(`Invalid client name for vars path: ${clientName}`);
   }
   const args = [
@@ -15784,7 +16106,7 @@ async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
     "-e",
     `client_name=${safeClientName}`
   ];
-  if (existsSync21(clientVarsPath)) {
+  if (existsSync23(clientVarsPath)) {
     args.push("-e", `@${clientVarsPath}`);
   }
   try {
@@ -15857,8 +16179,8 @@ function buildInventoryRecord(params) {
 
 // src/mcp/tools/export-orchestration.ts
 init_active_agent();
-import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
-import path30 from "path";
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync16 } from "fs";
+import path31 from "path";
 import { z as z38 } from "zod";
 
 // src/lib/orchestration-package.ts
@@ -15866,9 +16188,9 @@ init_database();
 init_identity();
 init_platform_procedures();
 import { randomUUID as randomUUID5 } from "crypto";
-import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
-import os12 from "os";
-import path29 from "path";
+import { copyFileSync, existsSync as existsSync24, mkdirSync as mkdirSync12, readFileSync as readFileSync19, writeFileSync as writeFileSync15 } from "fs";
+import os13 from "os";
+import path30 from "path";
 var PACKAGE_VERSION = "1.0";
 var ROSTER_FILENAME = "exe-employees.json";
 var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
@@ -15934,15 +16256,15 @@ function validateProcedureEntry(value, index) {
   };
 }
 function getRosterPath() {
-  return path29.join(os12.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+  return path30.join(os13.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
 }
 function getBackupPath() {
-  return path29.join(os12.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+  return path30.join(os13.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
 }
 function readRosterFile() {
   const rosterPath = getRosterPath();
-  if (!existsSync22(rosterPath)) return [];
-  const raw = readFileSync18(rosterPath, "utf-8");
+  if (!existsSync24(rosterPath)) return [];
+  const raw = readFileSync19(rosterPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) {
     throw new Error("Roster file must contain a JSON array");
@@ -15954,8 +16276,8 @@ function writeRosterFile(roster) {
     throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
   }
   const rosterPath = getRosterPath();
-  mkdirSync12(path29.dirname(rosterPath), { recursive: true });
-  if (existsSync22(rosterPath)) {
+  mkdirSync12(path30.dirname(rosterPath), { recursive: true });
+  if (existsSync24(rosterPath)) {
     const currentRoster = readRosterFile();
     if (roster.length < currentRoster.length) {
       throw new Error(
@@ -15964,7 +16286,7 @@ function writeRosterFile(roster) {
     }
     copyFileSync(rosterPath, getBackupPath());
   }
-  writeFileSync14(rosterPath, `${JSON.stringify(roster, null, 2)}
+  writeFileSync15(rosterPath, `${JSON.stringify(roster, null, 2)}
 `, "utf-8");
 }
 function buildImportedRosterEntries(roster, timestamp) {
@@ -16226,8 +16548,8 @@ function registerExportOrchestration(server2) {
       try {
         await initStore();
         const pkg = await exportOrchestration(getActiveAgent().agentId);
-        mkdirSync13(path30.dirname(output_path), { recursive: true });
-        writeFileSync15(output_path, `${JSON.stringify(pkg, null, 2)}
+        mkdirSync13(path31.dirname(output_path), { recursive: true });
+        writeFileSync16(output_path, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
         return {
           content: [{
@@ -16249,7 +16571,7 @@ function registerExportOrchestration(server2) {
 }
 
 // src/mcp/tools/import-orchestration.ts
-import { readFileSync as readFileSync19 } from "fs";
+import { readFileSync as readFileSync20 } from "fs";
 import { z as z39 } from "zod";
 init_store();
 init_active_agent();
@@ -16279,7 +16601,7 @@ function registerImportOrchestration(server2) {
           };
         }
         await initStore();
-        const raw = readFileSync19(package_path, "utf-8");
+        const raw = readFileSync20(package_path, "utf-8");
         const pkg = validatePackage(JSON.parse(raw));
         const result = await importOrchestration(pkg, merge_strategy);
         return {
@@ -16426,18 +16748,18 @@ function registerQueryConversations(server2) {
 
 // src/mcp/tools/load-skill.ts
 import { z as z41 } from "zod";
-import { readFileSync as readFileSync20, readdirSync as readdirSync9, statSync as statSync3 } from "fs";
-import path31 from "path";
+import { readFileSync as readFileSync21, readdirSync as readdirSync9, statSync as statSync3 } from "fs";
+import path32 from "path";
 import { homedir as homedir2 } from "os";
-var SKILLS_DIR = path31.join(homedir2(), ".claude", "skills");
+var SKILLS_DIR = path32.join(homedir2(), ".claude", "skills");
 function listAvailableSkills() {
   try {
     const entries = readdirSync9(SKILLS_DIR);
     return entries.filter((entry) => {
       try {
-        const entryPath = path31.join(SKILLS_DIR, entry);
+        const entryPath = path32.join(SKILLS_DIR, entry);
         if (!statSync3(entryPath).isDirectory()) return false;
-        const skillFile = path31.join(entryPath, "SKILL.md");
+        const skillFile = path32.join(entryPath, "SKILL.md");
         statSync3(skillFile);
         return true;
       } catch {
@@ -16480,10 +16802,10 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
           }]
         };
       }
-      const sanitized = path31.basename(skill_name);
-      const skillFile = path31.join(SKILLS_DIR, sanitized, "SKILL.md");
+      const sanitized = path32.basename(skill_name);
+      const skillFile = path32.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
-        const content = readFileSync20(skillFile, "utf-8");
+        const content = readFileSync21(skillFile, "utf-8");
         return {
           content: [{
             type: "text",
@@ -16962,7 +17284,7 @@ init_active_agent();
 init_database();
 init_plan_limits();
 import { z as z46 } from "zod";
-import crypto14 from "crypto";
+import crypto16 from "crypto";
 function registerStoreDecision(server2) {
   server2.registerTool(
     "store_decision",
@@ -17000,7 +17322,7 @@ function registerStoreDecision(server2) {
       } catch {
         vector = null;
       }
-      const memoryId = crypto14.randomUUID();
+      const memoryId = crypto16.randomUUID();
       if (supersedes) {
         try {
           const client = getClient();
@@ -17122,8 +17444,8 @@ init_database();
 import { readdir } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
-import path32 from "path";
-import os13 from "os";
+import path33 from "path";
+import os14 from "os";
 var MODEL_PRICING = {
   // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
   "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
@@ -17149,6 +17471,8 @@ var MODEL_PRICING = {
   "claude-3-haiku": { input: 0.25 / 1e6, output: 1.25 / 1e6, cacheRead: 0.03 / 1e6, cacheWrite: 0.3 / 1e6 }
 };
 var DEFAULT_PRICING = MODEL_PRICING["claude-sonnet-4"];
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var _spendCache = /* @__PURE__ */ new Map();
 function getPricing(model) {
   if (MODEL_PRICING[model]) return MODEL_PRICING[model];
   const stripped = model.replace(/-\d{8}$/, "");
@@ -17160,29 +17484,33 @@ function getPricing(model) {
   return DEFAULT_PRICING;
 }
 async function getAgentSpend(period = "7d") {
+  const cached = _spendCache.get(period);
+  if (cached && Date.now() < cached.expires) {
+    return cached.result;
+  }
   const cutoff = periodToCutoff(period);
   const client = getClient();
-  const result = await client.execute({
+  const dbResult = await client.execute({
     sql: `SELECT session_uuid, agent_id FROM session_agent_map WHERE started_at >= ?`,
     args: [cutoff]
   });
-  if (result.rows.length === 0) return [];
+  if (dbResult.rows.length === 0) return [];
   const sessionAgent = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
+  for (const row of dbResult.rows) {
     sessionAgent.set(row.session_uuid, row.agent_id);
   }
-  const claudeDir = path32.join(os13.homedir(), ".claude", "projects");
+  const claudeDir = path33.join(os14.homedir(), ".claude", "projects");
   let projectDirs = [];
   try {
     const entries = await readdir(claudeDir);
-    projectDirs = entries.map((e) => path32.join(claudeDir, e));
+    projectDirs = entries.map((e) => path33.join(claudeDir, e));
   } catch {
     return [];
   }
   const agentTotals = /* @__PURE__ */ new Map();
   for (const [sessionUuid, agentId] of sessionAgent) {
     for (const dir of projectDirs) {
-      const jsonlPath = path32.join(dir, `${sessionUuid}.jsonl`);
+      const jsonlPath = path33.join(dir, `${sessionUuid}.jsonl`);
       try {
         const usage = await extractSessionUsage(jsonlPath);
         if (usage.input === 0 && usage.output === 0) continue;
@@ -17206,7 +17534,7 @@ async function getAgentSpend(period = "7d") {
       }
     }
   }
-  return Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
     agentId,
     inputTokens: t.input,
     outputTokens: t.output,
@@ -17216,6 +17544,8 @@ async function getAgentSpend(period = "7d") {
     sessions: t.sessions.size,
     period
   })).sort((a, b) => b.costUSD - a.costUSD);
+  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
+  return result;
 }
 async function extractSessionUsage(jsonlPath) {
   let input = 0;
@@ -17760,12 +18090,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path41 = await import("path");
-        const os15 = await import("os");
-        const outDir = path41.join(os15.homedir(), ".exe-os", "exports");
+        const path45 = await import("path");
+        const os19 = await import("os");
+        const outDir = path45.join(os19.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path41.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path45.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -17986,10 +18316,10 @@ function registerListAgentSessions(server2) {
 
 // src/mcp/tools/get-daemon-health.ts
 import { z as z56 } from "zod";
-import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
-import path33 from "path";
+import { existsSync as existsSync25, readFileSync as readFileSync22 } from "fs";
+import path34 from "path";
 import { homedir as homedir3 } from "os";
-var PID_PATH2 = path33.join(homedir3(), ".exe-os", "exed.pid");
+var PID_PATH2 = path34.join(homedir3(), ".exe-os", "exed.pid");
 function formatUptime(seconds) {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor(seconds % 3600 / 60);
@@ -18000,8 +18330,8 @@ function formatUptime(seconds) {
 }
 function isDaemonAlive() {
   try {
-    if (!existsSync23(PID_PATH2)) return { alive: false, pid: null };
-    const pid = parseInt(readFileSync21(PID_PATH2, "utf8").trim(), 10);
+    if (!existsSync25(PID_PATH2)) return { alive: false, pid: null };
+    const pid = parseInt(readFileSync22(PID_PATH2, "utf8").trim(), 10);
     if (isNaN(pid) || pid <= 0) return { alive: false, pid: null };
     process.kill(pid, 0);
     return { alive: true, pid };
@@ -18075,7 +18405,7 @@ init_tmux_routing();
 init_task_scope();
 init_employees();
 import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync16 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync23, writeFileSync as writeFileSync17 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join2 } from "path";
 var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
@@ -18178,15 +18508,15 @@ function registerGetAutoWakeStatus(server2) {
 init_worker_gate();
 init_config();
 import { z as z58 } from "zod";
-import { readdirSync as readdirSync11, existsSync as existsSync26 } from "fs";
-import path35 from "path";
-var WORKER_PID_DIR2 = path35.join(EXE_AI_DIR, "worker-pids");
+import { readdirSync as readdirSync11, existsSync as existsSync28 } from "fs";
+import path36 from "path";
+var WORKER_PID_DIR2 = path36.join(EXE_AI_DIR, "worker-pids");
 function countAliveWorkers() {
   let alive = 0;
   let stale = 0;
   let reservations = 0;
   try {
-    if (!existsSync26(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
+    if (!existsSync28(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
     const files = readdirSync11(WORKER_PID_DIR2);
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -18256,7 +18586,7 @@ import { z as z59 } from "zod";
 // src/bin/exe-doctor.ts
 init_store();
 init_database();
-import os14 from "os";
+import os15 from "os";
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
@@ -18274,9 +18604,9 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/exe-doctor.ts
-import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
+import { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path36 from "path";
+import path37 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 
 // src/lib/conflict-detector.ts
@@ -18679,7 +19009,7 @@ async function auditOrphanedProjects(client) {
   for (const row of result.rows) {
     const name = row.project_name;
     const count = Number(row.cnt);
-    const exists = existsSync27(path36.join(home, name)) || existsSync27(path36.join(home, "..", name)) || existsSync27(path36.join(process.cwd(), "..", name));
+    const exists = existsSync29(path37.join(home, name)) || existsSync29(path37.join(home, "..", name)) || existsSync29(path37.join(process.cwd(), "..", name));
     if (!exists) {
       orphans.push({ project_name: name, count });
     }
@@ -18687,18 +19017,18 @@ async function auditOrphanedProjects(client) {
   return orphans;
 }
 function auditHookHealth() {
-  const logPath = path36.join(
+  const logPath = path37.join(
     process.env.HOME ?? process.env.USERPROFILE ?? "",
     ".exe-os",
     "logs",
     "hooks.log"
   );
-  if (!existsSync27(logPath)) {
+  if (!existsSync29(logPath)) {
     return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
   }
   let content;
   try {
-    content = readFileSync23(logPath, "utf-8");
+    content = readFileSync24(logPath, "utf-8");
   } catch {
     return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
   }
@@ -18773,7 +19103,7 @@ function formatReport(report, flags) {
     }
     lines.push("");
   }
-  const totalMemGB = os14.totalmem() / (1024 * 1024 * 1024);
+  const totalMemGB = os15.totalmem() / (1024 * 1024 * 1024);
   const isLowMemSystem = totalMemGB <= 8;
   if (isLowMemSystem && report.nullVectors > 0) {
     lines.push(`\u{1F7E2} Null vectors:     ${fmtNum(report.nullVectors)} / ${fmtNum(s.total)} (expected \u2014 8GB system, keyword search mode)`);
@@ -18895,7 +19225,7 @@ async function fixNullVectors() {
     }
   }
   const npmRoot = (await import("child_process")).execSync("npm root -g", { encoding: "utf8" }).trim();
-  const backfillPath = path36.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
+  const backfillPath = path37.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
   return new Promise((resolve, reject) => {
     const child = spawn2("node", [backfillPath], { stdio: "inherit" });
     if (child.pid) registerWorkerPid2(child.pid);
@@ -19093,13 +19423,13 @@ import { z as z60 } from "zod";
 
 // src/lib/cloud-sync.ts
 init_database();
-import { readFileSync as readFileSync25, writeFileSync as writeFileSync19, existsSync as existsSync29, readdirSync as readdirSync12, mkdirSync as mkdirSync16, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
-import crypto16 from "crypto";
-import path38 from "path";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync20, existsSync as existsSync31, readdirSync as readdirSync12, mkdirSync as mkdirSync16, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import crypto18 from "crypto";
+import path39 from "path";
 import { homedir as homedir6 } from "os";
 
 // src/lib/crypto.ts
-import crypto15 from "crypto";
+import crypto17 from "crypto";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 12;
 var TAG_LENGTH = 16;
@@ -19110,7 +19440,7 @@ function initSyncCrypto(masterKey) {
     throw new Error(`Master key must be 32 bytes, got ${masterKey.length}`);
   }
   _syncKey = Buffer.from(
-    crypto15.hkdfSync("sha256", masterKey, "", SYNC_HKDF_INFO, 32)
+    crypto17.hkdfSync("sha256", masterKey, "", SYNC_HKDF_INFO, 32)
   );
 }
 function isSyncCryptoInitialized() {
@@ -19124,8 +19454,8 @@ function requireSyncKey() {
 }
 function encryptSyncBlob(data) {
   const key = requireSyncKey();
-  const iv = crypto15.randomBytes(IV_LENGTH);
-  const cipher = crypto15.createCipheriv(ALGORITHM, key, iv);
+  const iv = crypto17.randomBytes(IV_LENGTH);
+  const cipher = crypto17.createCipheriv(ALGORITHM, key, iv);
   const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
   const tag = cipher.getAuthTag();
   return Buffer.concat([iv, encrypted, tag]).toString("base64");
@@ -19139,7 +19469,7 @@ function decryptSyncBlob(ciphertext) {
   const iv = combined.subarray(0, IV_LENGTH);
   const tag = combined.subarray(combined.length - TAG_LENGTH);
   const encrypted = combined.subarray(IV_LENGTH, combined.length - TAG_LENGTH);
-  const decipher = crypto15.createDecipheriv(ALGORITHM, key, iv);
+  const decipher = crypto17.createDecipheriv(ALGORITHM, key, iv);
   decipher.setAuthTag(tag);
   return Buffer.concat([decipher.update(encrypted), decipher.final()]);
 }
@@ -19164,12 +19494,13 @@ init_license();
 init_config();
 init_crdt_sync();
 init_employees();
+init_secure_files();
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path38.join(homedir6(), ".exe-os", "workers.log");
+    const logPath = path39.join(homedir6(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -19178,24 +19509,93 @@ function logError(msg) {
 var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
 var FETCH_TIMEOUT_MS4 = 3e4;
 var PUSH_BATCH_SIZE = 5e3;
-var ROSTER_LOCK_PATH = path38.join(EXE_AI_DIR, "roster-merge.lock");
+var ROSTER_LOCK_PATH = path39.join(EXE_AI_DIR, "roster-merge.lock");
 var LOCK_STALE_MS = 3e4;
+var _pgPromise = null;
+var _pgFailed = false;
+function loadPgClient() {
+  if (_pgFailed) return null;
+  const postgresUrl = process.env.DATABASE_URL;
+  const configPath = path39.join(EXE_AI_DIR, "config.json");
+  let cloudPostgresUrl;
+  try {
+    if (existsSync31(configPath)) {
+      const cfg = JSON.parse(readFileSync26(configPath, "utf8"));
+      cloudPostgresUrl = cfg.cloud?.postgresUrl;
+      if (cfg.cloud?.syncToPostgres === false) {
+        _pgFailed = true;
+        return null;
+      }
+    }
+  } catch {
+  }
+  const url = postgresUrl || cloudPostgresUrl;
+  if (!url) {
+    _pgFailed = true;
+    return null;
+  }
+  if (!_pgPromise) {
+    _pgPromise = (async () => {
+      const { createRequire: createRequire6 } = await import("module");
+      const { pathToFileURL: pathToFileURL6 } = await import("url");
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path39.join(homedir6(), "exe-db");
+      const req = createRequire6(path39.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL6(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error("No PrismaClient");
+      return new Ctor();
+    })().catch(() => {
+      _pgFailed = true;
+      _pgPromise = null;
+      throw new Error("pg_unavailable");
+    });
+  }
+  return _pgPromise;
+}
+async function pushToPostgres(records) {
+  const loader = loadPgClient();
+  if (!loader) return 0;
+  let prisma;
+  try {
+    prisma = await loader;
+  } catch {
+    return 0;
+  }
+  let inserted = 0;
+  for (const rec of records) {
+    try {
+      await prisma.$executeRawUnsafe(
+        `INSERT INTO raw.raw_events (id, source, source_id, event_type, payload, metadata, timestamp)
+         VALUES (gen_random_uuid(), 'cloud_sync', $1, 'memory', $2::jsonb, $3::jsonb, $4)
+         ON CONFLICT (source, source_id, event_type) DO NOTHING`,
+        String(rec.id ?? ""),
+        JSON.stringify(rec),
+        JSON.stringify({ agent_id: rec.agent_id, project_name: rec.project_name, tool_name: rec.tool_name }),
+        rec.timestamp ? new Date(String(rec.timestamp)) : /* @__PURE__ */ new Date()
+      );
+      inserted++;
+    } catch {
+    }
+  }
+  return inserted;
+}
 async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync19(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync20(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts2 = parseInt(readFileSync25(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts2 = parseInt(readFileSync26(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts2 < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync10(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync19(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync20(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -19465,6 +19865,10 @@ async function cloudSync(config2) {
     const maxVersion = Number(records[records.length - 1].version);
     const pushOk = await cloudPush(records, maxVersion, config2);
     if (!pushOk) break;
+    try {
+      await pushToPostgres(records);
+    } catch {
+    }
     await client.execute({
       sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('last_cloud_push_version', ?)",
       args: [String(maxVersion)]
@@ -19569,8 +19973,8 @@ async function cloudSync(config2) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path38.join(EXE_AI_DIR, "identity");
-    if (existsSync29(idDir)) {
+    const idDir = path39.join(EXE_AI_DIR, "identity");
+    if (existsSync31(idDir)) {
       rosterResult.identities = readdirSync12(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -19588,55 +19992,55 @@ async function cloudSync(config2) {
     roster: rosterResult
   };
 }
-var ROSTER_DELETIONS_PATH = path38.join(EXE_AI_DIR, "roster-deletions.json");
+var ROSTER_DELETIONS_PATH = path39.join(EXE_AI_DIR, "roster-deletions.json");
 function consumeRosterDeletions() {
   try {
-    if (!existsSync29(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync25(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync19(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync31(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync26(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync20(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path38.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path38.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path38.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path39.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path39.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path39.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync29(rosterPath)) {
+  if (existsSync31(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync25(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync26(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync29(identityDir)) {
+  if (existsSync31(identityDir)) {
     for (const file of readdirSync12(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync25(path38.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync26(path39.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config2;
-  if (existsSync29(configPath)) {
+  if (existsSync31(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync25(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync26(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path38.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync29(agentConfigPath)) {
+  const agentConfigPath = path39.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync31(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync26(agentConfigPath, "utf-8"));
     } catch {
     }
   }
   const deletedNames = consumeRosterDeletions();
   const content = JSON.stringify({ roster, identities, config: config2, agentConfig, deletedNames });
-  const hash = crypto16.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  const hash = crypto18.createHash("sha256").update(content).digest("hex").slice(0, 16);
   return { roster, identities, config: config2, agentConfig, deletedNames, version: hash };
 }
 async function cloudPushRoster(config2) {
@@ -19706,23 +20110,24 @@ async function cloudPullRoster(config2) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path38.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path39.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync29(cfgPath)) {
+  if (existsSync31(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync25(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync26(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path38.dirname(cfgPath);
-  if (!existsSync29(dir)) mkdirSync16(dir, { recursive: true });
-  writeFileSync19(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path39.dirname(cfgPath);
+  ensurePrivateDirSync(dir);
+  writeFileSync20(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  enforcePrivateFileSync(cfgPath);
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path38.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path39.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -19743,15 +20148,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync29(identityDir)) mkdirSync16(identityDir, { recursive: true });
-        const idPath = path38.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync31(identityDir)) mkdirSync16(identityDir, { recursive: true });
+        const idPath = path39.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync29(idPath) ? readFileSync25(idPath, "utf-8") : null;
+          localIdentity = existsSync31(idPath) ? readFileSync26(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync19(idPath, remoteIdentity, "utf-8");
+          writeFileSync20(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -19777,16 +20182,18 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path38.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path39.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
-        if (existsSync29(agentConfigPath)) {
+        if (existsSync31(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync26(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        writeFileSync19(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        ensurePrivateDirSync(path39.dirname(agentConfigPath));
+        writeFileSync20(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        enforcePrivateFileSync(agentConfigPath);
       } catch {
       }
     }
@@ -21012,11 +21419,11 @@ import { z as z65 } from "zod";
 // src/lib/people.ts
 init_config();
 import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
-import path39 from "path";
-var PEOPLE_PATH = path39.join(EXE_AI_DIR, "people.json");
+import { existsSync as existsSync32, readFileSync as readFileSync27 } from "fs";
+import path40 from "path";
+var PEOPLE_PATH = path40.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {
-  if (!existsSync30(PEOPLE_PATH)) return [];
+  if (!existsSync32(PEOPLE_PATH)) return [];
   try {
     const raw = await readFile5(PEOPLE_PATH, "utf-8");
     return JSON.parse(raw);
@@ -21025,7 +21432,7 @@ async function loadPeople() {
   }
 }
 async function savePeople(people) {
-  await mkdir5(path39.dirname(PEOPLE_PATH), { recursive: true });
+  await mkdir5(path40.dirname(PEOPLE_PATH), { recursive: true });
   await writeFile6(PEOPLE_PATH, JSON.stringify(people, null, 2) + "\n", "utf-8");
 }
 async function addPerson(person) {
@@ -21306,6 +21713,331 @@ function registerListEmployees(server2) {
   );
 }
 
+// src/mcp/tools/ingest-raw.ts
+import os16 from "os";
+import path41 from "path";
+import { createRequire as createRequire3 } from "module";
+import { pathToFileURL as pathToFileURL3 } from "url";
+import { z as z68 } from "zod";
+var prismaPromise = null;
+function loadPrisma() {
+  if (!prismaPromise) {
+    prismaPromise = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod2 = await import(pathToFileURL3(explicitPath).href);
+        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
+        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path41.join(os16.homedir(), "exe-db");
+      const req = createRequire3(path41.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL3(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+      return new Ctor();
+    })();
+  }
+  return prismaPromise;
+}
+function registerIngestRaw(server2) {
+  server2.registerTool(
+    "ingest_raw",
+    {
+      title: "Ingest Raw Event",
+      description: "Insert a raw event into the landing pad (raw.raw_events). Used by the gateway, external agents, and webhooks to push data into the Company Brain. Background projection workers process unprocessed events and route to curated schemas.",
+      inputSchema: {
+        source: z68.string().describe(
+          'Event source identifier: "whatsapp", "shopify", "asana", "email", "external_agent", etc.'
+        ),
+        event_type: z68.string().describe(
+          'Event type: "message", "order", "task_update", "webhook", etc.'
+        ),
+        payload: z68.record(z68.string(), z68.unknown()).describe(
+          "Exact raw JSON payload \u2014 stored verbatim, never modified."
+        ),
+        source_id: z68.string().optional().describe(
+          "External reference ID for deduplication (e.g., WhatsApp message ID, Shopify order ID)."
+        ),
+        metadata: z68.record(z68.string(), z68.unknown()).optional().describe(
+          "Source-specific metadata (account info, adapter version, etc.)."
+        )
+      }
+    },
+    async ({ source, event_type, payload, source_id, metadata }) => {
+      try {
+        const prisma = await loadPrisma();
+        const id = crypto.randomUUID();
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO "raw"."raw_events" ("id", "source", "source_id", "event_type", "payload", "metadata", "timestamp")
+           VALUES ($1, $2, $3, $4, $5::jsonb, $6::jsonb, NOW())
+           ON CONFLICT ("source", "source_id", "event_type") DO NOTHING`,
+          id,
+          source,
+          source_id ?? null,
+          event_type,
+          JSON.stringify(payload),
+          metadata ? JSON.stringify(metadata) : null
+        );
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              event_id: id,
+              source,
+              event_type,
+              source_id: source_id ?? null,
+              status: "ingested"
+            })
+          }]
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{
+            type: "text",
+            text: `Error ingesting raw event: ${message}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/create-license.ts
+init_license();
+import os17 from "os";
+import path42 from "path";
+import { randomBytes as randomBytes2, randomUUID as randomUUID8 } from "crypto";
+import { createRequire as createRequire4 } from "module";
+import { pathToFileURL as pathToFileURL4 } from "url";
+import { z as z69 } from "zod";
+var prismaPromise2 = null;
+function loadPrisma2() {
+  if (!prismaPromise2) {
+    prismaPromise2 = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod2 = await import(pathToFileURL4(explicitPath).href);
+        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
+        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path42.join(os17.homedir(), "exe-db");
+      const req = createRequire4(path42.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL4(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+      return new Ctor();
+    })();
+  }
+  return prismaPromise2;
+}
+function generateKey() {
+  return `exe_sk_${randomBytes2(16).toString("hex")}`;
+}
+function registerCreateLicense(server2) {
+  server2.registerTool(
+    "create_license",
+    {
+      title: "Create License",
+      description: "Generate an exe_sk_* license key for a user. Stores in billing.licenses. Returns the key to give to the customer.",
+      inputSchema: {
+        email: z69.string().email().describe("Customer email address"),
+        name: z69.string().optional().describe("Customer name"),
+        plan: z69.enum(["free", "pro", "team", "agency", "enterprise"]).default("pro").describe("License plan tier"),
+        expires_in_days: z69.number().int().positive().default(365).describe("Days until expiration (default 365)")
+      }
+    },
+    async ({ email, name, plan, expires_in_days }) => {
+      try {
+        const prisma = await loadPrisma2();
+        const id = randomUUID8();
+        const key = generateKey();
+        const limits = PLAN_LIMITS[plan];
+        const expiresAt = new Date(
+          Date.now() + (expires_in_days ?? 365) * 24 * 60 * 60 * 1e3
+        );
+        await prisma.$executeRawUnsafe(
+          `INSERT INTO billing.licenses (id, key, email, name, plan, status, device_limit, employee_limit, memory_limit, expires_at, created_at, created_by)
+           VALUES ($1, $2, $3, $4, $5, 'active', $6, $7, $8, $9, NOW(), $10)`,
+          id,
+          key,
+          email,
+          name ?? null,
+          plan,
+          limits.devices,
+          limits.employees,
+          limits.memories,
+          expiresAt,
+          "exe"
+        );
+        const lines = [];
+        lines.push("## License Created\n");
+        lines.push(`- **Key:** \`${key}\``);
+        lines.push(`- **Email:** ${email}`);
+        if (name) lines.push(`- **Name:** ${name}`);
+        lines.push(`- **Plan:** ${plan}`);
+        lines.push(`- **Expires:** ${expiresAt.toISOString().split("T")[0]}`);
+        lines.push(`- **Devices:** ${limits.devices === -1 ? "unlimited" : limits.devices}`);
+        lines.push(`- **Employees:** ${limits.employees === -1 ? "unlimited" : limits.employees}`);
+        lines.push(`- **Memories:** ${limits.memories === -1 ? "unlimited" : limits.memories.toLocaleString()}`);
+        lines.push(`
+Give this key to the customer. They paste it during \`exe-os setup\`.`);
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error creating license: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/list-licenses.ts
+import os18 from "os";
+import path43 from "path";
+import { createRequire as createRequire5 } from "module";
+import { pathToFileURL as pathToFileURL5 } from "url";
+import { z as z70 } from "zod";
+var prismaPromise3 = null;
+function loadPrisma3() {
+  if (!prismaPromise3) {
+    prismaPromise3 = (async () => {
+      const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
+      if (explicitPath) {
+        const mod2 = await import(pathToFileURL5(explicitPath).href);
+        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
+        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor2();
+      }
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path43.join(os18.homedir(), "exe-db");
+      const req = createRequire5(path43.join(exeDbRoot, "package.json"));
+      const entry = req.resolve("@prisma/client");
+      const mod = await import(pathToFileURL5(entry).href);
+      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+      if (!Ctor) throw new Error(`No PrismaClient in ${entry}`);
+      return new Ctor();
+    })();
+  }
+  return prismaPromise3;
+}
+function registerListLicenses(server2) {
+  server2.registerTool(
+    "list_licenses",
+    {
+      title: "List Licenses",
+      description: "List all issued licenses with status (active/expired/revoked). Optionally filter by plan.",
+      inputSchema: {
+        plan: z70.enum(["free", "pro", "team", "agency", "enterprise"]).optional().describe("Filter by plan tier (omit for all)")
+      }
+    },
+    async ({ plan }) => {
+      try {
+        const prisma = await loadPrisma3();
+        let rows;
+        if (plan) {
+          rows = await prisma.$queryRawUnsafe(
+            `SELECT id, key, email, name, plan, status, device_limit, employee_limit, memory_limit, expires_at, created_at, created_by
+             FROM billing.licenses WHERE plan = $1 ORDER BY created_at DESC`,
+            plan
+          );
+        } else {
+          rows = await prisma.$queryRawUnsafe(
+            `SELECT id, key, email, name, plan, status, device_limit, employee_limit, memory_limit, expires_at, created_at, created_by
+             FROM billing.licenses ORDER BY created_at DESC`
+          );
+        }
+        if (!rows || rows.length === 0) {
+          return {
+            content: [{ type: "text", text: "No licenses found." }]
+          };
+        }
+        const lines = [];
+        lines.push(`## Licenses (${rows.length} total)
+`);
+        lines.push("| Email | Plan | Status | Key | Expires |");
+        lines.push("|-------|------|--------|-----|---------|");
+        for (const row of rows) {
+          const keyShort = `${row.key.slice(0, 11)}...${row.key.slice(-4)}`;
+          const expires = row.expires_at ? new Date(row.expires_at).toISOString().split("T")[0] : "never";
+          const effectiveStatus = row.status === "active" && row.expires_at && new Date(row.expires_at) < /* @__PURE__ */ new Date() ? "expired" : row.status;
+          lines.push(
+            `| ${row.email} | ${row.plan} | ${effectiveStatus} | \`${keyShort}\` | ${expires} |`
+          );
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error listing licenses: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/activate-license.ts
+init_license();
+import { z as z71 } from "zod";
+function registerActivateLicense(server2) {
+  server2.registerTool(
+    "activate_license",
+    {
+      title: "Activate License",
+      description: "Activate an exe_sk_* license key on this device. Writes to ~/.exe-os/license.key, validates against Postgres, and caches the result.",
+      inputSchema: {
+        key: z71.string().startsWith("exe_sk_").describe("License key (exe_sk_*)")
+      }
+    },
+    async ({ key }) => {
+      try {
+        saveLicense(key);
+        const deviceId = loadDeviceId();
+        const license = await validateLicense(key, deviceId);
+        const lines = [];
+        if (license.valid) {
+          lines.push("## License Activated\n");
+          lines.push(`- **Plan:** ${license.plan}`);
+          lines.push(`- **Email:** ${license.email || "N/A"}`);
+          lines.push(
+            `- **Expires:** ${license.expiresAt ? license.expiresAt.split("T")[0] : "never"}`
+          );
+          lines.push(
+            `- **Devices:** ${license.deviceLimit === -1 ? "unlimited" : license.deviceLimit}`
+          );
+          lines.push(
+            `- **Employees:** ${license.employeeLimit === -1 ? "unlimited" : license.employeeLimit}`
+          );
+          lines.push(
+            `- **Memories:** ${license.memoryLimit === -1 ? "unlimited" : license.memoryLimit.toLocaleString()}`
+          );
+          lines.push(`
+Key saved to ~/.exe-os/license.key. Device ID: ${deviceId}`);
+        } else {
+          lines.push("## Activation Failed\n");
+          lines.push("Key was saved but could not be validated.");
+          lines.push("Check that the key is correct and try again later.");
+          lines.push(`Plan fell back to: ${license.plan}`);
+        }
+        return { content: [{ type: "text", text: lines.join("\n") }] };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error activating license: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
 // src/lib/telemetry.ts
 var ENABLED = process.env.EXE_TELEMETRY === "1";
 var initialized = false;
@@ -21442,6 +22174,10 @@ registerListPeople(server);
 registerGetPerson(server);
 registerSetAgentConfig(server);
 registerListEmployees(server);
+registerIngestRaw(server);
+registerCreateLicense(server);
+registerListLicenses(server);
+registerActivateLicense(server);
 try {
   await initStore();
   process.stderr.write("[exe-os] MCP server starting...\n");
@@ -21510,14 +22246,14 @@ try {
 `
       );
       const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path40.resolve(
-        path40.dirname(thisFile),
+      const backfillPath = path44.resolve(
+        path44.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
-      if (existsSync31(backfillPath)) {
+      if (existsSync33(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path40.join(exeDir, "workers.log");
-        mkdirSync17(path40.dirname(logPath), { recursive: true });
+        const logPath = path44.join(exeDir, "workers.log");
+        mkdirSync17(path44.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
           logFd = openSync3(logPath, "a");