@askexenow/exe-os 0.8.32 → 0.8.36

package/dist/mcp/server.js

@@ -454,11 +454,11 @@ async function connectEmbedDaemon() {
     }
   }
   const start = Date.now();
-  let delay = 100;
+  let delay2 = 100;
   while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-    await new Promise((r) => setTimeout(r, delay));
+    await new Promise((r) => setTimeout(r, delay2));
     if (await connectToSocket()) return true;
-    delay = Math.min(delay * 2, 3e3);
+    delay2 = Math.min(delay2 * 2, 3e3);
   }
   return false;
 }
@@ -550,11 +550,11 @@ async function embedViaClient(text, priority = "high") {
 `);
       killAndRespawnDaemon();
       const start = Date.now();
-      let delay = 200;
+      let delay2 = 200;
       while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-        await new Promise((r) => setTimeout(r, delay));
+        await new Promise((r) => setTimeout(r, delay2));
         if (await connectToSocket()) break;
-        delay = Math.min(delay * 2, 3e3);
+        delay2 = Math.min(delay2 * 2, 3e3);
       }
       if (!_connected) return null;
     }
@@ -566,11 +566,11 @@ async function embedViaClient(text, priority = "high") {
 `);
     killAndRespawnDaemon();
     const start = Date.now();
-    let delay = 200;
+    let delay2 = 200;
     while (Date.now() - start < CONNECT_TIMEOUT_MS) {
-      await new Promise((r) => setTimeout(r, delay));
+      await new Promise((r) => setTimeout(r, delay2));
       if (await connectToSocket()) break;
-      delay = Math.min(delay * 2, 3e3);
+      delay2 = Math.min(delay2 * 2, 3e3);
     }
     if (!_connected) return null;
     const retry = await sendRequest([text], priority);
@@ -681,12 +681,68 @@ var init_embedder = __esm({
   }
 });
 
+// src/lib/db-retry.ts
+function isBusyError(err) {
+  if (err instanceof Error) {
+    const msg = err.message.toLowerCase();
+    return msg.includes("sqlite_busy") || msg.includes("database is locked");
+  }
+  return false;
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function retryOnBusy(fn, label) {
+  let lastError;
+  for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isBusyError(err) || attempt === MAX_RETRIES) {
+        throw err;
+      }
+      const backoff = BASE_DELAY_MS * Math.pow(2, attempt);
+      const jitter = Math.floor(Math.random() * MAX_JITTER_MS);
+      process.stderr.write(
+        `[exe-os] SQLITE_BUSY ${label} retry ${attempt + 1}/${MAX_RETRIES} \u2014 waiting ${backoff + jitter}ms
+`
+      );
+      await delay(backoff + jitter);
+    }
+  }
+  throw lastError;
+}
+function wrapWithRetry(client) {
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      if (prop === "execute") {
+        return (sql) => retryOnBusy(() => target.execute(sql), "execute");
+      }
+      if (prop === "batch") {
+        return (stmts) => retryOnBusy(() => target.batch(stmts), "batch");
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+var MAX_RETRIES, BASE_DELAY_MS, MAX_JITTER_MS;
+var init_db_retry = __esm({
+  "src/lib/db-retry.ts"() {
+    "use strict";
+    MAX_RETRIES = 3;
+    BASE_DELAY_MS = 200;
+    MAX_JITTER_MS = 300;
+  }
+});
+
 // src/lib/database.ts
 import { createClient } from "@libsql/client";
 async function initDatabase(config2) {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
   const opts = {
     url: `file:${config2.dbPath}`
@@ -695,20 +751,27 @@ async function initDatabase(config2) {
     opts.encryptionKey = config2.encryptionKey;
   }
   _client = createClient(opts);
+  _resilientClient = wrapWithRetry(_client);
 }
 function isInitialized() {
   return _client !== null;
 }
 function getClient() {
+  if (!_resilientClient) {
+    throw new Error("Database client not initialized. Call initDatabase() first.");
+  }
+  return _resilientClient;
+}
+function getRawClient() {
   if (!_client) {
     throw new Error("Database client not initialized. Call initDatabase() first.");
   }
   return _client;
 }
 async function ensureSchema() {
-  const client = getClient();
+  const client = getRawClient();
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -1501,13 +1564,16 @@ async function disposeDatabase() {
   if (_client) {
     _client.close();
     _client = null;
+    _resilientClient = null;
   }
 }
-var _client, initTurso, disposeTurso;
+var _client, _resilientClient, initTurso, disposeTurso;
 var init_database = __esm({
   "src/lib/database.ts"() {
     "use strict";
+    init_db_retry();
     _client = null;
+    _resilientClient = null;
     initTurso = initDatabase;
     disposeTurso = disposeDatabase;
   }
@@ -1620,7 +1686,7 @@ function listShards() {
 }
 async function ensureShardSchema(client) {
   await client.execute("PRAGMA journal_mode = WAL");
-  await client.execute("PRAGMA busy_timeout = 5000");
+  await client.execute("PRAGMA busy_timeout = 30000");
   try {
     await client.execute("PRAGMA libsql_vector_search_ef = 128");
   } catch {
@@ -2890,10 +2956,40 @@ var init_active_agent = __esm({
 });
 
 // src/lib/employees.ts
+var employees_exports = {};
+__export(employees_exports, {
+  EMPLOYEES_PATH: () => EMPLOYEES_PATH,
+  addEmployee: () => addEmployee,
+  getEmployee: () => getEmployee,
+  getEmployeeByRole: () => getEmployeeByRole,
+  getEmployeeNamesByRole: () => getEmployeeNamesByRole,
+  hasRole: () => hasRole,
+  isMultiInstance: () => isMultiInstance,
+  loadEmployees: () => loadEmployees,
+  loadEmployeesSync: () => loadEmployeesSync,
+  registerBinSymlinks: () => registerBinSymlinks,
+  saveEmployees: () => saveEmployees,
+  validateEmployeeName: () => validateEmployeeName
+});
 import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir3 } from "fs/promises";
-import { existsSync as existsSync7, symlinkSync, readlinkSync } from "fs";
+import { existsSync as existsSync7, symlinkSync, readlinkSync, readFileSync as readFileSync5 } from "fs";
 import { execSync as execSync5 } from "child_process";
 import path9 from "path";
+function validateEmployeeName(name) {
+  if (!name) {
+    return { valid: false, error: "Name is required" };
+  }
+  if (name.length > 32) {
+    return { valid: false, error: "Name must be 32 characters or fewer" };
+  }
+  if (!/^[a-z][a-z0-9]*$/.test(name)) {
+    return {
+      valid: false,
+      error: "Name must start with a letter and contain only lowercase alphanumeric characters"
+    };
+  }
+  return { valid: true };
+}
 async function loadEmployees(employeesPath = EMPLOYEES_PATH) {
   if (!existsSync7(employeesPath)) {
     return [];
@@ -2909,6 +3005,36 @@ async function saveEmployees(employees, employeesPath = EMPLOYEES_PATH) {
   await mkdir3(path9.dirname(employeesPath), { recursive: true });
   await writeFile3(employeesPath, JSON.stringify(employees, null, 2) + "\n", "utf-8");
 }
+function loadEmployeesSync(employeesPath = EMPLOYEES_PATH) {
+  if (!existsSync7(employeesPath)) return [];
+  try {
+    return JSON.parse(readFileSync5(employeesPath, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+function getEmployee(employees, name) {
+  return employees.find((e) => e.name.toLowerCase() === name.toLowerCase());
+}
+function getEmployeeByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.find((e) => e.role.toLowerCase() === lower);
+}
+function getEmployeeNamesByRole(employees, role) {
+  const lower = role.toLowerCase();
+  return employees.filter((e) => e.role.toLowerCase() === lower).map((e) => e.name);
+}
+function hasRole(agentName, role) {
+  const employees = loadEmployeesSync();
+  const emp = getEmployee(employees, agentName);
+  return emp ? emp.role.toLowerCase() === role.toLowerCase() : false;
+}
+function isMultiInstance(agentName, employees) {
+  const roster = employees ?? loadEmployeesSync();
+  const emp = getEmployee(roster, agentName);
+  if (!emp) return false;
+  return MULTI_INSTANCE_ROLES.has(emp.role.toLowerCase());
+}
 function addEmployee(employees, employee) {
   const normalized = { ...employee, name: employee.name.toLowerCase() };
   if (employees.some((e) => e.name.toLowerCase() === normalized.name)) {
@@ -2916,12 +3042,48 @@ function addEmployee(employees, employee) {
   }
   return [...employees, normalized];
 }
-var EMPLOYEES_PATH;
+function registerBinSymlinks(name) {
+  const created = [];
+  const skipped = [];
+  const errors = [];
+  let exeBinPath;
+  try {
+    exeBinPath = execSync5("which exe", { encoding: "utf-8" }).trim();
+  } catch {
+    errors.push("Could not find 'exe' in PATH");
+    return { created, skipped, errors };
+  }
+  const binDir = path9.dirname(exeBinPath);
+  let target;
+  try {
+    target = readlinkSync(exeBinPath);
+  } catch {
+    errors.push("Could not read 'exe' symlink");
+    return { created, skipped, errors };
+  }
+  for (const suffix of ["", "-opencode"]) {
+    const linkName = `${name}${suffix}`;
+    const linkPath = path9.join(binDir, linkName);
+    if (existsSync7(linkPath)) {
+      skipped.push(linkName);
+      continue;
+    }
+    try {
+      symlinkSync(target, linkPath);
+      created.push(linkName);
+    } catch (err) {
+      errors.push(`${linkName}: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  return { created, skipped, errors };
+}
+var EMPLOYEES_PATH, MULTI_INSTANCE_ROLES;
 var init_employees = __esm({
   "src/lib/employees.ts"() {
     "use strict";
     init_config();
     EMPLOYEES_PATH = path9.join(EXE_AI_DIR, "exe-employees.json");
+    MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["principal engineer", "content production specialist", "staff code reviewer"]);
   }
 });
 
@@ -2940,7 +3102,7 @@ __export(license_exports, {
   saveLicense: () => saveLicense,
   validateLicense: () => validateLicense
 });
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync2, existsSync as existsSync8, mkdirSync as mkdirSync3 } from "fs";
 import { randomUUID as randomUUID2 } from "crypto";
 import path10 from "path";
 import { jwtVerify, importSPKI } from "jose";
@@ -2948,14 +3110,14 @@ function loadDeviceId() {
   const deviceJsonPath = path10.join(EXE_AI_DIR, "device.json");
   try {
     if (existsSync8(deviceJsonPath)) {
-      const data = JSON.parse(readFileSync5(deviceJsonPath, "utf8"));
+      const data = JSON.parse(readFileSync6(deviceJsonPath, "utf8"));
       if (data.deviceId) return data.deviceId;
     }
   } catch {
   }
   try {
     if (existsSync8(DEVICE_ID_PATH)) {
-      const id2 = readFileSync5(DEVICE_ID_PATH, "utf8").trim();
+      const id2 = readFileSync6(DEVICE_ID_PATH, "utf8").trim();
       if (id2) return id2;
     }
   } catch {
@@ -2968,7 +3130,7 @@ function loadDeviceId() {
 function loadLicense() {
   try {
     if (!existsSync8(LICENSE_PATH)) return null;
-    return readFileSync5(LICENSE_PATH, "utf8").trim();
+    return readFileSync6(LICENSE_PATH, "utf8").trim();
   } catch {
     return null;
   }
@@ -3002,7 +3164,7 @@ async function verifyLicenseJwt(token) {
 async function getCachedLicense() {
   try {
     if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return null;
     return await verifyLicenseJwt(raw.token);
   } catch {
@@ -3012,7 +3174,7 @@ async function getCachedLicense() {
 function readCachedToken() {
   try {
     if (!existsSync8(CACHE_PATH)) return null;
-    const raw = JSON.parse(readFileSync5(CACHE_PATH, "utf8"));
+    const raw = JSON.parse(readFileSync6(CACHE_PATH, "utf8"));
     return typeof raw.token === "string" ? raw.token : null;
   } catch {
     return null;
@@ -3234,12 +3396,12 @@ __export(plan_limits_exports, {
   countActiveMemories: () => countActiveMemories,
   getLicenseSync: () => getLicenseSync
 });
-import { readFileSync as readFileSync6, existsSync as existsSync9 } from "fs";
+import { readFileSync as readFileSync7, existsSync as existsSync9 } from "fs";
 import path11 from "path";
 function getLicenseSync() {
   try {
     if (!existsSync9(CACHE_PATH2)) return freeLicense();
-    const raw = JSON.parse(readFileSync6(CACHE_PATH2, "utf8"));
+    const raw = JSON.parse(readFileSync7(CACHE_PATH2, "utf8"));
     if (!raw.token || typeof raw.token !== "string") return freeLicense();
     const parts = raw.token.split(".");
     if (parts.length !== 3) return freeLicense();
@@ -3307,7 +3469,7 @@ function assertEmployeeLimitSync(rosterPath) {
   let count = 0;
   try {
     if (existsSync9(filePath)) {
-      const raw = readFileSync6(filePath, "utf8");
+      const raw = readFileSync7(filePath, "utf8");
       const employees = JSON.parse(raw);
       count = Array.isArray(employees) ? employees.length : 0;
     }
@@ -3353,7 +3515,7 @@ import crypto5 from "crypto";
 import path14 from "path";
 import os2 from "os";
 import {
-  readFileSync as readFileSync7,
+  readFileSync as readFileSync8,
   readdirSync as readdirSync3,
   unlinkSync as unlinkSync3,
   existsSync as existsSync10,
@@ -3405,7 +3567,7 @@ import crypto6 from "crypto";
 import path15 from "path";
 import { execSync as execSync6 } from "child_process";
 import { mkdir as mkdir4, writeFile as writeFile4, appendFile } from "fs/promises";
-import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync9 } from "fs";
 async function writeCheckpoint(input) {
   const client = getClient();
   const row = await resolveTask(client, input.taskId);
@@ -3782,7 +3944,7 @@ async function ensureGitignoreExe(baseDir) {
   const gitignorePath = path15.join(baseDir, ".gitignore");
   try {
     if (existsSync11(gitignorePath)) {
-      const content = readFileSync8(gitignorePath, "utf-8");
+      const content = readFileSync9(gitignorePath, "utf-8");
       if (/^\/?exe\/?$/m.test(content)) return;
       await appendFile(gitignorePath, "\n# Employee task assignments (private)\n/exe/\n");
     } else {
@@ -3802,7 +3964,7 @@ var init_tasks_crud = __esm({
 });
 
 // src/lib/session-registry.ts
-import { readFileSync as readFileSync9, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync12 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, mkdirSync as mkdirSync4, existsSync as existsSync12 } from "fs";
 import path16 from "path";
 import os3 from "os";
 function registerSession(entry) {
@@ -3821,7 +3983,7 @@ function registerSession(entry) {
 }
 function listSessions() {
   try {
-    const raw = readFileSync9(REGISTRY_PATH, "utf8");
+    const raw = readFileSync10(REGISTRY_PATH, "utf8");
     return JSON.parse(raw);
   } catch {
     return [];
@@ -4016,7 +4178,7 @@ var init_provider_table = __esm({
 });
 
 // src/lib/intercom-queue.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync6, renameSync as renameSync2, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync6, renameSync as renameSync2, existsSync as existsSync13, mkdirSync as mkdirSync5 } from "fs";
 import path17 from "path";
 import os4 from "os";
 function ensureDir() {
@@ -4026,7 +4188,7 @@ function ensureDir() {
 function readQueue() {
   try {
     if (!existsSync13(QUEUE_PATH)) return [];
-    return JSON.parse(readFileSync10(QUEUE_PATH, "utf8"));
+    return JSON.parse(readFileSync11(QUEUE_PATH, "utf8"));
   } catch {
     return [];
   }
@@ -4066,7 +4228,7 @@ var init_intercom_queue = __esm({
 
 // src/lib/tmux-routing.ts
 import { execFileSync as execFileSync2, execSync as execSync8 } from "child_process";
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync14, appendFileSync } from "fs";
+import { readFileSync as readFileSync12, writeFileSync as writeFileSync7, mkdirSync as mkdirSync6, existsSync as existsSync14, appendFileSync } from "fs";
 import path18 from "path";
 import os5 from "os";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -4115,7 +4277,7 @@ function extractRootExe(name) {
 }
 function getParentExe(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
+    const data = JSON.parse(readFileSync12(path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`), "utf8"));
     return data.parentExe || null;
   } catch {
     return null;
@@ -4123,7 +4285,7 @@ function getParentExe(sessionKey) {
 }
 function getDispatchedBy(sessionKey) {
   try {
-    const data = JSON.parse(readFileSync11(
+    const data = JSON.parse(readFileSync12(
       path18.join(SESSION_CACHE, `parent-exe-${sessionKey}.json`),
       "utf8"
     ));
@@ -4160,7 +4322,7 @@ function findFreeInstance(employeeName, exeSession, maxInstances = 10, isAlive =
 function readDebounceState() {
   try {
     if (!existsSync14(DEBOUNCE_FILE)) return {};
-    return JSON.parse(readFileSync11(DEBOUNCE_FILE, "utf8"));
+    return JSON.parse(readFileSync12(DEBOUNCE_FILE, "utf8"));
   } catch {
     return {};
   }
@@ -4356,7 +4518,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const claudeJsonPath = path18.join(os5.homedir(), ".claude.json");
     let claudeJson = {};
     try {
-      claudeJson = JSON.parse(readFileSync11(claudeJsonPath, "utf8"));
+      claudeJson = JSON.parse(readFileSync12(claudeJsonPath, "utf8"));
     } catch {
     }
     if (!claudeJson.projects) claudeJson.projects = {};
@@ -4374,7 +4536,7 @@ function spawnEmployee(employeeName, exeSession, projectDir, opts) {
     const settingsPath = path18.join(projSettingsDir, "settings.json");
     let settings = {};
     try {
-      settings = JSON.parse(readFileSync11(settingsPath, "utf8"));
+      settings = JSON.parse(readFileSync12(settingsPath, "utf8"));
     } catch {
     }
     const perms = settings.permissions ?? {};
@@ -4879,7 +5041,7 @@ async function dispatchTaskToEmployee(input) {
     } else {
       const projectDir = input.projectDir ?? process.cwd();
       const result = ensureEmployee(input.assignedTo, exeSession, projectDir, {
-        autoInstance: input.assignedTo === "tom" || input.assignedTo === "sasha"
+        autoInstance: isMultiInstance(input.assignedTo)
       });
       if (result.status === "failed") {
         process.stderr.write(
@@ -4914,6 +5076,7 @@ var init_tasks_notify = __esm({
     init_session_key();
     init_notifications();
     init_transport();
+    init_employees();
   }
 });
 
@@ -5611,7 +5774,7 @@ async function deliverLocalMessage(messageId) {
     return true;
   } catch {
     const newRetryCount = msg.retryCount + 1;
-    if (newRetryCount >= MAX_RETRIES) {
+    if (newRetryCount >= MAX_RETRIES2) {
       await markFailed(messageId, "session unavailable after 10 retries");
     } else {
       await client.execute({
@@ -5629,25 +5792,25 @@ async function markFailed(messageId, reason) {
     args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId]
   });
 }
-var MAX_RETRIES, _wsClientSend;
+var MAX_RETRIES2, _wsClientSend;
 var init_messaging = __esm({
   "src/lib/messaging.ts"() {
     "use strict";
     init_database();
     init_tmux_routing();
-    MAX_RETRIES = 10;
+    MAX_RETRIES2 = 10;
     _wsClientSend = null;
   }
 });
 
 // src/gateway/whatsapp-accounts.ts
-import { readFileSync as readFileSync13 } from "fs";
+import { readFileSync as readFileSync14 } from "fs";
 import { join } from "path";
 import { homedir } from "os";
 function loadAccounts() {
   if (cachedAccounts !== null) return cachedAccounts;
   try {
-    const raw = readFileSync13(CONFIG_PATH2, "utf8");
+    const raw = readFileSync14(CONFIG_PATH2, "utf8");
     const parsed = JSON.parse(raw);
     if (!Array.isArray(parsed)) {
       console.warn("[whatsapp] Config is not an array, ignoring");
@@ -5680,6 +5843,376 @@ var init_whatsapp_accounts = __esm({
   }
 });
 
+// src/lib/consolidation.ts
+var consolidation_exports = {};
+__export(consolidation_exports, {
+  buildConsolidationPrompt: () => buildConsolidationPrompt,
+  consolidateCluster: () => consolidateCluster,
+  countUnconsolidated: () => countUnconsolidated,
+  groupMemories: () => groupMemories,
+  isUserIdle: () => isUserIdle,
+  pushToWiki: () => pushToWiki,
+  runConsolidation: () => runConsolidation,
+  selectUnconsolidated: () => selectUnconsolidated,
+  storeConsolidation: () => storeConsolidation
+});
+import { randomUUID as randomUUID4 } from "crypto";
+async function selectUnconsolidated(client, limit = 200) {
+  const result = await client.execute({
+    sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp
+          FROM memories
+          WHERE consolidated = 0
+            AND timestamp >= datetime('now', '-7 days')
+          ORDER BY timestamp DESC
+          LIMIT ?`,
+    args: [limit]
+  });
+  return result.rows.map((row) => ({
+    id: row.id,
+    agent_id: row.agent_id,
+    project_name: row.project_name,
+    tool_name: row.tool_name,
+    raw_text: row.raw_text,
+    timestamp: row.timestamp
+  }));
+}
+function groupMemories(memories) {
+  const byProject = /* @__PURE__ */ new Map();
+  for (const mem of memories) {
+    const key = `${mem.agent_id}::${mem.project_name}`;
+    const list = byProject.get(key) ?? [];
+    list.push(mem);
+    byProject.set(key, list);
+  }
+  const clusters = [];
+  for (const [key, projectMemories] of byProject) {
+    const [agentId, projectName] = key.split("::");
+    const byDay = /* @__PURE__ */ new Map();
+    for (const mem of projectMemories) {
+      const day = mem.timestamp.slice(0, 10);
+      const list = byDay.get(day) ?? [];
+      list.push(mem);
+      byDay.set(day, list);
+    }
+    for (const [day, dayMemories] of byDay) {
+      if (dayMemories.length <= 15) {
+        clusters.push({
+          agentId,
+          projectName,
+          dateRange: day,
+          memories: dayMemories
+        });
+      } else {
+        for (let i = 0; i < dayMemories.length; i += 12) {
+          const chunk = dayMemories.slice(i, i + 12);
+          clusters.push({
+            agentId,
+            projectName,
+            dateRange: day,
+            memories: chunk
+          });
+        }
+      }
+    }
+  }
+  return clusters;
+}
+function buildConsolidationPrompt(cluster) {
+  const snippets = cluster.memories.map((m, i) => {
+    const text = m.raw_text.length > 200 ? m.raw_text.slice(0, 200) + "..." : m.raw_text;
+    return `${i + 1}. [${m.tool_name}] ${text}`;
+  }).join("\n");
+  return `You are reviewing a set of work memories from an AI coding agent.
+These are raw tool call records from ${cluster.dateRange}.
+
+Agent: ${cluster.agentId} | Project: ${cluster.projectName} | Date: ${cluster.dateRange}
+
+MEMORIES:
+${snippets}
+
+Extract EXACTLY THREE types of insights:
+
+1. KEY DECISIONS \u2014 choices that were made and why (at most 3)
+2. RECURRING PATTERNS \u2014 actions or approaches that repeated (at most 3)
+3. OPEN QUESTIONS \u2014 things that seem unresolved or risky (at most 2)
+
+Format each as a single sentence. Be specific \u2014 include file names,
+function names, and concrete details. Skip if no insight for a category.`;
+}
+async function consolidateCluster(cluster, model) {
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildConsolidationPrompt(cluster);
+  const response = await client.messages.create({
+    model,
+    max_tokens: 300,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  return textBlock?.text ?? "";
+}
+async function storeConsolidation(client, cluster, synthesisText, embedFn) {
+  const consolidatedId = randomUUID4();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const rawText = `CONSOLIDATION [${cluster.dateRange}, ${cluster.projectName}]:
+
+${synthesisText}`;
+  let vector = null;
+  if (embedFn) {
+    try {
+      vector = await embedFn(rawText);
+    } catch {
+    }
+  }
+  const insertSql = vector ? `INSERT INTO memories
+        (id, agent_id, agent_role, session_id, timestamp,
+         tool_name, project_name, has_error, raw_text, vector, version, consolidated, importance)
+        VALUES (?, ?, 'consolidation', 'daemon-consolidation', ?, 'consolidation', ?, 0, ?, vector32(?), 0, 1, 9)` : `INSERT INTO memories
+        (id, agent_id, agent_role, session_id, timestamp,
+         tool_name, project_name, has_error, raw_text, vector, version, consolidated, importance)
+        VALUES (?, ?, 'consolidation', 'daemon-consolidation', ?, 'consolidation', ?, 0, ?, NULL, 0, 1, 9)`;
+  const insertArgs = vector ? [consolidatedId, cluster.agentId, now, cluster.projectName, rawText, vectorToBlob(vector)] : [consolidatedId, cluster.agentId, now, cluster.projectName, rawText];
+  await client.execute({ sql: insertSql, args: insertArgs });
+  const sourceIds = cluster.memories.map((m) => m.id);
+  const linkStmts = sourceIds.map((sourceId) => ({
+    sql: `INSERT INTO consolidations (id, consolidated_memory_id, source_memory_id, created_at)
+          VALUES (?, ?, ?, ?)`,
+    args: [randomUUID4(), consolidatedId, sourceId, now]
+  }));
+  const placeholders = sourceIds.map(() => "?").join(",");
+  const markStmt = {
+    sql: `UPDATE memories SET consolidated = 1 WHERE id IN (${placeholders})`,
+    args: sourceIds
+  };
+  await client.batch([...linkStmts, markStmt], "write");
+  return { consolidatedMemoryId: consolidatedId, sourceIds, rawText };
+}
+async function pushToWiki(consolidation, config2) {
+  if (!config2.wikiEnabled || !config2.wikiAutoUpdate) {
+    return { updated: false };
+  }
+  const apiUrl = config2.wikiUrl || process.env.EXE_WIKI_API_URL;
+  const apiKey = config2.wikiApiKey || process.env.EXE_WIKI_API_KEY;
+  if (!apiUrl || !apiKey) {
+    return { updated: false };
+  }
+  const workspace = config2.wikiWorkspaceMapping[consolidation.projectName] ?? consolidation.projectName;
+  try {
+    const listRes = await fetch(
+      `${apiUrl}/v1/workspace/${encodeURIComponent(workspace)}/documents`,
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      }
+    );
+    if (!listRes.ok) {
+      return { updated: false, error: `Workspace "${workspace}" not accessible (${listRes.status})` };
+    }
+    const listJson = await listRes.json();
+    const docs = listJson.documents ?? listJson.localFiles?.items ?? [];
+    const contentLines = consolidation.rawText.split("\n").filter((l) => l.trim() && !l.startsWith("CONSOLIDATION") && !l.match(/^[A-Z\s]+:$/)).join(" ");
+    const keywords = contentLines.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+    let bestMatch = null;
+    for (const doc of docs) {
+      if (!doc.id || !doc.title) continue;
+      const titleWords = doc.title.toLowerCase().replace(/[^a-z0-9\s]/g, "").split(/\s+/).filter((w) => w.length > 3);
+      if (titleWords.length === 0) continue;
+      const matchCount = titleWords.filter(
+        (tw) => keywords.some((k) => k.includes(tw) || tw.includes(k))
+      ).length;
+      const score = matchCount / titleWords.length;
+      if (score > (bestMatch?.score ?? 0)) {
+        bestMatch = { id: doc.id, title: doc.title, score };
+      }
+    }
+    if (bestMatch && bestMatch.score >= config2.wikiAutoUpdateThreshold) {
+      const updateRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          textContent: consolidation.rawText,
+          metadata: { title: bestMatch.title, appendTo: bestMatch.id },
+          workspaceSlugs: [workspace]
+        }),
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      });
+      if (updateRes.ok) {
+        process.stderr.write(
+          `[consolidation] Wiki auto-updated: ${workspace}/${bestMatch.title}
+`
+        );
+        return { updated: true, action: "updated", page: bestMatch.title };
+      }
+      return { updated: false, error: `Update failed (${updateRes.status})` };
+    }
+    if (config2.wikiAutoUpdateCreateNew) {
+      const title = `Consolidated Insights \u2014 ${consolidation.projectName} (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)})`;
+      const createRes = await fetch(`${apiUrl}/v1/document/raw-text`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          textContent: consolidation.rawText,
+          metadata: { title },
+          workspaceSlugs: [workspace]
+        }),
+        signal: AbortSignal.timeout(WIKI_FETCH_TIMEOUT_MS)
+      });
+      if (createRes.ok) {
+        process.stderr.write(
+          `[consolidation] Wiki page created: ${workspace}/${title}
+`
+        );
+        return { updated: true, action: "created", page: title };
+      }
+      return { updated: false, error: `Create failed (${createRes.status})` };
+    }
+    return { updated: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[consolidation] Wiki push failed: ${msg}
+`);
+    return { updated: false, error: msg };
+  }
+}
+async function runConsolidation(client, options) {
+  const memories = await selectUnconsolidated(client);
+  if (memories.length < 20) {
+    return { clustersProcessed: 0, memoriesConsolidated: 0 };
+  }
+  const clusters = groupMemories(memories);
+  let clustersProcessed = 0;
+  let memoriesConsolidated = 0;
+  for (const cluster of clusters) {
+    if (clustersProcessed >= options.maxCalls) break;
+    if (cluster.memories.length < 3) continue;
+    try {
+      const isExe = cluster.agentId === "exe";
+      if (isExe) {
+        const synthesis = await consolidateCluster(cluster, options.model);
+        if (!synthesis.trim()) continue;
+        const result = await storeConsolidation(client, cluster, synthesis, options.embedFn);
+        if (options.wikiConfig) {
+          await pushToWiki(
+            { ...result, projectName: cluster.projectName },
+            options.wikiConfig
+          ).catch((err) => {
+            process.stderr.write(
+              `[consolidation] Wiki push error (non-fatal): ${err instanceof Error ? err.message : String(err)}
+`
+            );
+          });
+        }
+        const sourceIds = result.sourceIds;
+        if (sourceIds.length > 0) {
+          const placeholders = sourceIds.map(() => "?").join(",");
+          await client.execute({
+            sql: `UPDATE memories SET status = 'archived' WHERE id IN (${placeholders})`,
+            args: sourceIds
+          });
+        }
+      } else {
+        const dedupCount = await dedupCluster(client, cluster, options.embedFn);
+        memoriesConsolidated += dedupCount;
+        if (dedupCount === 0) continue;
+      }
+      clustersProcessed++;
+      memoriesConsolidated += isExe ? cluster.memories.length : 0;
+    } catch (err) {
+      process.stderr.write(
+        `[consolidation] Cluster failed (${cluster.projectName}/${cluster.dateRange}): ${err instanceof Error ? err.message : String(err)}
+`
+      );
+    }
+  }
+  return { clustersProcessed, memoriesConsolidated };
+}
+async function dedupCluster(client, cluster, embedFn) {
+  if (!embedFn || cluster.memories.length < 2) return 0;
+  const vectors = [];
+  for (const mem of cluster.memories) {
+    try {
+      const v = await embedFn(mem.raw_text.slice(0, 500));
+      vectors.push({ id: mem.id, vector: v });
+    } catch {
+    }
+  }
+  if (vectors.length < 2) return 0;
+  const toArchive = /* @__PURE__ */ new Set();
+  for (let i = 0; i < vectors.length; i++) {
+    if (toArchive.has(vectors[i].id)) continue;
+    for (let j = i + 1; j < vectors.length; j++) {
+      if (toArchive.has(vectors[j].id)) continue;
+      const sim = cosineSimilarity(vectors[i].vector, vectors[j].vector);
+      if (sim > 0.95) {
+        toArchive.add(vectors[j].id);
+      }
+    }
+  }
+  if (toArchive.size === 0) return 0;
+  const ids = [...toArchive];
+  const placeholders = ids.map(() => "?").join(",");
+  await client.execute({
+    sql: `UPDATE memories SET status = 'archived', consolidated = 1 WHERE id IN (${placeholders})`,
+    args: ids
+  });
+  const survivors = vectors.filter((v) => !toArchive.has(v.id)).map((v) => v.id);
+  if (survivors.length > 0) {
+    const survivorPlaceholders = survivors.map(() => "?").join(",");
+    await client.execute({
+      sql: `UPDATE memories SET confidence = MIN(1.0, COALESCE(confidence, 0.7) + 0.1) WHERE id IN (${survivorPlaceholders})`,
+      args: survivors
+    });
+  }
+  return ids.length;
+}
+function cosineSimilarity(a, b) {
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+async function isUserIdle(client, idleMinutes = 30) {
+  const result = 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;
+  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({
+    sql: `SELECT COUNT(*) as cnt FROM memories
+          WHERE consolidated = 0
+            AND timestamp >= datetime('now', '-7 days')`,
+    args: []
+  });
+  return Number(result.rows[0]?.cnt ?? 0);
+}
+var WIKI_FETCH_TIMEOUT_MS;
+var init_consolidation = __esm({
+  "src/lib/consolidation.ts"() {
+    "use strict";
+    init_store();
+    WIKI_FETCH_TIMEOUT_MS = 1e4;
+  }
+});
+
 // src/mcp/server.ts
 init_embedder();
 init_store();
@@ -6779,8 +7312,8 @@ function registerCreateTask(server2) {
         try {
           const exeSession = resolveExeSession();
           if (exeSession) {
-            const MULTI_INSTANCE_ROLES = /* @__PURE__ */ new Set(["tom", "sasha"]);
-            const useAutoInstance = MULTI_INSTANCE_ROLES.has(assigned_to);
+            const { isMultiInstance: isMultiInstance2 } = await Promise.resolve().then(() => (init_employees(), employees_exports));
+            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(), {
@@ -7588,7 +8121,7 @@ import { z as z20 } from "zod";
 // src/lib/identity.ts
 init_config();
 init_database();
-import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync12, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync8, readFileSync as readFileSync13, writeFileSync as writeFileSync9 } from "fs";
 import { readdirSync as readdirSync5 } from "fs";
 import path22 from "path";
 import { createHash } from "crypto";
@@ -7641,7 +8174,7 @@ function contentHash(content) {
 function getIdentity(agentId) {
   const filePath = identityPath(agentId);
   if (!existsSync16(filePath)) return null;
-  const raw = readFileSync12(filePath, "utf-8");
+  const raw = readFileSync13(filePath, "utf-8");
   const { frontmatter, body } = parseFrontmatter(raw);
   return {
     agentId,
@@ -8297,7 +8830,6 @@ function registerAcknowledgeMessages(server2) {
       const agent = getActiveAgent();
       const agentId = agent.agentId || "exe";
       const client = getClient();
-      await client.execute({ sql: "PRAGMA busy_timeout = 5000", args: [] });
       const result = await client.execute({
         sql: `UPDATE messages SET status = 'acknowledged', processed_at = datetime('now')
               WHERE target_agent = ? AND status IN ('pending', 'delivered')`,
@@ -8627,7 +9159,7 @@ function registerSendWhatsapp(server2) {
 import { z as z29 } from "zod";
 
 // src/automation/trigger-engine.ts
-import { readFileSync as readFileSync14, writeFileSync as writeFileSync10, existsSync as existsSync17, mkdirSync as mkdirSync9 } from "fs";
+import { readFileSync as readFileSync15, writeFileSync as writeFileSync10, existsSync as existsSync17, mkdirSync as mkdirSync9 } from "fs";
 import { randomUUID as randomUUID3 } from "crypto";
 import path23 from "path";
 import os6 from "os";
@@ -8635,7 +9167,7 @@ var TRIGGERS_PATH = path23.join(os6.homedir(), ".exe-os", "triggers.json");
 function loadTriggers(project) {
   if (!existsSync17(TRIGGERS_PATH)) return [];
   try {
-    const raw = readFileSync14(TRIGGERS_PATH, "utf-8");
+    const raw = readFileSync15(TRIGGERS_PATH, "utf-8");
     const all = JSON.parse(raw);
     if (!Array.isArray(all)) return [];
     if (project) {
@@ -8933,7 +9465,7 @@ function registerListTriggers(server2) {
 import { z as z31 } from "zod";
 
 // src/automation/starter-packs/index.ts
-import { readFileSync as readFileSync15, readdirSync as readdirSync6, existsSync as existsSync18 } from "fs";
+import { readFileSync as readFileSync16, readdirSync as readdirSync6, existsSync as existsSync18 } from "fs";
 import path24 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 var __dirname = path24.dirname(fileURLToPath3(import.meta.url));
@@ -8955,7 +9487,7 @@ function loadPack(industry) {
   let customObjects = [];
   try {
     customObjects = JSON.parse(
-      readFileSync15(objectsPath, "utf-8")
+      readFileSync16(objectsPath, "utf-8")
     );
   } catch {
     customObjects = [];
@@ -8964,7 +9496,7 @@ function loadPack(industry) {
   if (existsSync18(triggersPath)) {
     try {
       triggers = JSON.parse(
-        readFileSync15(triggersPath, "utf-8")
+        readFileSync16(triggersPath, "utf-8")
       );
     } catch {
       triggers = [];
@@ -8974,7 +9506,7 @@ function loadPack(industry) {
   if (existsSync18(wikiDir)) {
     const files = readdirSync6(wikiDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync15(path24.join(wikiDir, file), "utf-8");
+      const content = readFileSync16(path24.join(wikiDir, file), "utf-8");
       const titleMatch = content.match(/^#\s+(.+)/m);
       wikiSeeds.push({
         filename: file,
@@ -8986,7 +9518,7 @@ function loadPack(industry) {
   let manifest = {};
   if (existsSync18(manifestPath)) {
     try {
-      manifest = JSON.parse(readFileSync15(manifestPath, "utf-8"));
+      manifest = JSON.parse(readFileSync16(manifestPath, "utf-8"));
     } catch {
       manifest = {};
     }
@@ -8994,7 +9526,7 @@ function loadPack(industry) {
   let identityContext = null;
   if (existsSync18(identityContextPath)) {
     try {
-      identityContext = readFileSync15(identityContextPath, "utf-8");
+      identityContext = readFileSync16(identityContextPath, "utf-8");
     } catch {
       identityContext = null;
     }
@@ -10474,7 +11006,7 @@ function registerQueryConversations(server2) {
 
 // src/mcp/tools/load-skill.ts
 import { z as z39 } from "zod";
-import { readFileSync as readFileSync16, readdirSync as readdirSync7, statSync as statSync3 } from "fs";
+import { readFileSync as readFileSync17, readdirSync as readdirSync7, statSync as statSync3 } from "fs";
 import path27 from "path";
 import { homedir as homedir2 } from "os";
 var SKILLS_DIR = path27.join(homedir2(), ".claude", "skills");
@@ -10531,7 +11063,7 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
       const sanitized = path27.basename(skill_name);
       const skillFile = path27.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
-        const content = readFileSync16(skillFile, "utf-8");
+        const content = readFileSync17(skillFile, "utf-8");
         return {
           content: [{
             type: "text",
@@ -10557,12 +11089,133 @@ ${available.map((s) => `- ${s}`).join("\n")}` : "\n\nNo skills found in ~/.claud
   );
 }
 
+// src/mcp/tools/consolidate-memories.ts
+init_database();
+init_active_agent();
+import { z as z40 } from "zod";
+function registerConsolidateMemories(server2) {
+  server2.registerTool(
+    "consolidate_memories",
+    {
+      title: "Consolidate Memories",
+      description: "Trigger content-aware memory consolidation. Groups recent memories by project, uses LLM to extract key facts, decisions, and patterns, then stores a high-importance summary and archives the originals. Runs automatically during idle time, but can be triggered manually when you want to compress your working memory.",
+      inputSchema: {
+        max_clusters: z40.coerce.number().optional().default(5).describe("Maximum number of clusters to consolidate (default 5)"),
+        model: z40.string().optional().describe("LLM model for summarization (defaults to config value)")
+      }
+    },
+    async ({ max_clusters, model }) => {
+      const { agentId } = getActiveAgent();
+      try {
+        const { loadConfig: loadConfig2 } = await Promise.resolve().then(() => (init_config(), config_exports));
+        const config2 = await loadConfig2();
+        const consolidationModel = model ?? config2.consolidationModel ?? "claude-haiku-4-5-20251001";
+        const { runConsolidation: runConsolidation2 } = await Promise.resolve().then(() => (init_consolidation(), consolidation_exports));
+        const client = getClient();
+        let embedFn;
+        try {
+          const { embed: embed2 } = await Promise.resolve().then(() => (init_embedder(), embedder_exports));
+          embedFn = embed2;
+        } catch {
+        }
+        const result = await runConsolidation2(client, {
+          model: consolidationModel,
+          maxCalls: max_clusters,
+          embedFn
+        });
+        if (result.clustersProcessed === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: `No consolidation needed \u2014 fewer than 20 unconsolidated memories for ${agentId}.`
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: `Consolidation complete:
+- Clusters processed: ${result.clustersProcessed}
+- Memories consolidated: ${result.memoriesConsolidated}
+
+Consolidated summaries stored as tier-1 (importance=9) memories.`
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Consolidation failed: ${err instanceof Error ? err.message : String(err)}`
+          }]
+        };
+      }
+    }
+  );
+}
+
+// src/lib/telemetry.ts
+var ENABLED = process.env.EXE_TELEMETRY === "1";
+var initialized = false;
+async function ensureInit() {
+  if (initialized || !ENABLED) return;
+  initialized = true;
+  try {
+    const { NodeSDK } = await import("@opentelemetry/sdk-node");
+    const { ConsoleSpanExporter } = await import("@opentelemetry/sdk-trace-base");
+    const sdk = new NodeSDK({
+      serviceName: "exe-os",
+      traceExporter: new ConsoleSpanExporter()
+    });
+    sdk.start();
+    process.stderr.write("[exe-os] OpenTelemetry tracing enabled\n");
+  } catch (err) {
+    process.stderr.write(
+      `[exe-os] OpenTelemetry init failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function withTrace(toolName, fn) {
+  if (!ENABLED) return fn();
+  await ensureInit();
+  const { trace, SpanStatusCode } = await import("@opentelemetry/api");
+  const tracer = trace.getTracer("exe-os", "1.0.0");
+  return tracer.startActiveSpan(`mcp.tool.${toolName}`, async (span) => {
+    span.setAttribute("mcp.tool.name", toolName);
+    try {
+      const result = await fn();
+      span.setStatus({ code: SpanStatusCode.OK });
+      return result;
+    } catch (err) {
+      span.setStatus({
+        code: SpanStatusCode.ERROR,
+        message: err instanceof Error ? err.message : String(err)
+      });
+      span.recordException(
+        err instanceof Error ? err : new Error(String(err))
+      );
+      throw err;
+    } finally {
+      span.end();
+    }
+  });
+}
+function instrumentServer(server2) {
+  if (!ENABLED) return;
+  const original = server2.registerTool.bind(server2);
+  server2.registerTool = (name, config2, handler) => {
+    const traced = async (...args) => withTrace(name, () => handler(...args));
+    return original(name, config2, traced);
+  };
+}
+
 // src/mcp/server.ts
 var server = new McpServer({
   name: "exe-os",
   version: "1.3.0"
 });
 var _backfillTimer = null;
+instrumentServer(server);
 registerRecallMyMemory(server);
 registerAskTeamMemory(server);
 registerGetSessionContext(server);
@@ -10603,6 +11256,7 @@ registerUpdateWikiPage(server);
 registerDeployClient(server);
 registerQueryConversations(server);
 registerLoadSkill(server);
+registerConsolidateMemories(server);
 try {
   await initStore();
   process.stderr.write("[exe-os] MCP server starting...\n");
@@ -10678,3 +11332,18 @@ async function shutdown() {
 }
 process.on("SIGINT", () => void shutdown());
 process.on("SIGTERM", () => void shutdown());
+process.on("uncaughtException", (err) => {
+  process.stderr.write(
+    `[exe-os] uncaughtException (non-fatal): ${err.message}
+`
+  );
+  if (err.stack) {
+    process.stderr.write(`[exe-os]   ${err.stack.split("\n").slice(1, 3).join("\n  ")}
+`);
+  }
+});
+process.on("unhandledRejection", (reason) => {
+  const msg = reason instanceof Error ? reason.message : String(reason);
+  process.stderr.write(`[exe-os] unhandledRejection (non-fatal): ${msg}
+`);
+});