@askexenow/exe-os 0.9.66 → 0.9.67

package/dist/mcp/server.js

@@ -192,6 +192,10 @@ async function loadConfig() {
     if (config2.dbPath.startsWith("~")) {
       config2.dbPath = config2.dbPath.replace(/^~/, os.homedir());
     }
+    const envDbPath = path.join(dir, "memories.db");
+    if (process.env.EXE_OS_DIR && config2.dbPath !== envDbPath && !existsSync2(config2.dbPath) && existsSync2(envDbPath)) {
+      config2.dbPath = envDbPath;
+    }
     return config2;
   } catch {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
@@ -212,7 +216,15 @@ function loadConfigSync() {
     normalizeSessionLifecycle(migratedCfg);
     normalizeAutoUpdate(migratedCfg);
     normalizeOrchestration(migratedCfg);
-    return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
+    const config2 = { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db"), ...migratedCfg };
+    if (config2.dbPath.startsWith("~")) {
+      config2.dbPath = config2.dbPath.replace(/^~/, os.homedir());
+    }
+    const envDbPath = path.join(dir, "memories.db");
+    if (process.env.EXE_OS_DIR && config2.dbPath !== envDbPath && !existsSync2(config2.dbPath) && existsSync2(envDbPath)) {
+      config2.dbPath = envDbPath;
+    }
+    return config2;
   } catch {
     return { ...DEFAULT_CONFIG, dbPath: path.join(dir, "memories.db") };
   }
@@ -695,15 +707,15 @@ function isDaemonTooYoung() {
   }
 }
 async function retryThenRestart(doRequest, label) {
-  const result = await doRequest();
-  if (!result.error) {
+  const result2 = await doRequest();
+  if (!result2.error) {
     _consecutiveFailures = 0;
-    return result;
+    return result2;
   }
   _consecutiveFailures++;
   for (let i = 0; i < MAX_RETRIES_BEFORE_RESTART; i++) {
     const delayMs = RETRY_DELAYS_MS[i] ?? 5e3;
-    process.stderr.write(`[exed-client] ${label} failed (${result.error}), retry ${i + 1}/${MAX_RETRIES_BEFORE_RESTART} in ${delayMs}ms
+    process.stderr.write(`[exed-client] ${label} failed (${result2.error}), retry ${i + 1}/${MAX_RETRIES_BEFORE_RESTART} in ${delayMs}ms
 `);
     await new Promise((r) => setTimeout(r, delayMs));
     if (!_connected) {
@@ -719,7 +731,7 @@ async function retryThenRestart(doRequest, label) {
   if (isDaemonTooYoung()) {
     process.stderr.write(`[exed-client] ${label}: daemon too young (< ${MIN_DAEMON_AGE_MS / 1e3}s) \u2014 skipping restart
 `);
-    return { error: result.error };
+    return { error: result2.error };
   }
   process.stderr.write(`[exed-client] ${label}: ${_consecutiveFailures} consecutive failures \u2014 restarting daemon
 `);
@@ -755,20 +767,20 @@ async function embedViaClient(text3, priority = "high") {
       if (!_connected) return null;
     }
   }
-  const result = await retryThenRestart(
+  const result2 = await retryThenRestart(
     () => sendRequest([text3], priority),
     "Embed"
   );
-  return !result.error && result.vectors?.[0] ? result.vectors[0] : null;
+  return !result2.error && result2.vectors?.[0] ? result2.vectors[0] : null;
 }
 async function embedBatchViaClient(texts, priority = "high") {
   if (!_connected && !await connectEmbedDaemon()) return null;
   _requestCount++;
-  const result = await retryThenRestart(
+  const result2 = await retryThenRestart(
     () => sendRequest(texts, priority),
     "Batch embed"
   );
-  return !result.error && result.vectors ? result.vectors : null;
+  return !result2.error && result2.vectors ? result2.vectors : null;
 }
 function disconnectClient() {
   if (_socket) {
@@ -861,10 +873,10 @@ async function disposeEmbedder() {
 async function embedDirect(text3) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync38 } = await import("fs");
-  const path49 = await import("path");
-  const modelPath = path49.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync38(modelPath)) {
+  const { existsSync: existsSync39 } = await import("fs");
+  const path50 = await import("path");
+  const modelPath = path50.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync39(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -2214,6 +2226,9 @@ function getClient() {
   if (_daemonClient && _daemonClient._isDaemonActive()) {
     return _daemonClient;
   }
+  if (!_resilientClient) {
+    return _adapterClient;
+  }
   return _resilientClient;
 }
 async function initDaemonClient() {
@@ -3246,6 +3261,127 @@ async function ensureSchema() {
       VALUES (new.rowid, new.content, new.subject, new.predicate, new.object);
     END;
   `);
+  await client.executeMultiple(`
+    CREATE TABLE IF NOT EXISTS agent_sessions (
+      id              TEXT PRIMARY KEY,
+      agent_id        TEXT NOT NULL,
+      project_name    TEXT,
+      started_at      TEXT NOT NULL,
+      last_event_at   TEXT NOT NULL,
+      event_count     INTEGER NOT NULL DEFAULT 0,
+      properties      TEXT DEFAULT '{}'
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_sessions_agent_time
+      ON agent_sessions(agent_id, started_at);
+
+    CREATE TABLE IF NOT EXISTS agent_goals (
+      id                TEXT PRIMARY KEY,
+      statement         TEXT NOT NULL,
+      owner_agent_id    TEXT,
+      project_name      TEXT,
+      status            TEXT NOT NULL DEFAULT 'open',
+      priority          INTEGER NOT NULL DEFAULT 5,
+      success_criteria  TEXT,
+      parent_goal_id    TEXT,
+      due_at            TEXT,
+      achieved_at       TEXT,
+      supersedes_id     TEXT,
+      created_at        TEXT NOT NULL,
+      updated_at        TEXT NOT NULL,
+      source_memory_id  TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_goals_project_status
+      ON agent_goals(project_name, status, priority);
+
+    CREATE TABLE IF NOT EXISTS agent_events (
+      id                  TEXT PRIMARY KEY,
+      event_type          TEXT NOT NULL,
+      occurred_at         TEXT NOT NULL,
+      sequence_index      INTEGER NOT NULL,
+      actor_agent_id      TEXT,
+      agent_role          TEXT,
+      project_name        TEXT,
+      session_id          TEXT,
+      task_id             TEXT,
+      goal_id             TEXT,
+      parent_event_id     TEXT,
+      intention           TEXT,
+      outcome             TEXT,
+      evidence_memory_id  TEXT,
+      impact              TEXT,
+      payload             TEXT DEFAULT '{}',
+      created_at          TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_time
+      ON agent_events(occurred_at, sequence_index);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_session_seq
+      ON agent_events(session_id, sequence_index);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_goal_time
+      ON agent_events(goal_id, occurred_at);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_events_memory
+      ON agent_events(evidence_memory_id);
+
+    CREATE TABLE IF NOT EXISTS agent_goal_links (
+      id           TEXT PRIMARY KEY,
+      goal_id      TEXT NOT NULL,
+      link_type    TEXT NOT NULL,
+      target_id    TEXT NOT NULL,
+      target_type  TEXT NOT NULL,
+      created_at   TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_goal_links_goal
+      ON agent_goal_links(goal_id, target_type);
+
+    CREATE TABLE IF NOT EXISTS agent_semantic_labels (
+      id                TEXT PRIMARY KEY,
+      source_memory_id  TEXT NOT NULL,
+      event_id          TEXT,
+      labeler           TEXT NOT NULL,
+      schema_version    INTEGER NOT NULL DEFAULT 1,
+      confidence        REAL NOT NULL DEFAULT 0,
+      labels            TEXT NOT NULL,
+      created_at        TEXT NOT NULL,
+      updated_at        TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_semantic_labels_memory
+      ON agent_semantic_labels(source_memory_id, labeler);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_semantic_labels_event
+      ON agent_semantic_labels(event_id);
+
+    CREATE TABLE IF NOT EXISTS agent_reflection_checkpoints (
+      id                  TEXT PRIMARY KEY,
+      project_name        TEXT,
+      session_id          TEXT,
+      window_start_at     TEXT NOT NULL,
+      window_end_at       TEXT NOT NULL,
+      event_count         INTEGER NOT NULL DEFAULT 0,
+      goal_count          INTEGER NOT NULL DEFAULT 0,
+      success_count       INTEGER NOT NULL DEFAULT 0,
+      failure_count       INTEGER NOT NULL DEFAULT 0,
+      risk_count          INTEGER NOT NULL DEFAULT 0,
+      summary             TEXT NOT NULL,
+      learnings           TEXT NOT NULL DEFAULT '[]',
+      next_actions        TEXT NOT NULL DEFAULT '[]',
+      evidence_event_ids  TEXT NOT NULL DEFAULT '[]',
+      confidence          REAL NOT NULL DEFAULT 0,
+      created_at          TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_agent_reflection_project_time
+      ON agent_reflection_checkpoints(project_name, window_end_at);
+
+    CREATE INDEX IF NOT EXISTS idx_agent_reflection_session_time
+      ON agent_reflection_checkpoints(session_id, window_end_at);
+  `);
   try {
     await client.execute({
       sql: `ALTER TABLE memories ADD COLUMN tier INTEGER DEFAULT 3`,
@@ -3398,12 +3534,13 @@ var keychain_exports = {};
 __export(keychain_exports, {
   deleteMasterKey: () => deleteMasterKey,
   exportMnemonic: () => exportMnemonic,
+  getKeyStorageInfo: () => getKeyStorageInfo,
   getMasterKey: () => getMasterKey,
   importMnemonic: () => importMnemonic,
   setMasterKey: () => setMasterKey
 });
 import { readFile as readFile3, writeFile as writeFile3, unlink, mkdir as mkdir3, chmod as chmod2 } from "fs/promises";
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync7, statSync as statSync2 } from "fs";
 import { execSync as execSync2 } from "child_process";
 import path7 from "path";
 import os5 from "os";
@@ -3413,29 +3550,65 @@ function getKeyDir() {
 function getKeyPath() {
   return path7.join(getKeyDir(), "master.key");
 }
-function macKeychainGet() {
+function nativeKeychainAllowed() {
+  return process.env.EXE_OS_DISABLE_NATIVE_KEYCHAIN !== "1";
+}
+function linuxSecretAvailable() {
+  if (!nativeKeychainAllowed()) return false;
+  if (process.platform !== "linux") return false;
+  if (linuxSecretAvailability !== null) return linuxSecretAvailability;
+  try {
+    execSync2("command -v secret-tool >/dev/null 2>&1", { timeout: 1e3 });
+  } catch {
+    linuxSecretAvailability = false;
+    return false;
+  }
+  try {
+    execSync2("secret-tool search --all exe-os probe >/dev/null 2>&1", { timeout: 1e3 });
+    linuxSecretAvailability = true;
+  } catch {
+    linuxSecretAvailability = false;
+  }
+  return linuxSecretAvailability;
+}
+function isRootOnlyTrustedServerKeyFile(keyPath) {
+  if (process.platform !== "linux") return false;
+  try {
+    const uid = typeof os5.userInfo().uid === "number" ? os5.userInfo().uid : -1;
+    const st = statSync2(keyPath);
+    if (!st.isFile() || (st.mode & 63) !== 0) return false;
+    if (uid === 0) return true;
+    const exeOsDir = process.env.EXE_OS_DIR;
+    return Boolean(exeOsDir && path7.resolve(keyPath).startsWith(path7.resolve(exeOsDir) + path7.sep));
+  } catch {
+    return false;
+  }
+}
+function macKeychainGet(service = SERVICE) {
+  if (!nativeKeychainAllowed()) return null;
   if (process.platform !== "darwin") return null;
   try {
     return execSync2(
-      `security find-generic-password -s "${SERVICE}" -a "${ACCOUNT}" -w 2>/dev/null`,
+      `security find-generic-password -s "${service}" -a "${ACCOUNT}" -w 2>/dev/null`,
       { encoding: "utf-8", timeout: 5e3 }
     ).trim();
   } catch {
     return null;
   }
 }
-function macKeychainSet(value) {
+function macKeychainSet(value, service = SERVICE) {
+  if (!nativeKeychainAllowed()) return false;
   if (process.platform !== "darwin") return false;
   try {
     try {
       execSync2(
-        `security delete-generic-password -s "${SERVICE}" -a "${ACCOUNT}" 2>/dev/null`,
+        `security delete-generic-password -s "${service}" -a "${ACCOUNT}" 2>/dev/null`,
         { timeout: 5e3 }
       );
     } catch {
     }
     execSync2(
-      `security add-generic-password -s "${SERVICE}" -a "${ACCOUNT}" -w "${value}"`,
+      `security add-generic-password -s "${service}" -a "${ACCOUNT}" -w "${value}"`,
       { timeout: 5e3 }
     );
     return true;
@@ -3443,11 +3616,12 @@ function macKeychainSet(value) {
     return false;
   }
 }
-function macKeychainDelete() {
+function macKeychainDelete(service = SERVICE) {
+  if (!nativeKeychainAllowed()) return false;
   if (process.platform !== "darwin") return false;
   try {
     execSync2(
-      `security delete-generic-password -s "${SERVICE}" -a "${ACCOUNT}" 2>/dev/null`,
+      `security delete-generic-password -s "${service}" -a "${ACCOUNT}" 2>/dev/null`,
       { timeout: 5e3 }
     );
     return true;
@@ -3455,22 +3629,22 @@ function macKeychainDelete() {
     return false;
   }
 }
-function linuxSecretGet() {
-  if (process.platform !== "linux") return null;
+function linuxSecretGet(service = SERVICE) {
+  if (!linuxSecretAvailable()) return null;
   try {
     return execSync2(
-      `secret-tool lookup service "${SERVICE}" account "${ACCOUNT}" 2>/dev/null`,
+      `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;
+function linuxSecretSet(value, service = SERVICE) {
+  if (!linuxSecretAvailable()) return false;
   try {
     execSync2(
-      `echo -n "${value}" | secret-tool store --label="exe-os master key" service "${SERVICE}" account "${ACCOUNT}"`,
+      `echo -n "${value}" | secret-tool store --label="exe-os master key" service "${service}" account "${ACCOUNT}" 2>/dev/null`,
       { timeout: 5e3 }
     );
     return true;
@@ -3478,11 +3652,12 @@ function linuxSecretSet(value) {
     return false;
   }
 }
-function linuxSecretDelete() {
+function linuxSecretDelete(service = SERVICE) {
+  if (!nativeKeychainAllowed()) return false;
   if (process.platform !== "linux") return false;
   try {
     execSync2(
-      `secret-tool clear service "${SERVICE}" account "${ACCOUNT}" 2>/dev/null`,
+      `secret-tool clear service "${service}" account "${ACCOUNT}" 2>/dev/null`,
       { timeout: 5e3 }
     );
     return true;
@@ -3491,6 +3666,7 @@ function linuxSecretDelete() {
   }
 }
 async function tryKeytar() {
+  if (!nativeKeychainAllowed()) return null;
   try {
     return await import("keytar");
   } catch {
@@ -3499,7 +3675,7 @@ async function tryKeytar() {
 }
 function deriveMachineKey() {
   try {
-    const crypto19 = __require("crypto");
+    const crypto20 = __require("crypto");
     const material = [
       os5.hostname(),
       os5.userInfo().username,
@@ -3508,23 +3684,23 @@ function deriveMachineKey() {
       // Machine ID on Linux (stable across reboots)
       process.platform === "linux" ? readMachineId() : ""
     ].join("|");
-    return crypto19.createHash("sha256").update(material).digest();
+    return crypto20.createHash("sha256").update(material).digest();
   } catch {
     return null;
   }
 }
 function readMachineId() {
   try {
-    const { readFileSync: readFileSync31 } = __require("fs");
-    return readFileSync31("/etc/machine-id", "utf-8").trim();
+    const { readFileSync: readFileSync32 } = __require("fs");
+    return readFileSync32("/etc/machine-id", "utf-8").trim();
   } catch {
     return "";
   }
 }
 function encryptWithMachineKey(plaintext, machineKey) {
-  const crypto19 = __require("crypto");
-  const iv = crypto19.randomBytes(12);
-  const cipher = crypto19.createCipheriv("aes-256-gcm", machineKey, iv);
+  const crypto20 = __require("crypto");
+  const iv = crypto20.randomBytes(12);
+  const cipher = crypto20.createCipheriv("aes-256-gcm", machineKey, iv);
   let encrypted = cipher.update(plaintext, "utf-8", "base64");
   encrypted += cipher.final("base64");
   const authTag = cipher.getAuthTag().toString("base64");
@@ -3533,13 +3709,13 @@ function encryptWithMachineKey(plaintext, machineKey) {
 function decryptWithMachineKey(encrypted, machineKey) {
   if (!encrypted.startsWith(ENCRYPTED_PREFIX)) return null;
   try {
-    const crypto19 = __require("crypto");
+    const crypto20 = __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 = crypto19.createDecipheriv("aes-256-gcm", machineKey, iv);
+    const decipher = crypto20.createDecipheriv("aes-256-gcm", machineKey, iv);
     decipher.setAuthTag(authTag);
     let decrypted = decipher.update(cipherB64, "base64", "utf-8");
     decrypted += decipher.final("utf-8");
@@ -3564,7 +3740,19 @@ async function writeMachineBoundFileFallback(b64) {
   return "plaintext";
 }
 async function getMasterKey() {
-  const nativeValue = macKeychainGet() ?? linuxSecretGet();
+  let nativeValue = macKeychainGet() ?? linuxSecretGet();
+  if (!nativeValue) {
+    const legacyValue = macKeychainGet(LEGACY_SERVICE) ?? linuxSecretGet(LEGACY_SERVICE);
+    if (legacyValue) {
+      const migrated = macKeychainSet(legacyValue) || linuxSecretSet(legacyValue);
+      if (migrated) {
+        macKeychainDelete(LEGACY_SERVICE);
+        linuxSecretDelete(LEGACY_SERVICE);
+        process.stderr.write("[keychain] Migrated keychain service from exe-mem to exe-os.\n");
+      }
+      nativeValue = legacyValue;
+    }
+  }
   if (nativeValue) {
     return Buffer.from(nativeValue, "base64");
   }
@@ -3572,12 +3760,17 @@ async function getMasterKey() {
   if (keytar) {
     try {
       const keytarValue = await keytar.getPassword(SERVICE, ACCOUNT);
-      if (keytarValue) {
-        const migrated = macKeychainSet(keytarValue) || linuxSecretSet(keytarValue);
+      const legacyKeytarValue = keytarValue ?? await keytar.getPassword(LEGACY_SERVICE, ACCOUNT);
+      if (legacyKeytarValue) {
+        const migrated = macKeychainSet(legacyKeytarValue) || linuxSecretSet(legacyKeytarValue);
         if (migrated) {
           process.stderr.write("[keychain] Migrated key from keytar to native keychain.\n");
+          try {
+            await keytar.deletePassword(LEGACY_SERVICE, ACCOUNT);
+          } catch {
+          }
         }
-        return Buffer.from(keytarValue, "base64");
+        return Buffer.from(legacyKeytarValue, "base64");
       }
     } catch {
     }
@@ -3602,7 +3795,7 @@ async function getMasterKey() {
       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"
+          "[keychain] Key decryption failed \u2014 machine may have changed.\n  Use your 24-word recovery phrase during setup: exe-os setup\n"
         );
         return null;
       }
@@ -3611,6 +3804,9 @@ async function getMasterKey() {
       b64Value = content;
     }
     const key = Buffer.from(b64Value, "base64");
+    if (!content.startsWith(ENCRYPTED_PREFIX) && isRootOnlyTrustedServerKeyFile(keyPath)) {
+      return key;
+    }
     const migrated = macKeychainSet(b64Value) || linuxSecretSet(b64Value);
     if (migrated) {
       process.stderr.write("[keychain] Migrated key from file to native keychain.\n");
@@ -3638,6 +3834,97 @@ async function getMasterKey() {
     return null;
   }
 }
+async function getKeyStorageInfo() {
+  if (macKeychainGet()) {
+    return {
+      kind: "macos-keychain",
+      secure: true,
+      note: "stored in macOS Keychain via built-in security CLI"
+    };
+  }
+  if (macKeychainGet(LEGACY_SERVICE)) {
+    return {
+      kind: "macos-keychain",
+      secure: true,
+      note: "stored in legacy macOS Keychain service exe-mem; next key read migrates it to exe-os"
+    };
+  }
+  if (linuxSecretGet()) {
+    return {
+      kind: "linux-secret-service",
+      secure: true,
+      note: "stored in Linux Secret Service via secret-tool"
+    };
+  }
+  if (linuxSecretGet(LEGACY_SERVICE)) {
+    return {
+      kind: "linux-secret-service",
+      secure: true,
+      note: "stored in legacy Linux Secret Service service exe-mem; next key read migrates it to exe-os"
+    };
+  }
+  const keytar = await tryKeytar();
+  if (keytar) {
+    try {
+      if (await keytar.getPassword(SERVICE, ACCOUNT)) {
+        return {
+          kind: "legacy-keytar",
+          secure: true,
+          note: "stored in legacy keytar backend; will migrate to native keychain when possible"
+        };
+      }
+      if (await keytar.getPassword(LEGACY_SERVICE, ACCOUNT)) {
+        return {
+          kind: "legacy-keytar",
+          secure: true,
+          note: "stored in legacy keytar service exe-mem; will migrate to native exe-os keychain when possible"
+        };
+      }
+    } catch {
+    }
+  }
+  const keyPath = getKeyPath();
+  if (!existsSync7(keyPath)) {
+    return {
+      kind: "missing",
+      secure: false,
+      path: keyPath,
+      note: "no key found in OS keychain, legacy keytar, or file fallback"
+    };
+  }
+  try {
+    const content = (await readFile3(keyPath, "utf-8")).trim();
+    if (content.startsWith(ENCRYPTED_PREFIX)) {
+      return {
+        kind: "encrypted-file",
+        secure: true,
+        path: keyPath,
+        note: "stored in machine-bound encrypted file fallback"
+      };
+    }
+    if (isRootOnlyTrustedServerKeyFile(keyPath)) {
+      return {
+        kind: "server-secret-file",
+        secure: true,
+        path: keyPath,
+        note: "stored as root-only trusted server secret file"
+      };
+    }
+    return {
+      kind: "plaintext-file",
+      secure: false,
+      path: keyPath,
+      note: "stored in legacy plaintext file; reading it will migrate or encrypt it"
+    };
+  } catch {
+    return {
+      kind: "missing",
+      secure: false,
+      path: keyPath,
+      note: "key file exists but could not be read"
+    };
+  }
+}
 async function setMasterKey(key) {
   const b64 = key.toString("base64");
   if (macKeychainSet(b64) || linuxSecretSet(b64)) {
@@ -3663,10 +3950,13 @@ async function setMasterKey(key) {
 async function deleteMasterKey() {
   macKeychainDelete();
   linuxSecretDelete();
+  macKeychainDelete(LEGACY_SERVICE);
+  linuxSecretDelete(LEGACY_SERVICE);
   const keytar = await tryKeytar();
   if (keytar) {
     try {
       await keytar.deletePassword(SERVICE, ACCOUNT);
+      await keytar.deletePassword(LEGACY_SERVICE, ACCOUNT);
     } catch {
     }
   }
@@ -3704,12 +3994,14 @@ async function importMnemonic(mnemonic) {
   const entropy = mnemonicToEntropy(trimmed);
   return Buffer.from(entropy, "hex");
 }
-var SERVICE, ACCOUNT, ENCRYPTED_PREFIX;
+var SERVICE, LEGACY_SERVICE, ACCOUNT, linuxSecretAvailability, ENCRYPTED_PREFIX;
 var init_keychain = __esm({
   "src/lib/keychain.ts"() {
     "use strict";
-    SERVICE = "exe-mem";
+    SERVICE = "exe-os";
+    LEGACY_SERVICE = "exe-mem";
     ACCOUNT = "master-key";
+    linuxSecretAvailability = null;
     ENCRYPTED_PREFIX = "enc:";
   }
 });
@@ -3859,8 +4151,8 @@ async function findScopedDuplicate(input) {
     args.push(input.excludeId);
   }
   sql += " ORDER BY timestamp DESC LIMIT 1";
-  const result = await client.execute({ sql, args });
-  return result.rows[0]?.id ? String(result.rows[0].id) : null;
+  const result2 = await client.execute({ sql, args });
+  return result2.rows[0]?.id ? String(result2.rows[0].id) : null;
 }
 async function runPostWriteMemoryHygiene(memoryId) {
   try {
@@ -3979,7 +4271,7 @@ __export(shard_manager_exports, {
   shardExists: () => shardExists
 });
 import path8 from "path";
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readdirSync, renameSync as renameSync3, statSync as statSync2 } from "fs";
+import { existsSync as existsSync8, mkdirSync as mkdirSync2, readdirSync, renameSync as renameSync3, statSync as statSync3 } from "fs";
 import { createClient as createClient2 } from "@libsql/client";
 function initShardManager(encryptionKey) {
   _encryptionKey = encryptionKey;
@@ -4043,7 +4335,7 @@ async function auditShardHealth(options = {}) {
   const shards = [];
   for (const name of names) {
     const dbPath = path8.join(SHARDS_DIR, `${name}.db`);
-    const stat = statSync2(dbPath);
+    const stat = statSync3(dbPath);
     const item = {
       name,
       path: dbPath,
@@ -4296,7 +4588,7 @@ async function getReadyShardClient(projectName) {
     _shardLastAccess.delete(safeName);
     const dbPath = path8.join(SHARDS_DIR, `${safeName}.db`);
     if (existsSync8(dbPath)) {
-      const stat = statSync2(dbPath);
+      const stat = statSync3(dbPath);
       const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const archivedPath = path8.join(SHARDS_DIR, `${safeName}.db.broken-${stamp}`);
       renameSync3(dbPath, archivedPath);
@@ -4585,11 +4877,11 @@ __export(global_procedures_exports, {
 import { randomUUID as randomUUID2 } from "crypto";
 async function loadGlobalProcedures() {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: "SELECT * FROM company_procedures WHERE active = 1 ORDER BY priority ASC, created_at ASC",
     args: []
   });
-  const allRows = result.rows;
+  const allRows = result2.rows;
   const customerOnly = allRows.filter((p) => !PLATFORM_PROCEDURE_TITLES.has(p.title));
   if (customerOnly.length > 0) {
     _customerCache = customerOnly.map((p) => `### ${p.title}
@@ -4625,12 +4917,12 @@ async function storeGlobalProcedure(input) {
 async function deactivateGlobalProcedure(id) {
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: "UPDATE company_procedures SET active = 0, updated_at = ? WHERE id = ?",
     args: [now, id]
   });
   await loadGlobalProcedures();
-  return result.rowsAffected > 0;
+  return result2.rowsAffected > 0;
 }
 var _customerCache, _cacheLoaded, _platformCache;
 var init_global_procedures = __esm({
@@ -4774,8 +5066,8 @@ async function searchMemoryCards(queryText, agentId, options) {
   }
   sql += ` ORDER BY rank LIMIT ?`;
   args.push(limit);
-  const result = await getClient().execute({ sql, args });
-  return result.rows.map((row) => ({
+  const result2 = await getClient().execute({ sql, args });
+  return result2.rows.map((row) => ({
     id: `card:${String(row.id)}`,
     agent_id: String(row.agent_id),
     agent_role: "memory_card",
@@ -4803,6 +5095,274 @@ var init_memory_cards = __esm({
   }
 });
 
+// src/lib/agentic-ontology.ts
+var agentic_ontology_exports = {};
+__export(agentic_ontology_exports, {
+  clean: () => clean,
+  extractGoalCandidates: () => extractGoalCandidates,
+  inferIntention: () => inferIntention,
+  inferOntologyEventType: () => inferOntologyEventType,
+  inferOutcome: () => inferOutcome,
+  inferSemanticLabel: () => inferSemanticLabel,
+  insertOntologyForBatch: () => insertOntologyForBatch,
+  insertOntologyForMemory: () => insertOntologyForMemory,
+  ontologyPayload: () => ontologyPayload,
+  stableId: () => stableId2
+});
+import { createHash as createHash3 } from "crypto";
+function stableId2(...parts) {
+  return createHash3("sha256").update(parts.map((p) => String(p ?? "")).join("::")).digest("hex").slice(0, 32);
+}
+function clean(text3, max = 240) {
+  return text3.replace(/\u0000/g, "").replace(/```[\s\S]*?```/g, " ").replace(/\s+/g, " ").trim().slice(0, max);
+}
+function inferOntologyEventType(row) {
+  const lower = row.raw_text.toLowerCase();
+  if (row.has_error) return "error";
+  if (/\b(done|complete|completed|fixed|resolved|shipped|deployed|pushed|published)\b/.test(lower)) return "milestone";
+  if (/\b(blocked|failed|error|bug|regression|broken)\b/.test(lower)) return "problem";
+  if (/\b(decided|decision|adr|we chose|approved|rejected)\b/.test(lower)) return "decision";
+  if (/\b(goal|need to|we need|want to|trying to|objective)\b/.test(lower)) return "goal_signal";
+  if (["Bash", "Read", "Edit", "Write", "Grep", "Glob"].includes(row.tool_name)) return "tool_action";
+  if (row.tool_name.startsWith("memory_card")) return "memory_card";
+  return "memory_observation";
+}
+function inferIntention(row) {
+  if (row.intent) return clean(row.intent, 220);
+  const text3 = clean(row.raw_text, 1e3);
+  const patterns = [
+    /(?:we need to|need to|let'?s|i want to|we should|goal is to|objective is to|trying to)\s+([^.!?\n]{8,220})/i,
+    /(?:so that|in order to)\s+([^.!?\n]{8,220})/i,
+    /(?:task|plan):\s*([^.!?\n]{8,220})/i
+  ];
+  for (const p of patterns) {
+    const m = text3.match(p);
+    if (m?.[1]) return clean(m[1], 220);
+  }
+  if (["Bash", "Read", "Edit", "Write", "Grep", "Glob"].includes(row.tool_name)) {
+    return `${row.tool_name} during ${row.project_name}`;
+  }
+  return null;
+}
+function inferOutcome(row) {
+  if (row.outcome) return clean(row.outcome, 220);
+  if (row.has_error) return "error";
+  const lower = row.raw_text.toLowerCase();
+  if (/\b(done|complete|completed|fixed|resolved|shipped|deployed|pushed|published|passed)\b/.test(lower)) return "success_signal";
+  if (/\b(blocked|failed|error|regression|broken|not working|could not)\b/.test(lower)) return "failure_signal";
+  if (/\b(warning|risk|concern|caveat)\b/.test(lower)) return "risk_signal";
+  return null;
+}
+function extractGoalCandidates(row) {
+  const text3 = clean(row.raw_text, 1600);
+  const patterns = [
+    /(?:we need to|need to|i want to|we should|goal is to|objective is to|trying to|let'?s)\s+([^.!?\n]{12,220})/gi,
+    /(?:success means|success criteria|so that)\s+([^.!?\n]{12,220})/gi
+  ];
+  const out = [];
+  for (const pattern of patterns) {
+    for (const m of text3.matchAll(pattern)) {
+      const candidate = clean(m[1] ?? "", 220);
+      if (candidate.length >= 12 && !out.some((x) => x.toLowerCase() === candidate.toLowerCase())) out.push(candidate);
+      if (out.length >= 3) return out;
+    }
+  }
+  return out;
+}
+function uniq(values, max = 6) {
+  const out = [];
+  for (const value of values.map((v) => clean(v, 220)).filter(Boolean)) {
+    if (!out.some((x) => x.toLowerCase() === value.toLowerCase())) out.push(value);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+function extractMatches(text3, patterns, max = 5) {
+  const out = [];
+  for (const pattern of patterns) {
+    for (const match of text3.matchAll(pattern)) {
+      const value = match[1] ?? match[0];
+      if (value) out.push(value);
+      if (out.length >= max) return uniq(out, max);
+    }
+  }
+  return uniq(out, max);
+}
+function inferSemanticLabel(row) {
+  const text3 = clean(row.raw_text, 2400);
+  const eventType = inferOntologyEventType(row);
+  const intention = inferIntention(row);
+  const outcome = inferOutcome(row);
+  const goals = extractGoalCandidates(row);
+  const milestones = extractMatches(text3, [
+    /\b(?:completed|finished|fixed|resolved|shipped|deployed|published|pushed|passed)\b([^.!?\n]{0,180})/gi,
+    /(?:milestone|done):\s*([^.!?\n]{8,220})/gi
+  ]);
+  const problems = extractMatches(text3, [
+    /\b(?:blocked by|failed because|bug|regression|broken|not working|error)\b([^.!?\n]{0,180})/gi,
+    /(?:problem|issue|risk):\s*([^.!?\n]{8,220})/gi
+  ]);
+  const decisions = extractMatches(text3, [
+    /(?:decided|decision|adr|we chose|approved|rejected)\s+([^.!?\n]{8,220})/gi
+  ]);
+  const temporalAnchors = extractMatches(text3, [
+    /\b(\d{4}-\d{2}-\d{2}(?:[T ][0-9:.+-Z]+)?)\b/g,
+    /\b(today|yesterday|tomorrow|this week|next week|last week|morning|afternoon|tonight)\b/gi
+  ], 8);
+  const nextActions = extractMatches(text3, [
+    /(?:next|todo|follow[- ]?up|remaining|need to)\s*:?\s*([^.!?\n]{8,220})/gi
+  ]);
+  const actors = uniq([
+    row.agent_id,
+    ...extractMatches(text3, [/\b(?:agent|employee|owner|assignee)[:= ]+([a-zA-Z][a-zA-Z0-9_-]{1,40})/gi], 5)
+  ], 6);
+  const successSignals = milestones.length ? milestones : outcome === "success_signal" ? [clean(text3, 180)] : [];
+  const failureSignals = problems.length ? problems : outcome === "failure_signal" || row.has_error ? [clean(text3, 180)] : [];
+  const impact = successSignals.length && failureSignals.length ? "mixed" : failureSignals.length ? "negative" : successSignals.length ? "positive" : "neutral";
+  const signalCount = goals.length + milestones.length + problems.length + decisions.length + nextActions.length;
+  return {
+    labeler: "deterministic",
+    schemaVersion: 1,
+    eventType,
+    intention,
+    outcome,
+    impact,
+    confidence: Math.min(0.95, 0.45 + signalCount * 0.08 + (intention ? 0.1 : 0) + (outcome ? 0.1 : 0)),
+    goals,
+    milestones,
+    problems,
+    decisions,
+    actors,
+    temporalAnchors,
+    successSignals,
+    failureSignals,
+    nextActions,
+    summary: clean(text3, 280)
+  };
+}
+function ontologyPayload(row) {
+  const semantic = inferSemanticLabel(row);
+  return {
+    tool_name: row.tool_name,
+    memory_version: row.version ?? null,
+    domain: row.domain ?? null,
+    trajectory: row.trajectory ? safeJson(row.trajectory) : null,
+    semantic
+  };
+}
+function safeJson(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value.slice(0, 1e3);
+  }
+}
+async function resolveClient(client) {
+  if (client) return client;
+  const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
+  return getClient2();
+}
+async function insertOntologyForMemory(row, client) {
+  const db = await resolveClient(client);
+  const occurredAt = row.timestamp;
+  const sequence = Number(row.version ?? 0) || Math.floor(new Date(occurredAt).getTime() / 1e3);
+  const eventType = inferOntologyEventType(row);
+  const intention = inferIntention(row);
+  const outcome = inferOutcome(row);
+  const eventId = stableId2("event", row.id);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  await db.execute({
+    sql: `INSERT INTO agent_sessions (id, agent_id, project_name, started_at, last_event_at, event_count, properties)
+          VALUES (?, ?, ?, ?, ?, 1, ?)
+          ON CONFLICT(id) DO UPDATE SET last_event_at = MAX(last_event_at, excluded.last_event_at),
+            event_count = event_count + 1`,
+    args: [row.session_id, row.agent_id, row.project_name, occurredAt, occurredAt, JSON.stringify({ agent_role: row.agent_role })]
+  });
+  await db.execute({
+    sql: `INSERT OR IGNORE INTO agent_events
+          (id, event_type, occurred_at, sequence_index, actor_agent_id, agent_role, project_name,
+           session_id, task_id, goal_id, parent_event_id, intention, outcome, evidence_memory_id,
+           impact, payload, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      eventId,
+      eventType,
+      occurredAt,
+      sequence,
+      row.agent_id,
+      row.agent_role,
+      row.project_name,
+      row.session_id,
+      row.task_id ?? null,
+      intention,
+      outcome,
+      row.id,
+      row.has_error ? "negative" : outcome === "success_signal" ? "positive" : "neutral",
+      JSON.stringify(ontologyPayload(row)),
+      now
+    ]
+  });
+  const semantic = inferSemanticLabel(row);
+  await db.execute({
+    sql: `INSERT INTO agent_semantic_labels
+          (id, source_memory_id, event_id, labeler, schema_version, confidence, labels, created_at, updated_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+          ON CONFLICT(id) DO UPDATE SET confidence = excluded.confidence,
+            labels = excluded.labels, updated_at = excluded.updated_at`,
+    args: [
+      stableId2("semantic", row.id, semantic.labeler, semantic.schemaVersion),
+      row.id,
+      eventId,
+      semantic.labeler,
+      semantic.schemaVersion,
+      semantic.confidence,
+      JSON.stringify(semantic),
+      now,
+      now
+    ]
+  });
+  for (const statement of extractGoalCandidates(row)) {
+    const goalId = stableId2("goal", row.project_name, statement.toLowerCase());
+    await db.execute({
+      sql: `INSERT INTO agent_goals
+            (id, statement, owner_agent_id, project_name, status, priority, success_criteria,
+             parent_goal_id, due_at, achieved_at, supersedes_id, created_at, updated_at, source_memory_id)
+            VALUES (?, ?, ?, ?, 'open', 5, NULL, NULL, NULL, NULL, NULL, ?, ?, ?)
+            ON CONFLICT(id) DO UPDATE SET updated_at = excluded.updated_at`,
+      args: [goalId, statement, row.agent_id, row.project_name, now, now, row.id]
+    });
+    await db.execute({
+      sql: `INSERT OR IGNORE INTO agent_goal_links
+            (id, goal_id, link_type, target_id, target_type, created_at)
+            VALUES (?, ?, 'evidence', ?, 'memory', ?)`,
+      args: [stableId2("goal_link", goalId, row.id, "memory"), goalId, row.id, now]
+    });
+    await db.execute({
+      sql: `INSERT OR IGNORE INTO agent_goal_links
+            (id, goal_id, link_type, target_id, target_type, created_at)
+            VALUES (?, ?, 'event', ?, 'event', ?)`,
+      args: [stableId2("goal_link", goalId, eventId, "event"), goalId, eventId, now]
+    });
+  }
+}
+async function insertOntologyForBatch(rows, client) {
+  const db = await resolveClient(client);
+  let count = 0;
+  for (const row of rows) {
+    try {
+      await insertOntologyForMemory(row, db);
+      count++;
+    } catch {
+    }
+  }
+  return count;
+}
+var init_agentic_ontology = __esm({
+  "src/lib/agentic-ontology.ts"() {
+    "use strict";
+  }
+});
+
 // src/lib/store.ts
 var store_exports = {};
 __export(store_exports, {
@@ -5146,6 +5706,11 @@ async function flushBatch() {
       await insertMemoryCardsForBatch2(batch);
     } catch {
     }
+    try {
+      const { insertOntologyForBatch: insertOntologyForBatch2 } = await Promise.resolve().then(() => (init_agentic_ontology(), agentic_ontology_exports));
+      await insertOntologyForBatch2(batch);
+    } catch {
+    }
     schedulePostWriteMemoryHygiene(batch.map((row) => row.id));
     _pendingRecords.splice(0, batch.length);
     try {
@@ -5279,8 +5844,8 @@ async function searchMemories(queryVector, agentId, options) {
   args.push(vectorToBlob(queryVector));
   sql += ` LIMIT ?`;
   args.push(limit);
-  const result = await client.execute({ sql, args });
-  return result.rows.map((row) => ({
+  const result2 = await client.execute({ sql, args });
+  return result2.rows.map((row) => ({
     id: row.id,
     agent_id: row.agent_id,
     agent_role: row.agent_role,
@@ -5314,14 +5879,14 @@ async function attachDocumentMetadata(records) {
   try {
     const client = getClient();
     const placeholders = docIds.map(() => "?").join(",");
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT id, filename, mime, source_type, uploaded_at
             FROM documents
             WHERE id IN (${placeholders})`,
       args: docIds
     });
     const byId = /* @__PURE__ */ new Map();
-    for (const row of result.rows) {
+    for (const row of result2.rows) {
       const id = row.id;
       byId.set(id, {
         document_id: id,
@@ -5344,19 +5909,19 @@ async function flushTier3(agentId, options) {
   const maxAge = options?.maxAgeHours ?? 72;
   const cutoff = new Date(Date.now() - maxAge * 36e5).toISOString();
   if (options?.dryRun) {
-    const result2 = await client.execute({
+    const result3 = await client.execute({
       sql: `SELECT COUNT(*) as cnt FROM memories
             WHERE agent_id = ? AND tier = 3 AND status = 'active' AND timestamp < ?`,
       args: [agentId, cutoff]
     });
-    return { archived: Number(result2.rows[0]?.cnt ?? 0) };
+    return { archived: Number(result3.rows[0]?.cnt ?? 0) };
   }
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `UPDATE memories SET status = 'archived'
           WHERE agent_id = ? AND tier = 3 AND status = 'active' AND timestamp < ?`,
     args: [agentId, cutoff]
   });
-  return { archived: result.rowsAffected };
+  return { archived: result2.rowsAffected };
 }
 async function disposeStore() {
   if (_flushTimer !== null) {
@@ -5391,11 +5956,11 @@ function reserveVersions(count) {
 async function getMemoryCardinality(agentId) {
   try {
     const client = getClient();
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT COUNT(*) as cnt FROM memories WHERE agent_id = ? AND COALESCE(status, 'active') = 'active'`,
       args: [agentId]
     });
-    return Number(result.rows[0]?.cnt) || 0;
+    return Number(result2.rows[0]?.cnt) || 0;
   } catch {
     return 0;
   }
@@ -5696,7 +6261,7 @@ __export(file_grep_exports, {
   grepProjectFiles: () => grepProjectFiles
 });
 import { execSync as execSync4 } from "child_process";
-import { readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync3, existsSync as existsSync10 } from "fs";
+import { readFileSync as readFileSync6, readdirSync as readdirSync2, statSync as statSync4, existsSync as existsSync10 } from "fs";
 import path11 from "path";
 import crypto2 from "crypto";
 function hasRipgrep() {
@@ -5813,7 +6378,7 @@ function grepWithNodeFs(pattern, projectRoot, patterns) {
   for (const filePath of files.slice(0, MAX_FILES)) {
     const absPath = path11.join(projectRoot, filePath);
     try {
-      const stat = statSync3(absPath);
+      const stat = statSync4(absPath);
       if (stat.size > MAX_FILE_SIZE) continue;
       const content = readFileSync6(absPath, "utf8");
       const lines = content.split("\n");
@@ -5930,9 +6495,9 @@ __export(graph_query_exports, {
 async function getEntityByName(client, name, type) {
   const sql = type ? `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) AND type = ? LIMIT 1` : `SELECT * FROM entities WHERE LOWER(name) = LOWER(?) LIMIT 1`;
   const args = type ? [name, type] : [name];
-  const result = await client.execute({ sql, args });
-  if (result.rows.length === 0) return null;
-  const row = result.rows[0];
+  const result2 = await client.execute({ sql, args });
+  if (result2.rows.length === 0) return null;
+  const row = result2.rows[0];
   return {
     id: String(row.id),
     name: String(row.name),
@@ -5943,11 +6508,11 @@ async function getEntityByName(client, name, type) {
   };
 }
 async function searchEntities(client, query, limit = 10) {
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT * FROM entities WHERE LOWER(name) LIKE ? ORDER BY last_seen DESC LIMIT ?`,
     args: [`%${query.toLowerCase()}%`, limit]
   });
-  return result.rows.map((row) => ({
+  return result2.rows.map((row) => ({
     id: String(row.id),
     name: String(row.name),
     type: String(row.type),
@@ -5987,8 +6552,8 @@ async function getRelationships(client, entityId2, options) {
     args.push(options.type);
   }
   sql += ` ORDER BY r.weight DESC, r.timestamp DESC`;
-  const result = await client.execute({ sql, args });
-  return result.rows.map((row) => ({
+  const result2 = await client.execute({ sql, args });
+  return result2.rows.map((row) => ({
     id: String(row.id),
     sourceEntityId: String(row.source_entity_id),
     targetEntityId: String(row.target_entity_id),
@@ -6003,7 +6568,7 @@ async function getRelationships(client, entityId2, options) {
   }));
 }
 async function traverseChain(client, startEntityId, relationshipType, maxDepth = 3) {
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `WITH RECURSIVE chain(entity_id, depth, rel_type) AS (
             SELECT ?, 0, ''
             UNION ALL
@@ -6018,7 +6583,7 @@ async function traverseChain(client, startEntityId, relationshipType, maxDepth =
           ORDER BY chain.depth ASC`,
     args: [startEntityId, relationshipType, maxDepth]
   });
-  return result.rows.map((row) => ({
+  return result2.rows.map((row) => ({
     entity: {
       id: String(row.id),
       name: String(row.name),
@@ -6032,7 +6597,7 @@ async function traverseChain(client, startEntityId, relationshipType, maxDepth =
   }));
 }
 async function getEntityNeighbors(client, entityId2, maxHops = 2) {
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `WITH RECURSIVE neighborhood(entity_id, depth, rel_type, rel_confidence) AS (
             SELECT ?, 0, '', 1.0
             UNION ALL
@@ -6054,7 +6619,7 @@ async function getEntityNeighbors(client, entityId2, maxHops = 2) {
           LIMIT 50`,
     args: [entityId2, maxHops]
   });
-  return result.rows.map((row) => ({
+  return result2.rows.map((row) => ({
     entity: {
       id: String(row.id),
       name: String(row.name),
@@ -6091,7 +6656,7 @@ async function getEntityTimeline(client, entityId2, since) {
     sinceClause = " AND r.timestamp >= ?";
     args.push(since.toISOString());
   }
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT r.*, s.name as source_name, t.name as target_name
           FROM relationships r
           JOIN entities s ON r.source_entity_id = s.id
@@ -6100,7 +6665,7 @@ async function getEntityTimeline(client, entityId2, since) {
           ORDER BY r.timestamp DESC`,
     args
   });
-  return result.rows.map((row) => ({
+  return result2.rows.map((row) => ({
     relationship: {
       id: String(row.id),
       sourceEntityId: String(row.source_entity_id),
@@ -6134,7 +6699,7 @@ async function getRelationshipFrequency(client, entityId2, options) {
     default:
       bucketExpr = `strftime('%Y-%m-%d', r.timestamp)`;
   }
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT ${bucketExpr} as bucket, COUNT(*) as cnt, r.type as rel_type
           FROM relationships r
           WHERE (r.source_entity_id = ? OR r.target_entity_id = ?)${typeClause}
@@ -6142,7 +6707,7 @@ async function getRelationshipFrequency(client, entityId2, options) {
           ORDER BY bucket DESC`,
     args
   });
-  return result.rows.map((row) => ({
+  return result2.rows.map((row) => ({
     bucket: String(row.bucket),
     count: Number(row.cnt),
     relationshipType: options?.type ? options.type : String(row.rel_type)
@@ -6155,7 +6720,7 @@ async function getConversationPartners(client, contactEntityId, since) {
     sinceClause = " AND r.timestamp >= ?";
     args.push(since.toISOString());
   }
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT
             CASE
               WHEN r.source_entity_id = ? THEN r.target_entity_id
@@ -6170,7 +6735,7 @@ async function getConversationPartners(client, contactEntityId, since) {
     args: [contactEntityId, ...args]
   });
   const partners = [];
-  for (const row of result.rows) {
+  for (const row of result2.rows) {
     const partnerId = String(row.partner_id);
     const entityResult = await client.execute({
       sql: "SELECT * FROM entities WHERE id = ?",
@@ -6195,7 +6760,7 @@ async function getConversationPartners(client, contactEntityId, since) {
 }
 async function getHotEntities(client, since, limit = 10) {
   const sinceISO = since.toISOString();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT entity_id, COUNT(*) as rel_count
           FROM (
             SELECT source_entity_id as entity_id FROM relationships WHERE timestamp >= ?
@@ -6208,7 +6773,7 @@ async function getHotEntities(client, since, limit = 10) {
     args: [sinceISO, sinceISO, limit]
   });
   const hotEntities = [];
-  for (const row of result.rows) {
+  for (const row of result2.rows) {
     const eid = String(row.entity_id);
     const entityResult = await client.execute({
       sql: "SELECT * FROM entities WHERE id = ?",
@@ -6255,7 +6820,7 @@ async function matchEntities(query, client) {
   if (words.length === 0) return [];
   try {
     const matchExpr = words.map((w) => `${w}*`).join(" OR ");
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT e.id, e.name FROM entities e
             JOIN entities_fts fts ON e.rowid = fts.rowid
             WHERE entities_fts MATCH ?
@@ -6263,8 +6828,8 @@ async function matchEntities(query, client) {
             LIMIT ?`,
       args: [matchExpr, MAX_ENTITY_MATCHES]
     });
-    if (result.rows.length > 0) {
-      return result.rows.map((row) => ({
+    if (result2.rows.length > 0) {
+      return result2.rows.map((row) => ({
         entityId: String(row.id),
         name: String(row.name)
       }));
@@ -6274,13 +6839,13 @@ async function matchEntities(query, client) {
   const conditions = words.map(() => `LOWER(name) LIKE ?`);
   const args = words.map((w) => `%${w}%`);
   try {
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT id, name FROM entities
             WHERE ${conditions.join(" OR ")}
             LIMIT ?`,
       args: [...args, MAX_ENTITY_MATCHES]
     });
-    return result.rows.map((row) => ({
+    return result2.rows.map((row) => ({
       entityId: String(row.id),
       name: String(row.name)
     }));
@@ -6293,12 +6858,12 @@ async function getLinkedMemories(entityIds, client) {
   if (entityIds.length === 0) return linked;
   const placeholders = entityIds.map(() => "?").join(",");
   try {
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT entity_id, memory_id FROM entity_memories
             WHERE entity_id IN (${placeholders})`,
       args: entityIds
     });
-    for (const row of result.rows) {
+    for (const row of result2.rows) {
       const entityId2 = String(row.entity_id);
       const memoryId = String(row.memory_id);
       const entry = linked.get(entityId2) ?? {
@@ -6371,13 +6936,13 @@ async function applyHyperedgeBoost(entities, client, boostMap, resultIds) {
   const entityIds = entities.map((e) => e.entityId);
   const placeholders = entityIds.map(() => "?").join(",");
   try {
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT hyperedge_id, entity_id FROM hyperedge_nodes
             WHERE entity_id IN (${placeholders})`,
       args: entityIds
     });
     const hyperedgeEntities = /* @__PURE__ */ new Map();
-    for (const row of result.rows) {
+    for (const row of result2.rows) {
       const hid = String(row.hyperedge_id);
       const eid = String(row.entity_id);
       const set = hyperedgeEntities.get(hid) ?? /* @__PURE__ */ new Set();
@@ -6702,10 +7267,10 @@ async function hybridSearch(queryText, agentId, options) {
     };
     try {
       const fs = await import("fs");
-      const path49 = await import("path");
+      const path50 = await import("path");
       const os21 = await import("os");
-      const logPath = path49.join(os21.homedir(), ".exe-os", "search-quality.jsonl");
-      fs.mkdirSync(path49.dirname(logPath), { recursive: true });
+      const logPath = path50.join(os21.homedir(), ".exe-os", "search-quality.jsonl");
+      fs.mkdirSync(path50.dirname(logPath), { recursive: true });
       fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
     } catch {
     }
@@ -6754,8 +7319,8 @@ async function estimateCardinality(agentId, options) {
   }
   sql = appendMemoryTypeFilter(sql, args, "memory_type", options);
   try {
-    const result = await client.execute({ sql, args });
-    return Number(result.rows[0]?.cnt) || 0;
+    const result2 = await client.execute({ sql, args });
+    return Number(result2.rows[0]?.cnt) || 0;
   } catch {
     return 0;
   }
@@ -6886,8 +7451,8 @@ async function ftsQuery(client, matchExpr, agentId, options, limit) {
   sql = appendMemoryTypeFilter(sql, args, "m.memory_type", options);
   sql += ` ORDER BY rank LIMIT ?`;
   args.push(limit);
-  const result = await client.execute({ sql, args });
-  return result.rows.map((row) => ({
+  const result2 = await client.execute({ sql, args });
+  return result2.rows.map((row) => ({
     id: row.id,
     agent_id: row.agent_id,
     agent_role: row.agent_role,
@@ -7002,8 +7567,8 @@ async function recentRecords(agentId, options, limit, textFilter) {
   }
   sql += ` ORDER BY timestamp DESC LIMIT ?`;
   args.push(limit);
-  const result = await client.execute({ sql, args });
-  const recentResults = result.rows.map((row) => rowToMemoryRecord(row));
+  const result2 = await client.execute({ sql, args });
+  const recentResults = result2.rows.map((row) => rowToMemoryRecord(row));
   if (sessionBoundaryMemories.length > 0) {
     const seenIds = new Set(recentResults.map((r) => r.id));
     for (const bm of sessionBoundaryMemories) {
@@ -7086,9 +7651,9 @@ async function trajectoryBypass(queryText, agentId, options, limit) {
     }
     sql += ` ORDER BY timestamp DESC LIMIT ?`;
     args.push(limit);
-    const result = await client.execute({ sql, args });
-    if (result.rows.length < 3) return null;
-    return result.rows.map((row) => ({
+    const result2 = await client.execute({ sql, args });
+    if (result2.rows.length < 3) return null;
+    return result2.rows.map((row) => ({
       id: row.id,
       agent_id: row.agent_id,
       agent_role: row.agent_role,
@@ -7658,8 +8223,8 @@ async function validateLicense(apiKey, deviceId) {
 }
 function getCacheAgeMs() {
   try {
-    const { statSync: statSync7 } = __require("fs");
-    const s = statSync7(CACHE_PATH);
+    const { statSync: statSync9 } = __require("fs");
+    const s = statSync9(CACHE_PATH);
     return Date.now() - s.mtimeMs;
   } catch {
     return Infinity;
@@ -7914,10 +8479,10 @@ function freeLicense() {
 async function countActiveMemories() {
   if (!isInitialized()) return 0;
   const client = getClient();
-  const result = await client.execute(
+  const result2 = await client.execute(
     "SELECT COUNT(*) as cnt FROM memories WHERE status = 'active' OR status IS NULL"
   );
-  const row = result.rows[0];
+  const row = result2.rows[0];
   return Number(row?.cnt ?? 0);
 }
 async function assertMemoryLimit() {
@@ -7997,8 +8562,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path49, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path49}`;
+async function wikiFetch(config2, path50, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path50}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
@@ -8031,7 +8596,7 @@ async function wikiFetch(config2, path49, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path49}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path50}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -8145,7 +8710,7 @@ __export(consolidation_exports, {
 });
 import { randomUUID as randomUUID4 } from "crypto";
 async function selectUnconsolidated(client, limit = 200) {
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp
           FROM memories
           WHERE consolidated = 0
@@ -8153,7 +8718,7 @@ async function selectUnconsolidated(client, limit = 200) {
           LIMIT ?`,
     args: [limit]
   });
-  return result.rows.map((row) => ({
+  return result2.rows.map((row) => ({
     id: row.id,
     agent_id: row.agent_id,
     project_name: row.project_name,
@@ -8393,10 +8958,10 @@ async function runConsolidation(client, options) {
         if (dedupCount > 0) clustersProcessed++;
         continue;
       }
-      const result = await storeConsolidation(client, cluster, synthesis, options.embedFn);
+      const result2 = await storeConsolidation(client, cluster, synthesis, options.embedFn);
       if (isCoordinator && options.wikiConfig) {
         await pushToWiki(
-          { ...result, projectName: cluster.projectName },
+          { ...result2, projectName: cluster.projectName },
           options.wikiConfig
         ).catch((err) => {
           process.stderr.write(
@@ -8406,7 +8971,7 @@ async function runConsolidation(client, options) {
         });
       }
       if (isCoordinator) {
-        const sourceIds = result.sourceIds;
+        const sourceIds = result2.sourceIds;
         if (sourceIds.length > 0) {
           const placeholders = sourceIds.map(() => "?").join(",");
           await client.execute({
@@ -8476,26 +9041,26 @@ function cosineSimilarity(a, b) {
   return denom === 0 ? 0 : dot / denom;
 }
 async function isUserIdle(client, idleMinutes = 30) {
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT MAX(timestamp) as last_activity
           FROM memories
           WHERE tool_name != 'consolidation'
             AND timestamp >= datetime('now', '-1 day')`,
     args: []
   });
-  const lastActivity = result.rows[0]?.last_activity;
+  const lastActivity = result2.rows[0]?.last_activity;
   if (!lastActivity) return true;
   const lastMs = new Date(lastActivity).getTime();
   const now = Date.now();
   return now - lastMs >= idleMinutes * 60 * 1e3;
 }
 async function countUnconsolidated(client) {
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM memories
           WHERE consolidated = 0`,
     args: []
   });
-  return Number(result.rows[0]?.cnt ?? 0);
+  return Number(result2.rows[0]?.cnt ?? 0);
 }
 var ROLE_PROMPTS, DEFAULT_ROLE_PROMPT, WIKI_FETCH_TIMEOUT_MS;
 var init_consolidation = __esm({
@@ -8634,12 +9199,12 @@ var init_tmux_transport = __esm({
       }
       isPaneInCopyMode(target) {
         try {
-          const result = execFileSync(
+          const result2 = execFileSync(
             "tmux",
             ["display-message", "-p", "-t", target, "#{pane_in_mode}"],
             { ...QUIET, timeout: 3e3 }
           ).trim();
-          return result === "1";
+          return result2 === "1";
         } catch {
           return false;
         }
@@ -8981,11 +9546,11 @@ async function recordSessionKill(input) {
 async function countKillsSince(sinceISO) {
   try {
     const client = getClient();
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT COUNT(*) AS n FROM session_kills WHERE killed_at >= ?`,
       args: [sinceISO]
     });
-    const row = result.rows[0];
+    const row = result2.rows[0];
     return row ? Number(row.n) : 0;
   } catch {
     return 0;
@@ -8994,13 +9559,13 @@ async function countKillsSince(sinceISO) {
 async function sumTokensSavedSince(sinceISO) {
   try {
     const client = getClient();
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT COALESCE(SUM(estimated_tokens_saved), 0) AS total
             FROM session_kills
             WHERE killed_at >= ?`,
       args: [sinceISO]
     });
-    const row = result.rows[0];
+    const row = result2.rows[0];
     return row ? Number(row.total) : 0;
   } catch {
     return 0;
@@ -9092,13 +9657,13 @@ function _resetLastRelaunchCache() {
 async function lastResumeCreatedAtMs(agentId) {
   const client = getClient();
   const cmScope = sessionScopeFilter(null);
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT MAX(created_at) AS last_created_at
           FROM tasks
           WHERE assigned_to = ? AND title LIKE ?${cmScope.sql}`,
     args: [agentId, `${RESUME_TITLE_PREFIX} %`, ...cmScope.args]
   });
-  const raw = result.rows[0]?.last_created_at;
+  const raw = result2.rows[0]?.last_created_at;
   if (raw === null || raw === void 0) return null;
   const parsed = Date.parse(String(raw));
   return Number.isNaN(parsed) ? null : parsed;
@@ -9335,37 +9900,37 @@ async function countPendingReviews(sessionScope) {
   const scope = strictSessionScopeFilter(
     sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
   );
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM tasks
           WHERE status = 'needs_review'${scope.sql}`,
     args: [...scope.args]
   });
-  return Number(result.rows[0]?.cnt) || 0;
+  return Number(result2.rows[0]?.cnt) || 0;
 }
 async function countNewPendingReviewsSince(sinceIso, sessionScope) {
   const client = getClient();
   const scope = strictSessionScopeFilter(
     sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
   );
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM tasks
           WHERE status = 'needs_review' AND updated_at > ?${scope.sql}`,
     args: [sinceIso, ...scope.args]
   });
-  return Number(result.rows[0]?.cnt) || 0;
+  return Number(result2.rows[0]?.cnt) || 0;
 }
 async function listPendingReviews(limit, sessionScope) {
   const client = getClient();
   const scope = strictSessionScopeFilter(
     sessionScope === void 0 ? getCurrentSessionScope() : sessionScope
   );
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT title, assigned_to, project_name, updated_at FROM tasks
           WHERE status = 'needs_review'${scope.sql}
           ORDER BY updated_at ASC LIMIT ?`,
     args: [...scope.args, limit]
   });
-  return result.rows;
+  return result2.rows;
 }
 async function cleanupOrphanedReviews() {
   const client = getClient();
@@ -9450,7 +10015,7 @@ function getReviewChecklist(role, agent, taskSlug) {
     ]
   };
 }
-async function createReviewForCompletedTask(row, result, _baseDir, now) {
+async function createReviewForCompletedTask(row, result2, _baseDir, now) {
   const taskFile = String(row.task_file);
   const employees = await loadEmployees();
   const coordinatorName = getCoordinatorName(employees);
@@ -9495,7 +10060,7 @@ async function createReviewForCompletedTask(row, result, _baseDir, now) {
     "- **Needs work:** re-open with notes"
   ].join("\n");
   const originalTaskId = String(row.id);
-  const updatedResult = (result ?? "No result summary provided") + reviewNotes;
+  const updatedResult = (result2 ?? "No result summary provided") + reviewNotes;
   await client.execute({
     sql: `UPDATE tasks SET result = ?, status = 'needs_review', updated_at = ?
           WHERE id = ?`,
@@ -9517,7 +10082,7 @@ async function createReviewForCompletedTask(row, result, _baseDir, now) {
     taskFile
   });
   const originalPriority = String(row.priority).toLowerCase();
-  const autoApprove = originalPriority === "p2" && result?.toLowerCase().includes("tests pass");
+  const autoApprove = originalPriority === "p2" && result2?.toLowerCase().includes("tests pass");
   if (!autoApprove) {
     try {
       const key = getSessionKey();
@@ -9546,11 +10111,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const parentId = row.parent_task_id ? String(row.parent_task_id) : null;
     if (parentId) {
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE id = ? AND status = 'needs_review'",
         args: [now, parentId]
       });
-      if (result.rowsAffected > 0) {
+      if (result2.rowsAffected > 0) {
         process.stderr.write(
           `[review-cleanup] Cascaded original task to done via parent_task_id: ${parentId}
 `
@@ -9564,11 +10129,11 @@ async function cleanupReviewFile(row, taskFile, _baseDir) {
         const agent = parts[1];
         const slug = parts.slice(2).join("-");
         const legacyTaskFile = `exe/${agent}/${slug}.md`;
-        const result = await client.execute({
+        const result2 = await client.execute({
           sql: "UPDATE tasks SET status = 'done', updated_at = ? WHERE (task_file = ? OR task_file LIKE ?) AND status = 'needs_review'",
           args: [now, legacyTaskFile, `tasks/%/${agent}/${slug}.md`]
         });
-        if (result.rowsAffected > 0) {
+        if (result2.rowsAffected > 0) {
           process.stderr.write(
             `[review-cleanup] Cascaded original task to done: ${agent}/${slug}.md
 `
@@ -10018,8 +10583,8 @@ function notifyParentExe(sessionKey) {
   }
   process.stderr.write(`[intercom] notifyParentExe \u2192 ${target}
 `);
-  const result = sendIntercom(target);
-  if (result === "failed") {
+  const result2 = sendIntercom(target);
+  if (result2 === "failed") {
     const rootExe = resolveExeSession();
     if (rootExe && rootExe !== target) {
       process.stderr.write(`[intercom] notifyParentExe: dispatcher ${target} dead, falling back to root coordinator session ${rootExe}
@@ -10109,19 +10674,19 @@ function ensureEmployee(employeeName, exeSession, projectDir, opts) {
   }
   const sessionName = employeeSessionName(employeeName, exeSession, effectiveInstance);
   if (isEmployeeAlive(sessionName)) {
-    const result2 = sendIntercom(sessionName);
-    if (result2 === "acknowledged" || result2 === "skipped_exe" || result2 === "debounced" || result2 === "queued") {
+    const result3 = sendIntercom(sessionName);
+    if (result3 === "acknowledged" || result3 === "skipped_exe" || result3 === "debounced" || result3 === "queued") {
       return { status: "intercom_sent", sessionName };
     }
-    if (result2 === "delivered") {
+    if (result3 === "delivered") {
       return { status: "intercom_unprocessed", sessionName };
     }
     return { status: "failed", sessionName, error: "intercom delivery failed" };
   }
   const spawnOpts = { ...opts, instance: effectiveInstance };
-  const result = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
-  if (result.error) {
-    return { status: "failed", sessionName, error: result.error };
+  const result2 = spawnEmployee(employeeName, exeSession, projectDir, spawnOpts);
+  if (result2.error) {
+    return { status: "failed", sessionName, error: result2.error };
   }
   return { status: "spawned", sessionName };
 }
@@ -10621,11 +11186,11 @@ async function writeCheckpoint(input) {
     blocked_by_ids: blockedByIds,
     last_checkpoint_at: now
   };
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `UPDATE tasks SET checkpoint = ?, checkpoint_count = checkpoint_count + 1, updated_at = ? WHERE id = ?`,
     args: [JSON.stringify(checkpoint), now, taskId]
   });
-  if (result.rowsAffected === 0) {
+  if (result2.rowsAffected === 0) {
     throw new Error(`Checkpoint write failed: task ${taskId} not found`);
   }
   const countResult = await client.execute({
@@ -10676,22 +11241,22 @@ function checkLaneAffinity(title, context, assigneeName) {
 }
 async function resolveTask(client, identifier, scopeSession) {
   const scope = sessionScopeFilter(scopeSession);
-  let result = await client.execute({
+  let result2 = await client.execute({
     sql: `SELECT * FROM tasks WHERE id = ?${scope.sql}`,
     args: [identifier, ...scope.args]
   });
-  if (result.rows.length === 1) return result.rows[0];
-  result = await client.execute({
+  if (result2.rows.length === 1) return result2.rows[0];
+  result2 = await client.execute({
     sql: `SELECT * FROM tasks WHERE task_file LIKE ?${scope.sql}`,
     args: [`%${identifier}%`, ...scope.args]
   });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const exact = result.rows.filter(
+  if (result2.rows.length === 1) return result2.rows[0];
+  if (result2.rows.length > 1) {
+    const exact = result2.rows.filter(
       (r) => String(r.task_file).endsWith(`/${identifier}.md`)
     );
     if (exact.length === 1) return exact[0];
-    const candidates = exact.length > 1 ? exact : result.rows;
+    const candidates = exact.length > 1 ? exact : result2.rows;
     const active = candidates.filter(
       (r) => !["done", "cancelled"].includes(String(r.status))
     );
@@ -10701,17 +11266,17 @@ async function resolveTask(client, identifier, scopeSession) {
       `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
     );
   }
-  result = await client.execute({
+  result2 = await client.execute({
     sql: `SELECT * FROM tasks WHERE title LIKE ?${scope.sql}`,
     args: [`%${identifier}%`, ...scope.args]
   });
-  if (result.rows.length === 1) return result.rows[0];
-  if (result.rows.length > 1) {
-    const active = result.rows.filter(
+  if (result2.rows.length === 1) return result2.rows[0];
+  if (result2.rows.length > 1) {
+    const active = result2.rows.filter(
       (r) => !["done", "cancelled"].includes(String(r.status))
     );
     if (active.length === 1) return active[0];
-    const matches = (active.length > 1 ? active : result.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
+    const matches = (active.length > 1 ? active : result2.rows).map((r) => `"${String(r.title)}" (${String(r.status)}, ${String(r.id)})`).join(", ");
     throw new Error(
       `Multiple tasks match "${identifier}": ${matches}. Use a UUID to disambiguate.`
     );
@@ -10921,11 +11486,11 @@ async function listTasks(input) {
     args.push(...scope.args);
   }
   const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT * FROM tasks ${where} ORDER BY CASE status WHEN 'blocked' THEN 0 WHEN 'in_progress' THEN 1 WHEN 'open' THEN 2 ELSE 3 END, priority ASC, created_at DESC LIMIT 1000`,
     args
   });
-  return result.rows.map((r) => ({
+  return result2.rows.map((r) => ({
     id: String(r.id),
     title: String(r.title),
     assignedTo: String(r.assigned_to),
@@ -11317,30 +11882,30 @@ async function dispatchTaskToEmployee(input) {
     if (!exeSession) return { dispatched: "session_missing" };
     const sessionName = employeeSessionName(input.assignedTo, exeSession);
     if (transport.isAlive(sessionName)) {
-      const result = sendIntercom(sessionName);
-      const dispatched = result === "acknowledged" || result === "debounced" || result === "queued" ? "verified" : result === "delivered" ? "sent_unverified" : "session_dead";
+      const result2 = sendIntercom(sessionName);
+      const dispatched = result2 === "acknowledged" || result2 === "debounced" || result2 === "queued" ? "verified" : result2 === "delivered" ? "sent_unverified" : "session_dead";
       process.stderr.write(
-        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result})
+        `[dispatch-audit] intercom \u2192 ${sessionName} | task="${input.title}" [${input.priority}] | result=${dispatched} (sendIntercom=${result2})
 `
       );
       return { dispatched, session: sessionName, crossProject };
     } else {
       const projectDir = input.projectDir ?? process.cwd();
-      const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
+      const result2 = ensureEmployee(input.assignedTo, exeSession, projectDir, {
         autoInstance: isMultiInstance(input.assignedTo)
       });
-      if (result.status === "failed") {
+      if (result2.status === "failed") {
         process.stderr.write(
-          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result.error}
+          `[dispatch-audit] SPAWN FAILED \u2192 ${input.assignedTo} | task="${input.title}" [${input.priority}] | error=${result2.error}
 `
         );
         return { dispatched: "session_missing" };
       }
       process.stderr.write(
-        `[dispatch-audit] SPAWNED \u2192 ${result.sessionName} | task="${input.title}" [${input.priority}]
+        `[dispatch-audit] SPAWNED \u2192 ${result2.sessionName} | task="${input.title}" [${input.priority}]
 `
       );
-      return { dispatched: "spawned", session: result.sessionName, crossProject };
+      return { dispatched: "spawned", session: result2.sessionName, crossProject };
     }
   } catch {
     return { dispatched: "session_missing" };
@@ -11398,13 +11963,13 @@ async function storeBehavior(opts) {
 }
 async function listBehaviorsByDomain(agentId, domain) {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT id, agent_id, project_name, domain, priority, content, active, created_at, updated_at, vector
           FROM behaviors
           WHERE agent_id = ? AND domain = ? AND active = 1`,
     args: [agentId, domain]
   });
-  return result.rows.map((r) => ({
+  return result2.rows.map((r) => ({
     id: String(r.id),
     agent_id: String(r.agent_id),
     project_name: r.project_name ? String(r.project_name) : null,
@@ -11419,11 +11984,11 @@ async function listBehaviorsByDomain(agentId, domain) {
 }
 async function deactivateBehavior(id) {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `UPDATE behaviors SET active = 0, updated_at = ? WHERE id = ? AND active = 1`,
     args: [(/* @__PURE__ */ new Date()).toISOString(), id]
   });
-  return (result.rowsAffected ?? 0) > 0;
+  return (result2.rowsAffected ?? 0) > 0;
 }
 var init_behaviors = __esm({
   "src/lib/behaviors.ts"() {
@@ -11448,15 +12013,15 @@ __export(skill_learning_exports, {
 import crypto9 from "crypto";
 async function extractTrajectory(taskId, agentId) {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT tool_name, raw_text
           FROM memories
           WHERE task_id = ? AND agent_id = ?
           ORDER BY timestamp ASC`,
     args: [taskId, agentId]
   });
-  if (result.rows.length === 0) return [];
-  const rawTools = result.rows.map((r) => {
+  if (result2.rows.length === 0) return [];
+  const rawTools = result2.rows.map((r) => {
     const toolName = String(r.tool_name);
     if (toolName === "Bash") {
       const text3 = String(r.raw_text);
@@ -11501,7 +12066,7 @@ async function storeTrajectory(opts) {
 async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
   const client = getClient();
   const hash = hashSignature(signature);
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
           FROM trajectories
           WHERE signature_hash = ?
@@ -11521,7 +12086,7 @@ async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRE
     skillId: r.skill_id ? String(r.skill_id) : null,
     createdAt: String(r.created_at)
   });
-  const matches = result.rows.map(mapRow);
+  const matches = result2.rows.map(mapRow);
   if (matches.length >= threshold) return matches;
   const nearResult = await client.execute({
     sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
@@ -11651,7 +12216,7 @@ async function sweepTrajectories(threshold, model) {
   if (!config2.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
   const t = threshold ?? config2.skillThreshold;
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT signature_hash, COUNT(*) as cnt
           FROM trajectories
           WHERE skill_id IS NULL
@@ -11663,7 +12228,7 @@ async function sweepTrajectories(threshold, model) {
   });
   let clustersProcessed = 0;
   let skillsExtracted = 0;
-  for (const row of result.rows) {
+  for (const row of result2.rows) {
     const hash = String(row.signature_hash);
     const trajResult = await client.execute({
       sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at
@@ -11746,18 +12311,18 @@ __export(tasks_exports, {
 import path25 from "path";
 import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync9, unlinkSync as unlinkSync7 } from "fs";
 async function createTask(input) {
-  const result = await createTaskCore(input);
-  if (!input.skipDispatch && result.status !== "blocked" && !process.env.VITEST) {
+  const result2 = await createTaskCore(input);
+  if (!input.skipDispatch && result2.status !== "blocked" && !process.env.VITEST) {
     dispatchTaskToEmployee({
       assignedTo: input.assignedTo,
       title: input.title,
       priority: input.priority,
-      taskFile: result.taskFile,
-      initialStatus: result.status,
+      taskFile: result2.taskFile,
+      initialStatus: result2.status,
       projectName: input.projectName
     });
   }
-  return result;
+  return result2;
 }
 async function updateTask(input) {
   const { row, taskFile, now, taskId } = await updateTaskStatus(input);
@@ -11937,7 +12502,7 @@ __export(identity_exports, {
 import { existsSync as existsSync20, mkdirSync as mkdirSync10, readFileSync as readFileSync15, writeFileSync as writeFileSync12 } from "fs";
 import { readdirSync as readdirSync7 } from "fs";
 import path26 from "path";
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function ensureDir2() {
   if (!existsSync20(IDENTITY_DIR2)) {
     mkdirSync10(IDENTITY_DIR2, { recursive: true });
@@ -11984,7 +12549,7 @@ function parseFrontmatter(raw) {
   };
 }
 function contentHash(content) {
-  return createHash3("sha256").update(content).digest("hex").slice(0, 16);
+  return createHash4("sha256").update(content).digest("hex").slice(0, 16);
 }
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
@@ -12664,20 +13229,20 @@ async function sendMessage(input) {
   } catch {
   }
   const sentScope = strictSessionScopeFilter(sessionScope);
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT * FROM messages WHERE id = ?${sentScope.sql}`,
     args: [id, ...sentScope.args]
   });
-  return rowToMessage(result.rows[0]);
+  return rowToMessage(result2.rows[0]);
 }
 async function deliverCrossMachineMessage(messageId, targetDevice) {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: "SELECT * FROM messages WHERE id = ?",
     args: [messageId]
   });
-  if (result.rows.length === 0) return false;
-  const msg = rowToMessage(result.rows[0]);
+  if (result2.rows.length === 0) return false;
+  const msg = rowToMessage(result2.rows[0]);
   if (msg.status !== "pending") return false;
   if (!_wsClientSend) {
     return false;
@@ -12704,12 +13269,12 @@ async function deliverCrossMachineMessage(messageId, targetDevice) {
 }
 async function deliverLocalMessage(messageId) {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: "SELECT * FROM messages WHERE id = ?",
     args: [messageId]
   });
-  if (result.rows.length === 0) return false;
-  const msg = rowToMessage(result.rows[0]);
+  if (result2.rows.length === 0) return false;
+  const msg = rowToMessage(result2.rows[0]);
   if (msg.status !== "pending") return false;
   const targetAgent = msg.targetAgent;
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -13036,7 +13601,7 @@ __export(db_backup_exports, {
   listBackups: () => listBackups,
   rotateBackups: () => rotateBackups
 });
-import { copyFileSync, existsSync as existsSync27, mkdirSync as mkdirSync13, readdirSync as readdirSync10, unlinkSync as unlinkSync9, statSync as statSync4 } from "fs";
+import { copyFileSync, existsSync as existsSync27, mkdirSync as mkdirSync13, readdirSync as readdirSync10, unlinkSync as unlinkSync9, statSync as statSync5 } from "fs";
 import path32 from "path";
 function findActiveDb() {
   for (const name of DB_NAMES) {
@@ -13080,7 +13645,7 @@ function rotateBackups(keepDays = DEFAULT_KEEP_DAYS) {
       if (!file.endsWith(".db") && !file.endsWith(".db-wal") && !file.endsWith(".db-shm")) continue;
       const filePath = path32.join(BACKUP_DIR, file);
       try {
-        const stat = statSync4(filePath);
+        const stat = statSync5(filePath);
         if (stat.mtimeMs < cutoff) {
           unlinkSync9(filePath);
           deleted++;
@@ -13098,7 +13663,7 @@ function listBackups() {
     const files = readdirSync10(BACKUP_DIR).filter((f) => f.endsWith(".db") && !f.endsWith("-wal") && !f.endsWith("-shm"));
     return files.map((name) => {
       const p = path32.join(BACKUP_DIR, name);
-      const stat = statSync4(p);
+      const stat = statSync5(p);
       return { path: p, name, size: stat.size, date: stat.mtime };
     }).sort((a, b) => b.date.getTime() - a.date.getTime());
   } catch {
@@ -13317,10 +13882,10 @@ function isCrdtSyncEnabled() {
 async function rebuildFromDb() {
   const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
   const client = getClient2();
-  const result = await client.execute(
+  const result2 = await client.execute(
     "SELECT id, agent_id, agent_role, session_id, timestamp, tool_name, project_name, has_error, raw_text, version, author_device_id, scope FROM memories"
   );
-  const memories = result.rows.map((row) => ({
+  const memories = result2.rows.map((row) => ({
     id: String(row.id),
     agent_id: row.agent_id,
     agent_role: row.agent_role,
@@ -13361,8 +13926,8 @@ init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync37, openSync as openSync3, mkdirSync as mkdirSync20, closeSync as closeSync3, readFileSync as readFileSync30 } from "fs";
-import path48 from "path";
+import { existsSync as existsSync38, openSync as openSync3, mkdirSync as mkdirSync21, closeSync as closeSync3, readFileSync as readFileSync31 } from "fs";
+import path49 from "path";
 import os20 from "os";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
@@ -13915,7 +14480,7 @@ async function searchConversations(query, limit) {
   try {
     const { getClient: getClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
     const client = getClient2();
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT c.id, c.platform, c.sender_id, c.sender_name,
                    c.content_text, c.agent_response, c.agent_name, c.timestamp
             FROM conversations c
@@ -13924,9 +14489,9 @@ async function searchConversations(query, limit) {
             LIMIT ?`,
       args: [query, limit]
     });
-    return result.rows.map((row, i) => ({
+    return result2.rows.map((row, i) => ({
       source: "conversations",
-      score: 1 - i / Math.max(result.rows.length, 1),
+      score: 1 - i / Math.max(result2.rows.length, 1),
       timestamp: row.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
       snippet: truncate(
         (row.content_text ?? "") + (row.agent_response ? ` \u2192 ${row.agent_response}` : ""),
@@ -14138,7 +14703,7 @@ function registerGetSessionContext(server2) {
     },
     async ({ session_id, target_timestamp, window_size, max_chars, body_chars }) => {
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: `SELECT id, agent_id, agent_role, session_id, timestamp,
                      tool_name, project_name,
                      has_error, raw_text, vector, task_id
@@ -14148,7 +14713,7 @@ function registerGetSessionContext(server2) {
               LIMIT 500`,
         args: [session_id]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         return {
           content: [
             {
@@ -14158,7 +14723,7 @@ function registerGetSessionContext(server2) {
           ]
         };
       }
-      const sorted = result.rows.map((row) => ({
+      const sorted = result2.rows.map((row) => ({
         id: row.id,
         agent_id: row.agent_id,
         agent_role: row.agent_role,
@@ -14225,7 +14790,7 @@ function registerGetMemoryById(server2) {
       const canReadOtherAgent = agentRole === "COO" || agentRole === "CTO";
       const ownerAgent = requestedAgent && canReadOtherAgent ? requestedAgent : agentId;
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: `SELECT id, agent_id, agent_role, session_id, timestamp,
                      tool_name, project_name, has_error, raw_text, task_id,
                      importance, status, memory_type, source_path, source_type
@@ -14234,14 +14799,14 @@ function registerGetMemoryById(server2) {
               LIMIT 1`,
         args: [id, ownerAgent]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         const extra = requestedAgent && !canReadOtherAgent ? " Non-COO/CTO agents may only fetch their own memories." : "";
         return {
           content: [{ type: "text", text: `No memory found for id '${id}'.${extra}` }],
           isError: true
         };
       }
-      const row = result.rows[0];
+      const row = result2.rows[0];
       const lines = [
         `id: ${asString(row.id)}`,
         `agent_id: ${asString(row.agent_id)}`,
@@ -14301,12 +14866,12 @@ function registerConsolidateMemories(server2) {
           embedFn = embed2;
         } catch {
         }
-        const result = await runConsolidation2(client, {
+        const result2 = await runConsolidation2(client, {
           model: consolidationModel,
           maxCalls: max_clusters,
           embedFn
         });
-        if (result.clustersProcessed === 0) {
+        if (result2.clustersProcessed === 0) {
           return {
             content: [{
               type: "text",
@@ -14318,8 +14883,8 @@ function registerConsolidateMemories(server2) {
           content: [{
             type: "text",
             text: `Consolidation complete:
-- Clusters processed: ${result.clustersProcessed}
-- Memories consolidated: ${result.memoriesConsolidated}
+- Clusters processed: ${result2.clustersProcessed}
+- Memories consolidated: ${result2.memoriesConsolidated}
 
 Consolidated summaries stored as tier-1 (importance=9) memories.`
           }]
@@ -14748,10 +15313,10 @@ function registerCreateTask(server2) {
         skipDispatch: true
       });
       try {
-        const { existsSync: existsSync38, mkdirSync: mkdirSync21, writeFileSync: writeFileSync22 } = await import("fs");
+        const { existsSync: existsSync39, mkdirSync: mkdirSync22, writeFileSync: writeFileSync23 } = await import("fs");
         const { identityPath: identityPath2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
         const idPath = identityPath2(assigned_to);
-        if (!existsSync38(idPath)) {
+        if (!existsSync39(idPath)) {
           const { loadEmployees: loadEmployees2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
           const employees = await loadEmployees2();
           const emp = employees.find((e) => e.name === assigned_to);
@@ -14760,8 +15325,8 @@ function registerCreateTask(server2) {
             const template = getTemplateForTitle2(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync38(dir)) mkdirSync21(dir, { recursive: true });
-              writeFileSync22(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+              if (!existsSync39(dir)) mkdirSync22(dir, { recursive: true });
+              writeFileSync23(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
         }
@@ -14776,22 +15341,22 @@ function registerCreateTask(server2) {
             const useAutoInstance = isMultiInstance2(assigned_to);
             const { loadConfigSync: loadConfigSync2 } = await Promise.resolve().then(() => (init_config(), config_exports));
             const cfg = loadConfigSync2();
-            const result = ensureEmployee(assigned_to, exeSession, process.cwd(), {
+            const result2 = ensureEmployee(assigned_to, exeSession, process.cwd(), {
               autoInstance: useAutoInstance,
               maxAutoInstances: useAutoInstance ? cfg.sessionLifecycle.maxAutoInstances : void 0
             });
-            switch (result.status) {
+            switch (result2.status) {
               case "intercom_sent":
                 dispatchStatus = `
-Dispatched: intercom sent to ${result.sessionName}`;
+Dispatched: intercom sent to ${result2.sessionName}`;
                 break;
               case "spawned":
                 dispatchStatus = `
-Dispatched: spawned ${result.sessionName}`;
+Dispatched: spawned ${result2.sessionName}`;
                 break;
               case "failed":
                 dispatchStatus = `
-Dispatch failed: ${result.error ?? "unknown"}`;
+Dispatch failed: ${result2.error ?? "unknown"}`;
                 break;
             }
           }
@@ -14909,7 +15474,7 @@ async function diagnoseMissingTask(client, identifier) {
   args.push(`%${identifier}%`);
   clauses.push("title LIKE ?");
   args.push(`%${identifier}%`);
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT id, title, status, assigned_to, project_name, session_scope, task_file
             FROM tasks
            WHERE ${clauses.map((c) => `(${c})`).join(" OR ")}
@@ -14917,10 +15482,10 @@ async function diagnoseMissingTask(client, identifier) {
            LIMIT 10`,
     args
   });
-  if (result.rows.length === 0) return null;
+  if (result2.rows.length === 0) return null;
   const scoped = sessionScopeFilter();
   const scopeNote = scoped.args.length > 0 ? `Current session scope appears to be ${String(scoped.args[0])}. get_task is session-scoped by default.` : "No current session scope detected.";
-  const matches = result.rows.map((r) => {
+  const matches = result2.rows.map((r) => {
     const id = String(r.id);
     return `- ${id.slice(0, 8)} ${String(r.title)} [${String(r.status)}] assigned_to=${String(r.assigned_to)} project=${String(r.project_name)} session_scope=${String(r.session_scope ?? "NULL")}`;
   }).join("\n");
@@ -15062,7 +15627,7 @@ function registerUpdateTask(server2) {
         result: z15.string().optional().describe("Result summary (include when status=done)")
       }
     },
-    async ({ task_id, status: rawStatus, result }) => {
+    async ({ task_id, status: rawStatus, result: result2 }) => {
       let status = rawStatus;
       if (status === "done") {
         try {
@@ -15129,7 +15694,7 @@ function registerUpdateTask(server2) {
         task = await updateTask({
           taskId: task_id,
           status,
-          result,
+          result: result2,
           baseDir: process.cwd(),
           callerAgentId
         });
@@ -15205,7 +15770,7 @@ function registerCloseTask(server2) {
         status: z16.enum(["closed", "done", "blocked", "cancelled"]).optional().default("closed").describe("Completion status (default: closed \u2014 terminal archive state)")
       }
     },
-    async ({ task_id, result, status }) => {
+    async ({ task_id, result: result2, status }) => {
       const agent = getActiveAgent();
       const canClose = canCoordinate(agent.agentId, agent.agentRole) || CLOSE_TASK_ALLOWED_ROLES.has(agent.agentRole ?? "");
       if (agent.agentId && !canClose) {
@@ -15243,7 +15808,7 @@ function registerCloseTask(server2) {
       const task = await updateTask({
         taskId: task_id,
         status,
-        result,
+        result: result2,
         baseDir,
         skipReviewCreation: true
       });
@@ -15613,7 +16178,7 @@ function registerAcknowledgeMessages(server2) {
       const agentId = agent.agentId || "default";
       const client = getClient();
       const scope = strictSessionScopeFilter();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: `UPDATE messages SET status = 'acknowledged', processed_at = datetime('now')
               WHERE target_agent = ? AND status IN ('pending', 'delivered')${scope.sql}`,
         args: [agentId, ...scope.args]
@@ -15622,7 +16187,7 @@ function registerAcknowledgeMessages(server2) {
         content: [
           {
             type: "text",
-            text: `Acknowledged ${result.rowsAffected} message(s) for ${agentId}.`
+            text: `Acknowledged ${result2.rowsAffected} message(s) for ${agentId}.`
           }
         ]
       };
@@ -15689,8 +16254,8 @@ async function createReminder(text3, dueDate) {
 async function listReminders(includeCompleted = false) {
   const client = getClient();
   const sql = includeCompleted ? `SELECT id, text, created_at, due_date, completed_at FROM reminders ORDER BY due_date ASC NULLS LAST LIMIT 500` : `SELECT id, text, created_at, due_date, completed_at FROM reminders WHERE completed_at IS NULL ORDER BY due_date ASC NULLS LAST LIMIT 500`;
-  const result = await client.execute(sql);
-  return result.rows.map((row) => ({
+  const result2 = await client.execute(sql);
+  return result2.rows.map((row) => ({
     id: String(row.id),
     text: String(row.text),
     createdAt: String(row.created_at),
@@ -15701,18 +16266,18 @@ async function listReminders(includeCompleted = false) {
 async function completeReminder(idOrText) {
   const client = getClient();
   const now = (/* @__PURE__ */ new Date()).toISOString();
-  let result = await client.execute({
+  let result2 = await client.execute({
     sql: `SELECT id, text FROM reminders WHERE id = ? AND completed_at IS NULL`,
     args: [idOrText]
   });
-  if (result.rows.length === 0) {
-    result = await client.execute({
+  if (result2.rows.length === 0) {
+    result2 = await client.execute({
       sql: `SELECT id, text FROM reminders WHERE completed_at IS NULL AND text LIKE '%' || ? || '%' LIMIT 1`,
       args: [idOrText]
     });
   }
-  if (result.rows.length === 0) return null;
-  const row = result.rows[0];
+  if (result2.rows.length === 0) return null;
+  const row = result2.rows[0];
   const id = String(row.id);
   await client.execute({
     sql: `UPDATE reminders SET completed_at = ? WHERE id = ?`,
@@ -15854,7 +16419,7 @@ function registerListBehaviors(server2) {
         args.push(proj);
       }
       const where = conditions.join(" AND ");
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: `SELECT id, agent_id, project_name, domain, content, active, created_at, updated_at
               FROM behaviors
               WHERE ${where}
@@ -15862,7 +16427,7 @@ function registerListBehaviors(server2) {
               LIMIT 50`,
         args
       });
-      const behaviors = result.rows.map((r) => rowToBehavior(r));
+      const behaviors = result2.rows.map((r) => rowToBehavior(r));
       if (behaviors.length === 0) {
         return {
           content: [{ type: "text", text: "No behaviors found." }]
@@ -16059,11 +16624,11 @@ function registerDeactivateBehavior(server2) {
         };
       }
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: `SELECT id, agent_id, content, domain, priority FROM behaviors WHERE id = ?`,
         args: [behavior_id]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         return {
           content: [{
             type: "text",
@@ -16072,7 +16637,7 @@ function registerDeactivateBehavior(server2) {
           isError: true
         };
       }
-      const row = result.rows[0];
+      const row = result2.rows[0];
       const wasActive = await deactivateBehavior(behavior_id);
       if (!wasActive) {
         return {
@@ -16186,7 +16751,7 @@ async function embedTexts(texts) {
     );
     results.push(
       ...settled.map(
-        (result) => result.status === "fulfilled" ? result.value : null
+        (result2) => result2.status === "fulfilled" ? result2.value : null
       )
     );
   }
@@ -16304,7 +16869,7 @@ var MIN_IMPORTANCE = 1;
 var MAX_IMPORTANCE = 10;
 async function listDocumentsByWorkspace(workspace_id, limit = DEFAULT_LIST_LIMIT, offset = 0) {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT d.*, COUNT(m.id) AS chunk_count
           FROM documents d
           LEFT JOIN memories m ON m.document_id = d.id
@@ -16314,7 +16879,7 @@ async function listDocumentsByWorkspace(workspace_id, limit = DEFAULT_LIST_LIMIT
           LIMIT ? OFFSET ?`,
     args: [workspace_id, limit, offset]
   });
-  return result.rows.map((row) => {
+  return result2.rows.map((row) => {
     const r = row;
     return {
       ...rowToDocument(r),
@@ -16346,11 +16911,11 @@ async function updateChunksImportance(document_id, importance) {
     );
   }
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: "UPDATE memories SET importance = ? WHERE document_id = ?",
     args: [importance, document_id]
   });
-  return Number(result.rowsAffected) || 0;
+  return Number(result2.rowsAffected) || 0;
 }
 
 // src/mcp/tools/ingest-document.ts
@@ -16381,11 +16946,11 @@ function registerIngestDocument(server2) {
         const { assertMemoryLimit: assertMemoryLimit2 } = await Promise.resolve().then(() => (init_plan_limits(), plan_limits_exports));
         await assertFeature2("wiki");
         await assertMemoryLimit2();
-        const result = await ingestDocument(input);
+        const result2 = await ingestDocument(input);
         return {
           content: [{
             type: "text",
-            text: JSON.stringify(result)
+            text: JSON.stringify(result2)
           }]
         };
       } catch (err) {
@@ -17046,7 +17611,7 @@ function registerQueryConversations(server2) {
         const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
         const limit = params.limit ?? 25;
         args.push(limit);
-        const result = await client.execute({
+        const result2 = await client.execute({
           sql: `SELECT c.id, c.platform, c.sender_id, c.sender_name, c.sender_phone,
                        c.sender_email, c.channel_id, c.thread_id, c.content_text,
                        c.agent_response, c.agent_name, c.timestamp
@@ -17056,7 +17621,7 @@ function registerQueryConversations(server2) {
                 LIMIT ?`,
           args
         });
-        const conversations = result.rows.map((row) => ({
+        const conversations = result2.rows.map((row) => ({
           id: row.id,
           platform: row.platform,
           sender: {
@@ -17668,8 +18233,8 @@ async function generateGraphReport(client, projectName) {
   }).slice(0, 10);
   let hyperedgeCount = 0;
   try {
-    const result = await client.execute("SELECT COUNT(*) as cnt FROM hyperedges");
-    hyperedgeCount = Number(result.rows[0]?.cnt ?? 0);
+    const result2 = await client.execute("SELECT COUNT(*) as cnt FROM hyperedges");
+    hyperedgeCount = Number(result2.rows[0]?.cnt ?? 0);
   } catch {
   }
   const nodeLabels = new Map(nodes.map((n) => [n.id, n.label]));
@@ -17723,12 +18288,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path49 = await import("path");
+        const path50 = await import("path");
         const os21 = await import("os");
-        const outDir = path49.join(os21.homedir(), ".exe-os", "exports");
+        const outDir = path50.join(os21.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path49.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path50.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -17766,6 +18331,198 @@ import crypto13 from "crypto";
 
 // src/lib/code-chunker.ts
 import ts from "typescript";
+function chunkSourceFile(source, fileName = "file.ts") {
+  const sourceFile = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    // setParentNodes
+    fileName.endsWith(".tsx") || fileName.endsWith(".jsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const chunks = [];
+  const lines = source.split("\n");
+  const importLines = [];
+  function getLineNumber(pos) {
+    return sourceFile.getLineAndCharacterOfPosition(pos).line + 1;
+  }
+  function getLeadingComment(node) {
+    const fullText = sourceFile.getFullText();
+    const ranges = ts.getLeadingCommentRanges(fullText, node.getFullStart());
+    if (!ranges || ranges.length === 0) return void 0;
+    return ranges.map((r) => fullText.slice(r.pos, r.end)).join("\n");
+  }
+  function getNodeText(node) {
+    return node.getText(sourceFile);
+  }
+  function getName(node) {
+    if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node)) {
+      return node.name?.getText(sourceFile) ?? "(anonymous)";
+    }
+    if (ts.isClassDeclaration(node)) {
+      return node.name?.getText(sourceFile) ?? "(anonymous class)";
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      return node.name.getText(sourceFile);
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      return node.name.getText(sourceFile);
+    }
+    if (ts.isEnumDeclaration(node)) {
+      return node.name.getText(sourceFile);
+    }
+    if (ts.isVariableStatement(node)) {
+      const decls = node.declarationList.declarations;
+      return decls.map((d) => d.name.getText(sourceFile)).join(", ");
+    }
+    if (ts.isExportAssignment(node)) {
+      return "default export";
+    }
+    return "(unknown)";
+  }
+  function visitTopLevel(node) {
+    if (ts.isImportDeclaration(node)) {
+      importLines.push({
+        start: getLineNumber(node.getStart(sourceFile)),
+        end: getLineNumber(node.getEnd())
+      });
+      return;
+    }
+    if (ts.isFunctionDeclaration(node)) {
+      chunks.push({
+        kind: "function",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isClassDeclaration(node)) {
+      chunks.push({
+        kind: "class",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isInterfaceDeclaration(node)) {
+      chunks.push({
+        kind: "type",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isTypeAliasDeclaration(node)) {
+      chunks.push({
+        kind: "type",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isEnumDeclaration(node)) {
+      chunks.push({
+        kind: "type",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isVariableStatement(node)) {
+      const decls = node.declarationList.declarations;
+      const isFnLike = decls.some(
+        (d) => d.initializer && (ts.isArrowFunction(d.initializer) || ts.isFunctionExpression(d.initializer))
+      );
+      chunks.push({
+        kind: isFnLike ? "function" : "variable",
+        name: getName(node),
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isExportAssignment(node)) {
+      chunks.push({
+        kind: "export",
+        name: "default export",
+        text: getNodeText(node),
+        startLine: getLineNumber(node.getStart(sourceFile)),
+        endLine: getLineNumber(node.getEnd()),
+        comment: getLeadingComment(node)
+      });
+      return;
+    }
+    if (ts.isExpressionStatement(node)) {
+      const text3 = getNodeText(node);
+      if (text3.length > 10) {
+        chunks.push({
+          kind: "other",
+          name: text3.slice(0, 40).replace(/\n/g, " "),
+          text: text3,
+          startLine: getLineNumber(node.getStart(sourceFile)),
+          endLine: getLineNumber(node.getEnd())
+        });
+      }
+      return;
+    }
+  }
+  sourceFile.statements.forEach(visitTopLevel);
+  if (importLines.length > 0) {
+    const startLine = importLines[0].start;
+    const endLine = importLines[importLines.length - 1].end;
+    const importText = lines.slice(startLine - 1, endLine).join("\n");
+    chunks.unshift({
+      kind: "import",
+      name: `${importLines.length} imports`,
+      text: importText,
+      startLine,
+      endLine
+    });
+  }
+  chunks.sort((a, b) => a.startLine - b.startLine);
+  return chunks;
+}
+function summarizeChunk(chunk, filePath) {
+  const location = `${filePath}:${chunk.startLine}-${chunk.endLine}`;
+  const comment = chunk.comment ? chunk.comment.replace(/\/\*\*|\*\/|\*\s?/g, "").trim().split("\n")[0] : "";
+  switch (chunk.kind) {
+    case "function":
+      return `Function ${chunk.name} in ${location}${comment ? ` \u2014 ${comment}` : ""}`;
+    case "class":
+      return `Class ${chunk.name} in ${location}${comment ? ` \u2014 ${comment}` : ""}`;
+    case "type":
+      return `Type ${chunk.name} in ${location}`;
+    case "import":
+      return `Imports (${chunk.name}) in ${filePath}`;
+    case "variable":
+      return `Variable ${chunk.name} in ${location}`;
+    case "export":
+      return `Default export in ${location}`;
+    default:
+      return `${chunk.kind} in ${location}`;
+  }
+}
+function isChunkable(filePath) {
+  const ext = filePath.split(".").pop()?.toLowerCase();
+  return ext === "ts" || ext === "tsx" || ext === "js" || ext === "jsx";
+}
 
 // src/lib/graph-rag.ts
 function normalizeEntityName(name) {
@@ -17869,14 +18626,14 @@ function registerMergeEntities(server2) {
         };
       }
       try {
-        const result = await mergeEntities(client, sourceId, targetId);
+        const result2 = await mergeEntities(client, sourceId, targetId);
         return {
           content: [
             {
               type: "text",
               text: `Merged "${source_name}" \u2192 "${target_name}":
-- ${result.relationshipsMoved} relationships moved
-- ${result.memoriesMoved} memory links moved
+- ${result2.relationshipsMoved} relationships moved
+- ${result2.memoriesMoved} memory links moved
 - "${source_name}" registered as alias for "${target_name}"`
             }
           ]
@@ -18159,10 +18916,10 @@ function registerSetAgentConfig(server2) {
           isError: true
         };
       }
-      const result = setAgentRuntime(agent_id, runtime, model, reasoning_effort);
-      if (!result.ok) {
+      const result2 = setAgentRuntime(agent_id, runtime, model, reasoning_effort);
+      if (!result2.ok) {
         return {
-          content: [{ type: "text", text: result.error }],
+          content: [{ type: "text", text: result2.error }],
           isError: true
         };
       }
@@ -18339,7 +19096,7 @@ async function getAgentSpend(period = "7d") {
       }
     }
   }
-  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+  const result2 = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
     agentId,
     inputTokens: t.input,
     outputTokens: t.output,
@@ -18349,8 +19106,8 @@ async function getAgentSpend(period = "7d") {
     sessions: t.sessions.size,
     period
   })).sort((a, b) => b.costUSD - a.costUSD);
-  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
-  return result;
+  _spendCache.set(period, { result: result2, expires: Date.now() + CACHE_TTL_MS });
+  return result2;
 }
 async function extractSessionUsage(jsonlPath) {
   let input = 0;
@@ -18914,14 +19671,14 @@ async function fetchMemoriesWithVectors(client, projectFilter, agentFilter2) {
     args.push(agentFilter2);
   }
   const where = " WHERE " + clauses.join(" AND ");
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT id, agent_id, raw_text, timestamp, project_name, vector
           FROM memories${where}
           ORDER BY project_name, timestamp DESC`,
     args
   });
   const byProject = /* @__PURE__ */ new Map();
-  for (const row of result.rows) {
+  for (const row of result2.rows) {
     const project = row.project_name;
     const vec = row.vector == null ? null : Array.isArray(row.vector) ? row.vector : Array.from(row.vector);
     if (!vec || vec.length === 0) continue;
@@ -19338,11 +20095,11 @@ async function auditStats(client, flags) {
 async function auditNullVectors(client, flags) {
   const { clause, args } = agentFilter(flags);
   const where = clause ? clause + " AND vector IS NULL" : " WHERE vector IS NULL";
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT COUNT(*) as cnt FROM memories${where}`,
     args
   });
-  return Number(result.rows[0].cnt);
+  return Number(result2.rows[0].cnt);
 }
 async function auditDuplicates(client, flags) {
   const { clause, args } = agentFilter(flags);
@@ -19391,14 +20148,14 @@ async function auditDuplicates(client, flags) {
 async function auditBloated(client, flags) {
   const { clause, args } = agentFilter(flags);
   const where = clause ? clause + " AND LENGTH(raw_text) > 5120 AND tool_name != 'ConversationBackfill'" : " WHERE LENGTH(raw_text) > 5120 AND tool_name != 'ConversationBackfill'";
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: `SELECT id, agent_id, LENGTH(raw_text) as size, tool_name
           FROM memories${where}
           ORDER BY size DESC
           LIMIT 100`,
     args
   });
-  return result.rows.map((r) => ({
+  return result2.rows.map((r) => ({
     id: r.id,
     agent_id: r.agent_id,
     size: Number(r.size),
@@ -19413,7 +20170,7 @@ async function auditFts(client) {
   return { memoryCount: mc, ftsCount: fc, inSync: mc === fc };
 }
 async function auditOrphanedProjects(client) {
-  const result = await client.execute(
+  const result2 = await client.execute(
     `SELECT project_name, COUNT(*) as cnt
      FROM memories
      WHERE tool_name != 'ConversationBackfill'
@@ -19422,7 +20179,7 @@ async function auditOrphanedProjects(client) {
   );
   const orphans = [];
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-  for (const row of result.rows) {
+  for (const row of result2.rows) {
     const name = row.project_name;
     const count = Number(row.cnt);
     const exists = existsSync28(path33.join(home, name)) || existsSync28(path33.join(home, "..", name)) || existsSync28(path33.join(process.cwd(), "..", name));
@@ -19701,7 +20458,7 @@ function formatReport(report, flags) {
   if (!kh.masterKeyPresent) {
     lines.push("\u{1F534} Recovery key:    master key missing \u2014 import phrase or run setup before syncing");
   } else if (!kh.recoveryBackupMarked) {
-    lines.push("\u{1F534} Recovery backup: not confirmed \u2014 run `exe-os link export --local-terminal-only` and save the 24-word phrase");
+    lines.push("\u{1F534} Recovery backup: not confirmed \u2014 run `exe-os cloud link --show-full` in your local Terminal and save the 24-word phrase");
   } else {
     const suffix = kh.recoveryBackupConfirmedAt ? ` (${kh.recoveryBackupConfirmedAt.slice(0, 10)}${kh.recoveryBackupSource ? ` via ${kh.recoveryBackupSource}` : ""})` : "";
     lines.push(`\u{1F7E2} Recovery backup: confirmed${suffix}`);
@@ -19873,12 +20630,12 @@ async function fixBloated(client, bloated, dryRun) {
   let chunksCreated = 0;
   const CHUNK_SIZE = 2048;
   for (const b of bloated) {
-    const result = await client.execute({
+    const result2 = await client.execute({
       sql: `SELECT * FROM memories WHERE id = ?`,
       args: [b.id]
     });
-    if (result.rows.length === 0) continue;
-    const row = result.rows[0];
+    if (result2.rows.length === 0) continue;
+    const row = result2.rows[0];
     const text3 = row.raw_text;
     const chunks = splitAtSentences(text3, CHUNK_SIZE);
     if (chunks.length <= 1) continue;
@@ -20112,15 +20869,15 @@ function registerRunConsolidation(server2) {
           };
         }
         const config2 = await loadConfig();
-        const result = await runConsolidation(client, {
+        const result2 = await runConsolidation(client, {
           model: config2.consolidationModel || "claude-haiku-4-5-20251001",
           maxCalls: 10
         });
         const lines = [];
         lines.push("## Consolidation Complete\n");
-        lines.push(`- **Clusters processed:** ${result.clustersProcessed}`);
-        lines.push(`- **Memories consolidated:** ${result.memoriesConsolidated}`);
-        lines.push(`- **Remaining unconsolidated:** ${(pending - result.memoriesConsolidated).toLocaleString()}`);
+        lines.push(`- **Clusters processed:** ${result2.clustersProcessed}`);
+        lines.push(`- **Memories consolidated:** ${result2.memoriesConsolidated}`);
+        lines.push(`- **Remaining unconsolidated:** ${(pending - result2.memoriesConsolidated).toLocaleString()}`);
         return {
           content: [{ type: "text", text: lines.join("\n") }]
         };
@@ -20143,7 +20900,7 @@ import { z as z58 } from "zod";
 
 // src/lib/cloud-sync.ts
 init_database();
-import { readFileSync as readFileSync23, writeFileSync as writeFileSync17, existsSync as existsSync30, readdirSync as readdirSync11, mkdirSync as mkdirSync15, appendFileSync as appendFileSync2, unlinkSync as unlinkSync11, openSync as openSync2, closeSync as closeSync2, statSync as statSync5 } from "fs";
+import { readFileSync as readFileSync23, writeFileSync as writeFileSync17, existsSync as existsSync30, readdirSync as readdirSync11, mkdirSync as mkdirSync15, appendFileSync as appendFileSync2, unlinkSync as unlinkSync11, openSync as openSync2, closeSync as closeSync2, statSync as statSync6 } from "fs";
 import crypto15 from "crypto";
 import path35 from "path";
 import { homedir as homedir6 } from "os";
@@ -20265,18 +21022,36 @@ function loadPgClient() {
       const { pathToFileURL: pathToFileURL6 } = await import("url");
       const explicitPath = process.env.EXE_OS_PRISMA_CLIENT_PATH;
       if (explicitPath) {
-        const mod2 = await import(pathToFileURL6(explicitPath).href);
-        const Ctor2 = mod2.PrismaClient ?? mod2.default?.PrismaClient;
-        if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
-        return new Ctor2();
+        const mod = await import(pathToFileURL6(explicitPath).href);
+        const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+        if (!Ctor) throw new Error(`No PrismaClient at ${explicitPath}`);
+        return new Ctor();
       }
       const exeDbRoot = process.env.EXE_DB_ROOT ?? path35.join(homedir6(), "exe-db");
-      const req = createRequire6(path35.join(exeDbRoot, "package.json"));
-      const entry = req.resolve("@prisma/client");
-      const mod = await import(pathToFileURL6(entry).href);
-      const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
-      if (!Ctor) throw new Error("No PrismaClient");
-      return new Ctor();
+      const packagePath = path35.join(exeDbRoot, "package.json");
+      if (existsSync30(packagePath)) {
+        const req = createRequire6(packagePath);
+        const entry = req.resolve("@prisma/client");
+        const mod = await import(pathToFileURL6(entry).href);
+        const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
+        if (!Ctor) throw new Error("No PrismaClient");
+        return new Ctor();
+      }
+      const { Pool } = await import("pg");
+      const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+      return {
+        async $queryRawUnsafe(query, ...values) {
+          const result2 = await pool.query(query, values);
+          return result2.rows;
+        },
+        async $executeRawUnsafe(query, ...values) {
+          const result2 = await pool.query(query, values);
+          return result2.rowCount ?? 0;
+        },
+        async $disconnect() {
+          await pool.end();
+        }
+      };
     })().catch(() => {
       _pgFailed = true;
       _pgPromise = null;
@@ -20297,7 +21072,7 @@ async function pushToPostgres(records) {
   let inserted = 0;
   for (const rec of records) {
     try {
-      await prisma.$executeRawUnsafe(
+      const changed = await prisma.$executeRawUnsafe(
         `INSERT INTO raw.raw_events (id, source, source_id, event_type, payload, metadata, timestamp)
          VALUES (gen_random_uuid(), 'cloud_sync', $1, 'memory', $2::jsonb, $3::jsonb, $4)
          ON CONFLICT (source, source_id, event_type) DO NOTHING`,
@@ -20306,7 +21081,7 @@ async function pushToPostgres(records) {
         JSON.stringify({ agent_id: rec.agent_id, project_name: rec.project_name, tool_name: rec.tool_name }),
         rec.timestamp ? new Date(String(rec.timestamp)) : /* @__PURE__ */ new Date()
       );
-      inserted++;
+      inserted += Number(changed ?? 0);
     } catch {
     }
   }
@@ -20430,32 +21205,62 @@ async function cloudPull(sinceVersion, config2) {
     if (!response.ok) return { records: [], maxVersion: sinceVersion };
     const data = await response.json();
     const allRecords = [];
-    for (const { blob } of data.blobs ?? []) {
+    let maxReadableVersion = sinceVersion;
+    let skippedBlobs = 0;
+    for (const { version, blob } of data.blobs ?? []) {
       try {
         const compressed = decryptSyncBlob(blob);
         const json = decompress(compressed).toString("utf8");
         const records = JSON.parse(json);
         allRecords.push(...records);
+        const recordMax = records.reduce((max, rec) => {
+          const v = Number(rec.version ?? 0);
+          return Number.isFinite(v) ? Math.max(max, v) : max;
+        }, 0);
+        const blobVersion = Number(version ?? 0);
+        maxReadableVersion = Math.max(
+          maxReadableVersion,
+          Number.isFinite(blobVersion) ? blobVersion : 0,
+          recordMax
+        );
       } catch {
+        skippedBlobs++;
         continue;
       }
     }
-    return { records: allRecords, maxVersion: data.max_version ?? sinceVersion };
+    if (skippedBlobs > 0) {
+      logError(`[cloud-sync] PULL skipped ${skippedBlobs} undecryptable blob(s); pull cursor advanced only to last readable version ${maxReadableVersion}`);
+    }
+    return { records: allRecords, maxVersion: maxReadableVersion };
   } catch (err) {
     logError(`[cloud-sync] PULL FAILED: ${err instanceof Error ? err.message : String(err)}`);
     return { records: [], maxVersion: sinceVersion };
   }
 }
-var CLOUD_RELINK_REQUIRED_MESSAGE = "[cloud-sync] Paused after key rotation. Run `exe-os cloud relink --dry-run` for the safe relink checklist.";
-async function getCloudRelinkRequired(client = getClient()) {
+var CLOUD_REUPLOAD_REQUIRED_MESSAGE = "Cloud sync is blocked because this device rotated its memory encryption key. Run `exe-os cloud reupload` first to re-upload the cloud backup with the new key.";
+async function getCloudReuploadRequired(client = getClient()) {
   try {
     await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
-    const relink = await client.execute("SELECT value FROM sync_meta WHERE key = 'cloud_relink_required' LIMIT 1");
-    return String(relink.rows[0]?.value ?? "") === "1";
+    const result2 = await client.execute("SELECT key, value FROM sync_meta WHERE key IN ('cloud_reupload_required', 'cloud_relink_required')");
+    return result2.rows.some((row) => String(row.value ?? "") === "1");
   } catch {
     return false;
   }
 }
+async function clearCloudReuploadRequired(client = getClient()) {
+  await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+  await client.execute("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('cloud_reupload_required', '0')");
+  await client.execute("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('cloud_relink_required', '0')");
+  await client.execute({
+    sql: "INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('cloud_reuploaded_at', ?)",
+    args: [(/* @__PURE__ */ new Date()).toISOString()]
+  });
+  await client.execute("DELETE FROM sync_meta WHERE key IN ('last_cloud_pull_version', 'last_cloud_push_version')");
+}
+async function markCloudReuploadRequired(client = getClient()) {
+  await client.execute("CREATE TABLE IF NOT EXISTS sync_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+  await client.execute("INSERT OR REPLACE INTO sync_meta (key, value) VALUES ('cloud_reupload_required', '1')");
+}
 async function cloudSync(config2) {
   if (!isSyncCryptoInitialized()) {
     try {
@@ -20477,10 +21282,10 @@ async function cloudSync(config2) {
     throw new Error("[cloud-sync] Database not initialized. Call initStore() before cloudSync().");
   }
   try {
-    if (await getCloudRelinkRequired(client)) throw new Error(CLOUD_RELINK_REQUIRED_MESSAGE);
+    if (await getCloudReuploadRequired(client)) throw new Error(CLOUD_REUPLOAD_REQUIRED_MESSAGE);
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
-    if (msg.includes("Paused after key rotation")) throw err;
+    if (msg === CLOUD_REUPLOAD_REQUIRED_MESSAGE || msg.includes("key rotation")) throw err;
   }
   try {
     const { getRawClient: getRawClient2 } = await Promise.resolve().then(() => (init_database(), database_exports));
@@ -20738,7 +21543,7 @@ async function cloudSync(config2) {
     const { getLatestBackup: getLatestBackup2 } = await Promise.resolve().then(() => (init_db_backup(), db_backup_exports));
     const latestBackup = getLatestBackup2();
     if (latestBackup) {
-      const backupSize = statSync5(latestBackup).size;
+      const backupSize = statSync6(latestBackup).size;
       const MAX_CLOUD_BACKUP_BYTES = 50 * 1024 * 1024;
       if (backupSize <= MAX_CLOUD_BACKUP_BYTES) {
         const backupData = readFileSync23(latestBackup);
@@ -21048,8 +21853,8 @@ async function cloudPullBlob(route, config2) {
 }
 async function cloudPushGlobalProcedures(config2) {
   const client = getClient();
-  const result = await client.execute("SELECT * FROM company_procedures LIMIT 1000");
-  const rows = result.rows;
+  const result2 = await client.execute("SELECT * FROM company_procedures LIMIT 1000");
+  const rows = result2.rows;
   const { ok } = await cloudPushBlob(
     "/sync/push-global-procedures",
     rows,
@@ -21093,8 +21898,8 @@ async function cloudPullGlobalProcedures(config2) {
 }
 async function cloudPushBehaviors(config2) {
   const client = getClient();
-  const result = await client.execute("SELECT * FROM behaviors LIMIT 10000");
-  const rows = result.rows;
+  const result2 = await client.execute("SELECT * FROM behaviors LIMIT 10000");
+  const rows = result2.rows;
   const { ok } = await cloudPushBlob(
     "/sync/push-behaviors",
     rows,
@@ -21249,8 +22054,8 @@ async function cloudPullGraphRAG(config2) {
 }
 async function cloudPushTasks(config2) {
   const client = getClient();
-  const result = await client.execute("SELECT * FROM tasks LIMIT 10000");
-  const rows = result.rows;
+  const result2 = await client.execute("SELECT * FROM tasks LIMIT 10000");
+  const rows = result2.rows;
   const { ok } = await cloudPushBlob(
     "/sync/push-tasks",
     rows,
@@ -21295,8 +22100,8 @@ async function cloudPullTasks(config2) {
 }
 async function cloudPushConversations(config2) {
   const client = getClient();
-  const result = await client.execute("SELECT * FROM conversations LIMIT 50000");
-  const rows = result.rows;
+  const result2 = await client.execute("SELECT * FROM conversations LIMIT 50000");
+  const rows = result2.rows;
   const { ok } = await cloudPushBlob(
     "/sync/push-conversations",
     rows,
@@ -21402,31 +22207,138 @@ async function cloudPullDocuments(config2) {
 
 // src/mcp/tools/cloud-sync.ts
 init_config();
+init_keychain();
+init_store();
+init_database();
+function result(text3, isError = false) {
+  return { content: [{ type: "text", text: text3 }], ...isError ? { isError: true } : {} };
+}
+function shortKeyFingerprint(key) {
+  if (!key) return "missing";
+  return `${key.toString("hex").slice(0, 8)}...`;
+}
+async function cloudStatusText() {
+  const config2 = await loadConfig();
+  const key = await getMasterKey();
+  const cloud = config2.cloud;
+  let reuploadRequired = false;
+  let localMemoryVersion = 0;
+  let lastPushedMemoryVersion = 0;
+  let lastPullVersion = 0;
+  let pendingMemoryCount = 0;
+  let lastReuploadedAt = null;
+  try {
+    await initStore({ lightweight: true });
+    const client = getClient();
+    reuploadRequired = await getCloudReuploadRequired(client);
+    const maxVersion = await client.execute("SELECT COALESCE(MAX(version), 0) as version FROM memories WHERE scope IS NULL OR scope != 'personal'");
+    localMemoryVersion = Number(maxVersion.rows[0]?.version ?? 0);
+    const meta = await client.execute("SELECT key, value FROM sync_meta WHERE key IN ('last_cloud_push_version', 'last_cloud_pull_version', 'cloud_reuploaded_at', 'cloud_relinked_at')");
+    for (const row of meta.rows) {
+      const keyName = String(row.key ?? "");
+      const value = String(row.value ?? "");
+      if (keyName === "last_cloud_push_version") lastPushedMemoryVersion = Number(value || 0);
+      if (keyName === "last_cloud_pull_version") lastPullVersion = Number(value || 0);
+      if (keyName === "cloud_reuploaded_at" || keyName === "cloud_relinked_at") lastReuploadedAt = value;
+    }
+    const pending = await client.execute({
+      sql: "SELECT COUNT(*) as cnt FROM memories WHERE (scope IS NULL OR scope != 'personal') AND version > ?",
+      args: [lastPushedMemoryVersion]
+    });
+    pendingMemoryCount = Number(pending.rows[0]?.cnt ?? 0);
+  } catch (err) {
+    pendingMemoryCount = -1;
+  }
+  const lines = [];
+  lines.push("## Exe Cloud Status");
+  lines.push("");
+  lines.push(`- Encryption key: ${key ? `present (${shortKeyFingerprint(key)})` : "missing"}`);
+  if (cloud?.apiKey && cloud?.endpoint) {
+    lines.push(`- Cloud account: connected (${cloud.apiKey.slice(0, 10)}...${cloud.apiKey.slice(-4)})`);
+    lines.push(`- Endpoint: ${cloud.endpoint}`);
+  } else {
+    lines.push("- Cloud account: not configured");
+  }
+  lines.push("- Status check: read-only; no data was uploaded or downloaded");
+  lines.push("");
+  if (!cloud?.apiKey || !cloud?.endpoint) {
+    lines.push("**Sync status:** NOT CONFIGURED");
+    lines.push("Run `exe-os cloud` in Terminal to set up Exe Cloud.");
+  } else if (reuploadRequired) {
+    lines.push("**Sync status:** NOT SYNCING \u2014 blocked for safety");
+    lines.push("**Why:** this device changed its memory encryption key.");
+    lines.push('**Required fix:** run MCP `cloud_sync` with `action="reupload"` and confirmation, or run `exe-os cloud reupload` in Terminal.');
+    lines.push("After re-upload, automatic background sync will resume.");
+  } else if (pendingMemoryCount > 0) {
+    lines.push("**Sync status:** SYNC ENABLED \u2014 waiting for background sync");
+    lines.push(`**Pending upload:** ${pendingMemoryCount.toLocaleString()} local memor${pendingMemoryCount === 1 ? "y" : "ies"}`);
+    lines.push('To sync now, run MCP `cloud_sync` with `action="sync"` or Terminal `exe-os cloud sync`.');
+  } else {
+    lines.push("**Sync status:** SYNC ENABLED \u2014 no obvious memory backlog");
+  }
+  lines.push("");
+  lines.push(`- Memory cursor: local=${localMemoryVersion} last pushed=${lastPushedMemoryVersion} last pulled=${lastPullVersion}`);
+  if (lastReuploadedAt) lines.push(`- Last re-upload: ${lastReuploadedAt}`);
+  lines.push("");
+  lines.push("Terminal-only safety rule: full recovery phrases are never returned by MCP. To reveal the phrase, the user must run `exe-os cloud link --show-full` directly in their local Terminal.");
+  return lines.join("\n");
+}
 function registerCloudSync(server2) {
   server2.registerTool(
     "cloud_sync",
     {
       title: "Cloud Sync",
-      description: "Trigger a cloud sync cycle \u2014 pulls remote changes then pushes local. Reports pushed/pulled counts for memories, behaviors, graph, tasks, and more.",
+      description: "Consolidated Exe Cloud tool. Supports read-only status, normal sync-now, and explicitly confirmed post-key-rotation re-upload. Does not reveal recovery phrases and does not rotate keys.",
       inputSchema: {
-        force: z58.boolean().default(false).describe("Force sync even if recently synced")
+        action: z58.enum(["status", "sync", "reupload"]).default("sync").describe("Cloud operation. status is read-only; sync is normal sync-now; reupload repairs cloud after key rotation."),
+        force: z58.boolean().default(false).describe("Reserved for sync compatibility; normal cloud sync already runs when requested."),
+        confirm_local_db_source_of_truth: z58.string().optional().describe('Required for action=reupload. Must exactly equal "LOCAL DB IS SOURCE OF TRUTH".')
       }
     },
-    async () => {
+    async ({ action = "sync", confirm_local_db_source_of_truth }) => {
       try {
+        if (action === "status") {
+          return result(await cloudStatusText());
+        }
         const config2 = await loadConfig();
         const cloud = config2.cloud;
         if (!cloud?.apiKey || !cloud?.endpoint) {
-          return {
-            content: [
-              {
-                type: "text",
-                text: "Cloud sync not configured. Run `/exe-cloud` to set up Exe Cloud."
-              }
-            ]
-          };
+          return result("Cloud sync not configured. Run `exe-os cloud` in Terminal to set up Exe Cloud.", true);
+        }
+        if (action === "reupload") {
+          await initStore({ lightweight: true });
+          const client = getClient();
+          const required = await getCloudReuploadRequired(client);
+          if (!required) {
+            return result("Cloud re-upload is not currently required. Normal cloud sync is safe to run.");
+          }
+          if (confirm_local_db_source_of_truth !== "LOCAL DB IS SOURCE OF TRUTH") {
+            return result(
+              'Cloud re-upload is blocked until explicitly confirmed. This operation treats the local DB as source of truth and re-uploads cloud data encrypted with the current key. Retry with confirm_local_db_source_of_truth="LOCAL DB IS SOURCE OF TRUTH", or run `exe-os cloud reupload` in Terminal.',
+              true
+            );
+          }
+          await clearCloudReuploadRequired(client);
+          let syncResult2;
+          try {
+            syncResult2 = await cloudSync({ apiKey: cloud.apiKey, endpoint: cloud.endpoint });
+          } catch (err) {
+            await markCloudReuploadRequired(client);
+            throw err;
+          }
+          return result([
+            "## Cloud Re-upload Complete",
+            "",
+            "Normal cloud sync is safe again. Other devices must reconnect using the current 24-word recovery phrase.",
+            "",
+            `- Active memories: ${syncResult2.totalMemories.toLocaleString()} (\u2191 ${syncResult2.pushed.toLocaleString()} syncable rows pushed, \u2193 ${syncResult2.pulled.toLocaleString()} pulled)`,
+            `- Behaviors: \u2191 ${syncResult2.behaviors.pushed.toLocaleString()}, \u2193 ${syncResult2.behaviors.pulled.toLocaleString()}`,
+            `- GraphRAG: \u2191 ${syncResult2.graphrag.pushed.toLocaleString()}, \u2193 ${syncResult2.graphrag.pulled.toLocaleString()}`,
+            `- Tasks: \u2191 ${syncResult2.tasks.pushed.toLocaleString()}, \u2193 ${syncResult2.tasks.pulled.toLocaleString()}`,
+            `- Documents: \u2191 ${syncResult2.documents.pushed.toLocaleString()}, \u2193 ${syncResult2.documents.pulled.toLocaleString()}`
+          ].join("\n"));
         }
-        const result = await cloudSync({
+        const syncResult = await cloudSync({
           apiKey: cloud.apiKey,
           endpoint: cloud.endpoint
         });
@@ -21434,27 +22346,18 @@ function registerCloudSync(server2) {
         lines.push("## Cloud Sync Complete\n");
         lines.push("| Category | Pushed | Pulled |");
         lines.push("|----------|--------|--------|");
-        lines.push(`| Memories | ${result.pushed.toLocaleString()} | ${result.pulled.toLocaleString()} |`);
-        lines.push(`| Behaviors | ${result.behaviors.pushed.toLocaleString()} | ${result.behaviors.pulled.toLocaleString()} |`);
-        lines.push(`| GraphRAG | ${result.graphrag.pushed.toLocaleString()} | ${result.graphrag.pulled.toLocaleString()} |`);
-        lines.push(`| Tasks | ${result.tasks.pushed.toLocaleString()} | ${result.tasks.pulled.toLocaleString()} |`);
-        lines.push(`| Conversations | ${result.conversations.pushed.toLocaleString()} | ${result.conversations.pulled.toLocaleString()} |`);
-        lines.push(`| Documents | ${result.documents.pushed.toLocaleString()} | ${result.documents.pulled.toLocaleString()} |`);
+        lines.push(`| Memories | ${syncResult.pushed.toLocaleString()} | ${syncResult.pulled.toLocaleString()} |`);
+        lines.push(`| Behaviors | ${syncResult.behaviors.pushed.toLocaleString()} | ${syncResult.behaviors.pulled.toLocaleString()} |`);
+        lines.push(`| GraphRAG | ${syncResult.graphrag.pushed.toLocaleString()} | ${syncResult.graphrag.pulled.toLocaleString()} |`);
+        lines.push(`| Tasks | ${syncResult.tasks.pushed.toLocaleString()} | ${syncResult.tasks.pulled.toLocaleString()} |`);
+        lines.push(`| Conversations | ${syncResult.conversations.pushed.toLocaleString()} | ${syncResult.conversations.pulled.toLocaleString()} |`);
+        lines.push(`| Documents | ${syncResult.documents.pushed.toLocaleString()} | ${syncResult.documents.pulled.toLocaleString()} |`);
         lines.push("");
-        lines.push(`**Total memories:** ${result.totalMemories.toLocaleString()}`);
-        lines.push(`**Roster:** ${result.roster.employees} employees, ${result.roster.identities} identities`);
-        return {
-          content: [{ type: "text", text: lines.join("\n") }]
-        };
+        lines.push(`**Active memories:** ${syncResult.totalMemories.toLocaleString()}`);
+        lines.push(`**Roster:** ${syncResult.roster.employees} employees, ${syncResult.roster.identities} identities`);
+        return result(lines.join("\n"));
       } catch (err) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Cloud sync failed: ${err instanceof Error ? err.message : String(err)}`
-            }
-          ]
-        };
+        return result(`Cloud operation failed: ${err instanceof Error ? err.message : String(err)}`, true);
       }
     }
   );
@@ -21967,14 +22870,14 @@ function registerBackupVps(server2) {
               r2AccessKeyId: input.r2AccessKeyId,
               r2SecretAccessKey: input.r2SecretAccessKey
             };
-            const result = await createBackup2(options);
+            const result2 = await createBackup2(options);
             return {
               content: [
                 {
                   type: "text",
-                  text: `Backup complete: ${result.key}
-${result.sizeBytes} bytes
-${result.timestamp}`
+                  text: `Backup complete: ${result2.key}
+${result2.sizeBytes} bytes
+${result2.timestamp}`
                 }
               ]
             };
@@ -22007,18 +22910,18 @@ ${result.timestamp}`
               r2AccessKeyId: input.r2AccessKeyId,
               r2SecretAccessKey: input.r2SecretAccessKey
             };
-            const result = await listBackups2(options);
+            const result2 = await listBackups2(options);
             return {
               content: [
                 {
                   type: "text",
-                  text: formatBackups(result)
+                  text: formatBackups(result2)
                 }
               ]
             };
           }
           case "health": {
-            const result = await backupHealth({
+            const result2 = await backupHealth({
               r2Bucket: input.r2Bucket,
               r2Endpoint: input.r2Endpoint,
               r2AccessKeyId: input.r2AccessKeyId,
@@ -22029,10 +22932,10 @@ ${result.timestamp}`
                 {
                   type: "text",
                   text: [
-                    `last_backup: ${result.lastBackup ?? "none"}`,
-                    `backup_count: ${result.backupCount}`,
-                    `total_size_bytes: ${result.totalSizeBytes}`,
-                    `oldest_backup: ${result.oldestBackup ?? "none"}`
+                    `last_backup: ${result2.lastBackup ?? "none"}`,
+                    `backup_count: ${result2.backupCount}`,
+                    `total_size_bytes: ${result2.totalSizeBytes}`,
+                    `oldest_backup: ${result2.oldestBackup ?? "none"}`
                   ].join("\n")
                 }
               ]
@@ -22140,9 +23043,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path49, body) {
+  async request(method, path50, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path49}`;
+    const url = `${this.baseUrl}${path50}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -22215,8 +23118,8 @@ async function requestCloudflare(cfApiToken, zoneId, options) {
   }
   return envelope.result;
 }
-function buildUrl(zoneId, path49 = "/dns_records", query) {
-  const normalizedPath = path49.startsWith("/") ? path49 : `/${path49}`;
+function buildUrl(zoneId, path50 = "/dns_records", query) {
+  const normalizedPath = path50.startsWith("/") ? path50 : `/${path50}`;
   const url = new URL(
     `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
   );
@@ -22380,7 +23283,7 @@ function registerDeployClient(server2) {
         };
       }
       try {
-        const result = await executeDeployment({
+        const result2 = await executeDeployment({
           client_name,
           domain,
           region,
@@ -22395,7 +23298,7 @@ function registerDeployClient(server2) {
           content: [
             {
               type: "text",
-              text: JSON.stringify(result, null, 2)
+              text: JSON.stringify(result2, null, 2)
             }
           ]
         };
@@ -23507,8 +24410,8 @@ Available: ${available.length > 0 ? available.join(", ") : "none"}`
           ]
         };
       }
-      const result = applyPack(industry, project);
-      if (!result) {
+      const result2 = applyPack(industry, project);
+      if (!result2) {
         return {
           content: [
             {
@@ -23521,22 +24424,22 @@ Available: ${available.length > 0 ? available.join(", ") : "none"}`
       const lines = [
         `Applied "${industry}" starter pack to project "${project}":
 `,
-        `**CRM Custom Objects** (${result.customObjects.count}):`,
-        ...result.customObjects.names.map((n) => `  - ${n}`),
+        `**CRM Custom Objects** (${result2.customObjects.count}):`,
+        ...result2.customObjects.names.map((n) => `  - ${n}`),
         "",
-        `**Triggers Created** (${result.triggers.created}):`,
-        ...result.triggers.ids.map((id, i) => {
+        `**Triggers Created** (${result2.triggers.created}):`,
+        ...result2.triggers.ids.map((id, i) => {
           const t = pack.triggers[i];
           return `  - ${t?.name ?? "Unknown"} (${id})`;
         }),
         "",
-        `**Wiki Seeds** (${result.wikiSeeds.count}):`,
-        ...result.wikiSeeds.titles.map((t) => `  - ${t}`)
+        `**Wiki Seeds** (${result2.wikiSeeds.count}):`,
+        ...result2.wikiSeeds.titles.map((t) => `  - ${t}`)
       ];
-      if (result.pendingVariables.length > 0) {
+      if (result2.pendingVariables.length > 0) {
         lines.push("");
         lines.push("**Requires manual configuration:**");
-        for (const pv of result.pendingVariables) {
+        for (const pv of result2.pendingVariables) {
           const vars = Object.entries(pv.variables).map(([k, v]) => `    - {{${k}}}: ${v}`).join("\n");
           lines.push(`  ${pv.trigger}:
 ${vars}`);
@@ -23612,7 +24515,7 @@ ${err.message}`
 
 // src/mcp/tools/load-skill.ts
 import { z as z69 } from "zod";
-import { readFileSync as readFileSync26, readdirSync as readdirSync13, statSync as statSync6 } from "fs";
+import { readFileSync as readFileSync26, readdirSync as readdirSync13, statSync as statSync7 } from "fs";
 import path42 from "path";
 import { homedir as homedir7 } from "os";
 var SKILLS_DIR = path42.join(homedir7(), ".claude", "skills");
@@ -23622,9 +24525,9 @@ function listAvailableSkills() {
     return entries.filter((entry) => {
       try {
         const entryPath = path42.join(SKILLS_DIR, entry);
-        if (!statSync6(entryPath).isDirectory()) return false;
+        if (!statSync7(entryPath).isDirectory()) return false;
         const skillFile = path42.join(entryPath, "SKILL.md");
-        statSync6(skillFile);
+        statSync7(skillFile);
         return true;
       } catch {
         return false;
@@ -23927,11 +24830,11 @@ async function importIdentities(identities, updatedBy) {
 }
 async function getActiveProcedureTitles() {
   const client = getClient();
-  const result = await client.execute({
+  const result2 = await client.execute({
     sql: "SELECT title FROM company_procedures WHERE active = 1",
     args: []
   });
-  return new Set(result.rows.map((row) => String(row.title)));
+  return new Set(result2.rows.map((row) => String(row.title)));
 }
 async function exportOrchestration(createdBy) {
   const client = getClient();
@@ -24121,11 +25024,11 @@ function registerImportOrchestration(server2) {
         await initStore();
         const raw = readFileSync28(package_path, "utf-8");
         const pkg = validatePackage(JSON.parse(raw));
-        const result = await importOrchestration(pkg, merge_strategy);
+        const result2 = await importOrchestration(pkg, merge_strategy);
         return {
           content: [{
             type: "text",
-            text: `Imported ${result.imported.roster} roster entries, ${result.imported.identities} identities, ${result.imported.behaviors} behaviors, ${result.imported.procedures} procedures using ${merge_strategy} strategy`
+            text: `Imported ${result2.imported.roster} roster entries, ${result2.imported.identities} identities, ${result2.imported.behaviors} behaviors, ${result2.imported.procedures} procedures using ${merge_strategy} strategy`
           }]
         };
       } catch (err) {
@@ -24236,11 +25139,11 @@ Domain: ${domain ?? "none"}`
         };
       }
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: "SELECT id, title, content, priority, domain FROM company_procedures WHERE id = ?",
         args: [procedure_id]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         return {
           content: [{
             type: "text",
@@ -24249,7 +25152,7 @@ Domain: ${domain ?? "none"}`
           isError: true
         };
       }
-      const row = result.rows[0];
+      const row = result2.rows[0];
       const wasActive = await deactivateGlobalProcedure(procedure_id);
       if (!wasActive) {
         return {
@@ -24387,15 +25290,20 @@ function registerConfig(server2) {
       subaction: z73.enum(["store", "list", "deactivate"]).optional().describe("Nested action for company_procedure/global_procedure"),
       max_clusters: z73.coerce.number().optional().describe("Consolidation max clusters"),
       force: z73.boolean().optional().describe("Force operation where supported"),
+      cloud_action: z73.enum(["status", "sync", "reupload"]).optional().describe("Nested operation for action=cloud_sync"),
+      confirm_local_db_source_of_truth: z73.string().optional().describe("Required for cloud_action=reupload; must exactly equal LOCAL DB IS SOURCE OF TRUTH"),
       domain_name: z73.string().optional().describe("Client deployment domain"),
       phase: z73.enum(["phase_1_coo", "phase_2_executives", "phase_3_parallel_org", "1", "2", "3"]).optional().describe("Orchestration phase for orchestration_phase action")
     }
   }, async (input, extra) => {
     const action = input.action;
-    const { action: _action, subaction, ...args } = input;
+    const { action: _action, subaction, cloud_action, ...args } = input;
     if (action === "company_procedure" || action === "global_procedure") {
       args.action = subaction ?? "list";
     }
+    if (action === "cloud_sync" && cloud_action) {
+      args.action = cloud_action;
+    }
     if (action === "export_orchestration" && !args.output_path) return errorResult8('config action "export_orchestration" requires output_path');
     if (action === "import_orchestration" && !args.input_path) return errorResult8('config action "import_orchestration" requires input_path');
     if (action === "activate_license" && !args.license_key) return errorResult8('config action "activate_license" requires license_key');
@@ -24793,7 +25701,7 @@ function registerBehavior(server2) {
           args.push(proj);
         }
         const where = conditions.join(" AND ");
-        const result2 = await client2.execute({
+        const result3 = await client2.execute({
           sql: `SELECT id, agent_id, project_name, domain, content, active, created_at, updated_at
                 FROM behaviors
                 WHERE ${where}
@@ -24801,7 +25709,7 @@ function registerBehavior(server2) {
                 LIMIT 50`,
           args
         });
-        const behaviors = result2.rows.map((r) => rowToBehavior2(r));
+        const behaviors = result3.rows.map((r) => rowToBehavior2(r));
         if (behaviors.length === 0) {
           return {
             content: [{ type: "text", text: "No behaviors found." }]
@@ -24900,11 +25808,11 @@ Use /exe-forget to remove any that this supersedes.`;
         };
       }
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: "SELECT id, agent_id, content, domain, priority FROM behaviors WHERE id = ?",
         args: [behavior_id]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         return {
           content: [{
             type: "text",
@@ -24913,7 +25821,7 @@ Use /exe-forget to remove any that this supersedes.`;
           isError: true
         };
       }
-      const row = result.rows[0];
+      const row = result2.rows[0];
       const wasActive = await deactivateBehavior(behavior_id);
       if (!wasActive) {
         return {
@@ -25119,11 +26027,11 @@ function registerDeactivateGlobalProcedure(server2) {
         };
       }
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: "SELECT id, title, content, priority, domain FROM company_procedures WHERE id = ?",
         args: [procedure_id]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         return {
           content: [{
             type: "text",
@@ -25132,7 +26040,7 @@ function registerDeactivateGlobalProcedure(server2) {
           isError: true
         };
       }
-      const row = result.rows[0];
+      const row = result2.rows[0];
       const wasActive = await deactivateGlobalProcedure(procedure_id);
       if (!wasActive) {
         return {
@@ -25261,14 +26169,14 @@ function registerGetDecision(server2) {
     },
     async ({ domain }) => {
       const client = getClient();
-      const result = await client.execute({
+      const result2 = await client.execute({
         sql: `SELECT id, agent_id, timestamp, raw_text, status, supersedes_id, project_name
               FROM memories
               WHERE memory_type = 'decision' AND source_path = ?
               ORDER BY timestamp DESC`,
         args: [domain]
       });
-      if (result.rows.length === 0) {
+      if (result2.rows.length === 0) {
         return {
           content: [
             {
@@ -25278,7 +26186,7 @@ function registerGetDecision(server2) {
           ]
         };
       }
-      const decisions = result.rows.map((r) => ({
+      const decisions = result2.rows.map((r) => ({
         id: String(r.id),
         agent_id: String(r.agent_id),
         timestamp: String(r.timestamp),
@@ -25852,10 +26760,429 @@ Upstream status: ${upstreamStatus}`
   );
 }
 
-// src/mcp/tools/support-inbox.ts
+// src/mcp/tools/code-context.ts
 import { z as z87 } from "zod";
+
+// src/lib/code-context-index.ts
+init_config();
+import crypto19 from "crypto";
+import path48 from "path";
+import { existsSync as existsSync37, mkdirSync as mkdirSync20, readFileSync as readFileSync30, statSync as statSync8, writeFileSync as writeFileSync22 } from "fs";
+import { spawnSync } from "child_process";
+var INDEX_VERSION = 1;
+var DEFAULT_MAX_FILES = 2e3;
+var CODE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
+var IGNORE_SEGMENTS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git", "coverage", ".worktrees", ".next", "build"]);
+function normalizeProjectRoot(projectRoot) {
+  return path48.resolve(projectRoot || process.cwd());
+}
+function hashText(text3) {
+  return crypto19.createHash("sha256").update(text3).digest("hex");
+}
+function indexDir() {
+  const dir = path48.join(EXE_AI_DIR, "code-context");
+  mkdirSync20(dir, { recursive: true });
+  return dir;
+}
+function getCodeContextIndexPath(projectRoot) {
+  const root = normalizeProjectRoot(projectRoot);
+  const rootHash = hashText(root).slice(0, 16);
+  return path48.join(indexDir(), `${rootHash}.json`);
+}
+function currentBranch(projectRoot) {
+  const result2 = spawnSync("git", ["branch", "--show-current"], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: 2e3
+  });
+  const branch = result2.status === 0 ? result2.stdout.trim() : "";
+  return branch || "detached-or-unknown";
+}
+function shouldIgnore(relPath) {
+  const parts = relPath.split(path48.sep);
+  return parts.some((part) => IGNORE_SEGMENTS.has(part));
+}
+function isCodeFile(relPath) {
+  return CODE_EXTENSIONS.has(path48.extname(relPath).toLowerCase());
+}
+function listCodeFiles(projectRoot, maxFiles) {
+  const git = spawnSync("git", ["ls-files", "*.ts", "*.tsx", "*.js", "*.jsx"], {
+    cwd: projectRoot,
+    encoding: "utf8",
+    timeout: 5e3,
+    maxBuffer: 1024 * 1024 * 8
+  });
+  let files = [];
+  if (git.status === 0 && git.stdout.trim()) {
+    files = git.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+  } else {
+    const rg = spawnSync("rg", ["--files", "-g", "*.ts", "-g", "*.tsx", "-g", "*.js", "-g", "*.jsx"], {
+      cwd: projectRoot,
+      encoding: "utf8",
+      timeout: 5e3,
+      maxBuffer: 1024 * 1024 * 8
+    });
+    if (rg.status === 0 && rg.stdout.trim()) {
+      files = rg.stdout.split("\n").map((s) => s.trim()).filter(Boolean);
+    }
+  }
+  return files.filter((file) => isCodeFile(file) && !shouldIgnore(file)).slice(0, maxFiles).sort();
+}
+function parseImportPaths(importText) {
+  const paths = [];
+  const fromRegex = /from\s+["']([^"']+)["']/g;
+  let match;
+  while ((match = fromRegex.exec(importText)) !== null) paths.push(match[1]);
+  const bareRegex = /^import\s+["']([^"']+)["']/gm;
+  while ((match = bareRegex.exec(importText)) !== null) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+  const requireRegex = /require\(["']([^"']+)["']\)/g;
+  while ((match = requireRegex.exec(importText)) !== null) {
+    if (!paths.includes(match[1])) paths.push(match[1]);
+  }
+  return paths;
+}
+function resolveImport(fromFile, importPath, allFiles) {
+  if (!importPath.startsWith(".")) return null;
+  const base = path48.posix.normalize(path48.posix.join(path48.posix.dirname(fromFile.replaceAll(path48.sep, "/")), importPath));
+  const withoutKnownExt = base.replace(/\.(?:js|jsx|ts|tsx)$/, "");
+  const candidates = [
+    base,
+    `${withoutKnownExt}.ts`,
+    `${withoutKnownExt}.tsx`,
+    `${withoutKnownExt}.js`,
+    `${withoutKnownExt}.jsx`,
+    `${base}.ts`,
+    `${base}.tsx`,
+    `${base}.js`,
+    `${base}.jsx`,
+    path48.posix.join(base, "index.ts"),
+    path48.posix.join(base, "index.tsx"),
+    path48.posix.join(base, "index.js"),
+    path48.posix.join(base, "index.jsx")
+  ];
+  return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
+}
+function symbolId(filePath, chunk) {
+  return hashText(`${filePath}:${chunk.kind}:${chunk.name}:${chunk.startLine}:${chunk.endLine}`).slice(0, 24);
+}
+function loadIndex(projectRoot) {
+  const file = getCodeContextIndexPath(projectRoot);
+  if (!existsSync37(file)) return null;
+  try {
+    const parsed = JSON.parse(readFileSync30(file, "utf8"));
+    if (parsed.version !== INDEX_VERSION || parsed.projectRoot !== projectRoot) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function saveIndex(index) {
+  writeFileSync22(getCodeContextIndexPath(index.projectRoot), JSON.stringify(index, null, 2));
+}
+function buildFileRecord(projectRoot, relPath, allFiles, previous) {
+  const absPath = path48.join(projectRoot, relPath);
+  let stat;
+  try {
+    stat = statSync8(absPath);
+  } catch {
+    return null;
+  }
+  if (!stat.isFile()) return null;
+  const source = readFileSync30(absPath, "utf8");
+  const hash = hashText(source);
+  if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) {
+    return previous;
+  }
+  if (!isChunkable(relPath)) return null;
+  const chunks = chunkSourceFile(source, relPath);
+  const imports = chunks.filter((chunk) => chunk.kind === "import").flatMap((chunk) => parseImportPaths(chunk.text));
+  const resolvedImports = imports.map((importPath) => resolveImport(relPath, importPath, allFiles)).filter((file) => Boolean(file));
+  const symbols = chunks.filter((chunk) => chunk.kind !== "import" && chunk.name !== "(unknown)").map((chunk) => ({
+    id: symbolId(relPath, chunk),
+    name: chunk.name,
+    kind: chunk.kind,
+    filePath: relPath,
+    startLine: chunk.startLine,
+    endLine: chunk.endLine,
+    summary: summarizeChunk(chunk, relPath),
+    text: chunk.text.slice(0, 6e3),
+    comment: chunk.comment
+  }));
+  return {
+    path: relPath,
+    absPath,
+    hash,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    imports,
+    resolvedImports,
+    symbols
+  };
+}
+function buildCodeContextIndex(options = {}) {
+  const projectRoot = normalizeProjectRoot(options.projectRoot);
+  const maxFiles = options.maxFiles ?? DEFAULT_MAX_FILES;
+  const branch = currentBranch(projectRoot);
+  const previous = options.force ? null : loadIndex(projectRoot);
+  const files = listCodeFiles(projectRoot, maxFiles);
+  const allFiles = new Set(files.map((file) => file.replaceAll(path48.sep, "/")));
+  const fileRecords = {};
+  for (const rel of files) {
+    const normalized = rel.replaceAll(path48.sep, "/");
+    const record = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
+    if (record) fileRecords[normalized] = record;
+  }
+  const index = {
+    version: INDEX_VERSION,
+    projectRoot,
+    rootHash: hashText(projectRoot).slice(0, 16),
+    branch,
+    indexedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    files: fileRecords
+  };
+  saveIndex(index);
+  return index;
+}
+function loadOrBuildCodeContextIndex(options = {}) {
+  const projectRoot = normalizeProjectRoot(options.projectRoot);
+  if (!options.force) {
+    const loaded = loadIndex(projectRoot);
+    if (loaded) {
+      const currentFiles = listCodeFiles(projectRoot, options.maxFiles ?? DEFAULT_MAX_FILES);
+      const unchanged = currentFiles.every((rel) => {
+        const normalized = rel.replaceAll(path48.sep, "/");
+        const existing = loaded.files[normalized];
+        if (!existing) return false;
+        try {
+          const stat = statSync8(path48.join(projectRoot, normalized));
+          return stat.mtimeMs === existing.mtimeMs && stat.size === existing.size;
+        } catch {
+          return false;
+        }
+      });
+      if (unchanged && Object.keys(loaded.files).length === currentFiles.length) return loaded;
+    }
+  }
+  return buildCodeContextIndex(options);
+}
+function tokenize(query) {
+  return query.toLowerCase().split(/[^a-z0-9_.$/-]+/).map((s) => s.trim()).filter((s) => s.length >= 2);
+}
+function scoreSymbol(symbol, terms) {
+  const haystacks = {
+    name: symbol.name.toLowerCase(),
+    path: symbol.filePath.toLowerCase(),
+    summary: symbol.summary.toLowerCase(),
+    text: symbol.text.toLowerCase()
+  };
+  let score = 0;
+  const matches = [];
+  for (const term of terms) {
+    if (haystacks.name === term) {
+      score += 80;
+      matches.push(`name=${term}`);
+      continue;
+    }
+    if (haystacks.name.includes(term)) {
+      score += 40;
+      matches.push(`name~${term}`);
+    }
+    if (haystacks.path.includes(term)) {
+      score += 15;
+      matches.push(`path~${term}`);
+    }
+    if (haystacks.summary.includes(term)) {
+      score += 12;
+      matches.push(`summary~${term}`);
+    }
+    if (haystacks.text.includes(term)) {
+      score += 4;
+      matches.push(`text~${term}`);
+    }
+  }
+  return { score, matches };
+}
+function searchCodeContext(query, options = {}) {
+  const terms = tokenize(query);
+  if (terms.length === 0) return [];
+  const index = loadOrBuildCodeContextIndex(options);
+  const results = [];
+  for (const file of Object.values(index.files)) {
+    for (const symbol of file.symbols) {
+      const scored = scoreSymbol(symbol, terms);
+      if (scored.score > 0) results.push({ symbol, score: scored.score, matches: scored.matches });
+    }
+  }
+  return results.sort((a, b) => b.score - a.score || a.symbol.filePath.localeCompare(b.symbol.filePath)).slice(0, options.limit ?? 20);
+}
+function dependentsMap(index) {
+  const map = /* @__PURE__ */ new Map();
+  for (const file of Object.values(index.files)) {
+    for (const dep of file.resolvedImports) {
+      if (!map.has(dep)) map.set(dep, /* @__PURE__ */ new Set());
+      map.get(dep).add(file.path);
+    }
+  }
+  return map;
+}
+function findSymbols(index, symbolName, limit = 20) {
+  const q = symbolName.toLowerCase();
+  const exact = [];
+  const fuzzy = [];
+  for (const file of Object.values(index.files)) {
+    for (const symbol of file.symbols) {
+      if (symbol.name.toLowerCase() === q) exact.push(symbol);
+      else if (symbol.name.toLowerCase().includes(q) || symbol.summary.toLowerCase().includes(q)) fuzzy.push(symbol);
+    }
+  }
+  return [...exact, ...fuzzy].slice(0, limit);
+}
+function traceCodeSymbol(symbolName, options = {}) {
+  const index = loadOrBuildCodeContextIndex(options);
+  const matches = findSymbols(index, symbolName, options.limit ?? 20);
+  const dependents = dependentsMap(index);
+  return {
+    query: symbolName,
+    matches,
+    definitions: matches.map((symbol) => {
+      const file = index.files[symbol.filePath];
+      return {
+        symbol,
+        imports: file.resolvedImports,
+        dependents: [...dependents.get(symbol.filePath) ?? /* @__PURE__ */ new Set()].sort(),
+        relatedSymbols: file.symbols.filter((s) => s.id !== symbol.id).slice(0, 20)
+      };
+    })
+  };
+}
+function resolveTargetFile(index, input) {
+  if (input.filePath) {
+    const normalized = input.filePath.replaceAll(path48.sep, "/").replace(/^\.\//, "");
+    if (index.files[normalized]) return { filePath: normalized, target: normalized };
+    const suffix = Object.keys(index.files).find((file) => file.endsWith(normalized));
+    if (suffix) return { filePath: suffix, target: input.filePath };
+  }
+  if (input.symbol) {
+    const match = findSymbols(index, input.symbol, 1)[0];
+    if (match) return { filePath: match.filePath, target: input.symbol };
+  }
+  return null;
+}
+function analyzeBlastRadius(input) {
+  const index = loadOrBuildCodeContextIndex({ projectRoot: input.projectRoot, force: input.force });
+  const target = resolveTargetFile(index, { filePath: input.filePath, symbol: input.symbol });
+  if (!target) return null;
+  const dependents = dependentsMap(index);
+  const maxDepth = input.depth ?? 2;
+  const impacted = /* @__PURE__ */ new Map();
+  const queue = [{ filePath: target.filePath, distance: 0 }];
+  impacted.set(target.filePath, { distance: 0, reason: "target" });
+  while (queue.length > 0) {
+    const item = queue.shift();
+    if (item.distance >= maxDepth) continue;
+    for (const dep of dependents.get(item.filePath) ?? []) {
+      if (!impacted.has(dep)) {
+        impacted.set(dep, { distance: item.distance + 1, reason: `imports ${item.filePath}` });
+        queue.push({ filePath: dep, distance: item.distance + 1 });
+      }
+    }
+  }
+  const targetBase = path48.basename(target.filePath).replace(/\.[^.]+$/, "").toLowerCase();
+  const symbolLower = input.symbol?.toLowerCase();
+  const tests = Object.keys(index.files).filter((file) => {
+    const lower = file.toLowerCase();
+    return (lower.includes("test") || lower.includes("spec")) && (lower.includes(targetBase) || (symbolLower ? index.files[file].symbols.some((s) => s.text.toLowerCase().includes(symbolLower)) : false));
+  });
+  for (const test of tests) {
+    if (!impacted.has(test)) impacted.set(test, { distance: 1, reason: "related test/spec" });
+  }
+  const impactedFiles = [...impacted.entries()].map(([filePath, value]) => ({ filePath, distance: value.distance, reason: value.reason })).sort((a, b) => a.distance - b.distance || a.filePath.localeCompare(b.filePath));
+  const nonTestImpacted = impactedFiles.filter((f) => !f.filePath.match(/(test|spec)\./i)).length;
+  const riskLevel = nonTestImpacted >= 8 ? "high" : nonTestImpacted >= 4 ? "medium" : "low";
+  return {
+    target: target.target,
+    targetFile: target.filePath,
+    impactedFiles,
+    tests,
+    symbolsInTarget: index.files[target.filePath]?.symbols ?? [],
+    riskLevel
+  };
+}
+function getCodeContextStats(options = {}) {
+  const index = loadOrBuildCodeContextIndex(options);
+  return {
+    projectRoot: index.projectRoot,
+    branch: index.branch,
+    indexedAt: index.indexedAt,
+    files: Object.keys(index.files).length,
+    symbols: Object.values(index.files).reduce((sum, file) => sum + file.symbols.length, 0),
+    imports: Object.values(index.files).reduce((sum, file) => sum + file.resolvedImports.length, 0),
+    indexPath: getCodeContextIndexPath(index.projectRoot)
+  };
+}
+
+// src/mcp/tools/code-context.ts
+function errorResult10(text3) {
+  return { content: [{ type: "text", text: text3 }], isError: true };
+}
+function jsonResult(value) {
+  return { content: [{ type: "text", text: JSON.stringify(value, null, 2) }] };
+}
+function registerCodeContext(server2) {
+  server2.registerTool("code_context", {
+    title: "Code Context",
+    description: "Persistent codebase context engine. One consolidated tool to avoid MCP bloat. Actions: index, search, trace, blast_radius, stats.",
+    inputSchema: {
+      action: z87.enum(["index", "search", "trace", "blast_radius", "stats"]).describe("Code context operation"),
+      project_root: z87.string().optional().describe("Repository root. Defaults to current working directory."),
+      query: z87.string().optional().describe("Search query for action=search"),
+      symbol: z87.string().optional().describe("Symbol/function/class/type name for trace or blast_radius"),
+      file_path: z87.string().optional().describe("File path for blast_radius"),
+      force: z87.boolean().optional().describe("Force rebuild before answering"),
+      limit: z87.coerce.number().int().min(1).max(100).optional().describe("Max results"),
+      depth: z87.coerce.number().int().min(1).max(5).optional().describe("Dependent traversal depth for blast_radius"),
+      max_files: z87.coerce.number().int().min(1).max(1e4).optional().describe("Max code files to index")
+    }
+  }, async ({ action, project_root, query, symbol, file_path, force, limit, depth, max_files }) => {
+    const opts = { projectRoot: project_root, force, maxFiles: max_files };
+    if (action === "index") {
+      const index = buildCodeContextIndex(opts);
+      return jsonResult({
+        projectRoot: index.projectRoot,
+        branch: index.branch,
+        indexedAt: index.indexedAt,
+        files: Object.keys(index.files).length,
+        symbols: Object.values(index.files).reduce((sum, file) => sum + file.symbols.length, 0),
+        imports: Object.values(index.files).reduce((sum, file) => sum + file.resolvedImports.length, 0)
+      });
+    }
+    if (action === "stats") {
+      return jsonResult(getCodeContextStats(opts));
+    }
+    if (action === "search") {
+      if (!query) return errorResult10('code_context action "search" requires query');
+      return jsonResult({ query, results: searchCodeContext(query, { ...opts, limit }) });
+    }
+    if (action === "trace") {
+      if (!symbol) return errorResult10('code_context action "trace" requires symbol');
+      return jsonResult(traceCodeSymbol(symbol, { ...opts, limit }));
+    }
+    if (action === "blast_radius") {
+      if (!symbol && !file_path) return errorResult10('code_context action "blast_radius" requires symbol or file_path');
+      const result2 = analyzeBlastRadius({ projectRoot: project_root, force, symbol, filePath: file_path, depth });
+      if (!result2) return errorResult10(`No code context target found for ${symbol || file_path}`);
+      return jsonResult(result2);
+    }
+    return errorResult10(`Unknown code_context action: ${String(action)}`);
+  });
+}
+
+// src/mcp/tools/support-inbox.ts
+import { z as z88 } from "zod";
 var DEFAULT_ENDPOINT = "https://askexe.com/admin/support/bug-reports";
-var STATUS = z87.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+var STATUS = z88.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
 function adminToken() {
   return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN;
 }
@@ -25894,9 +27221,9 @@ function registerListBugReports(server2) {
       title: "List Bug Reports",
       description: "AskExe-internal only: list incoming customer bug reports from the support inbox.",
       inputSchema: {
-        status: z87.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
-        severity: z87.enum(["p0", "p1", "p2", "p3"]).optional(),
-        limit: z87.number().int().min(1).max(100).default(25)
+        status: z88.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
+        severity: z88.enum(["p0", "p1", "p2", "p3"]).optional(),
+        limit: z88.number().int().min(1).max(100).default(25)
       }
     },
     async ({ status, severity, limit }) => {
@@ -25915,7 +27242,7 @@ function registerGetBugReport(server2) {
     {
       title: "Get Bug Report",
       description: "AskExe-internal only: fetch one customer bug report with full markdown payload.",
-      inputSchema: { id: z87.string().min(8) }
+      inputSchema: { id: z88.string().min(8) }
     },
     async ({ id }) => {
       const data = await requestJson(`${endpoint()}/${encodeURIComponent(id)}`);
@@ -25930,12 +27257,12 @@ function registerTriageBugReport(server2) {
       title: "Triage Bug Report",
       description: "AskExe-internal only: update bug report status and link task/commit/release metadata.",
       inputSchema: {
-        id: z87.string().min(8),
+        id: z88.string().min(8),
         status: STATUS.optional(),
-        triage_notes: z87.string().optional(),
-        linked_task_id: z87.string().optional(),
-        linked_commit: z87.string().optional(),
-        fixed_version: z87.string().optional()
+        triage_notes: z88.string().optional(),
+        linked_task_id: z88.string().optional(),
+        linked_commit: z88.string().optional(),
+        fixed_version: z88.string().optional()
       }
     },
     async ({ id, status, triage_notes, linked_task_id, linked_commit, fixed_version }) => {
@@ -25959,7 +27286,7 @@ var TOOL_GATES = {
   reminders: [],
   // all agents — create, list, complete, reminder
   "graph-read": [],
-  // all agents — query_relationships, get_entity_neighbors, get_hot_entities, get_graph_stats, find_similar_trajectories
+  // all agents — query_relationships, get_entity_neighbors, get_hot_entities, get_graph_stats, find_similar_trajectories, code_context
   "graph-write": ["COO", "CTO"],
   // merge_entities, export_graph
   wiki: ["COO", "Wiki Agent"],
@@ -25998,6 +27325,7 @@ var TOOL_CATEGORIES = {
   registerStoreDecision: "core",
   registerGetDecision: "core",
   registerCreateBugReport: "core",
+  registerCodeContext: "graph-read",
   registerListBugReports: "admin",
   registerGetBugReport: "admin",
   registerTriageBugReport: "admin",
@@ -26260,6 +27588,7 @@ function registerAllTools(server2) {
   gate("registerStoreDecision", registerStoreDecision);
   gate("registerGetDecision", registerGetDecision);
   gate("registerCreateBugReport", registerCreateBugReport);
+  gate("registerCodeContext", registerCodeContext);
   if (process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN) {
     gate("registerListBugReports", registerListBugReports);
     gate("registerGetBugReport", registerGetBugReport);
@@ -26342,9 +27671,9 @@ async function withTrace(toolName, fn) {
   return tracer.startActiveSpan(`mcp.tool.${toolName}`, async (span) => {
     span.setAttribute("mcp.tool.name", toolName);
     try {
-      const result = await fn();
+      const result2 = await fn();
       span.setStatus({ code: SpanStatusCode.OK });
-      return result;
+      return result2;
     } catch (err) {
       span.setStatus({
         code: SpanStatusCode.ERROR,
@@ -26429,16 +27758,16 @@ try {
     }
   }, 3e4);
   _ppidWatchdog.unref();
-  const MCP_VERSION_PATH = path48.join(os20.homedir(), ".exe-os", "mcp-version");
+  const MCP_VERSION_PATH = path49.join(os20.homedir(), ".exe-os", "mcp-version");
   let _currentMcpVersion = null;
   try {
-    _currentMcpVersion = existsSync37(MCP_VERSION_PATH) ? readFileSync30(MCP_VERSION_PATH, "utf8").trim() : null;
+    _currentMcpVersion = existsSync38(MCP_VERSION_PATH) ? readFileSync31(MCP_VERSION_PATH, "utf8").trim() : null;
   } catch {
   }
   const _versionWatchdog = setInterval(() => {
     try {
-      if (!existsSync37(MCP_VERSION_PATH)) return;
-      const diskVersion = readFileSync30(MCP_VERSION_PATH, "utf8").trim();
+      if (!existsSync38(MCP_VERSION_PATH)) return;
+      const diskVersion = readFileSync31(MCP_VERSION_PATH, "utf8").trim();
       if (_currentMcpVersion && diskVersion !== _currentMcpVersion) {
         process.stderr.write(
           `[exe-os] MCP version changed (${_currentMcpVersion} \u2192 ${diskVersion}). Hot-reloading...
@@ -26455,10 +27784,10 @@ try {
   _backfillTimer = setInterval(async () => {
     try {
       const client = getClient();
-      const result = await client.execute(
+      const result2 = await client.execute(
         "SELECT COUNT(*) as cnt FROM memories WHERE vector IS NULL"
       );
-      const nullCount = Number(result.rows[0]?.cnt) || 0;
+      const nullCount = Number(result2.rows[0]?.cnt) || 0;
       if (nullCount === 0) return;
       const { tryAcquireWorkerSlot: tryAcquireWorkerSlot2, registerWorkerPid: registerWorkerPid2 } = await Promise.resolve().then(() => (init_worker_gate(), worker_gate_exports));
       if (!tryAcquireWorkerSlot2()) {
@@ -26471,14 +27800,14 @@ try {
 `
       );
       const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path48.resolve(
-        path48.dirname(thisFile),
+      const backfillPath = path49.resolve(
+        path49.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
-      if (existsSync37(backfillPath)) {
+      if (existsSync38(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path48.join(exeDir, "workers.log");
-        mkdirSync20(path48.dirname(logPath), { recursive: true });
+        const logPath = path49.join(exeDir, "workers.log");
+        mkdirSync21(path49.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
           logFd = openSync3(logPath, "a");