@askexenow/exe-os 0.9.30 → 0.9.32

package/dist/bin/cli.js

@@ -1638,6 +1638,7 @@ __export(keychain_exports, {
 });
 import { readFile as readFile4, writeFile as writeFile4, unlink, mkdir as mkdir4, chmod as chmod2 } from "fs/promises";
 import { existsSync as existsSync8 } from "fs";
+import { execSync as execSync3 } from "child_process";
 import path7 from "path";
 import os6 from "os";
 function getKeyDir() {
@@ -1646,6 +1647,83 @@ function getKeyDir() {
 function getKeyPath() {
   return path7.join(getKeyDir(), "master.key");
 }
+function macKeychainGet() {
+  if (process.platform !== "darwin") return null;
+  try {
+    return execSync3(
+      `security find-generic-password -s "${SERVICE}" -a "${ACCOUNT}" -w 2>/dev/null`,
+      { encoding: "utf-8", timeout: 5e3 }
+    ).trim();
+  } catch {
+    return null;
+  }
+}
+function macKeychainSet(value) {
+  if (process.platform !== "darwin") return false;
+  try {
+    try {
+      execSync3(
+        `security delete-generic-password -s "${SERVICE}" -a "${ACCOUNT}" 2>/dev/null`,
+        { timeout: 5e3 }
+      );
+    } catch {
+    }
+    execSync3(
+      `security add-generic-password -s "${SERVICE}" -a "${ACCOUNT}" -w "${value}"`,
+      { timeout: 5e3 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function macKeychainDelete() {
+  if (process.platform !== "darwin") return false;
+  try {
+    execSync3(
+      `security delete-generic-password -s "${SERVICE}" -a "${ACCOUNT}" 2>/dev/null`,
+      { timeout: 5e3 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function linuxSecretGet() {
+  if (process.platform !== "linux") return null;
+  try {
+    return execSync3(
+      `secret-tool lookup service "${SERVICE}" account "${ACCOUNT}" 2>/dev/null`,
+      { encoding: "utf-8", timeout: 5e3 }
+    ).trim();
+  } catch {
+    return null;
+  }
+}
+function linuxSecretSet(value) {
+  if (process.platform !== "linux") return false;
+  try {
+    execSync3(
+      `echo -n "${value}" | secret-tool store --label="exe-os master key" service "${SERVICE}" account "${ACCOUNT}"`,
+      { timeout: 5e3 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+function linuxSecretDelete() {
+  if (process.platform !== "linux") return false;
+  try {
+    execSync3(
+      `secret-tool clear service "${SERVICE}" account "${ACCOUNT}" 2>/dev/null`,
+      { timeout: 5e3 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
 async function tryKeytar() {
   try {
     return await import("keytar");
@@ -1653,13 +1731,72 @@ async function tryKeytar() {
     return null;
   }
 }
+function deriveMachineKey() {
+  try {
+    const crypto13 = __require("crypto");
+    const material = [
+      os6.hostname(),
+      os6.userInfo().username,
+      os6.arch(),
+      os6.platform(),
+      // Machine ID on Linux (stable across reboots)
+      process.platform === "linux" ? readMachineId() : ""
+    ].join("|");
+    return crypto13.createHash("sha256").update(material).digest();
+  } catch {
+    return null;
+  }
+}
+function readMachineId() {
+  try {
+    const { readFileSync: readFileSync28 } = __require("fs");
+    return readFileSync28("/etc/machine-id", "utf-8").trim();
+  } catch {
+    return "";
+  }
+}
+function encryptWithMachineKey(plaintext, machineKey) {
+  const crypto13 = __require("crypto");
+  const iv = crypto13.randomBytes(12);
+  const cipher = crypto13.createCipheriv("aes-256-gcm", machineKey, iv);
+  let encrypted = cipher.update(plaintext, "utf-8", "base64");
+  encrypted += cipher.final("base64");
+  const authTag = cipher.getAuthTag().toString("base64");
+  return `${ENCRYPTED_PREFIX}${iv.toString("base64")}:${authTag}:${encrypted}`;
+}
+function decryptWithMachineKey(encrypted, machineKey) {
+  if (!encrypted.startsWith(ENCRYPTED_PREFIX)) return null;
+  try {
+    const crypto13 = __require("crypto");
+    const parts = encrypted.slice(ENCRYPTED_PREFIX.length).split(":");
+    if (parts.length !== 3) return null;
+    const [ivB64, tagB64, cipherB64] = parts;
+    const iv = Buffer.from(ivB64, "base64");
+    const authTag = Buffer.from(tagB64, "base64");
+    const decipher = crypto13.createDecipheriv("aes-256-gcm", machineKey, iv);
+    decipher.setAuthTag(authTag);
+    let decrypted = decipher.update(cipherB64, "base64", "utf-8");
+    decrypted += decipher.final("utf-8");
+    return decrypted;
+  } catch {
+    return null;
+  }
+}
 async function getMasterKey() {
+  const nativeValue = macKeychainGet() ?? linuxSecretGet();
+  if (nativeValue) {
+    return Buffer.from(nativeValue, "base64");
+  }
   const keytar = await tryKeytar();
   if (keytar) {
     try {
-      const stored = await keytar.getPassword(SERVICE, ACCOUNT);
-      if (stored) {
-        return Buffer.from(stored, "base64");
+      const keytarValue = await keytar.getPassword(SERVICE, ACCOUNT);
+      if (keytarValue) {
+        const migrated = macKeychainSet(keytarValue) || linuxSecretSet(keytarValue);
+        if (migrated) {
+          process.stderr.write("[keychain] Migrated key from keytar to native keychain.\n");
+        }
+        return Buffer.from(keytarValue, "base64");
       }
     } catch {
     }
@@ -1673,8 +1810,31 @@ async function getMasterKey() {
     return null;
   }
   try {
-    const content = await readFile4(keyPath, "utf-8");
-    return Buffer.from(content.trim(), "base64");
+    const content = (await readFile4(keyPath, "utf-8")).trim();
+    let b64Value;
+    if (content.startsWith(ENCRYPTED_PREFIX)) {
+      const machineKey = deriveMachineKey();
+      if (!machineKey) {
+        process.stderr.write("[keychain] Cannot derive machine key to decrypt stored key.\n");
+        return null;
+      }
+      const decrypted = decryptWithMachineKey(content, machineKey);
+      if (!decrypted) {
+        process.stderr.write(
+          "[keychain] Key decryption failed \u2014 machine may have changed.\n  Use your 24-word recovery phrase: exe-os link import\n"
+        );
+        return null;
+      }
+      b64Value = decrypted;
+    } else {
+      b64Value = content;
+    }
+    const key = Buffer.from(b64Value, "base64");
+    const migrated = macKeychainSet(b64Value) || linuxSecretSet(b64Value);
+    if (migrated) {
+      process.stderr.write("[keychain] Migrated key from file to native keychain.\n");
+    }
+    return key;
   } catch (err) {
     process.stderr.write(
       `[keychain] Key read failed at ${keyPath}: ${err instanceof Error ? err.message : String(err)}
@@ -1685,6 +1845,9 @@ async function getMasterKey() {
 }
 async function setMasterKey(key) {
   const b64 = key.toString("base64");
+  if (macKeychainSet(b64) || linuxSecretSet(b64)) {
+    return;
+  }
   const keytar = await tryKeytar();
   if (keytar) {
     try {
@@ -1696,10 +1859,23 @@ async function setMasterKey(key) {
   const dir = getKeyDir();
   await mkdir4(dir, { recursive: true });
   const keyPath = getKeyPath();
-  await writeFile4(keyPath, b64 + "\n", "utf-8");
-  await chmod2(keyPath, 384);
+  const machineKey = deriveMachineKey();
+  if (machineKey) {
+    const encrypted = encryptWithMachineKey(b64, machineKey);
+    await writeFile4(keyPath, encrypted + "\n", "utf-8");
+    await chmod2(keyPath, 384);
+    process.stderr.write("[keychain] Key stored encrypted (machine-bound).\n");
+  } else {
+    await writeFile4(keyPath, b64 + "\n", "utf-8");
+    await chmod2(keyPath, 384);
+    process.stderr.write(
+      "[keychain] WARNING: Key stored in plaintext file \u2014 no OS keychain available.\n"
+    );
+  }
 }
 async function deleteMasterKey() {
+  macKeychainDelete();
+  linuxSecretDelete();
   const keytar = await tryKeytar();
   if (keytar) {
     try {
@@ -1741,12 +1917,13 @@ async function importMnemonic(mnemonic) {
   const entropy = mnemonicToEntropy(trimmed);
   return Buffer.from(entropy, "hex");
 }
-var SERVICE, ACCOUNT;
+var SERVICE, ACCOUNT, ENCRYPTED_PREFIX;
 var init_keychain = __esm({
   "src/lib/keychain.ts"() {
     "use strict";
     SERVICE = "exe-mem";
     ACCOUNT = "master-key";
+    ENCRYPTED_PREFIX = "enc:";
   }
 });
 
@@ -2550,8 +2727,8 @@ function findPackageRoot() {
 function getAvailableMemoryGB() {
   if (process.platform === "darwin") {
     try {
-      const { execSync: execSync15 } = __require("child_process");
-      const vmstat = execSync15("vm_stat", { encoding: "utf8" });
+      const { execSync: execSync16 } = __require("child_process");
+      const vmstat = execSync16("vm_stat", { encoding: "utf8" });
       const pageSize = 16384;
       const pageSizeMatch = vmstat.match(/page size of (\d+) bytes/);
       const actualPageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : pageSize;
@@ -4572,8 +4749,8 @@ async function validateLicense(apiKey, deviceId) {
 }
 function getCacheAgeMs() {
   try {
-    const { statSync: statSync2 } = __require("fs");
-    const s = statSync2(CACHE_PATH);
+    const { statSync: statSync3 } = __require("fs");
+    const s = statSync3(CACHE_PATH);
     return Date.now() - s.mtimeMs;
   } catch {
     return Infinity;
@@ -5003,6 +5180,109 @@ var init_crdt_sync = __esm({
   }
 });
 
+// src/lib/db-backup.ts
+var db_backup_exports = {};
+__export(db_backup_exports, {
+  createBackup: () => createBackup,
+  findActiveDb: () => findActiveDb,
+  getBackupDir: () => getBackupDir,
+  getLatestBackup: () => getLatestBackup,
+  hasBackupToday: () => hasBackupToday,
+  listBackups: () => listBackups,
+  rotateBackups: () => rotateBackups
+});
+import { copyFileSync as copyFileSync2, existsSync as existsSync13, mkdirSync as mkdirSync6, readdirSync, unlinkSync as unlinkSync4, statSync as statSync2 } from "fs";
+import path13 from "path";
+function findActiveDb() {
+  for (const name of DB_NAMES) {
+    const p = path13.join(EXE_AI_DIR, name);
+    if (existsSync13(p)) return p;
+  }
+  return null;
+}
+function createBackup(reason = "manual") {
+  const dbPath = findActiveDb();
+  if (!dbPath) return null;
+  mkdirSync6(BACKUP_DIR, { recursive: true });
+  const dbName = path13.basename(dbPath, ".db");
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
+  const backupName = `${dbName}-${reason}-${timestamp}.db`;
+  const backupPath = path13.join(BACKUP_DIR, backupName);
+  copyFileSync2(dbPath, backupPath);
+  const walPath = dbPath + "-wal";
+  if (existsSync13(walPath)) {
+    try {
+      copyFileSync2(walPath, backupPath + "-wal");
+    } catch {
+    }
+  }
+  const shmPath = dbPath + "-shm";
+  if (existsSync13(shmPath)) {
+    try {
+      copyFileSync2(shmPath, backupPath + "-shm");
+    } catch {
+    }
+  }
+  return backupPath;
+}
+function rotateBackups(keepDays = DEFAULT_KEEP_DAYS) {
+  if (!existsSync13(BACKUP_DIR)) return 0;
+  const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1e3;
+  let deleted = 0;
+  try {
+    const files = readdirSync(BACKUP_DIR);
+    for (const file of files) {
+      if (!file.endsWith(".db") && !file.endsWith(".db-wal") && !file.endsWith(".db-shm")) continue;
+      const filePath = path13.join(BACKUP_DIR, file);
+      try {
+        const stat2 = statSync2(filePath);
+        if (stat2.mtimeMs < cutoff) {
+          unlinkSync4(filePath);
+          deleted++;
+        }
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return deleted;
+}
+function listBackups() {
+  if (!existsSync13(BACKUP_DIR)) return [];
+  try {
+    const files = readdirSync(BACKUP_DIR).filter((f) => f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm"));
+    return files.map((name) => {
+      const p = path13.join(BACKUP_DIR, name);
+      const stat2 = statSync2(p);
+      return { path: p, name, size: stat2.size, date: stat2.mtime };
+    }).sort((a, b) => b.date.getTime() - a.date.getTime());
+  } catch {
+    return [];
+  }
+}
+function hasBackupToday(reason) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const backups = listBackups();
+  return backups.some((b) => b.name.includes(reason) && b.name.includes(today.replace(/-/g, "-")));
+}
+function getLatestBackup() {
+  const backups = listBackups();
+  return backups.length > 0 ? backups[0].path : null;
+}
+function getBackupDir() {
+  return BACKUP_DIR;
+}
+var BACKUP_DIR, DEFAULT_KEEP_DAYS, DB_NAMES;
+var init_db_backup = __esm({
+  "src/lib/db-backup.ts"() {
+    "use strict";
+    init_config();
+    BACKUP_DIR = path13.join(EXE_AI_DIR, "backups");
+    DEFAULT_KEEP_DAYS = 3;
+    DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
+  }
+});
+
 // src/lib/cloud-sync.ts
 var cloud_sync_exports = {};
 __export(cloud_sync_exports, {
@@ -5032,16 +5312,16 @@ __export(cloud_sync_exports, {
   pushToPostgres: () => pushToPostgres,
   recordRosterDeletion: () => recordRosterDeletion
 });
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, existsSync as existsSync13, readdirSync, mkdirSync as mkdirSync6, appendFileSync, unlinkSync as unlinkSync4, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync8, existsSync as existsSync14, readdirSync as readdirSync2, mkdirSync as mkdirSync7, appendFileSync, unlinkSync as unlinkSync5, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto4 from "crypto";
-import path13 from "path";
+import path14 from "path";
 import { homedir as homedir2 } from "os";
 function sqlSafe(v) {
   return v === void 0 ? null : v;
 }
 function logError(msg) {
   try {
-    const logPath = path13.join(homedir2(), ".exe-os", "workers.log");
+    const logPath = path14.join(homedir2(), ".exe-os", "workers.log");
     appendFileSync(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -5050,10 +5330,10 @@ function logError(msg) {
 function loadPgClient() {
   if (_pgFailed) return null;
   const postgresUrl = process.env.DATABASE_URL;
-  const configPath = path13.join(EXE_AI_DIR, "config.json");
+  const configPath = path14.join(EXE_AI_DIR, "config.json");
   let cloudPostgresUrl;
   try {
-    if (existsSync13(configPath)) {
+    if (existsSync14(configPath)) {
       const cfg = JSON.parse(readFileSync10(configPath, "utf8"));
       cloudPostgresUrl = cfg.cloud?.postgresUrl;
       if (cfg.cloud?.syncToPostgres === false) {
@@ -5072,8 +5352,8 @@ function loadPgClient() {
     _pgPromise = (async () => {
       const { createRequire: createRequire3 } = await import("module");
       const { pathToFileURL: pathToFileURL3 } = await import("url");
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path13.join(homedir2(), "exe-db");
-      const req = createRequire3(path13.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path14.join(homedir2(), "exe-db");
+      const req = createRequire3(path14.join(exeDbRoot, "package.json"));
       const entry = req.resolve("@prisma/client");
       const mod = await import(pathToFileURL3(entry).href);
       const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
@@ -5126,7 +5406,7 @@ async function withRosterLock(fn) {
         if (Date.now() - ts < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
-        unlinkSync4(ROSTER_LOCK_PATH);
+        unlinkSync5(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
         writeFileSync8(ROSTER_LOCK_PATH, String(Date.now()));
@@ -5142,7 +5422,7 @@ async function withRosterLock(fn) {
     return await fn();
   } finally {
     try {
-      unlinkSync4(ROSTER_LOCK_PATH);
+      unlinkSync5(ROSTER_LOCK_PATH);
     } catch {
     }
   }
@@ -5513,13 +5793,42 @@ async function cloudSync(config) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path13.join(EXE_AI_DIR, "identity");
-    if (existsSync13(idDir)) {
-      rosterResult.identities = readdirSync(idDir).filter((f) => f.endsWith(".md")).length;
+    const idDir = path14.join(EXE_AI_DIR, "identity");
+    if (existsSync14(idDir)) {
+      rosterResult.identities = readdirSync2(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
   }
   const totalMemories = await countRows("SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL");
+  try {
+    const { getLatestBackup: getLatestBackup2 } = await Promise.resolve().then(() => (init_db_backup(), db_backup_exports));
+    const { statSync: statFile } = await import("fs");
+    const latestBackup = getLatestBackup2();
+    if (latestBackup) {
+      const backupSize = statFile(latestBackup).size;
+      const MAX_CLOUD_BACKUP_BYTES = 50 * 1024 * 1024;
+      if (backupSize <= MAX_CLOUD_BACKUP_BYTES) {
+        const backupData = readFileSync10(latestBackup);
+        const deviceId = loadDeviceId() ?? "unknown";
+        const encrypted = encryptSyncBlob(backupData);
+        const backupRes = await fetchWithRetry(`${config.endpoint}/sync/push-db-backup`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
+          body: JSON.stringify({
+            device_id: deviceId,
+            filename: path14.basename(latestBackup),
+            blob: encrypted,
+            size: backupData.length
+          })
+        });
+        if (backupRes && !backupRes.ok) {
+          logError(`[cloud-sync] DB backup upload failed: ${backupRes.status}`);
+        }
+      }
+    }
+  } catch (err) {
+    logError(`[cloud-sync] DB backup upload error: ${err instanceof Error ? err.message : String(err)}`);
+  }
   return {
     pushed,
     pulled,
@@ -5535,7 +5844,7 @@ async function cloudSync(config) {
 function recordRosterDeletion(name) {
   let deletions = [];
   try {
-    if (existsSync13(ROSTER_DELETIONS_PATH)) {
+    if (existsSync14(ROSTER_DELETIONS_PATH)) {
       deletions = JSON.parse(readFileSync10(ROSTER_DELETIONS_PATH, "utf-8"));
     }
   } catch {
@@ -5545,7 +5854,7 @@ function recordRosterDeletion(name) {
 }
 function consumeRosterDeletions() {
   try {
-    if (!existsSync13(ROSTER_DELETIONS_PATH)) return [];
+    if (!existsSync14(ROSTER_DELETIONS_PATH)) return [];
     const deletions = JSON.parse(readFileSync10(ROSTER_DELETIONS_PATH, "utf-8"));
     writeFileSync8(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
@@ -5554,35 +5863,35 @@ function consumeRosterDeletions() {
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path13.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path13.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path13.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path14.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path14.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path14.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync13(rosterPath)) {
+  if (existsSync14(rosterPath)) {
     try {
       roster = JSON.parse(readFileSync10(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync13(identityDir)) {
-    for (const file of readdirSync(identityDir).filter((f) => f.endsWith(".md"))) {
+  if (existsSync14(identityDir)) {
+    for (const file of readdirSync2(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync10(path13.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync10(path14.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config;
-  if (existsSync13(configPath)) {
+  if (existsSync14(configPath)) {
     try {
       config = JSON.parse(readFileSync10(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path13.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync13(agentConfigPath)) {
+  const agentConfigPath = path14.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync14(agentConfigPath)) {
     try {
       agentConfig = JSON.parse(readFileSync10(agentConfigPath, "utf-8"));
     } catch {
@@ -5660,16 +5969,16 @@ async function cloudPullRoster(config) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path13.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path14.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync13(cfgPath)) {
+  if (existsSync14(cfgPath)) {
     try {
       local = JSON.parse(readFileSync10(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path13.dirname(cfgPath);
+  const dir = path14.dirname(cfgPath);
   ensurePrivateDirSync(dir);
   writeFileSync8(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
   enforcePrivateFileSync(cfgPath);
@@ -5677,7 +5986,7 @@ function mergeConfig(remoteConfig, configPath) {
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path13.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path14.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -5698,11 +6007,11 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync13(identityDir)) mkdirSync6(identityDir, { recursive: true });
-        const idPath = path13.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync14(identityDir)) mkdirSync7(identityDir, { recursive: true });
+        const idPath = path14.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync13(idPath) ? readFileSync10(idPath, "utf-8") : null;
+          localIdentity = existsSync14(idPath) ? readFileSync10(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
@@ -5732,16 +6041,16 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path13.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path14.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
-        if (existsSync13(agentConfigPath)) {
+        if (existsSync14(agentConfigPath)) {
           try {
             local = JSON.parse(readFileSync10(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        ensurePrivateDirSync(path13.dirname(agentConfigPath));
+        ensurePrivateDirSync(path14.dirname(agentConfigPath));
         writeFileSync8(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
         enforcePrivateFileSync(agentConfigPath);
       } catch {
@@ -6182,11 +6491,11 @@ var init_cloud_sync = __esm({
     LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
     FETCH_TIMEOUT_MS = 3e4;
     PUSH_BATCH_SIZE = 5e3;
-    ROSTER_LOCK_PATH = path13.join(EXE_AI_DIR, "roster-merge.lock");
+    ROSTER_LOCK_PATH = path14.join(EXE_AI_DIR, "roster-merge.lock");
     LOCK_STALE_MS = 3e4;
     _pgPromise = null;
     _pgFailed = false;
-    ROSTER_DELETIONS_PATH = path13.join(EXE_AI_DIR, "roster-deletions.json");
+    ROSTER_DELETIONS_PATH = path14.join(EXE_AI_DIR, "roster-deletions.json");
   }
 });
 
@@ -6484,13 +6793,13 @@ __export(shard_manager_exports, {
   listShards: () => listShards,
   shardExists: () => shardExists
 });
-import path14 from "path";
-import { existsSync as existsSync14, mkdirSync as mkdirSync7, readdirSync as readdirSync2 } from "fs";
+import path15 from "path";
+import { existsSync as existsSync15, mkdirSync as mkdirSync8, readdirSync as readdirSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
-  if (!existsSync14(SHARDS_DIR)) {
-    mkdirSync7(SHARDS_DIR, { recursive: true });
+  if (!existsSync15(SHARDS_DIR)) {
+    mkdirSync8(SHARDS_DIR, { recursive: true });
   }
   _shardingEnabled = true;
   if (_evictionTimer) clearInterval(_evictionTimer);
@@ -6519,7 +6828,7 @@ function getShardClient(projectName) {
   while (_shards.size >= MAX_OPEN_SHARDS) {
     evictLRU();
   }
-  const dbPath = path14.join(SHARDS_DIR, `${safeName}.db`);
+  const dbPath = path15.join(SHARDS_DIR, `${safeName}.db`);
   const client = createClient2({
     url: `file:${dbPath}`,
     encryptionKey: _encryptionKey
@@ -6530,11 +6839,11 @@ function getShardClient(projectName) {
 }
 function shardExists(projectName) {
   const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return existsSync14(path14.join(SHARDS_DIR, `${safeName}.db`));
+  return existsSync15(path15.join(SHARDS_DIR, `${safeName}.db`));
 }
 function listShards() {
-  if (!existsSync14(SHARDS_DIR)) return [];
-  return readdirSync2(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
+  if (!existsSync15(SHARDS_DIR)) return [];
+  return readdirSync3(SHARDS_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(".db", ""));
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
@@ -6780,7 +7089,7 @@ var init_shard_manager = __esm({
   "src/lib/shard-manager.ts"() {
     "use strict";
     init_config();
-    SHARDS_DIR = path14.join(EXE_AI_DIR, "shards");
+    SHARDS_DIR = path15.join(EXE_AI_DIR, "shards");
     SHARD_IDLE_MS = 5 * 60 * 1e3;
     MAX_OPEN_SHARDS = 10;
     EVICTION_INTERVAL_MS = 60 * 1e3;
@@ -7650,12 +7959,12 @@ __export(backfill_conversations_exports, {
 import crypto5 from "crypto";
 import { createReadStream } from "fs";
 import { readdir as readdir2, stat } from "fs/promises";
-import path15 from "path";
+import path16 from "path";
 import { createInterface as createInterface2 } from "readline";
 import { homedir as homedir3 } from "os";
 import { parseArgs } from "util";
 async function findJsonlFiles(sinceDate, projectFilter) {
-  const projectsDir = path15.join(homedir3(), ".claude", "projects");
+  const projectsDir = path16.join(homedir3(), ".claude", "projects");
   const files = [];
   async function walk(dir, depth = 0) {
     if (depth > MAX_WALK_DEPTH) return;
@@ -7666,7 +7975,7 @@ async function findJsonlFiles(sinceDate, projectFilter) {
       return;
     }
     for (const entry of entries) {
-      const full = path15.join(dir, entry.name);
+      const full = path16.join(dir, entry.name);
       if (entry.isDirectory()) {
         if (entry.name === "subagents" || entry.name === "tool-results") continue;
         await walk(full, depth + 1);
@@ -7691,7 +8000,7 @@ async function findJsonlFiles(sinceDate, projectFilter) {
       if (!entry.isDirectory()) continue;
       const decoded = decodeProjectDir(entry.name);
       if (decoded.toLowerCase().includes(projectFilter.toLowerCase())) {
-        await walk(path15.join(projectsDir, entry.name));
+        await walk(path16.join(projectsDir, entry.name));
       }
     }
   } else {
@@ -7708,14 +8017,14 @@ function decodeProjectDir(dirName) {
   return dirName;
 }
 function projectNameFromPath(filePath) {
-  const projectsDir = path15.join(homedir3(), ".claude", "projects");
-  const relative = path15.relative(projectsDir, filePath);
-  const projectDir = relative.split(path15.sep)[0] ?? "unknown";
+  const projectsDir = path16.join(homedir3(), ".claude", "projects");
+  const relative = path16.relative(projectsDir, filePath);
+  const projectDir = relative.split(path16.sep)[0] ?? "unknown";
   return decodeProjectDir(projectDir);
 }
 async function parseConversation(filePath) {
   const conv = {
-    sessionId: path15.basename(filePath, ".jsonl"),
+    sessionId: path16.basename(filePath, ".jsonl"),
     projectName: projectNameFromPath(filePath),
     cwd: void 0,
     startTime: void 0,
@@ -7779,7 +8088,7 @@ async function parseConversation(filePath) {
     }
   }
   if (conv.cwd) {
-    conv.projectName = path15.basename(conv.cwd);
+    conv.projectName = path16.basename(conv.cwd);
     const worktreeMatch = conv.cwd.match(/\.worktrees\/([^/]+)/);
     if (worktreeMatch?.[1]) {
       conv.agentId = worktreeMatch[1];
@@ -8431,9 +8740,9 @@ Unclassified: ${unclassified}
 }
 async function exportBatches(options) {
   const fs8 = await import("fs");
-  const path47 = await import("path");
+  const path48 = await import("path");
   const client = getClient();
-  const outDir = path47.join(process.cwd(), "exe/output/classifications/input");
+  const outDir = path48.join(process.cwd(), "exe/output/classifications/input");
   fs8.mkdirSync(outDir, { recursive: true });
   const countResult = await client.execute({
     sql: "SELECT COUNT(*) as cnt FROM memories WHERE intent IS NULL AND outcome IS NULL AND domain IS NULL",
@@ -8457,7 +8766,7 @@ async function exportBatches(options) {
       const text = String(row.text || "").replace(/\n/g, " ");
       return JSON.stringify({ id: row.id, text });
     });
-    const batchFile = path47.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
+    const batchFile = path48.join(outDir, `batch-${String(batchNum).padStart(4, "0")}.jsonl`);
     fs8.writeFileSync(batchFile, lines.join("\n") + "\n");
     exported += batch.rows.length;
     offset += options.batchSize;
@@ -8473,7 +8782,7 @@ async function exportBatches(options) {
 }
 async function importClassifications(importDir) {
   const fs8 = await import("fs");
-  const path47 = await import("path");
+  const path48 = await import("path");
   const client = getClient();
   const files = fs8.readdirSync(importDir).filter((f) => f.endsWith(".jsonl")).sort();
   process.stderr.write(`[backfill-metadata] Found ${files.length} JSONL files to import from ${importDir}
@@ -8481,7 +8790,7 @@ async function importClassifications(importDir) {
   let imported = 0;
   let invalid = 0;
   for (const file of files) {
-    const lines = fs8.readFileSync(path47.join(importDir, file), "utf-8").split("\n").filter(Boolean);
+    const lines = fs8.readFileSync(path48.join(importDir, file), "utf-8").split("\n").filter(Boolean);
     for (const line of lines) {
       try {
         const rec = JSON.parse(line);
@@ -8622,17 +8931,17 @@ __export(identity_exports, {
   listIdentities: () => listIdentities,
   updateIdentity: () => updateIdentity
 });
-import { existsSync as existsSync15, mkdirSync as mkdirSync8, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
-import { readdirSync as readdirSync3 } from "fs";
-import path16 from "path";
+import { existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync11, writeFileSync as writeFileSync9 } from "fs";
+import { readdirSync as readdirSync4 } from "fs";
+import path17 from "path";
 import { createHash as createHash2 } from "crypto";
 function ensureDir() {
-  if (!existsSync15(IDENTITY_DIR2)) {
-    mkdirSync8(IDENTITY_DIR2, { recursive: true });
+  if (!existsSync16(IDENTITY_DIR2)) {
+    mkdirSync9(IDENTITY_DIR2, { recursive: true });
   }
 }
 function identityPath(agentId) {
-  return path16.join(IDENTITY_DIR2, `${agentId}.md`);
+  return path17.join(IDENTITY_DIR2, `${agentId}.md`);
 }
 function parseFrontmatter(raw) {
   const match = raw.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
@@ -8673,7 +8982,7 @@ function contentHash(content) {
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
-  if (!existsSync15(filePath)) return null;
+  if (!existsSync16(filePath)) return null;
   const raw = readFileSync11(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
@@ -8705,7 +9014,7 @@ async function updateIdentity(agentId, content, updatedBy) {
 }
 function listIdentities() {
   ensureDir();
-  const files = readdirSync3(IDENTITY_DIR2).filter((f) => f.endsWith(".md"));
+  const files = readdirSync4(IDENTITY_DIR2).filter((f) => f.endsWith(".md"));
   const results = [];
   for (const file of files) {
     const agentId = file.replace(".md", "");
@@ -8744,15 +9053,15 @@ var init_identity = __esm({
     "use strict";
     init_config();
     init_database();
-    IDENTITY_DIR2 = path16.join(EXE_AI_DIR, "identity");
+    IDENTITY_DIR2 = path17.join(EXE_AI_DIR, "identity");
   }
 });
 
 // src/lib/orchestration-package.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync16, mkdirSync as mkdirSync9, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
+import { copyFileSync as copyFileSync3, existsSync as existsSync17, mkdirSync as mkdirSync10, readFileSync as readFileSync12, writeFileSync as writeFileSync10 } from "fs";
 import os10 from "os";
-import path17 from "path";
+import path18 from "path";
 function ensureObject(value, label) {
   if (value == null || Array.isArray(value) || typeof value !== "object") {
     throw new Error(`${label} must be an object`);
@@ -8811,14 +9120,14 @@ function validateProcedureEntry(value, index) {
   };
 }
 function getRosterPath() {
-  return path17.join(os10.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+  return path18.join(os10.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
 }
 function getBackupPath() {
-  return path17.join(os10.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+  return path18.join(os10.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
 }
 function readRosterFile() {
   const rosterPath = getRosterPath();
-  if (!existsSync16(rosterPath)) return [];
+  if (!existsSync17(rosterPath)) return [];
   const raw = readFileSync12(rosterPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) {
@@ -8831,15 +9140,15 @@ function writeRosterFile(roster) {
     throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
   }
   const rosterPath = getRosterPath();
-  mkdirSync9(path17.dirname(rosterPath), { recursive: true });
-  if (existsSync16(rosterPath)) {
+  mkdirSync10(path18.dirname(rosterPath), { recursive: true });
+  if (existsSync17(rosterPath)) {
     const currentRoster = readRosterFile();
     if (roster.length < currentRoster.length) {
       throw new Error(
         `Refusing to write roster with ${roster.length} entries \u2014 current roster has ${currentRoster.length}. Import would delete ${currentRoster.length - roster.length} employee(s). Use merge strategy instead, or add the missing entries to the package.`
       );
     }
-    copyFileSync2(rosterPath, getBackupPath());
+    copyFileSync3(rosterPath, getBackupPath());
   }
   writeFileSync10(rosterPath, `${JSON.stringify(roster, null, 2)}
 `, "utf-8");
@@ -9108,8 +9417,8 @@ var exe_export_exports = {};
 __export(exe_export_exports, {
   runExeExport: () => runExeExport
 });
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
-import path18 from "path";
+import { mkdirSync as mkdirSync11, writeFileSync as writeFileSync11 } from "fs";
+import path19 from "path";
 function printUsage() {
   process.stdout.write("Usage: exe-os export --output <path>\n");
 }
@@ -9130,7 +9439,7 @@ async function runExeExport(argv = process.argv.slice(2)) {
   await initStore();
   try {
     const pkg = await exportOrchestration("cli");
-    mkdirSync10(path18.dirname(outputPath), { recursive: true });
+    mkdirSync11(path19.dirname(outputPath), { recursive: true });
     writeFileSync11(outputPath, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
     process.stdout.write(
@@ -9231,14 +9540,14 @@ __export(session_registry_exports, {
   refreshSessionProject: () => refreshSessionProject,
   registerSession: () => registerSession
 });
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync12, mkdirSync as mkdirSync11, existsSync as existsSync17 } from "fs";
-import { execSync as execSync3 } from "child_process";
-import path19 from "path";
+import { readFileSync as readFileSync14, writeFileSync as writeFileSync12, mkdirSync as mkdirSync12, existsSync as existsSync18 } from "fs";
+import { execSync as execSync4 } from "child_process";
+import path20 from "path";
 import os11 from "os";
 function registerSession(entry) {
-  const dir = path19.dirname(REGISTRY_PATH);
-  if (!existsSync17(dir)) {
-    mkdirSync11(dir, { recursive: true });
+  const dir = path20.dirname(REGISTRY_PATH);
+  if (!existsSync18(dir)) {
+    mkdirSync12(dir, { recursive: true });
   }
   const sessions = listSessions();
   const idx = sessions.findIndex((s) => s.windowName === entry.windowName);
@@ -9272,7 +9581,7 @@ function pruneStaleSessions() {
   if (sessions.length === 0) return 0;
   let liveSessions = [];
   try {
-    liveSessions = execSync3("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+    liveSessions = execSync4("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
       encoding: "utf8"
     }).trim().split("\n").filter(Boolean);
   } catch {
@@ -9290,12 +9599,12 @@ var REGISTRY_PATH;
 var init_session_registry = __esm({
   "src/lib/session-registry.ts"() {
     "use strict";
-    REGISTRY_PATH = path19.join(os11.homedir(), ".exe-os", "session-registry.json");
+    REGISTRY_PATH = path20.join(os11.homedir(), ".exe-os", "session-registry.json");
   }
 });
 
 // src/lib/session-key.ts
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 function normalizeCommand(command) {
   const trimmed = command.trim().toLowerCase();
   const parts = trimmed.split(/[\\/]/);
@@ -9314,7 +9623,7 @@ function resolveRuntimeProcess() {
   let pid = process.ppid;
   for (let i = 0; i < 10; i++) {
     try {
-      const info = execSync4(`ps -p ${pid} -o ppid=,comm=`, {
+      const info = execSync5(`ps -p ${pid} -o ppid=,comm=`, {
         encoding: "utf8",
         timeout: 2e3
       }).trim();
@@ -9488,14 +9797,14 @@ var init_transport = __esm({
 });
 
 // src/lib/cc-agent-support.ts
-import { execSync as execSync5 } from "child_process";
+import { execSync as execSync6 } from "child_process";
 function _resetCcAgentSupportCache() {
   _cachedSupport = null;
 }
 function claudeSupportsAgentFlag() {
   if (_cachedSupport !== null) return _cachedSupport;
   try {
-    const helpOutput = execSync5("claude --help 2>&1", {
+    const helpOutput = execSync6("claude --help 2>&1", {
       encoding: "utf-8",
       timeout: 5e3
     });
@@ -9546,16 +9855,16 @@ __export(intercom_queue_exports, {
   queueIntercom: () => queueIntercom,
   readQueue: () => readQueue
 });
-import { readFileSync as readFileSync15, writeFileSync as writeFileSync13, renameSync as renameSync3, existsSync as existsSync18, mkdirSync as mkdirSync12 } from "fs";
-import path20 from "path";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync13, renameSync as renameSync3, existsSync as existsSync19, mkdirSync as mkdirSync13 } from "fs";
+import path21 from "path";
 import os12 from "os";
 function ensureDir2() {
-  const dir = path20.dirname(QUEUE_PATH);
-  if (!existsSync18(dir)) mkdirSync12(dir, { recursive: true });
+  const dir = path21.dirname(QUEUE_PATH);
+  if (!existsSync19(dir)) mkdirSync13(dir, { recursive: true });
 }
 function readQueue() {
   try {
-    if (!existsSync18(QUEUE_PATH)) return [];
+    if (!existsSync19(QUEUE_PATH)) return [];
     return JSON.parse(readFileSync15(QUEUE_PATH, "utf8"));
   } catch {
     return [];
@@ -9656,19 +9965,19 @@ var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
-    QUEUE_PATH = path20.join(os12.homedir(), ".exe-os", "intercom-queue.json");
+    QUEUE_PATH = path21.join(os12.homedir(), ".exe-os", "intercom-queue.json");
     MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
-    INTERCOM_LOG = path20.join(os12.homedir(), ".exe-os", "intercom.log");
+    INTERCOM_LOG = path21.join(os12.homedir(), ".exe-os", "intercom.log");
   }
 });
 
 // src/lib/plan-limits.ts
-import { readFileSync as readFileSync16, existsSync as existsSync19 } from "fs";
-import path21 from "path";
+import { readFileSync as readFileSync16, existsSync as existsSync20 } from "fs";
+import path22 from "path";
 function getLicenseSync() {
   try {
-    if (!existsSync19(CACHE_PATH2)) return freeLicense();
+    if (!existsSync20(CACHE_PATH2)) return freeLicense();
     const raw = JSON.parse(readFileSync16(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
@@ -9707,7 +10016,7 @@ function assertEmployeeLimitSync(rosterPath) {
   const filePath = rosterPath ?? EMPLOYEES_PATH;
   let count = 0;
   try {
-    if (existsSync19(filePath)) {
+    if (existsSync20(filePath)) {
       const raw = readFileSync16(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
@@ -9737,7 +10046,7 @@ var init_plan_limits = __esm({
         this.name = "PlanLimitError";
       }
     };
-    CACHE_PATH2 = path21.join(EXE_AI_DIR, "license-cache.json");
+    CACHE_PATH2 = path22.join(EXE_AI_DIR, "license-cache.json");
   }
 });
 
@@ -9782,13 +10091,13 @@ var init_task_scope = __esm({
 
 // src/lib/notifications.ts
 import crypto6 from "crypto";
-import path22 from "path";
+import path23 from "path";
 import os13 from "os";
 import {
   readFileSync as readFileSync17,
-  readdirSync as readdirSync4,
-  unlinkSync as unlinkSync5,
-  existsSync as existsSync20,
+  readdirSync as readdirSync5,
+  unlinkSync as unlinkSync6,
+  existsSync as existsSync21,
   rmdirSync
 } from "fs";
 async function writeNotification(notification) {
@@ -9872,34 +10181,34 @@ var init_session_kill_telemetry = __esm({
 });
 
 // src/lib/project-name.ts
-import { execSync as execSync6 } from "child_process";
-import path23 from "path";
+import { execSync as execSync7 } from "child_process";
+import path24 from "path";
 function getProjectName(cwd2) {
   const dir = cwd2 ?? process.cwd();
   if (_cached2 && _cachedCwd === dir) return _cached2;
   try {
     let repoRoot;
     try {
-      const gitCommonDir = execSync6("git rev-parse --path-format=absolute --git-common-dir", {
+      const gitCommonDir = execSync7("git rev-parse --path-format=absolute --git-common-dir", {
         cwd: dir,
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
-      repoRoot = path23.dirname(gitCommonDir);
+      repoRoot = path24.dirname(gitCommonDir);
     } catch {
-      repoRoot = execSync6("git rev-parse --show-toplevel", {
+      repoRoot = execSync7("git rev-parse --show-toplevel", {
         cwd: dir,
         encoding: "utf8",
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       }).trim();
     }
-    _cached2 = path23.basename(repoRoot);
+    _cached2 = path24.basename(repoRoot);
     _cachedCwd = dir;
     return _cached2;
   } catch {
-    _cached2 = path23.basename(dir);
+    _cached2 = path24.basename(dir);
     _cachedCwd = dir;
     return _cached2;
   }
@@ -9993,11 +10302,11 @@ __export(tasks_crud_exports, {
   writeCheckpoint: () => writeCheckpoint
 });
 import crypto8 from "crypto";
-import path24 from "path";
+import path25 from "path";
 import os14 from "os";
-import { execSync as execSync7 } from "child_process";
+import { execSync as execSync8 } from "child_process";
 import { mkdir as mkdir5, writeFile as writeFile5, appendFile } from "fs/promises";
-import { existsSync as existsSync21, readFileSync as readFileSync18 } from "fs";
+import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -10196,8 +10505,8 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   }
   if (input.baseDir) {
     try {
-      await mkdir5(path24.join(input.baseDir, "exe", "output"), { recursive: true });
-      await mkdir5(path24.join(input.baseDir, "exe", "research"), { recursive: true });
+      await mkdir5(path25.join(input.baseDir, "exe", "output"), { recursive: true });
+      await mkdir5(path25.join(input.baseDir, "exe", "research"), { recursive: true });
       await ensureArchitectureDoc(input.baseDir, input.projectName);
       await ensureGitignoreExe(input.baseDir);
     } catch {
@@ -10233,10 +10542,10 @@ ${scopeMismatchWarning}` : scopeMismatchWarning;
   });
   if (input.baseDir) {
     try {
-      const EXE_OS_DIR = path24.join(os14.homedir(), ".exe-os");
-      const mdPath = path24.join(EXE_OS_DIR, taskFile);
-      const mdDir = path24.dirname(mdPath);
-      if (!existsSync21(mdDir)) await mkdir5(mdDir, { recursive: true });
+      const EXE_OS_DIR = path25.join(os14.homedir(), ".exe-os");
+      const mdPath = path25.join(EXE_OS_DIR, taskFile);
+      const mdDir = path25.dirname(mdPath);
+      if (!existsSync22(mdDir)) await mkdir5(mdDir, { recursive: true });
       const reviewer = input.reviewer ?? input.assignedBy;
       const mdContent = `# ${input.title}
 
@@ -10340,14 +10649,14 @@ function isTmuxSessionAlive(identifier) {
   if (!identifier || identifier === "unknown") return true;
   try {
     if (identifier.startsWith("%")) {
-      const output = execSync7("tmux list-panes -a -F '#{pane_id}'", {
+      const output = execSync8("tmux list-panes -a -F '#{pane_id}'", {
         timeout: 2e3,
         encoding: "utf8",
         stdio: ["pipe", "pipe", "pipe"]
       });
       return output.split("\n").some((l) => l.trim() === identifier);
     } else {
-      execSync7(`tmux has-session -t ${JSON.stringify(identifier)}`, {
+      execSync8(`tmux has-session -t ${JSON.stringify(identifier)}`, {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -10356,7 +10665,7 @@ function isTmuxSessionAlive(identifier) {
   } catch {
     if (identifier.startsWith("%")) return true;
     try {
-      execSync7("tmux list-sessions", {
+      execSync8("tmux list-sessions", {
         timeout: 2e3,
         stdio: ["pipe", "pipe", "pipe"]
       });
@@ -10371,12 +10680,12 @@ function checkStaleCompletion(taskContext, taskCreatedAt) {
   if (!DELEGATION_KEYWORDS.test(taskContext)) return null;
   try {
     const since = new Date(taskCreatedAt).toISOString();
-    const branch = execSync7(
+    const branch = execSync8(
       "git rev-parse --abbrev-ref HEAD 2>/dev/null",
       { encoding: "utf8", timeout: 3e3 }
     ).trim();
     const branchArg = branch && branch !== "HEAD" ? branch : "";
-    const commitCount = execSync7(
+    const commitCount = execSync8(
       `git log --oneline --since="${since}" ${branchArg} 2>/dev/null | wc -l`,
       { encoding: "utf8", timeout: 5e3 }
     ).trim();
@@ -10536,9 +10845,9 @@ async function deleteTaskCore(taskId, _baseDir) {
   return { taskFile, assignedTo, assignedBy, taskSlug };
 }
 async function ensureArchitectureDoc(baseDir, projectName) {
-  const archPath = path24.join(baseDir, "exe", "ARCHITECTURE.md");
+  const archPath = path25.join(baseDir, "exe", "ARCHITECTURE.md");
   try {
-    if (existsSync21(archPath)) return;
+    if (existsSync22(archPath)) return;
     const template = [
       `# ${projectName} \u2014 System Architecture`,
       "",
@@ -10571,9 +10880,9 @@ async function ensureArchitectureDoc(baseDir, projectName) {
   }
 }
 async function ensureGitignoreExe(baseDir) {
-  const gitignorePath = path24.join(baseDir, ".gitignore");
+  const gitignorePath = path25.join(baseDir, ".gitignore");
   try {
-    if (existsSync21(gitignorePath)) {
+    if (existsSync22(gitignorePath)) {
       const content = readFileSync18(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
@@ -10617,8 +10926,8 @@ __export(tasks_review_exports, {
   isStale: () => isStale,
   listPendingReviews: () => listPendingReviews
 });
-import path25 from "path";
-import { existsSync as existsSync22, readdirSync as readdirSync5, unlinkSync as unlinkSync6 } from "fs";
+import path26 from "path";
+import { existsSync as existsSync23, readdirSync as readdirSync6, unlinkSync as unlinkSync7 } from "fs";
 function formatAge(isoTimestamp) {
   if (!isoTimestamp) return "";
   const ms = Date.now() - new Date(isoTimestamp).getTime();
@@ -10887,11 +11196,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     );
   }
   try {
-    const cacheDir = path25.join(EXE_AI_DIR, "session-cache");
-    if (existsSync22(cacheDir)) {
-      for (const f of readdirSync5(cacheDir)) {
+    const cacheDir = path26.join(EXE_AI_DIR, "session-cache");
+    if (existsSync23(cacheDir)) {
+      for (const f of readdirSync6(cacheDir)) {
         if (f.startsWith("review-notified-")) {
-          unlinkSync6(path25.join(cacheDir, f));
+          unlinkSync7(path26.join(cacheDir, f));
         }
       }
     }
@@ -10913,7 +11222,7 @@ var init_tasks_review = __esm({
 });
 
 // src/lib/tasks-chain.ts
-import path26 from "path";
+import path27 from "path";
 import { readFile as readFile5, writeFile as writeFile6 } from "fs/promises";
 async function cascadeUnblock(taskId, baseDir, now) {
   const client = getClient();
@@ -10930,7 +11239,7 @@ async function cascadeUnblock(taskId, baseDir, now) {
     });
     for (const ur of unblockedRows.rows) {
       try {
-        const ubFile = path26.join(baseDir, String(ur.task_file));
+        const ubFile = path27.join(baseDir, String(ur.task_file));
         let ubContent = await readFile5(ubFile, "utf-8");
         ubContent = ubContent.replace(/\*\*Status:\*\* blocked/, "**Status:** open");
         ubContent = ubContent.replace(/\n\*\*Blocked by:\*\*.*\n/, "\n");
@@ -11114,10 +11423,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: existsSync33 } = await import("fs");
-  const path47 = await import("path");
-  const modelPath = path47.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync33(modelPath)) {
+  const { existsSync: existsSync34 } = await import("fs");
+  const path48 = await import("path");
+  const modelPath = path48.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();
@@ -11483,8 +11792,8 @@ __export(tasks_exports, {
   updateTaskStatus: () => updateTaskStatus,
   writeCheckpoint: () => writeCheckpoint
 });
-import path27 from "path";
-import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync13, unlinkSync as unlinkSync7 } from "fs";
+import path28 from "path";
+import { writeFileSync as writeFileSync14, mkdirSync as mkdirSync14, unlinkSync as unlinkSync8 } from "fs";
 async function createTask(input) {
   const result = await createTaskCore(input);
   if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
@@ -11503,14 +11812,14 @@ async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
   try {
     const agent = String(row.assigned_to);
-    const cacheDir = path27.join(EXE_AI_DIR, "session-cache");
-    const cachePath = path27.join(cacheDir, `current-task-${agent}.json`);
+    const cacheDir = path28.join(EXE_AI_DIR, "session-cache");
+    const cachePath = path28.join(cacheDir, `current-task-${agent}.json`);
     if (input.status === "in_progress") {
-      mkdirSync13(cacheDir, { recursive: true });
+      mkdirSync14(cacheDir, { recursive: true });
       writeFileSync14(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);
+        unlinkSync8(cachePath);
       } catch {
       }
     }
@@ -11974,14 +12283,14 @@ __export(tmux_routing_exports, {
   spawnEmployee: () => spawnEmployee,
   verifyPaneAtCapacity: () => verifyPaneAtCapacity
 });
-import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
-import { readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync14, existsSync as existsSync23, appendFileSync as appendFileSync2, readdirSync as readdirSync6 } from "fs";
-import path28 from "path";
+import { execFileSync as execFileSync2, execSync as execSync9 } from "child_process";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync15, mkdirSync as mkdirSync15, existsSync as existsSync24, appendFileSync as appendFileSync2, readdirSync as readdirSync7 } from "fs";
+import path29 from "path";
 import os15 from "os";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { unlinkSync as unlinkSync8 } from "fs";
+import { unlinkSync as unlinkSync9 } from "fs";
 function spawnLockPath(sessionName) {
-  return path28.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
+  return path29.join(SPAWN_LOCK_DIR, `${sessionName}.lock`);
 }
 function isProcessAlive(pid) {
   try {
@@ -11992,11 +12301,11 @@ function isProcessAlive(pid) {
   }
 }
 function acquireSpawnLock2(sessionName) {
-  if (!existsSync23(SPAWN_LOCK_DIR)) {
-    mkdirSync14(SPAWN_LOCK_DIR, { recursive: true });
+  if (!existsSync24(SPAWN_LOCK_DIR)) {
+    mkdirSync15(SPAWN_LOCK_DIR, { recursive: true });
   }
   const lockFile = spawnLockPath(sessionName);
-  if (existsSync23(lockFile)) {
+  if (existsSync24(lockFile)) {
     try {
       const lock = JSON.parse(readFileSync19(lockFile, "utf8"));
       const age = Date.now() - lock.timestamp;
@@ -12011,20 +12320,20 @@ function acquireSpawnLock2(sessionName) {
 }
 function releaseSpawnLock2(sessionName) {
   try {
-    unlinkSync8(spawnLockPath(sessionName));
+    unlinkSync9(spawnLockPath(sessionName));
   } catch {
   }
 }
 function resolveBehaviorsExporterScript() {
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const scriptPath = path28.join(
-      path28.dirname(thisFile),
+    const scriptPath = path29.join(
+      path29.dirname(thisFile),
       "..",
       "bin",
       "exe-export-behaviors.js"
     );
-    return existsSync23(scriptPath) ? scriptPath : null;
+    return existsSync24(scriptPath) ? scriptPath : null;
   } catch {
     return null;
   }
@@ -12090,11 +12399,11 @@ function extractRootExe(name) {
   return parts.length > 0 ? parts[parts.length - 1] : null;
 }
 function registerParentExe(sessionKey, parentExe, dispatchedBy) {
-  if (!existsSync23(SESSION_CACHE)) {
-    mkdirSync14(SESSION_CACHE, { recursive: true });
+  if (!existsSync24(SESSION_CACHE)) {
+    mkdirSync15(SESSION_CACHE, { recursive: true });
   }
   const rootExe = extractRootExe(parentExe) ?? parentExe;
-  const filePath = path28.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
+  const filePath = path29.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`);
   writeFileSync15(filePath, JSON.stringify({
     parentExe: rootExe,
     dispatchedBy: dispatchedBy || rootExe,
@@ -12103,7 +12412,7 @@ function registerParentExe(sessionKey, parentExe, dispatchedBy) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync19(path28.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync19(path29.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -12112,7 +12421,7 @@ function getParentExe(sessionKey) {
 function getDispatchedBy(sessionKey) {
   try {
     const data = JSON.parse(readFileSync19(
-      path28.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
+      path29.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
     return data.dispatchedBy ?? data.parentExe ?? null;
@@ -12182,7 +12491,7 @@ async function verifyPaneAtCapacity(sessionName) {
 }
 function readDebounceState() {
   try {
-    if (!existsSync23(DEBOUNCE_FILE)) return {};
+    if (!existsSync24(DEBOUNCE_FILE)) return {};
     const raw = JSON.parse(readFileSync19(DEBOUNCE_FILE, "utf8"));
     const state = {};
     for (const [key, val] of Object.entries(raw)) {
@@ -12199,7 +12508,7 @@ function readDebounceState() {
 }
 function writeDebounceState(state) {
   try {
-    if (!existsSync23(SESSION_CACHE)) mkdirSync14(SESSION_CACHE, { recursive: true });
+    if (!existsSync24(SESSION_CACHE)) mkdirSync15(SESSION_CACHE, { recursive: true });
     writeFileSync15(DEBOUNCE_FILE, JSON.stringify(state));
   } catch {
   }
@@ -12299,8 +12608,8 @@ function sendIntercom(targetSession) {
       try {
         const rawAgent = targetSession.split("-")[0] ?? targetSession;
         const agent = baseAgentName(rawAgent);
-        const markerPath = path28.join(SESSION_CACHE, `current-task-${agent}.json`);
-        if (existsSync23(markerPath)) {
+        const markerPath = path29.join(SESSION_CACHE, `current-task-${agent}.json`);
+        if (existsSync24(markerPath)) {
           logIntercom(`SKIP \u2192 ${targetSession} (has in_progress task marker + not idle \u2014 will auto-chain)`);
           return "debounced";
         }
@@ -12310,9 +12619,9 @@ function sendIntercom(targetSession) {
     try {
       const rawAgent = targetSession.split("-")[0] ?? targetSession;
       const agent = baseAgentName(rawAgent);
-      const taskDir = path28.join(process.cwd(), "exe", agent);
-      if (existsSync23(taskDir)) {
-        const files = readdirSync6(taskDir).filter(
+      const taskDir = path29.join(process.cwd(), "exe", agent);
+      if (existsSync24(taskDir)) {
+        const files = readdirSync7(taskDir).filter(
           (f) => f.endsWith(".md") && f !== "DONE.txt"
         );
         if (files.length === 0) {
@@ -12470,23 +12779,23 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   const transport = getTransport();
   const sessionName = employeeSessionName(employeeName, exeSession, opts?.instance);
   const instanceLabel = opts?.instance != null && opts.instance > 0 ? `${employeeName}${opts.instance}` : employeeName;
-  const logDir = path28.join(os15.homedir(), ".exe-os", "session-logs");
-  const logFile = path28.join(logDir, `${instanceLabel}-${Date.now()}.log`);
-  if (!existsSync23(logDir)) {
-    mkdirSync14(logDir, { recursive: true });
+  const logDir = path29.join(os15.homedir(), ".exe-os", "session-logs");
+  const logFile = path29.join(logDir, `${instanceLabel}-${Date.now()}.log`);
+  if (!existsSync24(logDir)) {
+    mkdirSync15(logDir, { recursive: true });
   }
   transport.kill(sessionName);
   let cleanupSuffix = "";
   try {
     const thisFile = fileURLToPath4(import.meta.url);
-    const cleanupScript = path28.join(path28.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
-    if (existsSync23(cleanupScript)) {
+    const cleanupScript = path29.join(path29.dirname(thisFile), "..", "bin", "exe-session-cleanup.js");
+    if (existsSync24(cleanupScript)) {
       cleanupSuffix = `; ${process.execPath} "${cleanupScript}" "${employeeName}" "${exeSession}"`;
     }
   } catch {
   }
   try {
-    const claudeJsonPath = path28.join(os15.homedir(), ".claude.json");
+    const claudeJsonPath = path29.join(os15.homedir(), ".claude.json");
     let claudeJson = {};
     try {
       claudeJson = JSON.parse(readFileSync19(claudeJsonPath, "utf8"));
@@ -12501,10 +12810,10 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   } catch {
   }
   try {
-    const settingsDir = path28.join(os15.homedir(), ".claude", "projects");
+    const settingsDir = path29.join(os15.homedir(), ".claude", "projects");
     const normalizedKey = (opts?.cwd ?? projectDir).replace(/\//g, "-").replace(/^-/, "");
-    const projSettingsDir = path28.join(settingsDir, normalizedKey);
-    const settingsPath = path28.join(projSettingsDir, "settings.json");
+    const projSettingsDir = path29.join(settingsDir, normalizedKey);
+    const settingsPath = path29.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
       settings = JSON.parse(readFileSync19(settingsPath, "utf8"));
@@ -12535,7 +12844,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     if (changed) {
       perms.allow = allow;
       settings.permissions = perms;
-      mkdirSync14(projSettingsDir, { recursive: true });
+      mkdirSync15(projSettingsDir, { recursive: true });
       writeFileSync15(settingsPath, JSON.stringify(settings, null, 2) + "\n");
     }
   } catch {
@@ -12551,7 +12860,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let behaviorsFlag = "";
   let legacyFallbackWarned = false;
   if (!useExeAgent && !useBinSymlink) {
-    const identityPath2 = path28.join(
+    const identityPath2 = path29.join(
       os15.homedir(),
       ".exe-os",
       "identity",
@@ -12561,13 +12870,13 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const hasAgentFlag = claudeSupportsAgentFlag();
     if (hasAgentFlag) {
       identityFlag = ` --agent ${employeeName}`;
-    } else if (existsSync23(identityPath2)) {
+    } else if (existsSync24(identityPath2)) {
       identityFlag = ` --append-system-prompt-file ${identityPath2}`;
       legacyFallbackWarned = true;
     }
     const behaviorsFile = exportBehaviorsSync(
       employeeName,
-      path28.basename(spawnCwd),
+      path29.basename(spawnCwd),
       sessionName
     );
     if (behaviorsFile) {
@@ -12582,9 +12891,9 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   }
   let sessionContextFlag = "";
   try {
-    const ctxDir = path28.join(os15.homedir(), ".exe-os", "session-cache");
-    mkdirSync14(ctxDir, { recursive: true });
-    const ctxFile = path28.join(ctxDir, `session-context-${sessionName}.md`);
+    const ctxDir = path29.join(os15.homedir(), ".exe-os", "session-cache");
+    mkdirSync15(ctxDir, { recursive: true });
+    const ctxFile = path29.join(ctxDir, `session-context-${sessionName}.md`);
     const ctxContent = [
       `## Session Context`,
       `You are running in tmux session: ${sessionName}.`,
@@ -12670,7 +12979,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   transport.pipeLog(sessionName, logFile);
   try {
     const mySession = getMySession();
-    const dispatchInfo = path28.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
+    const dispatchInfo = path29.join(SESSION_CACHE, `dispatch-info-${sessionName}.json`);
     writeFileSync15(dispatchInfo, JSON.stringify({
       dispatchedBy: mySession,
       rootExe: exeSession,
@@ -12684,7 +12993,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
   let booted = false;
   for (let i = 0; i < 30; i++) {
     try {
-      execSync8("sleep 0.5");
+      execSync9("sleep 0.5");
     } catch {
     }
     try {
@@ -12745,15 +13054,15 @@ var init_tmux_routing = __esm({
     init_intercom_queue();
     init_plan_limits();
     init_employees();
-    SPAWN_LOCK_DIR = path28.join(os15.homedir(), ".exe-os", "spawn-locks");
-    SESSION_CACHE = path28.join(os15.homedir(), ".exe-os", "session-cache");
+    SPAWN_LOCK_DIR = path29.join(os15.homedir(), ".exe-os", "spawn-locks");
+    SESSION_CACHE = path29.join(os15.homedir(), ".exe-os", "session-cache");
     BEHAVIORS_EXPORT_TIMEOUT_MS = 1e4;
     VALID_SESSION_NAME = /^[a-z]+\d*-[a-zA-Z0-9_]+$/;
     VERIFY_PANE_LINES = 200;
     INTERCOM_DEBOUNCE_MS = 3e4;
     CODEX_DEBOUNCE_MS = 12e4;
-    INTERCOM_LOG2 = path28.join(os15.homedir(), ".exe-os", "intercom.log");
-    DEBOUNCE_FILE = path28.join(SESSION_CACHE, "intercom-debounce.json");
+    INTERCOM_LOG2 = path29.join(os15.homedir(), ".exe-os", "intercom.log");
+    DEBOUNCE_FILE = path29.join(SESSION_CACHE, "intercom-debounce.json");
     DEBOUNCE_CLEANUP_AGE_MS = 5 * 60 * 1e3;
     BUSY_PATTERN = /[✻✽✶✳·].*…|Running…|• Working|• Ran |• Explored|• Called|esc to interrupt/;
   }
@@ -13042,9 +13351,9 @@ __export(active_agent_exports, {
   resolveActiveAgentFromTmuxSession: () => resolveActiveAgentFromTmuxSession,
   writeActiveAgent: () => writeActiveAgent
 });
-import { readFileSync as readFileSync20, writeFileSync as writeFileSync16, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9, readdirSync as readdirSync7 } from "fs";
-import { execSync as execSync9 } from "child_process";
-import path29 from "path";
+import { readFileSync as readFileSync20, writeFileSync as writeFileSync16, mkdirSync as mkdirSync16, unlinkSync as unlinkSync10, readdirSync as readdirSync8 } from "fs";
+import { execSync as execSync10 } from "child_process";
+import path30 from "path";
 function isNameWithOptionalInstance(candidate, baseName) {
   if (candidate === baseName) return true;
   if (!candidate.startsWith(baseName)) return false;
@@ -13088,11 +13397,11 @@ function resolveActiveAgentFromTmuxSession(sessionName) {
   return null;
 }
 function getMarkerPath() {
-  return path29.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
+  return path30.join(CACHE_DIR, `active-agent-${getSessionKey()}.json`);
 }
 function writeActiveAgent(agentId, agentRole) {
   try {
-    mkdirSync15(CACHE_DIR, { recursive: true });
+    mkdirSync16(CACHE_DIR, { recursive: true });
     writeFileSync16(
       getMarkerPath(),
       JSON.stringify({ agentId, agentRole, startedAt: (/* @__PURE__ */ new Date()).toISOString() })
@@ -13102,7 +13411,7 @@ function writeActiveAgent(agentId, agentRole) {
 }
 function clearActiveAgent() {
   try {
-    unlinkSync9(getMarkerPath());
+    unlinkSync10(getMarkerPath());
   } catch {
   }
 }
@@ -13116,7 +13425,7 @@ function getActiveAgent() {
         const age = Date.now() - new Date(data.startedAt).getTime();
         if (age > STALE_MS) {
           try {
-            unlinkSync9(markerPath);
+            unlinkSync10(markerPath);
           } catch {
           }
         } else {
@@ -13135,7 +13444,7 @@ function getActiveAgent() {
   } catch {
   }
   try {
-    const sessionName = execSync9(
+    const sessionName = execSync10(
       "tmux display-message -p '#{session_name}' 2>/dev/null",
       { encoding: "utf8", timeout: 2e3 }
     ).trim();
@@ -13150,21 +13459,21 @@ function getActiveAgent() {
 }
 function getAllActiveAgents() {
   try {
-    const files = readdirSync7(CACHE_DIR);
+    const files = readdirSync8(CACHE_DIR);
     const sessions = [];
     for (const file of files) {
       if (!file.startsWith("active-agent-") || !file.endsWith(".json")) continue;
       const key = file.slice("active-agent-".length, -".json".length);
       if (key === "undefined") continue;
       try {
-        const raw = readFileSync20(path29.join(CACHE_DIR, file), "utf8");
+        const raw = readFileSync20(path30.join(CACHE_DIR, file), "utf8");
         const data = JSON.parse(raw);
         if (!data.agentId) continue;
         if (data.startedAt) {
           const age = Date.now() - new Date(data.startedAt).getTime();
           if (age > STALE_MS) {
             try {
-              unlinkSync9(path29.join(CACHE_DIR, file));
+              unlinkSync10(path30.join(CACHE_DIR, file));
             } catch {
             }
             continue;
@@ -13187,11 +13496,11 @@ function getAllActiveAgents() {
 function cleanupSessionMarkers() {
   const key = getSessionKey();
   try {
-    unlinkSync9(path29.join(CACHE_DIR, `active-agent-${key}.json`));
+    unlinkSync10(path30.join(CACHE_DIR, `active-agent-${key}.json`));
   } catch {
   }
   try {
-    unlinkSync9(path29.join(CACHE_DIR, "active-agent-undefined.json"));
+    unlinkSync10(path30.join(CACHE_DIR, "active-agent-undefined.json"));
   } catch {
   }
 }
@@ -13202,7 +13511,7 @@ var init_active_agent = __esm({
     init_config();
     init_session_key();
     init_employees();
-    CACHE_DIR = path29.join(EXE_AI_DIR, "session-cache");
+    CACHE_DIR = path30.join(EXE_AI_DIR, "session-cache");
     STALE_MS = 24 * 60 * 60 * 1e3;
   }
 });
@@ -13830,14 +14139,14 @@ __export(exe_rename_exports, {
   main: () => main2,
   renameEmployee: () => renameEmployee
 });
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync17, renameSync as renameSync4, unlinkSync as unlinkSync10, existsSync as existsSync24 } from "fs";
-import { execSync as execSync10 } from "child_process";
-import path30 from "path";
+import { readFileSync as readFileSync21, writeFileSync as writeFileSync17, renameSync as renameSync4, unlinkSync as unlinkSync11, existsSync as existsSync25 } from "fs";
+import { execSync as execSync11 } from "child_process";
+import path31 from "path";
 import { homedir as homedir4 } from "os";
 async function renameEmployee(oldName, newName, opts = {}) {
-  const rosterPath = opts.rosterPath ?? path30.join(homedir4(), ".exe-os", "exe-employees.json");
-  const identityDir = opts.identityDir ?? path30.join(homedir4(), ".exe-os", "identity");
-  const agentsDir = opts.agentsDir ?? path30.join(homedir4(), ".claude", "agents");
+  const rosterPath = opts.rosterPath ?? path31.join(homedir4(), ".exe-os", "exe-employees.json");
+  const identityDir = opts.identityDir ?? path31.join(homedir4(), ".exe-os", "identity");
+  const agentsDir = opts.agentsDir ?? path31.join(homedir4(), ".claude", "agents");
   const validation = validateEmployeeName(newName);
   if (!validation.valid) {
     return { success: false, error: validation.error };
@@ -13869,9 +14178,9 @@ async function renameEmployee(oldName, newName, opts = {}) {
         writeFileSync17(rosterPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
       }
     });
-    const oldIdentityPath = path30.join(identityDir, `${rosterOldName}.md`);
-    const newIdentityPath = path30.join(identityDir, `${newName}.md`);
-    if (existsSync24(oldIdentityPath)) {
+    const oldIdentityPath = path31.join(identityDir, `${rosterOldName}.md`);
+    const newIdentityPath = path31.join(identityDir, `${newName}.md`);
+    if (existsSync25(oldIdentityPath)) {
       const content = readFileSync21(oldIdentityPath, "utf-8");
       const updatedContent = content.replace(
         /^(agent_id:\s*)\S+/m,
@@ -13882,22 +14191,22 @@ async function renameEmployee(oldName, newName, opts = {}) {
       rollbackStack.push({
         description: "restore identity file",
         undo: () => {
-          if (existsSync24(newIdentityPath)) {
+          if (existsSync25(newIdentityPath)) {
             writeFileSync17(newIdentityPath, content, "utf-8");
             renameSync4(newIdentityPath, oldIdentityPath);
           }
         }
       });
     }
-    const oldAgentPath = path30.join(agentsDir, `${rosterOldName}.md`);
-    const newAgentPath = path30.join(agentsDir, `${newName}.md`);
-    if (existsSync24(oldAgentPath)) {
+    const oldAgentPath = path31.join(agentsDir, `${rosterOldName}.md`);
+    const newAgentPath = path31.join(agentsDir, `${newName}.md`);
+    if (existsSync25(oldAgentPath)) {
       const agentContent = readFileSync21(oldAgentPath, "utf-8");
       renameSync4(oldAgentPath, newAgentPath);
       rollbackStack.push({
         description: "restore agent file",
         undo: () => {
-          if (existsSync24(newAgentPath)) {
+          if (existsSync25(newAgentPath)) {
             renameSync4(newAgentPath, oldAgentPath);
             writeFileSync17(oldAgentPath, agentContent, "utf-8");
           }
@@ -13968,7 +14277,7 @@ async function renameEmployee(oldName, newName, opts = {}) {
 }
 function findExeBin2() {
   try {
-    return execSync10(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+    return execSync11(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
   } catch {
     return null;
   }
@@ -13977,12 +14286,12 @@ function removeOldSymlinks(name) {
   try {
     const exeBinPath = findExeBin2();
     if (!exeBinPath) return;
-    const binDir = path30.dirname(exeBinPath);
+    const binDir = path31.dirname(exeBinPath);
     for (const suffix of ["", "-opencode"]) {
-      const linkPath = path30.join(binDir, `${name}${suffix}`);
-      if (existsSync24(linkPath)) {
+      const linkPath = path31.join(binDir, `${name}${suffix}`);
+      if (existsSync25(linkPath)) {
         try {
-          unlinkSync10(linkPath);
+          unlinkSync11(linkPath);
         } catch {
         }
       }
@@ -14025,16 +14334,16 @@ var init_exe_rename = __esm({
 });
 
 // src/lib/model-downloader.ts
-import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync25, unlinkSync as unlinkSync11, renameSync as renameSync5 } from "fs";
+import { createWriteStream, createReadStream as createReadStream2, existsSync as existsSync26, unlinkSync as unlinkSync12, renameSync as renameSync5 } from "fs";
 import { mkdir as mkdir6 } from "fs/promises";
 import { createHash as createHash3 } from "crypto";
-import path31 from "path";
+import path32 from "path";
 async function downloadModel(opts) {
   const { destDir, onProgress, fetchFn = globalThis.fetch } = opts;
-  const destPath = path31.join(destDir, LOCAL_FILENAME);
+  const destPath = path32.join(destDir, LOCAL_FILENAME);
   const tmpPath = destPath + ".tmp";
   await mkdir6(destDir, { recursive: true });
-  if (existsSync25(destPath)) {
+  if (existsSync26(destPath)) {
     const hash = await fileHash(destPath);
     if (hash === EXPECTED_SHA256) {
       return destPath;
@@ -14046,7 +14355,7 @@ async function downloadModel(opts) {
   let downloaded = 0;
   for (let attempt = 1; attempt <= MAX_RETRIES4; attempt++) {
     try {
-      if (existsSync25(tmpPath)) unlinkSync11(tmpPath);
+      if (existsSync26(tmpPath)) unlinkSync12(tmpPath);
       const response = await fetchFn(GGUF_URL, {
         redirect: "follow",
         signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
@@ -14078,7 +14387,7 @@ async function downloadModel(opts) {
       }
       const actualHash = hash.digest("hex");
       if (actualHash !== EXPECTED_SHA256) {
-        unlinkSync11(tmpPath);
+        unlinkSync12(tmpPath);
         throw new Error(
           `SHA256 mismatch: expected ${EXPECTED_SHA256}, got ${actualHash}`
         );
@@ -14091,7 +14400,7 @@ async function downloadModel(opts) {
         process.stderr.write(`
 Download attempt ${attempt} failed, retrying...
 `);
-        if (existsSync25(tmpPath)) unlinkSync11(tmpPath);
+        if (existsSync26(tmpPath)) unlinkSync12(tmpPath);
       }
     }
   }
@@ -14664,28 +14973,28 @@ __export(session_wrappers_exports, {
   generateSessionWrappers: () => generateSessionWrappers
 });
 import {
-  existsSync as existsSync26,
+  existsSync as existsSync27,
   readFileSync as readFileSync22,
   writeFileSync as writeFileSync18,
-  mkdirSync as mkdirSync16,
+  mkdirSync as mkdirSync17,
   chmodSync as chmodSync2,
-  readdirSync as readdirSync8,
-  unlinkSync as unlinkSync12
+  readdirSync as readdirSync9,
+  unlinkSync as unlinkSync13
 } from "fs";
-import path32 from "path";
+import path33 from "path";
 import { homedir as homedir5 } from "os";
 function generateSessionWrappers(packageRoot, homeDir) {
   const home = homeDir ?? homedir5();
-  const binDir = path32.join(home, ".exe-os", "bin");
-  const rosterPath = path32.join(home, ".exe-os", "exe-employees.json");
-  mkdirSync16(binDir, { recursive: true });
-  const exeStartDst = path32.join(binDir, "exe-start");
+  const binDir = path33.join(home, ".exe-os", "bin");
+  const rosterPath = path33.join(home, ".exe-os", "exe-employees.json");
+  mkdirSync17(binDir, { recursive: true });
+  const exeStartDst = path33.join(binDir, "exe-start");
   const candidates = [
-    path32.join(packageRoot, "dist", "bin", "exe-start.sh"),
-    path32.join(packageRoot, "src", "bin", "exe-start.sh")
+    path33.join(packageRoot, "dist", "bin", "exe-start.sh"),
+    path33.join(packageRoot, "src", "bin", "exe-start.sh")
   ];
   for (const src of candidates) {
-    if (existsSync26(src)) {
+    if (existsSync27(src)) {
       writeFileSync18(exeStartDst, readFileSync22(src));
       chmodSync2(exeStartDst, 493);
       break;
@@ -14701,13 +15010,13 @@ function generateSessionWrappers(packageRoot, homeDir) {
     return { created: 0, pathConfigured: false };
   }
   try {
-    for (const f of readdirSync8(binDir)) {
+    for (const f of readdirSync9(binDir)) {
       if (f === "exe-start") continue;
-      const fPath = path32.join(binDir, f);
+      const fPath = path33.join(binDir, f);
       try {
         const content = readFileSync22(fPath, "utf8");
         if (content.includes("exe-start")) {
-          unlinkSync12(fPath);
+          unlinkSync13(fPath);
         }
       } catch {
       }
@@ -14720,30 +15029,30 @@ exec "${exeStartDst}" "$0" "$@"
 `;
   for (const emp of employees) {
     for (let n = 1; n <= MAX_N; n++) {
-      const wrapperPath = path32.join(binDir, `${emp.name}${n}`);
+      const wrapperPath = path33.join(binDir, `${emp.name}${n}`);
       writeFileSync18(wrapperPath, wrapperContent);
       chmodSync2(wrapperPath, 493);
       created++;
-      const codexPath = path32.join(binDir, `${emp.name}${n}-codex`);
+      const codexPath = path33.join(binDir, `${emp.name}${n}-codex`);
       writeFileSync18(codexPath, wrapperContent);
       chmodSync2(codexPath, 493);
       created++;
     }
   }
   const codexLauncherCandidates = [
-    path32.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
-    path32.join(packageRoot, "src", "bin", "exe-start-codex.ts")
+    path33.join(packageRoot, "dist", "bin", "exe-start-codex.js"),
+    path33.join(packageRoot, "src", "bin", "exe-start-codex.ts")
   ];
   let codexLauncher = null;
   for (const c of codexLauncherCandidates) {
-    if (existsSync26(c)) {
+    if (existsSync27(c)) {
       codexLauncher = c;
       break;
     }
   }
   if (codexLauncher) {
     for (const emp of employees) {
-      const wrapperPath = path32.join(binDir, `${emp.name}-codex`);
+      const wrapperPath = path33.join(binDir, `${emp.name}-codex`);
       const content = `#!/bin/bash
 exec node "${codexLauncher}" --agent ${emp.name} "$@"
 `;
@@ -14766,12 +15075,12 @@ export PATH="${binDir}:$PATH"
   const shell = process.env.SHELL ?? "/bin/bash";
   const profilePaths = [];
   if (shell.includes("zsh")) {
-    profilePaths.push(path32.join(home, ".zshrc"));
+    profilePaths.push(path33.join(home, ".zshrc"));
   } else if (shell.includes("bash")) {
-    profilePaths.push(path32.join(home, ".bashrc"));
-    profilePaths.push(path32.join(home, ".bash_profile"));
+    profilePaths.push(path33.join(home, ".bashrc"));
+    profilePaths.push(path33.join(home, ".bash_profile"));
   } else {
-    profilePaths.push(path32.join(home, ".profile"));
+    profilePaths.push(path33.join(home, ".profile"));
   }
   for (const profilePath of profilePaths) {
     try {
@@ -14806,23 +15115,23 @@ __export(setup_wizard_exports, {
   validateModel: () => validateModel
 });
 import crypto12 from "crypto";
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync23, writeFileSync as writeFileSync19, unlinkSync as unlinkSync13 } from "fs";
+import { existsSync as existsSync28, mkdirSync as mkdirSync18, readFileSync as readFileSync23, writeFileSync as writeFileSync19, unlinkSync as unlinkSync14 } from "fs";
 import os16 from "os";
-import path33 from "path";
+import path34 from "path";
 import { createInterface as createInterface3 } from "readline";
 function findPackageRoot2() {
-  let dir = path33.dirname(new URL(import.meta.url).pathname);
-  const root = path33.parse(dir).root;
+  let dir = path34.dirname(new URL(import.meta.url).pathname);
+  const root = path34.parse(dir).root;
   while (dir !== root) {
-    const pkgPath = path33.join(dir, "package.json");
-    if (existsSync27(pkgPath)) {
+    const pkgPath = path34.join(dir, "package.json");
+    if (existsSync28(pkgPath)) {
       try {
         const pkg = JSON.parse(readFileSync23(pkgPath, "utf-8"));
         if (pkg.name === "@askexenow/exe-os" || pkg.name === "exe-os") return dir;
       } catch {
       }
     }
-    dir = path33.dirname(dir);
+    dir = path34.dirname(dir);
   }
   return null;
 }
@@ -14834,12 +15143,12 @@ function loadSetupState() {
   }
 }
 function saveSetupState(state) {
-  mkdirSync17(path33.dirname(SETUP_STATE_PATH), { recursive: true });
+  mkdirSync18(path34.dirname(SETUP_STATE_PATH), { recursive: true });
   writeFileSync19(SETUP_STATE_PATH, JSON.stringify(state, null, 2));
 }
 function clearSetupState() {
   try {
-    unlinkSync13(SETUP_STATE_PATH);
+    unlinkSync14(SETUP_STATE_PATH);
   } catch {
   }
 }
@@ -14856,8 +15165,8 @@ function ask2(rl, prompt) {
 function getAvailableMemoryGB2() {
   if (process.platform === "darwin") {
     try {
-      const { execSync: execSync15 } = __require("child_process");
-      const vmstat = execSync15("vm_stat", { encoding: "utf8" });
+      const { execSync: execSync16 } = __require("child_process");
+      const vmstat = execSync16("vm_stat", { encoding: "utf8" });
       const pageSizeMatch = vmstat.match(/page size of (\d+) bytes/);
       const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 16384;
       const free = vmstat.match(/Pages free:\s+(\d+)/);
@@ -14885,10 +15194,10 @@ async function validateModel(log) {
   if (totalGB <= 8 || isLowMemory()) {
     log(`System memory: ${totalGB.toFixed(0)}GB total, ${freeGB.toFixed(1)}GB free`);
     log("Skipping in-memory model validation (low memory \u2014 will validate on first use).");
-    const modelPath = path33.join(MODELS_DIR, LOCAL_FILENAME);
-    if (existsSync27(modelPath)) {
-      const { statSync: statSync2 } = await import("fs");
-      const size = statSync2(modelPath).size;
+    const modelPath = path34.join(MODELS_DIR, LOCAL_FILENAME);
+    if (existsSync28(modelPath)) {
+      const { statSync: statSync3 } = await import("fs");
+      const size = statSync3(modelPath).size;
       if (size > 300 * 1e6) {
         log(`Model file verified (${(size / 1e6).toFixed(0)} MB).`);
         return;
@@ -14977,7 +15286,7 @@ async function runSetupWizard(opts = {}) {
     if (state.completedSteps.length > 0) {
       log(`Resuming setup from step ${Math.max(...state.completedSteps) + 1}...`);
     }
-    if (existsSync27(LEGACY_LANCE_PATH)) {
+    if (existsSync28(LEGACY_LANCE_PATH)) {
       log("\u26A0 Found v1.0 LanceDB at ~/.exe-os/local.lance");
       log("  v1.1 uses libSQL (SQLite). Your existing memories are not automatically migrated.");
       log("  The old directory will not be modified or deleted.");
@@ -14992,6 +15301,23 @@ async function runSetupWizard(opts = {}) {
         const key = crypto12.randomBytes(32);
         await setMasterKey(key);
         log("Encryption key generated and stored securely.");
+        log("");
+        const { exportMnemonic: exportMnemonic2 } = await Promise.resolve().then(() => (init_keychain(), keychain_exports));
+        const mnemonic = await exportMnemonic2(key);
+        log("=============================================================");
+        log("  YOUR 24-WORD RECOVERY PHRASE");
+        log("=============================================================");
+        log("");
+        log("  " + mnemonic);
+        log("");
+        log("  SAVE THIS NOW. Write it down or store it in your password");
+        log("  manager. This phrase is the ONLY way to decrypt your memories");
+        log("  if you lose this computer. We cannot recover it for you.");
+        log("");
+        log("  Like a Bitcoin wallet \u2014 lose the phrase, lose everything.");
+        log("=============================================================");
+        log("");
+        await ask2(rl, "Press Enter after you've saved your recovery phrase...");
       }
       state.completedSteps.push(1);
       saveSetupState(state);
@@ -15141,7 +15467,7 @@ async function runSetupWizard(opts = {}) {
       await saveConfig(config);
       log("");
       try {
-        const claudeJsonPath = path33.join(os16.homedir(), ".claude.json");
+        const claudeJsonPath = path34.join(os16.homedir(), ".claude.json");
         let claudeJson = {};
         try {
           claudeJson = JSON.parse(readFileSync23(claudeJsonPath, "utf8"));
@@ -15167,7 +15493,7 @@ async function runSetupWizard(opts = {}) {
       const prefs = { ...existingPrefs };
       log("=== Config Defaults ===");
       log("");
-      const ghosttyDetected = existsSync27(path33.join(os16.homedir(), ".config", "ghostty")) || existsSync27(path33.join(os16.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
+      const ghosttyDetected = existsSync28(path34.join(os16.homedir(), ".config", "ghostty")) || existsSync28(path34.join(os16.homedir(), "Library", "Application Support", "com.mitchellh.ghostty"));
       if (ghosttyDetected) {
         const ghosttyAnswer = await ask2(rl, "Detected Ghostty terminal. Use exe-os Ghostty defaults? (Y/n) ");
         prefs.ghostty = ghosttyAnswer.toLowerCase() !== "n";
@@ -15214,7 +15540,7 @@ async function runSetupWizard(opts = {}) {
       let missingIdentities = [];
       for (const emp of roster) {
         const idPath = identityPath2(emp.name);
-        if (!existsSync27(idPath)) {
+        if (!existsSync28(idPath)) {
           missingIdentities.push(emp.name);
         }
       }
@@ -15246,7 +15572,7 @@ async function runSetupWizard(opts = {}) {
           }
           missingIdentities = [];
           for (const emp of roster) {
-            if (!existsSync27(identityPath2(emp.name))) {
+            if (!existsSync28(identityPath2(emp.name))) {
               missingIdentities.push(emp.name);
             }
           }
@@ -15311,7 +15637,7 @@ async function runSetupWizard(opts = {}) {
       const cooIdentityContent = getIdentityTemplate("coo");
       if (cooIdentityContent) {
         const cooIdPath = identityPath2(cooName);
-        mkdirSync17(path33.dirname(cooIdPath), { recursive: true });
+        mkdirSync18(path34.dirname(cooIdPath), { recursive: true });
         const replaced = cooIdentityContent.replace(/agent_id:\s*exe/g, `agent_id: ${cooName}`).replace(/\$\{agent_id\}/g, cooName);
         writeFileSync19(cooIdPath, replaced, "utf-8");
       }
@@ -15407,7 +15733,7 @@ async function runSetupWizard(opts = {}) {
       const ctoIdentityContent = getIdentityTemplate("cto");
       if (ctoIdentityContent) {
         const ctoIdPath = identityPath2(ctoName);
-        mkdirSync17(path33.dirname(ctoIdPath), { recursive: true });
+        mkdirSync18(path34.dirname(ctoIdPath), { recursive: true });
         const replaced = ctoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${ctoName}`).replace(/\$\{agent_id\}/g, ctoName);
         writeFileSync19(ctoIdPath, replaced, "utf-8");
       }
@@ -15430,7 +15756,7 @@ async function runSetupWizard(opts = {}) {
       const cmoIdentityContent = getIdentityTemplate("cmo");
       if (cmoIdentityContent) {
         const cmoIdPath = identityPath2(cmoName);
-        mkdirSync17(path33.dirname(cmoIdPath), { recursive: true });
+        mkdirSync18(path34.dirname(cmoIdPath), { recursive: true });
         const replaced = cmoIdentityContent.replace(/agent_id:\s*\w+/g, `agent_id: ${cmoName}`).replace(/\$\{agent_id\}/g, cmoName);
         writeFileSync19(cmoIdPath, replaced, "utf-8");
       }
@@ -15454,7 +15780,7 @@ async function runSetupWizard(opts = {}) {
             log(`Session shortcuts generated (${cooName}1, ${cooName}2, ...)`);
           }
           if (wrapResult.pathConfigured) {
-            const binDir = path33.join(os16.homedir(), ".exe-os", "bin");
+            const binDir = path34.join(os16.homedir(), ".exe-os", "bin");
             process.env.PATH = `${binDir}:${process.env.PATH ?? ""}`;
             pathJustConfigured = true;
           }
@@ -15497,7 +15823,7 @@ async function runSetupWizard(opts = {}) {
     const pkgRoot2 = findPackageRoot2();
     if (pkgRoot2) {
       try {
-        version = JSON.parse(readFileSync23(path33.join(pkgRoot2, "package.json"), "utf-8")).version;
+        version = JSON.parse(readFileSync23(path34.join(pkgRoot2, "package.json"), "utf-8")).version;
       } catch {
       }
     }
@@ -15531,32 +15857,32 @@ var init_setup_wizard = __esm({
     init_config();
     init_keychain();
     init_model_downloader();
-    SETUP_STATE_PATH = path33.join(os16.homedir(), ".exe-os", "setup-state.json");
+    SETUP_STATE_PATH = path34.join(os16.homedir(), ".exe-os", "setup-state.json");
   }
 });
 
 // src/lib/update-backup.ts
 import { copyFile, readFile as readFile6, readdir as readdir3, writeFile as writeFile7, rm, mkdir as mkdir7, cp } from "fs/promises";
-import { existsSync as existsSync28 } from "fs";
-import path34 from "path";
+import { existsSync as existsSync29 } from "fs";
+import path35 from "path";
 import os17 from "os";
 function resolveDataDir2() {
   if (process.env.EXE_OS_DIR) return process.env.EXE_OS_DIR;
   if (process.env.EXE_MEM_DIR) return process.env.EXE_MEM_DIR;
-  return path34.join(os17.homedir(), ".exe-os");
+  return path35.join(os17.homedir(), ".exe-os");
 }
 async function createUpdateBackup(currentVersion, dataDir) {
   const dir = dataDir ?? resolveDataDir2();
-  const backupDir = path34.join(dir, BACKUP_DIR_NAME);
-  if (existsSync28(backupDir)) {
+  const backupDir = path35.join(dir, BACKUP_DIR_NAME);
+  if (existsSync29(backupDir)) {
     await rm(backupDir, { recursive: true, force: true });
   }
   await mkdir7(backupDir, { recursive: true });
   const backedUpFiles = [];
   for (const target of BACKUP_TARGETS) {
-    const src = path34.join(dir, target.name);
-    if (!existsSync28(src)) continue;
-    const dest = path34.join(backupDir, target.name);
+    const src = path35.join(dir, target.name);
+    if (!existsSync29(src)) continue;
+    const dest = path35.join(backupDir, target.name);
     if (target.type === "file") {
       await copyFile(src, dest);
     } else {
@@ -15567,8 +15893,8 @@ async function createUpdateBackup(currentVersion, dataDir) {
   const entries = await readdir3(dir, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.isFile() && entry.name.endsWith(".db") && entry.name !== BACKUP_DIR_NAME) {
-      const src = path34.join(dir, entry.name);
-      const dest = path34.join(backupDir, entry.name);
+      const src = path35.join(dir, entry.name);
+      const dest = path35.join(backupDir, entry.name);
       await copyFile(src, dest);
       backedUpFiles.push(entry.name);
     }
@@ -15579,16 +15905,16 @@ async function createUpdateBackup(currentVersion, dataDir) {
     files: backedUpFiles
   };
   await writeFile7(
-    path34.join(backupDir, "manifest.json"),
+    path35.join(backupDir, "manifest.json"),
     JSON.stringify(manifest, null, 2) + "\n"
   );
   return manifest;
 }
 async function restoreFromBackup(dataDir) {
   const dir = dataDir ?? resolveDataDir2();
-  const backupDir = path34.join(dir, BACKUP_DIR_NAME);
-  const manifestPath = path34.join(backupDir, "manifest.json");
-  if (!existsSync28(manifestPath)) {
+  const backupDir = path35.join(dir, BACKUP_DIR_NAME);
+  const manifestPath = path35.join(backupDir, "manifest.json");
+  if (!existsSync29(manifestPath)) {
     throw new Error(
       `No backup found at ${backupDir}. Nothing to restore.`
     );
@@ -15597,9 +15923,9 @@ async function restoreFromBackup(dataDir) {
     await readFile6(manifestPath, "utf-8")
   );
   for (const fileName of manifest.files) {
-    const src = path34.join(backupDir, fileName);
-    const dest = path34.join(dir, fileName);
-    if (!existsSync28(src)) continue;
+    const src = path35.join(backupDir, fileName);
+    const dest = path35.join(dir, fileName);
+    if (!existsSync29(src)) continue;
     const stat2 = await import("fs/promises").then((m) => m.stat(src));
     if (stat2.isDirectory()) {
       await cp(src, dest, { recursive: true, force: true });
@@ -15611,8 +15937,8 @@ async function restoreFromBackup(dataDir) {
 }
 async function deleteBackup(dataDir) {
   const dir = dataDir ?? resolveDataDir2();
-  const backupDir = path34.join(dir, BACKUP_DIR_NAME);
-  if (existsSync28(backupDir)) {
+  const backupDir = path35.join(dir, BACKUP_DIR_NAME);
+  if (existsSync29(backupDir)) {
     await rm(backupDir, { recursive: true, force: true });
   }
 }
@@ -15632,17 +15958,17 @@ var init_update_backup = __esm({
 });
 
 // src/lib/update-check.ts
-import { execSync as execSync11 } from "child_process";
+import { execSync as execSync12 } from "child_process";
 import { readFileSync as readFileSync24 } from "fs";
-import path35 from "path";
+import path36 from "path";
 function getLocalVersion(packageRoot) {
-  const pkgPath = path35.join(packageRoot, "package.json");
+  const pkgPath = path36.join(packageRoot, "package.json");
   const pkg = JSON.parse(readFileSync24(pkgPath, "utf-8"));
   return pkg.version;
 }
 function getRemoteVersion() {
   try {
-    const output = execSync11("npm view @askexenow/exe-os version", {
+    const output = execSync12("npm view @askexenow/exe-os version", {
       encoding: "utf-8",
       timeout: 15e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -15681,7 +16007,7 @@ __export(update_exports, {
   getRemoteVersion: () => getRemoteVersion,
   runUpdate: () => runUpdate
 });
-import { execSync as execSync12 } from "child_process";
+import { execSync as execSync13 } from "child_process";
 import { createInterface as createInterface4 } from "readline";
 async function runRestore() {
   console.log("\n\u{1F504} Restoring from update backup...");
@@ -15692,7 +16018,7 @@ async function runRestore() {
     console.log(`
 \u{1F4E5} Reinstalling @askexenow/exe-os@${manifest.version}...`);
     try {
-      execSync12(`npm install -g @askexenow/exe-os@${manifest.version}`, {
+      execSync13(`npm install -g @askexenow/exe-os@${manifest.version}`, {
         stdio: ["pipe", "pipe", "inherit"],
         timeout: 3e5
       });
@@ -15769,7 +16095,7 @@ async function runUpdate(cliArgs) {
   }
   console.log("\u{1F9F9} Clearing npm cache...");
   try {
-    execSync12("npm cache clean --force", { stdio: "pipe" });
+    execSync13("npm cache clean --force", { stdio: "pipe" });
     console.log("   Done");
   } catch {
     console.log("   Skipped (non-critical)");
@@ -15777,7 +16103,7 @@ async function runUpdate(cliArgs) {
   console.log("\u{1F4E5} Installing @askexenow/exe-os@latest...");
   console.log("   This may take a minute...\n");
   try {
-    execSync12("npm install -g @askexenow/exe-os@latest", {
+    execSync13("npm install -g @askexenow/exe-os@latest", {
       stdio: ["pipe", "pipe", "inherit"],
       timeout: 3e5
     });
@@ -15795,7 +16121,7 @@ async function runUpdate(cliArgs) {
     newVersion = getLocalVersion(packageRoot);
   } catch {
     try {
-      const out = execSync12("npm list -g @askexenow/exe-os --depth=0 2>/dev/null", { encoding: "utf8" });
+      const out = execSync13("npm list -g @askexenow/exe-os --depth=0 2>/dev/null", { encoding: "utf8" });
       const match = out.match(/@askexenow\/exe-os@(\S+)/);
       newVersion = match?.[1] ?? "unknown";
     } catch {
@@ -20220,8 +20546,8 @@ var init_ErrorOverview = __esm({
     "use strict";
     init_Box();
     init_Text();
-    cleanupPath = (path47) => {
-      return path47?.replace(`file://${cwd()}/`, "");
+    cleanupPath = (path48) => {
+      return path48?.replace(`file://${cwd()}/`, "");
     };
     stackUtils = new StackUtils({
       cwd: cwd(),
@@ -22325,13 +22651,13 @@ __export(tmux_status_exports, {
   parseActivity: () => parseActivity,
   parseContextPercentage: () => parseContextPercentage
 });
-import { execSync as execSync13 } from "child_process";
+import { execSync as execSync14 } from "child_process";
 function inTmux() {
   if (process.env.TMUX || process.env.TMUX_PANE) return true;
   const term = process.env.TERM ?? "";
   if (term.startsWith("tmux") || term.startsWith("screen")) return true;
   try {
-    execSync13("tmux display-message -p '#{session_name}' 2>/dev/null", {
+    execSync14("tmux display-message -p '#{session_name}' 2>/dev/null", {
       encoding: "utf8",
       timeout: 2e3
     });
@@ -22341,12 +22667,12 @@ function inTmux() {
   try {
     let pid = process.ppid;
     for (let depth = 0; depth < 8 && pid > 1; depth++) {
-      const comm = execSync13(`ps -p ${pid} -o comm= 2>/dev/null`, {
+      const comm = execSync14(`ps -p ${pid} -o comm= 2>/dev/null`, {
         encoding: "utf8",
         timeout: 1e3
       }).trim();
       if (/tmux/.test(comm)) return true;
-      const ppid = execSync13(`ps -p ${pid} -o ppid= 2>/dev/null`, {
+      const ppid = execSync14(`ps -p ${pid} -o ppid= 2>/dev/null`, {
         encoding: "utf8",
         timeout: 1e3
       }).trim();
@@ -22359,7 +22685,7 @@ function inTmux() {
 }
 function listTmuxSessions() {
   try {
-    const out = execSync13("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+    const out = execSync14("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
       encoding: "utf8",
       timeout: 3e3
     });
@@ -22370,7 +22696,7 @@ function listTmuxSessions() {
 }
 function capturePaneLines(windowName, lines = 10) {
   try {
-    const out = execSync13(
+    const out = execSync14(
       `tmux capture-pane -t ${JSON.stringify(windowName)} -p 2>/dev/null | tail -${lines}`,
       { encoding: "utf8", timeout: 3e3 }
     );
@@ -22381,7 +22707,7 @@ function capturePaneLines(windowName, lines = 10) {
 }
 function getPaneCwd(windowName) {
   try {
-    const out = execSync13(
+    const out = execSync14(
       `tmux display-message -t ${JSON.stringify(windowName)} -p '#{pane_current_path}' 2>/dev/null`,
       { encoding: "utf8", timeout: 3e3 }
     );
@@ -22392,7 +22718,7 @@ function getPaneCwd(windowName) {
 }
 function projectFromPath(dir) {
   try {
-    const root = execSync13("git -C " + JSON.stringify(dir) + " rev-parse --show-toplevel 2>/dev/null", {
+    const root = execSync14("git -C " + JSON.stringify(dir) + " rev-parse --show-toplevel 2>/dev/null", {
       encoding: "utf8",
       timeout: 3e3
     }).trim();
@@ -22461,7 +22787,7 @@ function getEmployeeStatuses(employeeNames) {
     }
     let paneAlive = true;
     try {
-      const paneStatus = execSync13(
+      const paneStatus = execSync14(
         `tmux list-panes -t ${JSON.stringify(sessionName)} -F '#{pane_dead}' 2>/dev/null`,
         { encoding: "utf8", timeout: 3e3 }
       ).trim();
@@ -22629,11 +22955,11 @@ function Footer() {
       } catch {
       }
       try {
-        const { existsSync: existsSync33 } = await import("fs");
+        const { existsSync: existsSync34 } = await import("fs");
         const { join } = await import("path");
         const home = process.env.HOME ?? "";
         const pidPath = join(home, ".exe-os", "exed.pid");
-        setDaemon(existsSync33(pidPath) ? "running" : "stopped");
+        setDaemon(existsSync34(pidPath) ? "running" : "stopped");
       } catch {
         setDaemon("unknown");
       }
@@ -22651,8 +22977,8 @@ function Footer() {
           setSessions(allSessions.length);
           if (!currentSession) {
             try {
-              const { execSync: execSync15 } = await import("child_process");
-              const name = execSync15("tmux display-message -p '#{session_name}' 2>/dev/null", {
+              const { execSync: execSync16 } = await import("child_process");
+              const name = execSync16("tmux display-message -p '#{session_name}' 2>/dev/null", {
                 encoding: "utf8",
                 timeout: 2e3
               }).trim();
@@ -24684,10 +25010,10 @@ var init_hooks = __esm({
 });
 
 // src/runtime/safety-checks.ts
-import path36 from "path";
+import path37 from "path";
 import os18 from "os";
 function checkPathSafety(filePath) {
-  const resolved = path36.resolve(filePath);
+  const resolved = path37.resolve(filePath);
   for (const { pattern, reason } of BYPASS_IMMUNE_PATTERNS) {
     const matches = typeof pattern === "function" ? pattern(resolved) : pattern.test(resolved);
     if (matches) {
@@ -24697,7 +25023,7 @@ function checkPathSafety(filePath) {
   return { safe: true, bypassImmune: true };
 }
 function checkReadPathSafety(filePath) {
-  const resolved = path36.resolve(filePath);
+  const resolved = path37.resolve(filePath);
   const credPatterns = BYPASS_IMMUNE_PATTERNS.filter(
     (p) => typeof p.pattern !== "function" && (p.reason.includes("secrets") || p.reason.includes("Private key") || p.reason.includes("Credential"))
   );
@@ -24723,11 +25049,11 @@ var init_safety_checks = __esm({
         reason: "Git config can set hooks and command execution"
       },
       {
-        pattern: (p) => p.startsWith(path36.join(HOME, ".claude")),
+        pattern: (p) => p.startsWith(path37.join(HOME, ".claude")),
         reason: "Claude configuration files are protected"
       },
       {
-        pattern: (p) => p.startsWith(path36.join(HOME, ".exe-os")),
+        pattern: (p) => p.startsWith(path37.join(HOME, ".exe-os")),
         reason: "exe-os configuration files are protected"
       },
       {
@@ -24744,7 +25070,7 @@ var init_safety_checks = __esm({
       },
       {
         pattern: (p) => {
-          const name = path36.basename(p);
+          const name = path37.basename(p);
           return [".bashrc", ".zshrc", ".profile", ".bash_profile", ".zprofile", ".zshenv"].includes(name);
         },
         reason: "Shell configuration files can execute arbitrary code on login"
@@ -24771,7 +25097,7 @@ __export(file_read_exports, {
   FileReadTool: () => FileReadTool
 });
 import fs3 from "fs/promises";
-import path37 from "path";
+import path38 from "path";
 import { z } from "zod";
 function isBinary(buf) {
   for (let i = 0; i < buf.length; i++) {
@@ -24807,7 +25133,7 @@ var init_file_read = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path37.isAbsolute(input.file_path) ? input.file_path : path37.resolve(context.cwd, input.file_path);
+        const filePath = path38.isAbsolute(input.file_path) ? input.file_path : path38.resolve(context.cwd, input.file_path);
         let stat2;
         try {
           stat2 = await fs3.stat(filePath);
@@ -24847,7 +25173,7 @@ __export(glob_exports, {
   GlobTool: () => GlobTool
 });
 import fs4 from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 import { z as z2 } from "zod";
 async function walkDir(dir, maxDepth = 10) {
   const results = [];
@@ -24863,7 +25189,7 @@ async function walkDir(dir, maxDepth = 10) {
       if (entry.isDirectory() && (entry.name === "node_modules" || entry.name === ".git")) {
         continue;
       }
-      const fullPath = path38.join(current, entry.name);
+      const fullPath = path39.join(current, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath, depth + 1);
       } else {
@@ -24897,11 +25223,11 @@ var init_glob = __esm({
       inputSchema: inputSchema2,
       isReadOnly: true,
       async call(input, context) {
-        const baseDir = input.path ? path38.isAbsolute(input.path) ? input.path : path38.resolve(context.cwd, input.path) : context.cwd;
+        const baseDir = input.path ? path39.isAbsolute(input.path) ? input.path : path39.resolve(context.cwd, input.path) : context.cwd;
         try {
           const entries = await walkDir(baseDir);
           const matched = entries.filter(
-            (e) => simpleGlobMatch(path38.relative(baseDir, e.path), input.pattern)
+            (e) => simpleGlobMatch(path39.relative(baseDir, e.path), input.pattern)
           );
           matched.sort((a, b) => b.mtime - a.mtime);
           if (matched.length === 0) {
@@ -24927,7 +25253,7 @@ __export(grep_exports, {
 });
 import { spawn as spawn2 } from "child_process";
 import fs5 from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 import { z as z3 } from "zod";
 function runRipgrep(input, searchPath, context) {
   return new Promise((resolve, reject) => {
@@ -24981,7 +25307,7 @@ async function nodeGrep(input, searchPath) {
     }
     for (const entry of entries) {
       if (entry.name === "node_modules" || entry.name === ".git") continue;
-      const fullPath = path39.join(dir, entry.name);
+      const fullPath = path40.join(dir, entry.name);
       if (entry.isDirectory()) {
         await walk(fullPath);
       } else {
@@ -25027,7 +25353,7 @@ var init_grep = __esm({
       inputSchema: inputSchema3,
       isReadOnly: true,
       async call(input, context) {
-        const searchPath = input.path ? path39.isAbsolute(input.path) ? input.path : path39.resolve(context.cwd, input.path) : context.cwd;
+        const searchPath = input.path ? path40.isAbsolute(input.path) ? input.path : path40.resolve(context.cwd, input.path) : context.cwd;
         try {
           const result = await runRipgrep(input, searchPath, context);
           return result;
@@ -25052,7 +25378,7 @@ __export(file_write_exports, {
   FileWriteTool: () => FileWriteTool
 });
 import fs6 from "fs/promises";
-import path40 from "path";
+import path41 from "path";
 import { z as z4 } from "zod";
 var inputSchema4, FileWriteTool;
 var init_file_write = __esm({
@@ -25080,8 +25406,8 @@ var init_file_write = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path40.isAbsolute(input.file_path) ? input.file_path : path40.resolve(context.cwd, input.file_path);
-        const dir = path40.dirname(filePath);
+        const filePath = path41.isAbsolute(input.file_path) ? input.file_path : path41.resolve(context.cwd, input.file_path);
+        const dir = path41.dirname(filePath);
         await fs6.mkdir(dir, { recursive: true });
         await fs6.writeFile(filePath, input.content, "utf-8");
         return {
@@ -25099,7 +25425,7 @@ __export(file_edit_exports, {
   FileEditTool: () => FileEditTool
 });
 import fs7 from "fs/promises";
-import path41 from "path";
+import path42 from "path";
 import { z as z5 } from "zod";
 function countOccurrences(haystack, needle) {
   let count = 0;
@@ -25140,7 +25466,7 @@ var init_file_edit = __esm({
         return { behavior: "allow" };
       },
       async call(input, context) {
-        const filePath = path41.isAbsolute(input.file_path) ? input.file_path : path41.resolve(context.cwd, input.file_path);
+        const filePath = path42.isAbsolute(input.file_path) ? input.file_path : path42.resolve(context.cwd, input.file_path);
         let content;
         try {
           content = await fs7.readFile(filePath, "utf-8");
@@ -25382,7 +25708,7 @@ var init_bash = __esm({
 // src/tui/views/CommandCenter.tsx
 import { useState as useState6, useEffect as useEffect8, useMemo as useMemo4, useCallback as useCallback4, useRef as useRef4 } from "react";
 import TextInput from "ink-text-input";
-import path42 from "path";
+import path43 from "path";
 import { homedir as homedir6 } from "os";
 import { Fragment as Fragment2, jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
 function CommandCenterView({
@@ -25417,13 +25743,13 @@ function CommandCenterView({
         const { createPermissionsFromPreset: createPermissionsFromPreset2, EMPLOYEE_PERMISSIONS: EMPLOYEE_PERMISSIONS2 } = await Promise.resolve().then(() => (init_permissions(), permissions_exports));
         const { getPresetByRole: getPresetByRole2 } = await Promise.resolve().then(() => (init_permission_presets(), permission_presets_exports));
         const { createDefaultHooks: createDefaultHooks2 } = await Promise.resolve().then(() => (init_hooks(), hooks_exports));
-        const { readFileSync: readFileSync28, existsSync: existsSync33 } = await import("fs");
+        const { readFileSync: readFileSync28, existsSync: existsSync34 } = await import("fs");
         const { join } = await import("path");
         const { homedir: homedir8 } = await import("os");
         const configPath = join(homedir8(), ".exe-os", "config.json");
         let failoverChain = ["anthropic", "opencode", "gemini", "openai"];
         let providerConfigs = {};
-        if (existsSync33(configPath)) {
+        if (existsSync34(configPath)) {
           try {
             const raw = JSON.parse(readFileSync28(configPath, "utf8"));
             if (Array.isArray(raw.failoverChain)) failoverChain = raw.failoverChain;
@@ -25631,7 +25957,7 @@ function CommandCenterView({
       const demoEntries = DEMO_PROJECTS.map((p) => ({
         projectName: p.projectName,
         exeSession: p.exeSession,
-        projectDir: path42.join(homedir6(), p.projectName),
+        projectDir: path43.join(homedir6(), p.projectName),
         employeeCount: p.employees.length,
         activeCount: p.employees.filter((e) => e.status === "active").length,
         memoryCount: p.employees.length * 4e3,
@@ -25669,7 +25995,7 @@ function CommandCenterView({
         const { listSessions: listSessions2 } = await Promise.resolve().then(() => (init_session_registry(), session_registry_exports));
         const { listTmuxSessions: listTmuxSessions2, inTmux: inTmux2 } = await Promise.resolve().then(() => (init_tmux_status(), tmux_status_exports));
         const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
-        const { existsSync: existsSync33 } = await import("fs");
+        const { existsSync: existsSync34 } = await import("fs");
         const { join } = await import("path");
         const client = getClient2();
         if (!client) {
@@ -25740,7 +26066,7 @@ function CommandCenterView({
           }
           const memoryCount = memoryCounts.get(name) ?? 0;
           const openTaskCount = openTaskCounts.get(name) ?? 0;
-          const hasGit = projectDir ? existsSync33(join(projectDir, ".git")) : false;
+          const hasGit = projectDir ? existsSync34(join(projectDir, ".git")) : false;
           const type = hasGit ? "code" : memoryCount > 0 ? "code" : "automation";
           projectList.push({
             projectName: name,
@@ -25765,7 +26091,7 @@ function CommandCenterView({
         setHealth((h) => ({ ...h, memories: Number(totalResult.rows[0]?.cnt ?? 0) }));
         try {
           const pidPath = join(process.env.HOME ?? "", ".exe-os", "exed.pid");
-          setHealth((h) => ({ ...h, daemon: existsSync33(pidPath) ? "running" : "stopped" }));
+          setHealth((h) => ({ ...h, daemon: existsSync34(pidPath) ? "running" : "stopped" }));
         } catch {
         }
         const activityResult = await client.execute(
@@ -26006,8 +26332,8 @@ function TmuxPane({ sessionName, employeeName, employeeRole, projectName, onDeta
     }
     const capture = () => {
       try {
-        const { execSync: execSync15 } = __require("child_process");
-        const output = execSync15(
+        const { execSync: execSync16 } = __require("child_process");
+        const output = execSync16(
           `tmux capture-pane -t ${JSON.stringify(sessionName)} -p -e 2>/dev/null | tail -${CAPTURE_LINES}`,
           { encoding: "utf8", timeout: 3e3 }
         );
@@ -26031,8 +26357,8 @@ function TmuxPane({ sessionName, employeeName, employeeRole, projectName, onDeta
     if (key.return) {
       if (!demo && inputBuffer.trim()) {
         try {
-          const { execSync: execSync15 } = __require("child_process");
-          execSync15(
+          const { execSync: execSync16 } = __require("child_process");
+          execSync16(
             `tmux send-keys -t ${JSON.stringify(sessionName)} ${JSON.stringify(inputBuffer)} Enter`,
             { timeout: 2e3 }
           );
@@ -26040,8 +26366,8 @@ function TmuxPane({ sessionName, employeeName, employeeRole, projectName, onDeta
         }
       } else if (!demo) {
         try {
-          const { execSync: execSync15 } = __require("child_process");
-          execSync15(`tmux send-keys -t ${JSON.stringify(sessionName)} Enter`, { timeout: 2e3 });
+          const { execSync: execSync16 } = __require("child_process");
+          execSync16(`tmux send-keys -t ${JSON.stringify(sessionName)} Enter`, { timeout: 2e3 });
         } catch {
         }
       }
@@ -26635,7 +26961,7 @@ var init_useOrchestrator = __esm({
 
 // src/tui/views/Sessions.tsx
 import React19, { useState as useState9, useEffect as useEffect11, useCallback as useCallback6 } from "react";
-import path43 from "path";
+import path44 from "path";
 import { homedir as homedir7 } from "os";
 import { jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
 function isCoordinatorEntry(entry) {
@@ -26673,7 +26999,7 @@ function SessionsView({
     if (demo) {
       setProjects(DEMO_PROJECTS.map((p) => ({
         ...p,
-        projectDir: path43.join(homedir7(), p.projectName),
+        projectDir: path44.join(homedir7(), p.projectName),
         employees: p.employees.map((e) => ({ ...e, attached: e.status === "active" }))
       })));
       return;
@@ -26728,12 +27054,12 @@ function SessionsView({
           return;
         }
       } else {
-        const { execSync: execSync15 } = await import("child_process");
+        const { execSync: execSync16 } = await import("child_process");
         const dir = projectDir || process.cwd();
-        execSync15(`tmux new-session -d -s ${JSON.stringify(entry.sessionName)} -c ${JSON.stringify(dir)}`, { timeout: 5e3 });
-        execSync15(`tmux send-keys -t ${JSON.stringify(entry.sessionName)} "claude --dangerously-skip-permissions" Enter`, { timeout: 3e3 });
+        execSync16(`tmux new-session -d -s ${JSON.stringify(entry.sessionName)} -c ${JSON.stringify(dir)}`, { timeout: 5e3 });
+        execSync16(`tmux send-keys -t ${JSON.stringify(entry.sessionName)} "claude --dangerously-skip-permissions" Enter`, { timeout: 3e3 });
         await new Promise((r) => setTimeout(r, 3e3));
-        execSync15(`tmux send-keys -t ${JSON.stringify(entry.sessionName)} "/exe" Enter`, { timeout: 3e3 });
+        execSync16(`tmux send-keys -t ${JSON.stringify(entry.sessionName)} "/exe" Enter`, { timeout: 3e3 });
       }
       const updated = { ...entry, status: "active", activity: "Starting...", attached: false };
       setViewingEmployee(updated);
@@ -26836,7 +27162,7 @@ function SessionsView({
         const { listTmuxSessions: listTmuxSessions2, inTmux: inTmux2, capturePaneLines: capturePaneLines2, parseActivity: parseActivity2 } = await Promise.resolve().then(() => (init_tmux_status(), tmux_status_exports));
         const { getCoordinatorName: getCoordinatorName2, isCoordinatorRole: isCoordinatorRole2, loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
         const { isExeSession: isExeSession2 } = await Promise.resolve().then(() => (init_tmux_routing(), tmux_routing_exports));
-        const { execSync: execSync15 } = await import("child_process");
+        const { execSync: execSync16 } = await import("child_process");
         if (!inTmux2()) {
           setTmuxAvailable(false);
           setProjects([]);
@@ -26845,7 +27171,7 @@ function SessionsView({
         setTmuxAvailable(true);
         const attachedMap = /* @__PURE__ */ new Map();
         try {
-          const out = execSync15("tmux list-sessions -F '#{session_name}:#{session_attached}' 2>/dev/null", {
+          const out = execSync16("tmux list-sessions -F '#{session_name}:#{session_attached}' 2>/dev/null", {
             encoding: "utf8",
             timeout: 3e3
           });
@@ -27881,18 +28207,18 @@ function upsertConversation(conversations, platform, senderId, message) {
 async function loadGatewayConfig() {
   const state = { running: false, port: 3100, adapters: [], agents: [], gatewayUrl: "" };
   try {
-    const { execSync: execSync15 } = await import("child_process");
-    const ps = execSync15("pgrep -f exe-gateway 2>/dev/null", { encoding: "utf8", timeout: 3e3 });
+    const { execSync: execSync16 } = await import("child_process");
+    const ps = execSync16("pgrep -f exe-gateway 2>/dev/null", { encoding: "utf8", timeout: 3e3 });
     state.running = ps.trim().length > 0;
   } catch {
     state.running = false;
   }
   try {
-    const { existsSync: existsSync33, readFileSync: readFileSync28 } = await import("fs");
+    const { existsSync: existsSync34, readFileSync: readFileSync28 } = await import("fs");
     const { join } = await import("path");
     const home = process.env.HOME ?? "";
     const configPath = join(home, ".exe-os", "gateway.json");
-    if (existsSync33(configPath)) {
+    if (existsSync34(configPath)) {
       const raw = JSON.parse(readFileSync28(configPath, "utf8"));
       state.port = raw.port ?? 3100;
       state.gatewayUrl = raw.gatewayUrl ?? "";
@@ -28359,10 +28685,10 @@ var init_Gateway = __esm({
 });
 
 // src/tui/utils/agent-status.ts
-import { execSync as execSync14 } from "child_process";
+import { execSync as execSync15 } from "child_process";
 function getAgentStatus(agentId) {
   try {
-    const sessions = execSync14("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
+    const sessions = execSync15("tmux list-sessions -F '#{session_name}' 2>/dev/null", {
       encoding: "utf8",
       timeout: 2e3
     }).trim().split("\n");
@@ -28373,7 +28699,7 @@ function getAgentStatus(agentId) {
       return /^\d?-/.test(suffix) || /^\d+$/.test(suffix);
     });
     if (!agentSession) return { label: "offline", color: "gray" };
-    const pane = execSync14(`tmux capture-pane -t "${agentSession}" -p 2>/dev/null | tail -3`, {
+    const pane = execSync15(`tmux capture-pane -t "${agentSession}" -p 2>/dev/null | tail -3`, {
       encoding: "utf8",
       timeout: 2e3
     });
@@ -28491,11 +28817,11 @@ function TeamView({ onBack, onViewSessions }) {
         setMembers(teamData);
         setDbError(null);
         try {
-          const { existsSync: existsSync33, readFileSync: readFileSync28 } = await import("fs");
+          const { existsSync: existsSync34, readFileSync: readFileSync28 } = await import("fs");
           const { join } = await import("path");
           const home = process.env.HOME ?? "";
           const gatewayConfig = join(home, ".exe-os", "gateway.json");
-          if (existsSync33(gatewayConfig)) {
+          if (existsSync34(gatewayConfig)) {
             const raw = JSON.parse(readFileSync28(gatewayConfig, "utf8"));
             if (raw.agents && raw.agents.length > 0) {
               setExternals(raw.agents.map((a) => ({
@@ -28676,8 +29002,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config, path47, method = "GET", body) {
-  const url = `${config.baseUrl}/api/v1${path47}`;
+async function wikiFetch(config, path48, method = "GET", body) {
+  const url = `${config.baseUrl}/api/v1${path48}`;
   const headers = {
     Authorization: `Bearer ${config.apiKey}`,
     "Content-Type": "application/json"
@@ -28710,7 +29036,7 @@ async function wikiFetch(config, path47, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path47}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path48}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -29296,20 +29622,20 @@ function SettingsView({ onBack }) {
       };
     });
     try {
-      const { execSync: execSync15 } = await import("child_process");
-      execSync15("curl -s --max-time 1 http://localhost:11434/api/tags", { timeout: 2e3 });
+      const { execSync: execSync16 } = await import("child_process");
+      execSync16("curl -s --max-time 1 http://localhost:11434/api/tags", { timeout: 2e3 });
       providerList.push({ name: "Ollama", configured: true, detail: "localhost:11434" });
     } catch {
       providerList.push({ name: "Ollama", configured: false, detail: "not running" });
     }
     setProviders(providerList);
     try {
-      const { existsSync: existsSync33 } = await import("fs");
+      const { existsSync: existsSync34 } = await import("fs");
       const { join } = await import("path");
       const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
       const cfg = await loadConfig2();
       const home = process.env.HOME ?? "";
-      const hasKey = existsSync33(join(home, ".exe-os", "master.key"));
+      const hasKey = existsSync34(join(home, ".exe-os", "master.key"));
       if (cfg.cloud) {
         setCloud({
           configured: true,
@@ -29322,7 +29648,7 @@ function SettingsView({ onBack }) {
       const pidPath = join(home, ".exe-os", "exed.pid");
       let daemon = "unknown";
       try {
-        daemon = existsSync33(pidPath) ? "running" : "stopped";
+        daemon = existsSync34(pidPath) ? "running" : "stopped";
       } catch {
       }
       let version = "unknown";
@@ -30138,15 +30464,15 @@ __export(installer_exports2, {
   verifyOpenCodeHooks: () => verifyOpenCodeHooks
 });
 import { readFile as readFile7, writeFile as writeFile8, mkdir as mkdir8 } from "fs/promises";
-import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
-import path44 from "path";
+import { existsSync as existsSync31, readFileSync as readFileSync26 } from "fs";
+import path45 from "path";
 import os19 from "os";
 async function registerOpenCodeMcp(packageRoot, homeDir = os19.homedir()) {
-  const configDir = path44.join(homeDir, ".config", "opencode");
-  const configPath = path44.join(configDir, "opencode.json");
+  const configDir = path45.join(homeDir, ".config", "opencode");
+  const configPath = path45.join(configDir, "opencode.json");
   await mkdir8(configDir, { recursive: true });
   let config = {};
-  if (existsSync30(configPath)) {
+  if (existsSync31(configPath)) {
     try {
       config = JSON.parse(await readFile7(configPath, "utf-8"));
     } catch {
@@ -30158,7 +30484,7 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os19.homedir()) {
   }
   const newEntry = {
     type: "local",
-    command: ["node", path44.join(packageRoot, "dist", "mcp", "server.js")],
+    command: ["node", path45.join(packageRoot, "dist", "mcp", "server.js")],
     enabled: true
   };
   const current = config.mcp["exe-os"];
@@ -30173,14 +30499,14 @@ async function registerOpenCodeMcp(packageRoot, homeDir = os19.homedir()) {
   return true;
 }
 async function installOpenCodePlugin(packageRoot, homeDir = os19.homedir()) {
-  const pluginDir = path44.join(homeDir, ".config", "opencode", "plugins");
-  const pluginPath = path44.join(pluginDir, "exe-os.mjs");
+  const pluginDir = path45.join(homeDir, ".config", "opencode", "plugins");
+  const pluginPath = path45.join(pluginDir, "exe-os.mjs");
   await mkdir8(pluginDir, { recursive: true });
   const pluginContent = PLUGIN_TEMPLATE.replace(
     /__PACKAGE_ROOT__/g,
     packageRoot.replace(/\\/g, "\\\\")
   );
-  if (existsSync30(pluginPath)) {
+  if (existsSync31(pluginPath)) {
     const existing = await readFile7(pluginPath, "utf-8");
     if (existing === pluginContent) {
       return false;
@@ -30190,16 +30516,16 @@ async function installOpenCodePlugin(packageRoot, homeDir = os19.homedir()) {
   return true;
 }
 function verifyOpenCodeHooks(homeDir = os19.homedir()) {
-  const configPath = path44.join(homeDir, ".config", "opencode", "opencode.json");
-  const pluginPath = path44.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
-  if (!existsSync30(configPath)) return false;
+  const configPath = path45.join(homeDir, ".config", "opencode", "opencode.json");
+  const pluginPath = path45.join(homeDir, ".config", "opencode", "plugins", "exe-os.mjs");
+  if (!existsSync31(configPath)) return false;
   try {
     const config = JSON.parse(readFileSync26(configPath, "utf-8"));
     if (!config.mcp?.["exe-os"]?.enabled) return false;
   } catch {
     return false;
   }
-  if (!existsSync30(pluginPath)) return false;
+  if (!existsSync31(pluginPath)) return false;
   return true;
 }
 async function runOpenCodeInstaller(homeDir) {
@@ -30234,19 +30560,19 @@ __export(installer_exports3, {
   verifyCodexHooks: () => verifyCodexHooks
 });
 import { readFile as readFile8, writeFile as writeFile9, mkdir as mkdir9 } from "fs/promises";
-import { existsSync as existsSync31 } from "fs";
-import path45 from "path";
+import { existsSync as existsSync32 } from "fs";
+import path46 from "path";
 import os20 from "os";
 async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
-  const codexDir = path45.join(homeDir, ".codex");
-  const hooksPath = path45.join(codexDir, "hooks.json");
-  const logsDir = path45.join(homeDir, ".exe-os", "logs");
-  const hookLogPath = path45.join(logsDir, "hooks.log");
+  const codexDir = path46.join(homeDir, ".codex");
+  const hooksPath = path46.join(codexDir, "hooks.json");
+  const logsDir = path46.join(homeDir, ".exe-os", "logs");
+  const hookLogPath = path46.join(logsDir, "hooks.log");
   const logSuffix = ` 2>> "${hookLogPath}"`;
   await mkdir9(codexDir, { recursive: true });
   await mkdir9(logsDir, { recursive: true });
   let hooksJson = {};
-  if (existsSync31(hooksPath)) {
+  if (existsSync32(hooksPath)) {
     try {
       hooksJson = JSON.parse(await readFile8(hooksPath, "utf-8"));
     } catch {
@@ -30263,7 +30589,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path45.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
+            command: `node "${path46.join(packageRoot, "dist", "hooks", "session-start.js")}"${logSuffix}`,
             timeout: 30
           }
         ]
@@ -30279,7 +30605,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
             // Combined hook: runs ingest + error-recall in one Node process.
             // Eliminates a cold-start cycle per tool call (~3-6s savings on Codex).
             type: "command",
-            command: `node "${path45.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
+            command: `node "${path46.join(packageRoot, "dist", "hooks", "post-tool-combined.js")}"${logSuffix}`
           }
         ]
       },
@@ -30293,7 +30619,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
             // Single hook: prompt-submit handles memory retrieval + entity boost.
             // exe-heartbeat-hook is CC-specific (intercom) — omitted on Codex.
             type: "command",
-            command: `node "${path45.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
+            command: `node "${path46.join(packageRoot, "dist", "hooks", "prompt-submit.js")}"${logSuffix}`
           }
         ]
       },
@@ -30305,7 +30631,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path45.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
+            command: `node "${path46.join(packageRoot, "dist", "hooks", "stop.js")}"${logSuffix}`
           }
         ]
       },
@@ -30318,7 +30644,7 @@ async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
         hooks: [
           {
             type: "command",
-            command: `node "${path45.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
+            command: `node "${path46.join(packageRoot, "dist", "hooks", "pre-tool-use.js")}"${logSuffix}`
           }
         ]
       },
@@ -30350,8 +30676,8 @@ async function mergeCodexHooks(packageRoot, homeDir = os20.homedir()) {
   return { added, skipped };
 }
 function verifyCodexHooks(homeDir = os20.homedir()) {
-  const hooksPath = path45.join(homeDir, ".codex", "hooks.json");
-  if (!existsSync31(hooksPath)) return false;
+  const hooksPath = path46.join(homeDir, ".codex", "hooks.json");
+  if (!existsSync32(hooksPath)) return false;
   try {
     const hooksJson = JSON.parse(
       __require("fs").readFileSync(hooksPath, "utf-8")
@@ -30374,11 +30700,11 @@ function verifyCodexHooks(homeDir = os20.homedir()) {
 async function installCodexStatusLine(homeDir = os20.homedir()) {
   const prefs = loadPreferences(homeDir);
   if (prefs.codexStatusLine === false) return "opted-out";
-  const codexDir = path45.join(homeDir, ".codex");
-  const configPath = path45.join(codexDir, "config.toml");
+  const codexDir = path46.join(homeDir, ".codex");
+  const configPath = path46.join(codexDir, "config.toml");
   await mkdir9(codexDir, { recursive: true });
   let content = "";
-  if (existsSync31(configPath)) {
+  if (existsSync32(configPath)) {
     content = await readFile8(configPath, "utf-8");
     if (/\[tui\][\s\S]*?status_line\s*=/.test(content)) {
       return "already-configured";
@@ -30436,12 +30762,12 @@ ${desired}
   return { content: next, changed };
 }
 async function registerCodexMcpServer(packageRoot, homeDir = os20.homedir()) {
-  const codexDir = path45.join(homeDir, ".codex");
-  const configPath = path45.join(codexDir, "config.toml");
-  const serverJsPath = path45.join(packageRoot, "dist", "mcp", "server.js");
+  const codexDir = path46.join(homeDir, ".codex");
+  const configPath = path46.join(codexDir, "config.toml");
+  const serverJsPath = path46.join(packageRoot, "dist", "mcp", "server.js");
   await mkdir9(codexDir, { recursive: true });
   let content = "";
-  if (existsSync31(configPath)) {
+  if (existsSync32(configPath)) {
     content = await readFile8(configPath, "utf-8");
   }
   const sectionHeader = "[mcp_servers.exe-os]";
@@ -30466,10 +30792,10 @@ async function registerCodexMcpServer(packageRoot, homeDir = os20.homedir()) {
   return "registered";
 }
 async function ensureCodexHooksFeature(homeDir = os20.homedir()) {
-  const configPath = path45.join(homeDir, ".codex", "config.toml");
-  await mkdir9(path45.join(homeDir, ".codex"), { recursive: true });
+  const configPath = path46.join(homeDir, ".codex", "config.toml");
+  await mkdir9(path46.join(homeDir, ".codex"), { recursive: true });
   let content = "";
-  if (existsSync31(configPath)) {
+  if (existsSync32(configPath)) {
     content = await readFile8(configPath, "utf-8");
   }
   if (/\[features\][\s\S]*?codex_hooks\s*=\s*true/.test(content)) {
@@ -30537,13 +30863,13 @@ var init_installer3 = __esm({
 });
 
 // src/bin/cli.ts
-import { existsSync as existsSync32, readFileSync as readFileSync27, writeFileSync as writeFileSync20, readdirSync as readdirSync9, rmSync } from "fs";
-import path46 from "path";
+import { existsSync as existsSync33, readFileSync as readFileSync27, writeFileSync as writeFileSync20, readdirSync as readdirSync10, rmSync } from "fs";
+import path47 from "path";
 import os21 from "os";
 var args = process.argv.slice(2);
 if (args.includes("--version") || args.includes("-v")) {
   try {
-    const pkgPath = path46.join(path46.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
+    const pkgPath = path47.join(path47.dirname(new URL(import.meta.url).pathname), "..", "..", "package.json");
     const pkg = JSON.parse(readFileSync27(pkgPath, "utf8"));
     console.log(pkg.version);
   } catch {
@@ -30708,9 +31034,9 @@ ID: ${result.id}`);
   });
   await init_App2().then(() => App_exports);
 } else {
-  const claudeDir = path46.join(os21.homedir(), ".claude");
-  const settingsPath = path46.join(claudeDir, "settings.json");
-  const hasClaudeCode = existsSync32(settingsPath) && (() => {
+  const claudeDir = path47.join(os21.homedir(), ".claude");
+  const settingsPath = path47.join(claudeDir, "settings.json");
+  const hasClaudeCode = existsSync33(settingsPath) && (() => {
     try {
       const raw = readFileSync27(settingsPath, "utf8");
       return raw.includes("exe-os") || raw.includes("exe-mem");
@@ -30722,8 +31048,8 @@ ID: ${result.id}`);
     const { DEFAULT_COORDINATOR_TEMPLATE_NAME: DEFAULT_COORDINATOR_TEMPLATE_NAME2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
     let cooName = DEFAULT_COORDINATOR_TEMPLATE_NAME2;
     try {
-      const rosterPath = path46.join(os21.homedir(), ".exe-os", "exe-employees.json");
-      if (existsSync32(rosterPath)) {
+      const rosterPath = path47.join(os21.homedir(), ".exe-os", "exe-employees.json");
+      if (existsSync33(rosterPath)) {
         const roster = JSON.parse(readFileSync27(rosterPath, "utf8"));
         const coo = roster.find((e) => e.role === "COO");
         if (coo) cooName = coo.name;
@@ -30788,11 +31114,11 @@ async function runCodexInstall() {
   }
 }
 async function runClaudeCheck() {
-  const claudeDir = path46.join(os21.homedir(), ".claude");
-  const settingsPath = path46.join(claudeDir, "settings.json");
-  const claudeJsonPath = path46.join(os21.homedir(), ".claude.json");
+  const claudeDir = path47.join(os21.homedir(), ".claude");
+  const settingsPath = path47.join(claudeDir, "settings.json");
+  const claudeJsonPath = path47.join(os21.homedir(), ".claude.json");
   let ok = true;
-  if (existsSync32(settingsPath)) {
+  if (existsSync33(settingsPath)) {
     let settings;
     try {
       settings = JSON.parse(readFileSync27(settingsPath, "utf8"));
@@ -30821,7 +31147,7 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m settings.json not found");
     ok = false;
   }
-  if (existsSync32(claudeJsonPath)) {
+  if (existsSync33(claudeJsonPath)) {
     let claudeJson;
     try {
       claudeJson = JSON.parse(readFileSync27(claudeJsonPath, "utf8"));
@@ -30843,8 +31169,8 @@ async function runClaudeCheck() {
     console.log("\x1B[31m\u2717\x1B[0m claude.json not found");
     ok = false;
   }
-  const skillsDir = path46.join(claudeDir, "skills");
-  if (existsSync32(skillsDir)) {
+  const skillsDir = path47.join(claudeDir, "skills");
+  if (existsSync33(skillsDir)) {
     console.log("\x1B[32m\u2713\x1B[0m Slash skills directory exists");
   } else {
     console.log("\x1B[31m\u2717\x1B[0m Slash skills directory missing");
@@ -30861,14 +31187,14 @@ async function runClaudeUninstall(flags = []) {
   const dryRun = flags.includes("--dry-run");
   const purge = flags.includes("--purge");
   const homeDir = os21.homedir();
-  const claudeDir = path46.join(homeDir, ".claude");
-  const settingsPath = path46.join(claudeDir, "settings.json");
-  const claudeJsonPath = path46.join(homeDir, ".claude.json");
-  const exeOsDir = path46.join(homeDir, ".exe-os");
+  const claudeDir = path47.join(homeDir, ".claude");
+  const settingsPath = path47.join(claudeDir, "settings.json");
+  const claudeJsonPath = path47.join(homeDir, ".claude.json");
+  const exeOsDir = path47.join(homeDir, ".exe-os");
   let removed = 0;
   const log = (msg) => console.log(dryRun ? `[dry-run] ${msg}` : msg);
   let settings = {};
-  if (existsSync32(settingsPath)) {
+  if (existsSync33(settingsPath)) {
     try {
       settings = JSON.parse(readFileSync27(settingsPath, "utf8"));
     } catch {
@@ -30915,7 +31241,7 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  if (existsSync32(claudeJsonPath)) {
+  if (existsSync33(claudeJsonPath)) {
     const raw = readFileSync27(claudeJsonPath, "utf8");
     if (raw.length > 1e6) {
       console.error("claude.json exceeds 1 MB \u2014 skipping parse.");
@@ -30945,14 +31271,14 @@ async function runClaudeUninstall(flags = []) {
       }
     }
   }
-  const skillsDir = path46.join(claudeDir, "skills");
-  if (existsSync32(skillsDir)) {
+  const skillsDir = path47.join(claudeDir, "skills");
+  if (existsSync33(skillsDir)) {
     let skillCount = 0;
     try {
-      const entries = readdirSync9(skillsDir);
+      const entries = readdirSync10(skillsDir);
       for (const entry of entries) {
         if (entry.startsWith("exe")) {
-          const fullPath = path46.join(skillsDir, entry);
+          const fullPath = path47.join(skillsDir, entry);
           if (!dryRun) rmSync(fullPath, { recursive: true, force: true });
           skillCount++;
         }
@@ -30964,8 +31290,8 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const claudeMdPath = path46.join(claudeDir, "CLAUDE.md");
-  if (existsSync32(claudeMdPath)) {
+  const claudeMdPath = path47.join(claudeDir, "CLAUDE.md");
+  if (existsSync33(claudeMdPath)) {
     const content = readFileSync27(claudeMdPath, "utf8");
     const startMarker = "<!-- exe-os:orchestration-start -->";
     const endMarker = "<!-- exe-os:orchestration-end -->";
@@ -30978,14 +31304,14 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const agentsDir = path46.join(claudeDir, "agents");
-  if (existsSync32(agentsDir)) {
+  const agentsDir = path47.join(claudeDir, "agents");
+  if (existsSync33(agentsDir)) {
     let agentCount = 0;
     try {
-      const entries = readdirSync9(agentsDir).filter((f) => f.endsWith(".md"));
+      const entries = readdirSync10(agentsDir).filter((f) => f.endsWith(".md"));
       let knownNames = /* @__PURE__ */ new Set();
-      const rosterPath = path46.join(exeOsDir, "exe-employees.json");
-      if (existsSync32(rosterPath)) {
+      const rosterPath = path47.join(exeOsDir, "exe-employees.json");
+      if (existsSync33(rosterPath)) {
         try {
           const roster = JSON.parse(readFileSync27(rosterPath, "utf8"));
           knownNames = new Set(roster.map((e) => e.name));
@@ -30995,7 +31321,7 @@ async function runClaudeUninstall(flags = []) {
       for (const entry of entries) {
         const name = entry.replace(/\.md$/, "");
         if (knownNames.has(name)) {
-          if (!dryRun) rmSync(path46.join(agentsDir, entry), { force: true });
+          if (!dryRun) rmSync(path47.join(agentsDir, entry), { force: true });
           agentCount++;
         }
       }
@@ -31006,14 +31332,14 @@ async function runClaudeUninstall(flags = []) {
       removed++;
     }
   }
-  const projectsDir = path46.join(claudeDir, "projects");
-  if (existsSync32(projectsDir)) {
+  const projectsDir = path47.join(claudeDir, "projects");
+  if (existsSync33(projectsDir)) {
     let projectCount = 0;
     try {
-      const projects = readdirSync9(projectsDir);
+      const projects = readdirSync10(projectsDir);
       for (const proj of projects) {
-        const projSettings = path46.join(projectsDir, proj, "settings.json");
-        if (!existsSync32(projSettings)) continue;
+        const projSettings = path47.join(projectsDir, proj, "settings.json");
+        if (!existsSync33(projSettings)) continue;
         try {
           const pSettings = JSON.parse(readFileSync27(projSettings, "utf8"));
           let changed = false;
@@ -31039,28 +31365,28 @@ async function runClaudeUninstall(flags = []) {
     }
   }
   try {
-    const { execSync: execSync15 } = await import("child_process");
+    const { execSync: execSync16 } = await import("child_process");
     const findExeBin3 = () => {
       try {
-        return execSync15(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
+        return execSync16(process.platform === "win32" ? "where exe-os" : "which exe-os", { encoding: "utf8" }).trim();
       } catch {
         return null;
       }
     };
     const exeBinPath = findExeBin3();
     if (!exeBinPath) throw new Error("exe-os not found in PATH");
-    const binDir = path46.dirname(exeBinPath);
+    const binDir = path47.dirname(exeBinPath);
     let symlinkCount = 0;
-    const rosterPath = path46.join(exeOsDir, "exe-employees.json");
-    if (existsSync32(rosterPath)) {
+    const rosterPath = path47.join(exeOsDir, "exe-employees.json");
+    if (existsSync33(rosterPath)) {
       const roster = JSON.parse(readFileSync27(rosterPath, "utf8"));
       const { DEFAULT_COORDINATOR_TEMPLATE_NAME: DEFAULT_COORDINATOR_TEMPLATE_NAME2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
       const coordinatorName = roster.find((e) => e.role?.toLowerCase() === "coo")?.name ?? DEFAULT_COORDINATOR_TEMPLATE_NAME2;
       for (const emp of roster) {
         if (emp.name === coordinatorName) continue;
         for (const suffix of ["", "-opencode"]) {
-          const linkPath = path46.join(binDir, `${emp.name}${suffix}`);
-          if (existsSync32(linkPath)) {
+          const linkPath = path47.join(binDir, `${emp.name}${suffix}`);
+          if (existsSync33(linkPath)) {
             if (!dryRun) rmSync(linkPath, { force: true });
             symlinkCount++;
           }
@@ -31073,7 +31399,7 @@ async function runClaudeUninstall(flags = []) {
     }
   } catch {
   }
-  if (purge && existsSync32(exeOsDir)) {
+  if (purge && existsSync33(exeOsDir)) {
     if (!dryRun) {
       process.stdout.write("\x1B[33m\u26A0 This will delete all memories, identities, and agent data.\x1B[0m\n");
       process.stdout.write("  Removing ~/.exe-os...\n");
@@ -31098,7 +31424,7 @@ async function checkForUpdateOnBoot() {
     const config = await loadConfig2();
     if (!config.autoUpdate.checkOnBoot) return;
     const { checkForUpdate: checkForUpdate2 } = await Promise.resolve().then(() => (init_update(), update_exports));
-    const packageRoot = path46.resolve(
+    const packageRoot = path47.resolve(
       new URL("../..", import.meta.url).pathname
     );
     const result = checkForUpdate2(packageRoot);
@@ -31158,7 +31484,7 @@ async function runActivate(key) {
       const idTemplate = getIdentityTemplate(identityKey);
       if (idTemplate) {
         const idPath = identityPath2(name);
-        const dir = path46.dirname(idPath);
+        const dir = path47.dirname(idPath);
         if (!fs8.existsSync(dir)) fs8.mkdirSync(dir, { recursive: true });
         fs8.writeFileSync(idPath, idTemplate.replace(/^agent_id: \w+/m, `agent_id: ${name}`), "utf-8");
       }