@askexenow/exe-os 0.9.68 → 0.9.69

package/dist/mcp/server.js

@@ -873,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: 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)) {
+  const { existsSync: existsSync41 } = await import("fs");
+  const path52 = await import("path");
+  const modelPath = path52.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync41(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -3691,8 +3691,8 @@ function deriveMachineKey() {
 }
 function readMachineId() {
   try {
-    const { readFileSync: readFileSync32 } = __require("fs");
-    return readFileSync32("/etc/machine-id", "utf-8").trim();
+    const { readFileSync: readFileSync34 } = __require("fs");
+    return readFileSync34("/etc/machine-id", "utf-8").trim();
   } catch {
     return "";
   }
@@ -7267,10 +7267,10 @@ async function hybridSearch(queryText, agentId, options) {
     };
     try {
       const fs = await import("fs");
-      const path50 = await import("path");
+      const path52 = await import("path");
       const os21 = await import("os");
-      const logPath = path50.join(os21.homedir(), ".exe-os", "search-quality.jsonl");
-      fs.mkdirSync(path50.dirname(logPath), { recursive: true });
+      const logPath = path52.join(os21.homedir(), ".exe-os", "search-quality.jsonl");
+      fs.mkdirSync(path52.dirname(logPath), { recursive: true });
       fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
     } catch {
     }
@@ -8223,8 +8223,8 @@ async function validateLicense(apiKey, deviceId) {
 }
 function getCacheAgeMs() {
   try {
-    const { statSync: statSync9 } = __require("fs");
-    const s = statSync9(CACHE_PATH);
+    const { statSync: statSync10 } = __require("fs");
+    const s = statSync10(CACHE_PATH);
     return Date.now() - s.mtimeMs;
   } catch {
     return Infinity;
@@ -8562,8 +8562,8 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path50, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path50}`;
+async function wikiFetch(config2, path52, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path52}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
@@ -8596,7 +8596,7 @@ async function wikiFetch(config2, path50, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path50}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path52}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -9436,8 +9436,8 @@ function logQueue(msg) {
   process.stderr.write(`[intercom-queue] ${msg}
 `);
   try {
-    const { appendFileSync: appendFileSync3 } = __require("fs");
-    appendFileSync3(INTERCOM_LOG, line);
+    const { appendFileSync: appendFileSync4 } = __require("fs");
+    appendFileSync4(INTERCOM_LOG, line);
   } catch {
   }
 }
@@ -13377,14 +13377,14 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync8, writeFileSync as writeFileSync14, unlinkSync as unlinkSync8, mkdirSync as mkdirSync11, existsSync as existsSync24 } from "fs";
-import path29 from "path";
+import { readdirSync as readdirSync8, writeFileSync as writeFileSync15, unlinkSync as unlinkSync8, mkdirSync as mkdirSync12, existsSync as existsSync26 } from "fs";
+import path31 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync11(WORKER_PID_DIR, { recursive: true });
+    mkdirSync12(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path29.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync14(reservationPath, String(process.pid));
+    const reservationPath = path31.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync15(reservationPath, String(process.pid));
     const files = readdirSync8(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -13401,7 +13401,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path29.join(WORKER_PID_DIR, f));
+          unlinkSync8(path31.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -13424,21 +13424,21 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync11(WORKER_PID_DIR, { recursive: true });
-    writeFileSync14(path29.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync12(WORKER_PID_DIR, { recursive: true });
+    writeFileSync15(path31.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path29.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path31.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
-    mkdirSync11(WORKER_PID_DIR, { recursive: true });
-    if (existsSync24(BACKFILL_LOCK)) {
+    mkdirSync12(WORKER_PID_DIR, { recursive: true });
+    if (existsSync26(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -13454,7 +13454,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync14(BACKFILL_LOCK, String(process.pid));
+    writeFileSync15(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -13471,9 +13471,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path29.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path31.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path29.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path31.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -13484,16 +13484,16 @@ __export(key_backup_status_exports, {
   keyBackupMarkerPath: () => keyBackupMarkerPath,
   markKeyBackupConfirmed: () => markKeyBackupConfirmed
 });
-import { existsSync as existsSync26, mkdirSync as mkdirSync12, readFileSync as readFileSync20, writeFileSync as writeFileSync15 } from "fs";
-import path31 from "path";
+import { existsSync as existsSync28, mkdirSync as mkdirSync13, readFileSync as readFileSync22, writeFileSync as writeFileSync16 } from "fs";
+import path33 from "path";
 function keyBackupMarkerPath() {
-  return path31.join(EXE_AI_DIR, "key-backup-confirmed.json");
+  return path33.join(EXE_AI_DIR, "key-backup-confirmed.json");
 }
 function getKeyBackupStatus() {
   const marker = keyBackupMarkerPath();
-  if (!existsSync26(marker)) return { exists: false };
+  if (!existsSync28(marker)) return { exists: false };
   try {
-    const parsed = JSON.parse(readFileSync20(marker, "utf8"));
+    const parsed = JSON.parse(readFileSync22(marker, "utf8"));
     return {
       exists: true,
       confirmedAt: parsed.confirmedAt,
@@ -13504,8 +13504,8 @@ function getKeyBackupStatus() {
   }
 }
 function markKeyBackupConfirmed(source) {
-  mkdirSync12(EXE_AI_DIR, { recursive: true, mode: 448 });
-  writeFileSync15(
+  mkdirSync13(EXE_AI_DIR, { recursive: true, mode: 448 });
+  writeFileSync16(
     keyBackupMarkerPath(),
     JSON.stringify({ confirmedAt: (/* @__PURE__ */ new Date()).toISOString(), source }, null, 2) + "\n",
     { mode: 384 }
@@ -13601,33 +13601,33 @@ __export(db_backup_exports, {
   listBackups: () => listBackups,
   rotateBackups: () => rotateBackups
 });
-import { copyFileSync, existsSync as existsSync27, mkdirSync as mkdirSync13, readdirSync as readdirSync10, unlinkSync as unlinkSync9, statSync as statSync5 } from "fs";
-import path32 from "path";
+import { copyFileSync, existsSync as existsSync29, mkdirSync as mkdirSync14, readdirSync as readdirSync10, unlinkSync as unlinkSync9, statSync as statSync6 } from "fs";
+import path34 from "path";
 function findActiveDb() {
   for (const name of DB_NAMES) {
-    const p = path32.join(EXE_AI_DIR, name);
-    if (existsSync27(p)) return p;
+    const p = path34.join(EXE_AI_DIR, name);
+    if (existsSync29(p)) return p;
   }
   return null;
 }
 function createBackup(reason = "manual") {
   const dbPath = findActiveDb();
   if (!dbPath) return null;
-  mkdirSync13(BACKUP_DIR, { recursive: true });
-  const dbName = path32.basename(dbPath, ".db");
+  mkdirSync14(BACKUP_DIR, { recursive: true });
+  const dbName = path34.basename(dbPath, ".db");
   const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
   const backupName = `${dbName}-${reason}-${timestamp}.db`;
-  const backupPath = path32.join(BACKUP_DIR, backupName);
+  const backupPath = path34.join(BACKUP_DIR, backupName);
   copyFileSync(dbPath, backupPath);
   const walPath = dbPath + "-wal";
-  if (existsSync27(walPath)) {
+  if (existsSync29(walPath)) {
     try {
       copyFileSync(walPath, backupPath + "-wal");
     } catch {
     }
   }
   const shmPath = dbPath + "-shm";
-  if (existsSync27(shmPath)) {
+  if (existsSync29(shmPath)) {
     try {
       copyFileSync(shmPath, backupPath + "-shm");
     } catch {
@@ -13636,16 +13636,16 @@ function createBackup(reason = "manual") {
   return backupPath;
 }
 function rotateBackups(keepDays = DEFAULT_KEEP_DAYS) {
-  if (!existsSync27(BACKUP_DIR)) return 0;
+  if (!existsSync29(BACKUP_DIR)) return 0;
   const cutoff = Date.now() - keepDays * 24 * 60 * 60 * 1e3;
   let deleted = 0;
   try {
     const files = readdirSync10(BACKUP_DIR);
     for (const file of files) {
       if (!file.endsWith(".db") && !file.endsWith(".db-wal") && !file.endsWith(".db-shm")) continue;
-      const filePath = path32.join(BACKUP_DIR, file);
+      const filePath = path34.join(BACKUP_DIR, file);
       try {
-        const stat = statSync5(filePath);
+        const stat = statSync6(filePath);
         if (stat.mtimeMs < cutoff) {
           unlinkSync9(filePath);
           deleted++;
@@ -13658,12 +13658,12 @@ function rotateBackups(keepDays = DEFAULT_KEEP_DAYS) {
   return deleted;
 }
 function listBackups() {
-  if (!existsSync27(BACKUP_DIR)) return [];
+  if (!existsSync29(BACKUP_DIR)) return [];
   try {
     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 = statSync5(p);
+      const p = path34.join(BACKUP_DIR, name);
+      const stat = statSync6(p);
       return { path: p, name, size: stat.size, date: stat.mtime };
     }).sort((a, b) => b.date.getTime() - a.date.getTime());
   } catch {
@@ -13687,7 +13687,7 @@ var init_db_backup = __esm({
   "src/lib/db-backup.ts"() {
     "use strict";
     init_config();
-    BACKUP_DIR = path32.join(EXE_AI_DIR, "backups");
+    BACKUP_DIR = path34.join(EXE_AI_DIR, "backups");
     DEFAULT_KEEP_DAYS = 3;
     DB_NAMES = ["memories.db", "exe-mem.db", "exe-os.db", "exe.db"];
   }
@@ -13712,9 +13712,9 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync16, existsSync as existsSync29, mkdirSync as mkdirSync14, unlinkSync as unlinkSync10 } from "fs";
-import path34 from "path";
-import { homedir as homedir5 } from "os";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync17, existsSync as existsSync31, mkdirSync as mkdirSync15, unlinkSync as unlinkSync10 } from "fs";
+import path36 from "path";
+import { homedir as homedir6 } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
 }
@@ -13725,9 +13725,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync29(sp)) {
+  if (existsSync31(sp)) {
     try {
-      const state = readFileSync22(sp);
+      const state = readFileSync24(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -13869,10 +13869,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path34.dirname(sp);
-    if (!existsSync29(dir)) mkdirSync14(dir, { recursive: true });
+    const dir = path36.dirname(sp);
+    if (!existsSync31(dir)) mkdirSync15(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync16(sp, Buffer.from(state));
+    writeFileSync17(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -13913,7 +13913,7 @@ var DEFAULT_STATE_PATH, _statePathOverride, doc;
 var init_crdt_sync = __esm({
   "src/lib/crdt-sync.ts"() {
     "use strict";
-    DEFAULT_STATE_PATH = path34.join(homedir5(), ".exe-os", "crdt-state.bin");
+    DEFAULT_STATE_PATH = path36.join(homedir6(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -13926,10 +13926,10 @@ 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 existsSync38, openSync as openSync3, mkdirSync as mkdirSync21, closeSync as closeSync3, readFileSync as readFileSync31 } from "fs";
-import path49 from "path";
+import { existsSync as existsSync40, openSync as openSync4, mkdirSync as mkdirSync22, closeSync as closeSync4, readFileSync as readFileSync33 } from "fs";
+import path51 from "path";
 import os20 from "os";
-import { fileURLToPath as fileURLToPath5 } from "url";
+import { fileURLToPath as fileURLToPath6 } from "url";
 
 // src/mcp/tools/memory.ts
 import { z as z10 } from "zod";
@@ -15313,10 +15313,10 @@ function registerCreateTask(server2) {
         skipDispatch: true
       });
       try {
-        const { existsSync: existsSync39, mkdirSync: mkdirSync22, writeFileSync: writeFileSync23 } = await import("fs");
+        const { existsSync: existsSync41, mkdirSync: mkdirSync23, writeFileSync: writeFileSync24 } = await import("fs");
         const { identityPath: identityPath2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
         const idPath = identityPath2(assigned_to);
-        if (!existsSync39(idPath)) {
+        if (!existsSync41(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);
@@ -15325,8 +15325,8 @@ function registerCreateTask(server2) {
             const template = getTemplateForTitle2(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync39(dir)) mkdirSync22(dir, { recursive: true });
-              writeFileSync23(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+              if (!existsSync41(dir)) mkdirSync23(dir, { recursive: true });
+              writeFileSync24(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
         }
@@ -18288,12 +18288,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path50 = await import("path");
+        const path52 = await import("path");
         const os21 = await import("os");
-        const outDir = path50.join(os21.homedir(), ".exe-os", "exports");
+        const outDir = path52.join(os21.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path50.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path52.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -18808,7 +18808,7 @@ function registerGraph(server2) {
 }
 
 // src/mcp/tools/config.ts
-import { z as z73 } from "zod";
+import { z as z74 } from "zod";
 
 // src/mcp/tools/set-agent-config.ts
 init_active_agent();
@@ -19346,10 +19346,133 @@ function registerGetSessionKills(server2) {
 
 // src/mcp/tools/get-daemon-health.ts
 import { z as z53 } from "zod";
-import { existsSync as existsSync22, readFileSync as readFileSync18 } from "fs";
-import path28 from "path";
+import { existsSync as existsSync23, readFileSync as readFileSync19 } from "fs";
+import path29 from "path";
 import { homedir as homedir3 } from "os";
-var PID_PATH2 = path28.join(homedir3(), ".exe-os", "exed.pid");
+
+// src/lib/mcp-transport-health.ts
+init_config();
+import { appendFileSync as appendFileSync2, closeSync as closeSync2, existsSync as existsSync22, mkdirSync as mkdirSync11, openSync as openSync2, readFileSync as readFileSync18, readSync, statSync as statSync5, writeFileSync as writeFileSync13 } from "fs";
+import path28 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+var MCP_HTTP_EVENTS_PATH = path28.join(EXE_AI_DIR, "mcp-http-events.jsonl");
+var MCP_MONITOR_DIR = path28.join(EXE_AI_DIR, "monitor");
+var MCP_TRANSPORT_SUMMARY_PATH = path28.join(MCP_MONITOR_DIR, "mcp-transport-summary.json");
+var DEFAULT_EVENT_READ_BYTES = 256 * 1024;
+var DEFAULT_EVENT_MAX_BYTES = 1024 * 1024;
+var EVENT_READ_BYTES = parsePositiveInt(process.env.EXE_MCP_HTTP_EVENT_READ_BYTES, DEFAULT_EVENT_READ_BYTES);
+var EVENT_MAX_BYTES = parsePositiveInt(process.env.EXE_MCP_HTTP_EVENT_MAX_BYTES, DEFAULT_EVENT_MAX_BYTES);
+function parsePositiveInt(value, fallback) {
+  if (!value) return fallback;
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function readTailText(filePath, maxBytes) {
+  const stats = statSync5(filePath);
+  if (stats.size <= maxBytes) return readFileSync18(filePath, "utf8");
+  const fd = openSync2(filePath, "r");
+  try {
+    const buffer = Buffer.allocUnsafe(maxBytes);
+    readSync(fd, buffer, 0, maxBytes, stats.size - maxBytes);
+    const text3 = buffer.toString("utf8");
+    const firstNewline = text3.indexOf("\n");
+    return firstNewline >= 0 ? text3.slice(firstNewline + 1) : text3;
+  } finally {
+    closeSync2(fd);
+  }
+}
+function readPackageVersion() {
+  let dir = path28.dirname(fileURLToPath3(import.meta.url));
+  const { root } = path28.parse(dir);
+  while (dir !== root) {
+    const pkgPath = path28.join(dir, "package.json");
+    if (existsSync22(pkgPath)) {
+      try {
+        const parsed = JSON.parse(readFileSync18(pkgPath, "utf8"));
+        return parsed.version ?? "unknown";
+      } catch {
+        return "unknown";
+      }
+    }
+    dir = path28.dirname(dir);
+  }
+  return "unknown";
+}
+function parseMcpHttpEventLines(raw, limit = 200) {
+  const lines = raw.trim().split("\n").filter(Boolean).slice(-limit);
+  const events = [];
+  for (const line of lines) {
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
+}
+function readMcpHttpEvents(limit = 200) {
+  if (!existsSync22(MCP_HTTP_EVENTS_PATH)) return [];
+  const raw = readTailText(MCP_HTTP_EVENTS_PATH, EVENT_READ_BYTES);
+  return parseMcpHttpEventLines(raw, limit);
+}
+function summarizeMcpTransport(events = readMcpHttpEvents()) {
+  const lastServerStartIndex = events.map((event) => event.message).lastIndexOf("server_started");
+  const scopedEvents = lastServerStartIndex >= 0 ? events.slice(lastServerStartIndex) : events;
+  const activeSessionEvent = [...scopedEvents].reverse().find((event) => typeof event.activeSessions === "number");
+  const successfulToolCalls = scopedEvents.filter((event) => event.message === "tool_call_ok");
+  const lastSuccessfulToolCall = successfulToolCalls.at(-1) ?? null;
+  const summary = {
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    version: readPackageVersion(),
+    scope: "local",
+    privacy: "metadata_only",
+    eventLogPath: MCP_HTTP_EVENTS_PATH,
+    activeSessions: activeSessionEvent?.activeSessions ?? null,
+    sessionsCreated: scopedEvents.filter((event) => event.message === "session_initialized").length,
+    sessionsClosed: scopedEvents.filter((event) => event.message === "session_closed").length,
+    missingSessionErrors: scopedEvents.filter((event) => event.message?.includes("missing MCP session")).length,
+    staleSessionErrors: scopedEvents.filter((event) => event.message?.includes("stale or unknown")).length,
+    transportErrors: scopedEvents.filter((event) => event.level === "warn" || event.level === "error").length,
+    lastSuccessfulHandshake: scopedEvents.filter((event) => event.message === "session_initialized").at(-1)?.timestamp ?? null,
+    lastSuccessfulToolCall: lastSuccessfulToolCall?.timestamp ?? null,
+    lastSuccessfulToolCallByRuntime: {},
+    lastSuccessfulToolCallByAgent: {},
+    lastSuccessfulToolCallByFamily: {},
+    activeSessionsByRuntime: {},
+    recentWarnings: scopedEvents.filter((event) => event.level === "warn" || event.level === "error").slice(-10),
+    remediation: [
+      "If MCP tools fail with missing/stale session, reconnect the MCP client (/mcp or restart the runtime).",
+      "Do not access the database directly; MCP is the only data interface.",
+      "Check get_daemon_health or exe-healthcheck for daemon/MCP endpoint status before retrying work."
+    ]
+  };
+  const createdBySession = /* @__PURE__ */ new Map();
+  for (const event of scopedEvents) {
+    if (event.message === "session_initialized" && event.sessionId) createdBySession.set(event.sessionId, event);
+    if ((event.message === "session_closed" || event.message === "session_expired") && event.sessionId) {
+      createdBySession.delete(event.sessionId);
+    }
+  }
+  for (const event of createdBySession.values()) {
+    const runtime = event.runtime ?? "Unknown";
+    summary.activeSessionsByRuntime[runtime] = (summary.activeSessionsByRuntime[runtime] ?? 0) + 1;
+  }
+  for (const event of successfulToolCalls) {
+    if (event.runtime) summary.lastSuccessfulToolCallByRuntime[event.runtime] = event.timestamp ?? "";
+    if (event.agentId) summary.lastSuccessfulToolCallByAgent[event.agentId] = event.timestamp ?? "";
+    if (event.toolFamily) summary.lastSuccessfulToolCallByFamily[event.toolFamily] = event.timestamp ?? "";
+  }
+  return summary;
+}
+function writeMcpTransportSummary(events) {
+  try {
+    mkdirSync11(MCP_MONITOR_DIR, { recursive: true });
+    writeFileSync13(MCP_TRANSPORT_SUMMARY_PATH, JSON.stringify(summarizeMcpTransport(events), null, 2) + "\n");
+  } catch {
+  }
+}
+
+// src/mcp/tools/get-daemon-health.ts
+var PID_PATH2 = path29.join(homedir3(), ".exe-os", "exed.pid");
 function formatUptime(seconds) {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor(seconds % 3600 / 60);
@@ -19360,8 +19483,8 @@ function formatUptime(seconds) {
 }
 function isDaemonAlive() {
   try {
-    if (!existsSync22(PID_PATH2)) return { alive: false, pid: null };
-    const pid = parseInt(readFileSync18(PID_PATH2, "utf8").trim(), 10);
+    if (!existsSync23(PID_PATH2)) return { alive: false, pid: null };
+    const pid = parseInt(readFileSync19(PID_PATH2, "utf8").trim(), 10);
     if (isNaN(pid) || pid <= 0) return { alive: false, pid: null };
     process.kill(pid, 0);
     return { alive: true, pid };
@@ -19408,6 +19531,27 @@ function registerGetDaemonHealth(server2) {
           lines.push(`| Uptime | ${formatUptime(health.uptime)} |`);
           lines.push(`| Requests served | ${health.requests_served.toLocaleString()} |`);
         }
+        const events = readMcpHttpEvents(50);
+        const summary = summarizeMcpTransport(events);
+        const lastEvent = events.at(-1);
+        lines.push(`| MCP HTTP events | ${events.length > 0 ? `${events.length} recent` : "none recorded"} |`);
+        lines.push(`| MCP HTTP active sessions | ${summary.activeSessions ?? "unknown"} |`);
+        lines.push(`| Last MCP handshake | ${summary.lastSuccessfulHandshake ?? "none"} |`);
+        lines.push(`| Last MCP tool call | ${summary.lastSuccessfulToolCall ?? "none"} |`);
+        lines.push(`| MCP monitor summary | ${summary.eventLogPath.replace("mcp-http-events.jsonl", "monitor/mcp-transport-summary.json")} |`);
+        if (lastEvent) {
+          lines.push(`| Last MCP HTTP event | ${lastEvent.timestamp ?? "unknown"} ${lastEvent.message ?? "unknown"} |`);
+        }
+        if (summary.recentWarnings.length > 0) {
+          lines.push("\n### Recent MCP HTTP warnings");
+          for (const event of summary.recentWarnings.slice(-5)) {
+            lines.push(
+              `- ${event.timestamp ?? "unknown"} \u2014 ${event.message ?? "unknown"} (agent=${event.agentId ?? "unknown"}, session=${event.sessionId ?? "none"})`
+            );
+          }
+        }
+        lines.push("\n### Agent remediation");
+        for (const item of summary.remediation) lines.push(`- ${item}`);
         return {
           content: [{ type: "text", text: lines.join("\n") }]
         };
@@ -19425,24 +19569,73 @@ function registerGetDaemonHealth(server2) {
   );
 }
 
+// src/mcp/tools/mcp-ping.ts
+import { existsSync as existsSync24, readFileSync as readFileSync20 } from "fs";
+import path30 from "path";
+import { homedir as homedir4 } from "os";
+import { z as z54 } from "zod";
+var PID_PATH3 = path30.join(homedir4(), ".exe-os", "exed.pid");
+function isDaemonAlive2() {
+  try {
+    if (!existsSync24(PID_PATH3)) return { alive: false, pid: null };
+    const pid = parseInt(readFileSync20(PID_PATH3, "utf8").trim(), 10);
+    if (!Number.isFinite(pid) || pid <= 0) return { alive: false, pid: null };
+    process.kill(pid, 0);
+    return { alive: true, pid };
+  } catch {
+    return { alive: false, pid: null };
+  }
+}
+function registerMcpPing(server2) {
+  server2.registerTool(
+    "mcp_ping",
+    {
+      title: "MCP Ping",
+      description: "Safe local MCP synthetic probe: daemon liveness plus privacy-safe transport/session summary.",
+      inputSchema: {
+        _placeholder: z54.string().optional().describe("No input required")
+      }
+    },
+    async () => {
+      const daemon = isDaemonAlive2();
+      const summary = summarizeMcpTransport();
+      writeMcpTransportSummary();
+      const status = daemon.alive ? "ok" : "degraded";
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              status,
+              daemon,
+              mcpTransport: summary,
+              remediation: daemon.alive ? "MCP transport probe reached the server. If tools still fail, reconnect the MCP client." : "Daemon is offline. Restart exe-os/exed; do not bypass MCP or access the DB directly."
+            }, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
 // src/mcp/tools/get-auto-wake-status.ts
 init_database();
 init_session_registry();
-import { z as z54 } from "zod";
+import { z as z55 } from "zod";
 
 // src/lib/daemon-orchestration.ts
 init_tmux_routing();
 init_task_scope();
 init_employees();
 import { execSync as execSync10 } from "child_process";
-import { existsSync as existsSync23, readFileSync as readFileSync19, writeFileSync as writeFileSync13 } from "fs";
-import { homedir as homedir4 } from "os";
+import { existsSync as existsSync25, readFileSync as readFileSync21, writeFileSync as writeFileSync14 } from "fs";
+import { homedir as homedir5 } from "os";
 import { join as join3 } from "path";
 var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
 var SESSION_TTL_HOURS = Number(process.env.EXE_SESSION_TTL_HOURS) || 4;
 var SESSION_CONTEXT_THRESHOLD_PCT = Number(process.env.EXE_CONTEXT_KILL_PCT) || 50;
 var IDLE_KILL_INTERCOM_ACK_WINDOW_MS = Number(process.env.EXE_INTERCOM_ACK_WINDOW_MS) || 1e4;
-var NUDGE_STATE_PATH = join3(homedir4(), ".exe-os", "review-nudge-state.json");
+var NUDGE_STATE_PATH = join3(homedir5(), ".exe-os", "review-nudge-state.json");
 var AUTO_WAKE_COOLDOWN_MS = 5 * 60 * 1e3;
 var AUTO_WAKE_MAX_RETRIES = 3;
 
@@ -19456,7 +19649,7 @@ function registerGetAutoWakeStatus(server2) {
       title: "Get Auto-Wake Status",
       description: "Check auto-wake status: orphaned tasks (assigned agent has no running session), tasks blocked by auto-wake retry limit, and session activity.",
       inputSchema: {
-        _placeholder: z54.string().optional().describe("No input required")
+        _placeholder: z55.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -19537,16 +19730,16 @@ function registerGetAutoWakeStatus(server2) {
 // src/mcp/tools/get-worker-gate.ts
 init_worker_gate();
 init_config();
-import { z as z55 } from "zod";
-import { readdirSync as readdirSync9, existsSync as existsSync25 } from "fs";
-import path30 from "path";
-var WORKER_PID_DIR2 = path30.join(EXE_AI_DIR, "worker-pids");
+import { z as z56 } from "zod";
+import { readdirSync as readdirSync9, existsSync as existsSync27 } from "fs";
+import path32 from "path";
+var WORKER_PID_DIR2 = path32.join(EXE_AI_DIR, "worker-pids");
 function countAliveWorkers() {
   let alive = 0;
   let stale = 0;
   let reservations = 0;
   try {
-    if (!existsSync25(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
+    if (!existsSync27(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
     const files = readdirSync9(WORKER_PID_DIR2);
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -19575,7 +19768,7 @@ function registerGetWorkerGate(server2) {
       title: "Get Worker Gate",
       description: "Check worker concurrency gate status: how many worker slots are in use, the maximum allowed, and whether new workers can spawn.",
       inputSchema: {
-        _placeholder: z55.string().optional().describe("No input required")
+        _placeholder: z56.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -19611,20 +19804,20 @@ function registerGetWorkerGate(server2) {
 
 // src/mcp/tools/run-memory-audit.ts
 init_database();
-import { z as z56 } from "zod";
+import { z as z57 } from "zod";
 
 // src/bin/exe-doctor.ts
 import os14 from "os";
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
-import { fileURLToPath as fileURLToPath3 } from "url";
+import { fileURLToPath as fileURLToPath4 } from "url";
 function isMainModule(importMetaUrl) {
   if (process.argv[1] == null) return false;
   if (process.argv[1].includes("mcp/server")) return false;
   try {
     const scriptPath = realpathSync(process.argv[1]);
-    const modulePath = realpathSync(fileURLToPath3(importMetaUrl));
+    const modulePath = realpathSync(fileURLToPath4(importMetaUrl));
     return scriptPath === modulePath;
   } catch {
     return importMetaUrl === `file://${process.argv[1]}` || importMetaUrl === new URL(process.argv[1], "file://").href;
@@ -19632,9 +19825,9 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/exe-doctor.ts
-import { existsSync as existsSync28, readFileSync as readFileSync21 } from "fs";
+import { existsSync as existsSync30, readFileSync as readFileSync23 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path33 from "path";
+import path35 from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // src/lib/conflict-detector.ts
@@ -20182,7 +20375,7 @@ async function auditOrphanedProjects(client) {
   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));
+    const exists = existsSync30(path35.join(home, name)) || existsSync30(path35.join(home, "..", name)) || existsSync30(path35.join(process.cwd(), "..", name));
     if (!exists) {
       orphans.push({ project_name: name, count });
     }
@@ -20190,18 +20383,18 @@ async function auditOrphanedProjects(client) {
   return orphans;
 }
 function auditHookHealth() {
-  const logPath = path33.join(
+  const logPath = path35.join(
     process.env.HOME ?? process.env.USERPROFILE ?? "",
     ".exe-os",
     "logs",
     "hooks.log"
   );
-  if (!existsSync28(logPath)) {
+  if (!existsSync30(logPath)) {
     return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
   }
   let content;
   try {
-    content = readFileSync21(logPath, "utf-8");
+    content = readFileSync23(logPath, "utf-8");
   } catch {
     return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
   }
@@ -20230,9 +20423,9 @@ function auditHookHealth() {
   return { logExists: true, totalLines, errorsLastHour, topPatterns };
 }
 function safeReadJson(filePath) {
-  if (!existsSync28(filePath)) return null;
+  if (!existsSync30(filePath)) return null;
   try {
-    return JSON.parse(readFileSync21(filePath, "utf-8"));
+    return JSON.parse(readFileSync23(filePath, "utf-8"));
   } catch {
     return null;
   }
@@ -20326,13 +20519,13 @@ function auditHookOwnership() {
   const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
   const checkedFiles = [];
   const issues = [];
-  const claudeSettingsPath = path33.join(home, ".claude", "settings.json");
+  const claudeSettingsPath = path35.join(home, ".claude", "settings.json");
   const claudeSettings = safeReadJson(claudeSettingsPath);
   if (claudeSettings) {
     checkedFiles.push(claudeSettingsPath);
     issues.push(...buildHookOwnershipIssues("claude", collectHookCommandsFromClaudeSettings(claudeSettings)));
   }
-  const codexHooksPath = path33.join(home, ".codex", "hooks.json");
+  const codexHooksPath = path35.join(home, ".codex", "hooks.json");
   const codexHooks = safeReadJson(codexHooksPath);
   if (codexHooks) {
     checkedFiles.push(codexHooksPath);
@@ -20596,7 +20789,7 @@ async function fixNullVectors() {
     }
   }
   const npmRoot = (await import("child_process")).execSync("npm root -g", { encoding: "utf8" }).trim();
-  const backfillPath = path33.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
+  const backfillPath = path35.join(npmRoot, "exe-os", "dist", "bin", "backfill-vectors.js");
   return new Promise((resolve, reject) => {
     const child = spawn2("node", [backfillPath], { stdio: "inherit" });
     if (child.pid) registerWorkerPid2(child.pid);
@@ -20781,8 +20974,8 @@ function registerRunMemoryAudit(server2) {
       title: "Run Memory Audit",
       description: "Run a memory health audit: total counts, per-agent breakdown, null vectors, duplicates, FTS sync status, bloated records, and conflict detection (contradictory/superseded memories).",
       inputSchema: {
-        agent_id: z56.string().optional().describe("Filter audit to a specific agent"),
-        project_name: z56.string().optional().describe("Filter audit to a specific project")
+        agent_id: z57.string().optional().describe("Filter audit to a specific agent"),
+        project_name: z57.string().optional().describe("Filter audit to a specific project")
       }
     },
     async ({ agent_id, project_name }) => {
@@ -20820,7 +21013,7 @@ function registerRunMemoryAudit(server2) {
 init_database();
 init_consolidation();
 init_config();
-import { z as z57 } from "zod";
+import { z as z58 } from "zod";
 function registerRunConsolidation(server2) {
   server2.registerTool(
     "run_consolidation",
@@ -20828,7 +21021,7 @@ function registerRunConsolidation(server2) {
       title: "Run Consolidation",
       description: "Run memory consolidation \u2014 synthesizes unconsolidated memories into meta-insights. Use dry_run=true (default) to preview without executing.",
       inputSchema: {
-        dry_run: z57.boolean().default(true).describe("Preview mode \u2014 show what would be consolidated without doing it")
+        dry_run: z58.boolean().default(true).describe("Preview mode \u2014 show what would be consolidated without doing it")
       }
     },
     async ({ dry_run }) => {
@@ -20896,14 +21089,14 @@ function registerRunConsolidation(server2) {
 }
 
 // src/mcp/tools/cloud-sync.ts
-import { z as z58 } from "zod";
+import { z as z59 } 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 statSync6 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync18, existsSync as existsSync32, readdirSync as readdirSync11, mkdirSync as mkdirSync16, appendFileSync as appendFileSync3, unlinkSync as unlinkSync11, openSync as openSync3, closeSync as closeSync3, statSync as statSync7 } from "fs";
 import crypto15 from "crypto";
-import path35 from "path";
-import { homedir as homedir6 } from "os";
+import path37 from "path";
+import { homedir as homedir7 } from "os";
 
 // src/lib/crypto.ts
 import crypto14 from "crypto";
@@ -20977,8 +21170,8 @@ function sqlSafe(v) {
 }
 function logError(msg) {
   try {
-    const logPath = path35.join(homedir6(), ".exe-os", "workers.log");
-    appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
+    const logPath = path37.join(homedir7(), ".exe-os", "workers.log");
+    appendFileSync3(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
   }
@@ -20986,7 +21179,7 @@ function logError(msg) {
 var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
 var FETCH_TIMEOUT_MS2 = 3e4;
 var PUSH_BATCH_SIZE = 5e3;
-var ROSTER_LOCK_PATH = path35.join(EXE_AI_DIR, "roster-merge.lock");
+var ROSTER_LOCK_PATH = path37.join(EXE_AI_DIR, "roster-merge.lock");
 var LOCK_STALE_MS = 3e4;
 var _pgPromise = null;
 var _pgFailed = false;
@@ -20995,12 +21188,12 @@ function isTruthyEnv(value) {
 }
 function loadPgClient() {
   if (_pgFailed) return null;
-  const configPath = path35.join(EXE_AI_DIR, "config.json");
+  const configPath = path37.join(EXE_AI_DIR, "config.json");
   let cloudPostgresUrl;
   let configEnabled = false;
   try {
-    if (existsSync30(configPath)) {
-      const cfg = JSON.parse(readFileSync23(configPath, "utf8"));
+    if (existsSync32(configPath)) {
+      const cfg = JSON.parse(readFileSync25(configPath, "utf8"));
       cloudPostgresUrl = cfg.cloud?.postgresUrl;
       configEnabled = cfg.cloud?.syncToPostgres === true;
     }
@@ -21027,9 +21220,9 @@ function loadPgClient() {
         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 packagePath = path35.join(exeDbRoot, "package.json");
-      if (existsSync30(packagePath)) {
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path37.join(homedir7(), "exe-db");
+      const packagePath = path37.join(exeDbRoot, "package.json");
+      if (existsSync32(packagePath)) {
         const req = createRequire6(packagePath);
         const entry = req.resolve("@prisma/client");
         const mod = await import(pathToFileURL6(entry).href);
@@ -21089,20 +21282,20 @@ async function pushToPostgres(records) {
 }
 async function withRosterLock(fn) {
   try {
-    const fd = openSync2(ROSTER_LOCK_PATH, "wx");
-    closeSync2(fd);
-    writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
+    const fd = openSync3(ROSTER_LOCK_PATH, "wx");
+    closeSync3(fd);
+    writeFileSync18(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts2 = parseInt(readFileSync23(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts2 = parseInt(readFileSync25(ROSTER_LOCK_PATH, "utf-8"), 10);
         if (Date.now() - ts2 < LOCK_STALE_MS) {
           throw new Error("Roster merge already in progress \u2014 another sync is running");
         }
         unlinkSync11(ROSTER_LOCK_PATH);
-        const fd = openSync2(ROSTER_LOCK_PATH, "wx");
-        closeSync2(fd);
-        writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
+        const fd = openSync3(ROSTER_LOCK_PATH, "wx");
+        closeSync3(fd);
+        writeFileSync18(ROSTER_LOCK_PATH, String(Date.now()));
       } catch (retryErr) {
         if (retryErr instanceof Error && retryErr.message.includes("already in progress")) throw retryErr;
         throw new Error("Roster merge already in progress \u2014 another sync is running");
@@ -21532,8 +21725,8 @@ async function cloudSync(config2) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path35.join(EXE_AI_DIR, "identity");
-    if (existsSync30(idDir)) {
+    const idDir = path37.join(EXE_AI_DIR, "identity");
+    if (existsSync32(idDir)) {
       rosterResult.identities = readdirSync11(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -21543,10 +21736,10 @@ async function cloudSync(config2) {
     const { getLatestBackup: getLatestBackup2 } = await Promise.resolve().then(() => (init_db_backup(), db_backup_exports));
     const latestBackup = getLatestBackup2();
     if (latestBackup) {
-      const backupSize = statSync6(latestBackup).size;
+      const backupSize = statSync7(latestBackup).size;
       const MAX_CLOUD_BACKUP_BYTES = 50 * 1024 * 1024;
       if (backupSize <= MAX_CLOUD_BACKUP_BYTES) {
-        const backupData = readFileSync23(latestBackup);
+        const backupData = readFileSync25(latestBackup);
         const deviceId = loadDeviceId() ?? "unknown";
         const encrypted = encryptSyncBlob(backupData);
         const backupRes = await fetchWithRetry(`${config2.endpoint}/sync/push-db-backup`, {
@@ -21554,7 +21747,7 @@ async function cloudSync(config2) {
           headers: { "Content-Type": "application/json", Authorization: `Bearer ${config2.apiKey}` },
           body: JSON.stringify({
             device_id: deviceId,
-            filename: path35.basename(latestBackup),
+            filename: path37.basename(latestBackup),
             blob: encrypted,
             size: backupData.length
           })
@@ -21579,49 +21772,49 @@ async function cloudSync(config2) {
     roster: rosterResult
   };
 }
-var ROSTER_DELETIONS_PATH = path35.join(EXE_AI_DIR, "roster-deletions.json");
+var ROSTER_DELETIONS_PATH = path37.join(EXE_AI_DIR, "roster-deletions.json");
 function consumeRosterDeletions() {
   try {
-    if (!existsSync30(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync23(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync17(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync32(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync25(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync18(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
     return [];
   }
 }
 function buildRosterBlob(paths) {
-  const rosterPath = paths?.rosterPath ?? path35.join(EXE_AI_DIR, "exe-employees.json");
-  const identityDir = paths?.identityDir ?? path35.join(EXE_AI_DIR, "identity");
-  const configPath = paths?.configPath ?? path35.join(EXE_AI_DIR, "config.json");
+  const rosterPath = paths?.rosterPath ?? path37.join(EXE_AI_DIR, "exe-employees.json");
+  const identityDir = paths?.identityDir ?? path37.join(EXE_AI_DIR, "identity");
+  const configPath = paths?.configPath ?? path37.join(EXE_AI_DIR, "config.json");
   let roster = [];
-  if (existsSync30(rosterPath)) {
+  if (existsSync32(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync23(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync25(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync30(identityDir)) {
+  if (existsSync32(identityDir)) {
     for (const file of readdirSync11(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync23(path35.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync25(path37.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config2;
-  if (existsSync30(configPath)) {
+  if (existsSync32(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync23(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync25(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync30(agentConfigPath)) {
+  const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync32(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync23(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
     } catch {
     }
   }
@@ -21697,24 +21890,24 @@ async function cloudPullRoster(config2) {
   }
 }
 function mergeConfig(remoteConfig, configPath) {
-  const cfgPath = configPath ?? path35.join(EXE_AI_DIR, "config.json");
+  const cfgPath = configPath ?? path37.join(EXE_AI_DIR, "config.json");
   let local = {};
-  if (existsSync30(cfgPath)) {
+  if (existsSync32(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync23(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync25(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path35.dirname(cfgPath);
+  const dir = path37.dirname(cfgPath);
   ensurePrivateDirSync(dir);
-  writeFileSync17(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  writeFileSync18(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
   enforcePrivateFileSync(cfgPath);
 }
 async function mergeRosterFromRemote(remote, paths) {
   return withRosterLock(async () => {
     const rosterPath = paths?.rosterPath ?? void 0;
-    const identityDir = paths?.identityDir ?? path35.join(EXE_AI_DIR, "identity");
+    const identityDir = paths?.identityDir ?? path37.join(EXE_AI_DIR, "identity");
     const localEmployees = await loadEmployees(rosterPath);
     const localNames = new Set(localEmployees.map((e) => e.name));
     let added = 0;
@@ -21735,15 +21928,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync30(identityDir)) mkdirSync15(identityDir, { recursive: true });
-        const idPath = path35.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync32(identityDir)) mkdirSync16(identityDir, { recursive: true });
+        const idPath = path37.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync30(idPath) ? readFileSync23(idPath, "utf-8") : null;
+          localIdentity = existsSync32(idPath) ? readFileSync25(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync17(idPath, remoteIdentity, "utf-8");
+          writeFileSync18(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -21769,17 +21962,17 @@ async function mergeRosterFromRemote(remote, paths) {
     }
     if (remote.agentConfig && Object.keys(remote.agentConfig).length > 0) {
       try {
-        const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
+        const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
         let local = {};
-        if (existsSync30(agentConfigPath)) {
+        if (existsSync32(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync23(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        ensurePrivateDirSync(path35.dirname(agentConfigPath));
-        writeFileSync17(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        ensurePrivateDirSync(path37.dirname(agentConfigPath));
+        writeFileSync18(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
         enforcePrivateFileSync(agentConfigPath);
       } catch {
       }
@@ -22290,9 +22483,9 @@ function registerCloudSync(server2) {
       title: "Cloud Sync",
       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: {
-        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".')
+        action: z59.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: z59.boolean().default(false).describe("Reserved for sync compatibility; normal cloud sync already runs when requested."),
+        confirm_local_db_source_of_truth: z59.string().optional().describe('Required for action=reupload. Must exactly equal "LOCAL DB IS SOURCE OF TRUTH".')
       }
     },
     async ({ action = "sync", confirm_local_db_source_of_truth }) => {
@@ -22364,7 +22557,7 @@ function registerCloudSync(server2) {
 }
 
 // src/mcp/tools/orchestration-phase.ts
-import { z as z59 } from "zod";
+import { z as z60 } from "zod";
 
 // src/lib/orchestration-phase.ts
 init_config();
@@ -22450,8 +22643,8 @@ function registerOrchestrationPhase(server2) {
       title: "Orchestration Phase",
       description: "View or change the customer-owned orchestration maturity phase. MCP parity for `exe-os org phase`, `exe-os org unlock executives`, and `exe-os org unlock parallel`. This is a recommendation layer, not a blocker; it never exposes recovery phrases or secrets.",
       inputSchema: {
-        action: z59.enum(["status", "set", "unlock_executives", "unlock_parallel"]).default("status"),
-        phase: z59.enum(["phase_1_coo", "phase_2_executives", "phase_3_parallel_org", "1", "2", "3"]).optional().describe("Phase to set when action='set'.")
+        action: z60.enum(["status", "set", "unlock_executives", "unlock_parallel"]).default("status"),
+        phase: z60.enum(["phase_1_coo", "phase_2_executives", "phase_3_parallel_org", "1", "2", "3"]).optional().describe("Phase to set when action='set'.")
       }
     },
     async ({ action = "status", phase }) => {
@@ -22492,7 +22685,7 @@ function registerOrchestrationPhase(server2) {
 
 // src/mcp/tools/backup-vps.ts
 init_keychain();
-import { z as z60 } from "zod";
+import { z as z61 } from "zod";
 
 // src/lib/vps-backup.ts
 import { createCipheriv, createDecipheriv, randomBytes } from "crypto";
@@ -22817,43 +23010,43 @@ function registerBackupVps(server2) {
     {
       title: "VPS Backup",
       description: "Run VPS Postgres backup/restore workflows and check status.",
-      inputSchema: z60.discriminatedUnion("action", [
-        z60.object({
-          action: z60.literal("backup"),
-          databaseUrl: z60.string().min(1).describe("Postgres DATABASE_URL to dump from"),
-          encryptionKeyB64: z60.string().min(1).max(4096).optional().describe(
+      inputSchema: z61.discriminatedUnion("action", [
+        z61.object({
+          action: z61.literal("backup"),
+          databaseUrl: z61.string().min(1).describe("Postgres DATABASE_URL to dump from"),
+          encryptionKeyB64: z61.string().min(1).max(4096).optional().describe(
             "Base64 AES-256 key (defaults to local master key if omitted)"
           ),
-          r2Bucket: z60.string().min(1).describe("R2 bucket name"),
-          r2Endpoint: z60.string().min(1).describe("R2 endpoint URL"),
-          r2AccessKeyId: z60.string().min(1).describe("R2 access key ID"),
-          r2SecretAccessKey: z60.string().min(1).describe("R2 secret access key")
+          r2Bucket: z61.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z61.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z61.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z61.string().min(1).describe("R2 secret access key")
         }),
-        z60.object({
-          action: z60.literal("restore"),
-          databaseUrl: z60.string().min(1).describe("Target Postgres DATABASE_URL for restore"),
-          backupKey: z60.string().min(1).describe("R2 object key to restore from"),
-          encryptionKeyB64: z60.string().min(1).max(4096).optional().describe(
+        z61.object({
+          action: z61.literal("restore"),
+          databaseUrl: z61.string().min(1).describe("Target Postgres DATABASE_URL for restore"),
+          backupKey: z61.string().min(1).describe("R2 object key to restore from"),
+          encryptionKeyB64: z61.string().min(1).max(4096).optional().describe(
             "Base64 AES-256 key (defaults to local master key if omitted)"
           ),
-          r2Bucket: z60.string().min(1).describe("R2 bucket name"),
-          r2Endpoint: z60.string().min(1).describe("R2 endpoint URL"),
-          r2AccessKeyId: z60.string().min(1).describe("R2 access key ID"),
-          r2SecretAccessKey: z60.string().min(1).describe("R2 secret access key")
+          r2Bucket: z61.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z61.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z61.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z61.string().min(1).describe("R2 secret access key")
         }),
-        z60.object({
-          action: z60.literal("list"),
-          r2Bucket: z60.string().min(1).describe("R2 bucket name"),
-          r2Endpoint: z60.string().min(1).describe("R2 endpoint URL"),
-          r2AccessKeyId: z60.string().min(1).describe("R2 access key ID"),
-          r2SecretAccessKey: z60.string().min(1).describe("R2 secret access key")
+        z61.object({
+          action: z61.literal("list"),
+          r2Bucket: z61.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z61.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z61.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z61.string().min(1).describe("R2 secret access key")
         }),
-        z60.object({
-          action: z60.literal("health"),
-          r2Bucket: z60.string().min(1).describe("R2 bucket name"),
-          r2Endpoint: z60.string().min(1).describe("R2 endpoint URL"),
-          r2AccessKeyId: z60.string().min(1).describe("R2 access key ID"),
-          r2SecretAccessKey: z60.string().min(1).describe("R2 secret access key")
+        z61.object({
+          action: z61.literal("health"),
+          r2Bucket: z61.string().min(1).describe("R2 bucket name"),
+          r2Endpoint: z61.string().min(1).describe("R2 endpoint URL"),
+          r2AccessKeyId: z61.string().min(1).describe("R2 access key ID"),
+          r2SecretAccessKey: z61.string().min(1).describe("R2 secret access key")
         })
       ])
     },
@@ -22991,11 +23184,11 @@ async function resolveEncryptionKey(providedB64) {
 }
 
 // src/mcp/tools/deploy-client.ts
-import { z as z61 } from "zod";
+import { z as z62 } from "zod";
 import { execFile } from "child_process";
 import { promisify } from "util";
-import path36 from "path";
-import { existsSync as existsSync31 } from "fs";
+import path38 from "path";
+import { existsSync as existsSync33 } from "fs";
 
 // src/lib/hostinger-api.ts
 var DEFAULT_BASE_URL = "https://developers.hostinger.com/api/vps/v1";
@@ -23043,9 +23236,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path50, body) {
+  async request(method, path52, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path50}`;
+    const url = `${this.baseUrl}${path52}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -23118,8 +23311,8 @@ async function requestCloudflare(cfApiToken, zoneId, options) {
   }
   return envelope.result;
 }
-function buildUrl(zoneId, path50 = "/dns_records", query) {
-  const normalizedPath = path50.startsWith("/") ? path50 : `/${path50}`;
+function buildUrl(zoneId, path52 = "/dns_records", query) {
+  const normalizedPath = path52.startsWith("/") ? path52 : `/${path52}`;
   const url = new URL(
     `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
   );
@@ -23259,12 +23452,12 @@ function registerDeployClient(server2) {
       title: "Deploy Client",
       description: "Provision a Hostinger VPS and deploy exe-os for a client. Creates VPS, waits for ready state, runs Ansible playbook, verifies health.",
       inputSchema: {
-        client_name: z61.string().min(1).describe("Client name (used for hostname and identification)"),
-        domain: z61.string().min(1).describe("Domain name for the deployment (e.g., client.exe.ai)"),
-        region: z61.string().default("jakarta").describe("VPS region (default: jakarta)"),
-        plan: z61.string().default("kvm-2").describe("Hostinger VPS plan (default: kvm-2)"),
-        ssl_email: z61.string().email().describe("Email for Let's Encrypt SSL certificate"),
-        user_id: z61.string().min(1).describe("User/customer ID for inventory tracking")
+        client_name: z62.string().min(1).describe("Client name (used for hostname and identification)"),
+        domain: z62.string().min(1).describe("Domain name for the deployment (e.g., client.exe.ai)"),
+        region: z62.string().default("jakarta").describe("VPS region (default: jakarta)"),
+        plan: z62.string().default("kvm-2").describe("Hostinger VPS plan (default: kvm-2)"),
+        ssl_email: z62.string().email().describe("Email for Let's Encrypt SSL certificate"),
+        user_id: z62.string().min(1).describe("User/customer ID for inventory tracking")
       }
     },
     async ({ client_name, domain, region, plan, ssl_email, user_id }) => {
@@ -23332,12 +23525,12 @@ async function waitForReady(client, vpsId) {
 }
 async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
   const safeClientName = clientName.replace(/[^a-zA-Z0-9_-]/g, "-");
-  const playbookDir = path36.resolve(process.cwd(), "infrastructure", "ansible");
-  const playbookPath = path36.join(playbookDir, "deploy.yml");
-  const inventoryPath = path36.join(playbookDir, "inventory", "hosts.yml");
-  const clientVarsPath = path36.join(playbookDir, "vars", `${safeClientName}.yml`);
-  const varsDir = path36.join(playbookDir, "vars");
-  if (!path36.resolve(clientVarsPath).startsWith(path36.resolve(varsDir))) {
+  const playbookDir = path38.resolve(process.cwd(), "infrastructure", "ansible");
+  const playbookPath = path38.join(playbookDir, "deploy.yml");
+  const inventoryPath = path38.join(playbookDir, "inventory", "hosts.yml");
+  const clientVarsPath = path38.join(playbookDir, "vars", `${safeClientName}.yml`);
+  const varsDir = path38.join(playbookDir, "vars");
+  if (!path38.resolve(clientVarsPath).startsWith(path38.resolve(varsDir))) {
     throw new Error(`Invalid client name for vars path: ${clientName}`);
   }
   const args = [
@@ -23353,7 +23546,7 @@ async function runAnsiblePlaybook(vpsIp, domain, sslEmail, clientName) {
     "-e",
     `client_name=${safeClientName}`
   ];
-  if (existsSync31(clientVarsPath)) {
+  if (existsSync33(clientVarsPath)) {
     args.push("-e", `@${clientVarsPath}`);
   }
   try {
@@ -23426,7 +23619,7 @@ function buildInventoryRecord(params) {
 
 // src/mcp/tools/get-license-status.ts
 init_license();
-import { z as z62 } from "zod";
+import { z as z63 } from "zod";
 var FEATURES = [
   "cloud_sync",
   "external_agents",
@@ -23440,7 +23633,7 @@ function registerGetLicenseStatus(server2) {
       title: "Get License Status",
       description: "Get current license status: plan, validity, feature gates, limits, and expiry.",
       inputSchema: {
-        _dummy: z62.string().optional().describe("Unused \u2014 no input required")
+        _dummy: z63.string().optional().describe("Unused \u2014 no input required")
       }
     },
     async () => {
@@ -23494,11 +23687,11 @@ function registerGetLicenseStatus(server2) {
 // src/mcp/tools/create-license.ts
 init_license();
 import os15 from "os";
-import path37 from "path";
+import path39 from "path";
 import { randomBytes as randomBytes2, randomUUID as randomUUID6 } from "crypto";
 import { createRequire as createRequire3 } from "module";
 import { pathToFileURL as pathToFileURL3 } from "url";
-import { z as z63 } from "zod";
+import { z as z64 } from "zod";
 var prismaPromise = null;
 function loadPrisma() {
   if (!prismaPromise) {
@@ -23510,8 +23703,8 @@ function loadPrisma() {
         if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
         return new Ctor2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path37.join(os15.homedir(), "exe-db");
-      const req = createRequire3(path37.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path39.join(os15.homedir(), "exe-db");
+      const req = createRequire3(path39.join(exeDbRoot, "package.json"));
       const entry = req.resolve("@prisma/client");
       const mod = await import(pathToFileURL3(entry).href);
       const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
@@ -23531,10 +23724,10 @@ function registerCreateLicense(server2) {
       title: "Create License",
       description: "Generate an exe_sk_* license key for a user. Stores in billing.licenses. Returns the key to give to the customer.",
       inputSchema: {
-        email: z63.string().email().describe("Customer email address"),
-        name: z63.string().optional().describe("Customer name"),
-        plan: z63.enum(["free", "pro", "team", "agency", "enterprise"]).default("pro").describe("License plan tier"),
-        expires_in_days: z63.number().int().positive().default(365).describe("Days until expiration (default 365)")
+        email: z64.string().email().describe("Customer email address"),
+        name: z64.string().optional().describe("Customer name"),
+        plan: z64.enum(["free", "pro", "team", "agency", "enterprise"]).default("pro").describe("License plan tier"),
+        expires_in_days: z64.number().int().positive().default(365).describe("Days until expiration (default 365)")
       }
     },
     async ({ email, name, plan, expires_in_days }) => {
@@ -23586,10 +23779,10 @@ Give this key to the customer. They paste it during \`exe-os setup\`.`);
 
 // src/mcp/tools/list-licenses.ts
 import os16 from "os";
-import path38 from "path";
+import path40 from "path";
 import { createRequire as createRequire4 } from "module";
 import { pathToFileURL as pathToFileURL4 } from "url";
-import { z as z64 } from "zod";
+import { z as z65 } from "zod";
 var prismaPromise2 = null;
 function loadPrisma2() {
   if (!prismaPromise2) {
@@ -23601,8 +23794,8 @@ function loadPrisma2() {
         if (!Ctor2) throw new Error(`No PrismaClient at ${explicitPath}`);
         return new Ctor2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path38.join(os16.homedir(), "exe-db");
-      const req = createRequire4(path38.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path40.join(os16.homedir(), "exe-db");
+      const req = createRequire4(path40.join(exeDbRoot, "package.json"));
       const entry = req.resolve("@prisma/client");
       const mod = await import(pathToFileURL4(entry).href);
       const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
@@ -23619,7 +23812,7 @@ function registerListLicenses(server2) {
       title: "List Licenses",
       description: "List all issued licenses with status (active/expired/revoked). Optionally filter by plan.",
       inputSchema: {
-        plan: z64.enum(["free", "pro", "team", "agency", "enterprise"]).optional().describe("Filter by plan tier (omit for all)")
+        plan: z65.enum(["free", "pro", "team", "agency", "enterprise"]).optional().describe("Filter by plan tier (omit for all)")
       }
     },
     async ({ plan }) => {
@@ -23670,7 +23863,7 @@ function registerListLicenses(server2) {
 
 // src/mcp/tools/activate-license.ts
 init_license();
-import { z as z65 } from "zod";
+import { z as z66 } from "zod";
 function registerActivateLicense(server2) {
   server2.registerTool(
     "activate_license",
@@ -23678,7 +23871,7 @@ function registerActivateLicense(server2) {
       title: "Activate License",
       description: "Activate an exe_sk_* license key on this device. Writes to ~/.exe-os/license.key, validates against Postgres, and caches the result.",
       inputSchema: {
-        key: z65.string().startsWith("exe_sk_").describe("License key (exe_sk_*)")
+        key: z66.string().startsWith("exe_sk_").describe("License key (exe_sk_*)")
       }
     },
     async ({ key }) => {
@@ -23724,18 +23917,18 @@ Key saved to ~/.exe-os/license.key. Device ID: ${deviceId}`);
 }
 
 // src/mcp/tools/create-trigger.ts
-import { z as z66 } from "zod";
+import { z as z67 } from "zod";
 
 // src/automation/trigger-engine.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync18, existsSync as existsSync32, mkdirSync as mkdirSync16 } from "fs";
+import { readFileSync as readFileSync26, writeFileSync as writeFileSync19, existsSync as existsSync34, mkdirSync as mkdirSync17 } from "fs";
 import { randomUUID as randomUUID7 } from "crypto";
-import path39 from "path";
+import path41 from "path";
 import os17 from "os";
-var TRIGGERS_PATH = path39.join(os17.homedir(), ".exe-os", "triggers.json");
+var TRIGGERS_PATH = path41.join(os17.homedir(), ".exe-os", "triggers.json");
 function loadTriggers(project) {
-  if (!existsSync32(TRIGGERS_PATH)) return [];
+  if (!existsSync34(TRIGGERS_PATH)) return [];
   try {
-    const raw = readFileSync24(TRIGGERS_PATH, "utf-8");
+    const raw = readFileSync26(TRIGGERS_PATH, "utf-8");
     const all = JSON.parse(raw);
     if (!Array.isArray(all)) return [];
     if (project) {
@@ -23747,9 +23940,9 @@ function loadTriggers(project) {
   }
 }
 function saveTriggers(triggers) {
-  const dir = path39.dirname(TRIGGERS_PATH);
-  if (!existsSync32(dir)) mkdirSync16(dir, { recursive: true });
-  writeFileSync18(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
+  const dir = path41.dirname(TRIGGERS_PATH);
+  if (!existsSync34(dir)) mkdirSync17(dir, { recursive: true });
+  writeFileSync19(TRIGGERS_PATH, JSON.stringify(triggers, null, 2), "utf-8");
 }
 function createNewTrigger(input) {
   const triggers = loadTriggers();
@@ -23905,14 +24098,14 @@ function addToCrontab(id, cron, prompt, projectDir) {
 }
 
 // src/mcp/tools/create-trigger.ts
-var conditionSchema = z66.object({
-  field: z66.string().describe("Dot-path field to evaluate, e.g., 'stage' or 'amount'"),
-  op: z66.enum(["eq", "neq", "gt", "lt", "gte", "lte", "contains", "not_contains"]).describe("Comparison operator"),
-  value: z66.string().or(z66.number()).or(z66.boolean()).describe("Value to compare against")
+var conditionSchema = z67.object({
+  field: z67.string().describe("Dot-path field to evaluate, e.g., 'stage' or 'amount'"),
+  op: z67.enum(["eq", "neq", "gt", "lt", "gte", "lte", "contains", "not_contains"]).describe("Comparison operator"),
+  value: z67.string().or(z67.number()).or(z67.boolean()).describe("Value to compare against")
 });
-var actionSchema = z66.object({
-  type: z66.enum(["send_whatsapp", "send_message", "create_task", "mcp_tool"]).describe("Action type to execute"),
-  params: z66.record(z66.string(), z66.string()).describe(
+var actionSchema = z67.object({
+  type: z67.enum(["send_whatsapp", "send_message", "create_task", "mcp_tool"]).describe("Action type to execute"),
+  params: z67.record(z67.string(), z67.string()).describe(
     "Action parameters. Supports {{record.field}} templates for dynamic values."
   )
 });
@@ -23923,18 +24116,18 @@ function registerCreateTrigger(server2) {
       title: "Create Trigger",
       description: "Create a CRM event trigger or scheduled automation. When matching events occur (e.g., Deal.updated with stage=won), configured actions fire automatically (send_whatsapp, create_task, etc.).",
       inputSchema: {
-        name: z66.string().describe("Human-readable trigger name"),
-        event: z66.string().describe(
+        name: z67.string().describe("Human-readable trigger name"),
+        event: z67.string().describe(
           'CRM event to match, e.g., "Deal.updated", "Order.created", "*" for all'
         ),
-        conditions: z66.array(conditionSchema).default([]).describe("Conditions that must all match (AND logic)"),
-        actions: z66.array(actionSchema).min(1).describe("Actions to execute when trigger fires"),
-        project: z66.string().optional().describe("Scope trigger to a specific project"),
-        enabled: z66.boolean().default(true).describe("Whether trigger is active"),
-        schedule: z66.string().optional().describe(
+        conditions: z67.array(conditionSchema).default([]).describe("Conditions that must all match (AND logic)"),
+        actions: z67.array(actionSchema).min(1).describe("Actions to execute when trigger fires"),
+        project: z67.string().optional().describe("Scope trigger to a specific project"),
+        enabled: z67.boolean().default(true).describe("Whether trigger is active"),
+        schedule: z67.string().optional().describe(
           'Cron schedule for time-based triggers, e.g., "0 9 * * *" or "Monday 9am"'
         ),
-        query: z66.string().optional().describe(
+        query: z67.string().optional().describe(
           "CRM GraphQL query to run on schedule (required if schedule is set)"
         )
       }
@@ -24007,7 +24200,7 @@ Enabled: ${trigger.enabled}` + scheduleInfo;
 }
 
 // src/mcp/tools/list-triggers.ts
-import { z as z67 } from "zod";
+import { z as z68 } from "zod";
 function registerListTriggers(server2) {
   server2.registerTool(
     "list_triggers",
@@ -24015,7 +24208,7 @@ function registerListTriggers(server2) {
       title: "List Triggers",
       description: "List configured CRM event triggers and scheduled automations.",
       inputSchema: {
-        project: z67.string().optional().describe("Filter triggers by project name")
+        project: z68.string().optional().describe("Filter triggers by project name")
       }
     },
     async ({ project }) => {
@@ -24050,51 +24243,51 @@ function registerListTriggers(server2) {
 }
 
 // src/mcp/tools/apply-starter-pack.ts
-import { z as z68 } from "zod";
+import { z as z69 } from "zod";
 
 // src/automation/starter-packs/index.ts
-import { readFileSync as readFileSync25, readdirSync as readdirSync12, existsSync as existsSync33 } from "fs";
-import path40 from "path";
-import { fileURLToPath as fileURLToPath4 } from "url";
-var __dirname = path40.dirname(fileURLToPath4(import.meta.url));
+import { readFileSync as readFileSync27, readdirSync as readdirSync12, existsSync as existsSync35 } from "fs";
+import path42 from "path";
+import { fileURLToPath as fileURLToPath5 } from "url";
+var __dirname = path42.dirname(fileURLToPath5(import.meta.url));
 function listPacks() {
-  const packsDir = path40.join(__dirname, ".");
-  if (!existsSync33(packsDir)) return [];
+  const packsDir = path42.join(__dirname, ".");
+  if (!existsSync35(packsDir)) return [];
   return readdirSync12(packsDir, { withFileTypes: true }).filter(
-    (d) => d.isDirectory() && existsSync33(path40.join(packsDir, d.name, "custom-objects.json"))
+    (d) => d.isDirectory() && existsSync35(path42.join(packsDir, d.name, "custom-objects.json"))
   ).map((d) => d.name);
 }
 function loadPack(industry) {
-  const packDir = path40.join(__dirname, industry);
-  const objectsPath = path40.join(packDir, "custom-objects.json");
-  const triggersPath = path40.join(packDir, "triggers.json");
-  const wikiDir = path40.join(packDir, "wiki-seeds");
-  const manifestPath = path40.join(packDir, "pack.json");
-  const identityContextPath = path40.join(packDir, "identity-context.md");
-  if (!existsSync33(objectsPath)) return null;
+  const packDir = path42.join(__dirname, industry);
+  const objectsPath = path42.join(packDir, "custom-objects.json");
+  const triggersPath = path42.join(packDir, "triggers.json");
+  const wikiDir = path42.join(packDir, "wiki-seeds");
+  const manifestPath = path42.join(packDir, "pack.json");
+  const identityContextPath = path42.join(packDir, "identity-context.md");
+  if (!existsSync35(objectsPath)) return null;
   let customObjects = [];
   try {
     customObjects = JSON.parse(
-      readFileSync25(objectsPath, "utf-8")
+      readFileSync27(objectsPath, "utf-8")
     );
   } catch {
     customObjects = [];
   }
   let triggers = [];
-  if (existsSync33(triggersPath)) {
+  if (existsSync35(triggersPath)) {
     try {
       triggers = JSON.parse(
-        readFileSync25(triggersPath, "utf-8")
+        readFileSync27(triggersPath, "utf-8")
       );
     } catch {
       triggers = [];
     }
   }
   const wikiSeeds = [];
-  if (existsSync33(wikiDir)) {
+  if (existsSync35(wikiDir)) {
     const files = readdirSync12(wikiDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
-      const content = readFileSync25(path40.join(wikiDir, file), "utf-8");
+      const content = readFileSync27(path42.join(wikiDir, file), "utf-8");
       const titleMatch = content.match(/^#\s+(.+)/m);
       wikiSeeds.push({
         filename: file,
@@ -24104,17 +24297,17 @@ function loadPack(industry) {
     }
   }
   let manifest = {};
-  if (existsSync33(manifestPath)) {
+  if (existsSync35(manifestPath)) {
     try {
-      manifest = JSON.parse(readFileSync25(manifestPath, "utf-8"));
+      manifest = JSON.parse(readFileSync27(manifestPath, "utf-8"));
     } catch {
       manifest = {};
     }
   }
   let identityContext = null;
-  if (existsSync33(identityContextPath)) {
+  if (existsSync35(identityContextPath)) {
     try {
-      identityContext = readFileSync25(identityContextPath, "utf-8");
+      identityContext = readFileSync27(identityContextPath, "utf-8");
     } catch {
       identityContext = null;
     }
@@ -24171,8 +24364,8 @@ function applyPack(industry, project) {
 
 // src/lib/client-coo.ts
 init_config();
-import { existsSync as existsSync34, mkdirSync as mkdirSync17, writeFileSync as writeFileSync19 } from "fs";
-import path41 from "path";
+import { existsSync as existsSync36, mkdirSync as mkdirSync18, writeFileSync as writeFileSync20 } from "fs";
+import path43 from "path";
 
 // src/lib/employee-templates.ts
 init_global_procedures();
@@ -24312,18 +24505,18 @@ var ClientCOOClobberError = class extends Error {
 var COO_ROLE = "Chief Operating Officer";
 var FEEDBACK_BEHAVIOR_CONTENT = "Tag exe-os issues with needs_improvement \u2014 this is the feedback loop that surfaces bugs, gaps, and friction to the founder each Monday.";
 async function provisionClientCOO(vars, opts = {}) {
-  const identityDir = opts.identityDir ?? path41.join(EXE_AI_DIR, "identity");
+  const identityDir = opts.identityDir ?? path43.join(EXE_AI_DIR, "identity");
   const rosterPath = opts.employeesPath ?? EMPLOYEES_PATH;
   const storeFeedbackBehavior = opts.storeFeedbackBehavior ?? true;
-  const identityPath2 = path41.join(identityDir, `${vars.agent_name}.md`);
-  if (existsSync34(identityPath2)) {
+  const identityPath2 = path43.join(identityDir, `${vars.agent_name}.md`);
+  if (existsSync36(identityPath2)) {
     throw new ClientCOOClobberError(vars.agent_name, identityPath2);
   }
   const body = renderClientCOOTemplate(vars);
-  if (!existsSync34(identityDir)) {
-    mkdirSync17(identityDir, { recursive: true });
+  if (!existsSync36(identityDir)) {
+    mkdirSync18(identityDir, { recursive: true });
   }
-  writeFileSync19(identityPath2, body, "utf-8");
+  writeFileSync20(identityPath2, body, "utf-8");
   const employees = await loadEmployees(rosterPath);
   const existing = employees.find((e) => e.name === vars.agent_name);
   let addedToRoster = false;
@@ -24359,17 +24552,17 @@ function registerApplyStarterPack(server2) {
       title: "Apply Starter Pack",
       description: "Apply an industry starter pack to a project. Sets up CRM custom objects, pre-wired automation triggers, and wiki seed content. When the pack creates a Client COO (e.g. distribution) and agent_name, company_name, founder_name are all provided, also provisions the COO identity, roster entry, and feedback-loop behavior. Available packs: distribution. More coming.",
       inputSchema: {
-        industry: z68.string().describe(
+        industry: z69.string().describe(
           'Industry pack to apply (e.g., "distribution"). Use without args to list available packs.'
         ),
-        project: z68.string().describe("Project name to scope the triggers to"),
-        agent_name: z68.string().optional().describe(
+        project: z69.string().describe("Project name to scope the triggers to"),
+        agent_name: z69.string().optional().describe(
           "Optional. Lowercase alphanumeric name for the Client COO agent. Required (alongside company_name and founder_name) to provision a COO."
         ),
-        company_name: z68.string().optional().describe(
+        company_name: z69.string().optional().describe(
           "Optional. The client company the COO serves. Required to provision a COO."
         ),
-        founder_name: z68.string().optional().describe(
+        founder_name: z69.string().optional().describe(
           "Optional. The founder the COO reports to. Required to provision a COO."
         )
       }
@@ -24514,20 +24707,20 @@ ${err.message}`
 }
 
 // src/mcp/tools/load-skill.ts
-import { z as z69 } from "zod";
-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");
+import { z as z70 } from "zod";
+import { readFileSync as readFileSync28, readdirSync as readdirSync13, statSync as statSync8 } from "fs";
+import path44 from "path";
+import { homedir as homedir8 } from "os";
+var SKILLS_DIR = path44.join(homedir8(), ".claude", "skills");
 function listAvailableSkills() {
   try {
     const entries = readdirSync13(SKILLS_DIR);
     return entries.filter((entry) => {
       try {
-        const entryPath = path42.join(SKILLS_DIR, entry);
-        if (!statSync7(entryPath).isDirectory()) return false;
-        const skillFile = path42.join(entryPath, "SKILL.md");
-        statSync7(skillFile);
+        const entryPath = path44.join(SKILLS_DIR, entry);
+        if (!statSync8(entryPath).isDirectory()) return false;
+        const skillFile = path44.join(entryPath, "SKILL.md");
+        statSync8(skillFile);
         return true;
       } catch {
         return false;
@@ -24544,7 +24737,7 @@ function registerLoadSkill(server2) {
       title: "Load Skill",
       description: "Load domain-specific guidance into your context. Use when you need specialized knowledge for a task (e.g., load_skill('seo') before doing SEO work, load_skill('code-reviewer') before reviewing code). Pass skill_name='list' to see all available skills.",
       inputSchema: {
-        skill_name: z69.string().describe(
+        skill_name: z70.string().describe(
           "Skill to load (e.g. 'seo', 'code-reviewer', 'frontend-design'). Pass 'list' to see all available skills."
         )
       }
@@ -24569,10 +24762,10 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
           }]
         };
       }
-      const sanitized = path42.basename(skill_name);
-      const skillFile = path42.join(SKILLS_DIR, sanitized, "SKILL.md");
+      const sanitized = path44.basename(skill_name);
+      const skillFile = path44.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
-        const content = readFileSync26(skillFile, "utf-8");
+        const content = readFileSync28(skillFile, "utf-8");
         return {
           content: [{
             type: "text",
@@ -24600,18 +24793,18 @@ ${available.map((s) => `- ${s}`).join("\n")}` : "\n\nNo skills found in ~/.claud
 
 // src/mcp/tools/export-orchestration.ts
 init_active_agent();
-import { mkdirSync as mkdirSync19, writeFileSync as writeFileSync21 } from "fs";
-import path44 from "path";
-import { z as z70 } from "zod";
+import { mkdirSync as mkdirSync20, writeFileSync as writeFileSync22 } from "fs";
+import path46 from "path";
+import { z as z71 } from "zod";
 
 // src/lib/orchestration-package.ts
 init_database();
 init_identity();
 init_platform_procedures();
 import { randomUUID as randomUUID8 } from "crypto";
-import { copyFileSync as copyFileSync2, existsSync as existsSync35, mkdirSync as mkdirSync18, readFileSync as readFileSync27, writeFileSync as writeFileSync20 } from "fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync37, mkdirSync as mkdirSync19, readFileSync as readFileSync29, writeFileSync as writeFileSync21 } from "fs";
 import os18 from "os";
-import path43 from "path";
+import path45 from "path";
 var PACKAGE_VERSION = "1.0";
 var ROSTER_FILENAME = "exe-employees.json";
 var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
@@ -24677,15 +24870,15 @@ function validateProcedureEntry(value, index) {
   };
 }
 function getRosterPath() {
-  return path43.join(os18.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+  return path45.join(os18.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
 }
 function getBackupPath() {
-  return path43.join(os18.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+  return path45.join(os18.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
 }
 function readRosterFile() {
   const rosterPath = getRosterPath();
-  if (!existsSync35(rosterPath)) return [];
-  const raw = readFileSync27(rosterPath, "utf-8");
+  if (!existsSync37(rosterPath)) return [];
+  const raw = readFileSync29(rosterPath, "utf-8");
   const parsed = JSON.parse(raw);
   if (!Array.isArray(parsed)) {
     throw new Error("Roster file must contain a JSON array");
@@ -24697,8 +24890,8 @@ function writeRosterFile(roster) {
     throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
   }
   const rosterPath = getRosterPath();
-  mkdirSync18(path43.dirname(rosterPath), { recursive: true });
-  if (existsSync35(rosterPath)) {
+  mkdirSync19(path45.dirname(rosterPath), { recursive: true });
+  if (existsSync37(rosterPath)) {
     const currentRoster = readRosterFile();
     if (roster.length < currentRoster.length) {
       throw new Error(
@@ -24707,7 +24900,7 @@ function writeRosterFile(roster) {
     }
     copyFileSync2(rosterPath, getBackupPath());
   }
-  writeFileSync20(rosterPath, `${JSON.stringify(roster, null, 2)}
+  writeFileSync21(rosterPath, `${JSON.stringify(roster, null, 2)}
 `, "utf-8");
 }
 function buildImportedRosterEntries(roster, timestamp) {
@@ -24962,15 +25155,15 @@ function registerExportOrchestration(server2) {
       title: "Export Orchestration",
       description: "Export roster, identities, behaviors, and customer procedures to a JSON package.",
       inputSchema: {
-        output_path: z70.string().describe("File path to write the JSON package")
+        output_path: z71.string().describe("File path to write the JSON package")
       }
     },
     async ({ output_path }) => {
       try {
         await initStore();
         const pkg = await exportOrchestration(getActiveAgent().agentId);
-        mkdirSync19(path44.dirname(output_path), { recursive: true });
-        writeFileSync21(output_path, `${JSON.stringify(pkg, null, 2)}
+        mkdirSync20(path46.dirname(output_path), { recursive: true });
+        writeFileSync22(output_path, `${JSON.stringify(pkg, null, 2)}
 `, "utf-8");
         return {
           content: [{
@@ -24992,8 +25185,8 @@ function registerExportOrchestration(server2) {
 }
 
 // src/mcp/tools/import-orchestration.ts
-import { readFileSync as readFileSync28 } from "fs";
-import { z as z71 } from "zod";
+import { readFileSync as readFileSync30 } from "fs";
+import { z as z72 } from "zod";
 init_store();
 init_active_agent();
 init_employees();
@@ -25004,8 +25197,8 @@ function registerImportOrchestration(server2) {
       title: "Import Orchestration",
       description: "Import roster, identities, behaviors, and procedures from an orchestration package. Restricted to coordinator/founder.",
       inputSchema: {
-        package_path: z71.string().describe("Path to the orchestration package JSON file"),
-        merge_strategy: z71.enum(["replace", "merge"]).default("merge").describe("How to apply the package: both strategies are additive-only \u2014 existing data is never deleted or overwritten")
+        package_path: z72.string().describe("Path to the orchestration package JSON file"),
+        merge_strategy: z72.enum(["replace", "merge"]).default("merge").describe("How to apply the package: both strategies are additive-only \u2014 existing data is never deleted or overwritten")
       }
     },
     async ({ package_path, merge_strategy }) => {
@@ -25022,7 +25215,7 @@ function registerImportOrchestration(server2) {
           };
         }
         await initStore();
-        const raw = readFileSync28(package_path, "utf-8");
+        const raw = readFileSync30(package_path, "utf-8");
         const pkg = validatePackage(JSON.parse(raw));
         const result2 = await importOrchestration(pkg, merge_strategy);
         return {
@@ -25050,7 +25243,7 @@ init_platform_procedures();
 init_active_agent();
 init_database();
 init_employees();
-import { z as z72 } from "zod";
+import { z as z73 } from "zod";
 function registerCompanyProcedureTool(server2, toolName) {
   server2.registerTool(
     toolName,
@@ -25058,12 +25251,12 @@ function registerCompanyProcedureTool(server2, toolName) {
       title: "Company Procedure",
       description: "Manage company procedures (customer-owned Layer 0 rules) that supersede identity, expertise, and experience. Actions: store (create new, restricted), list (view all, open), deactivate (soft-delete, restricted).",
       inputSchema: {
-        action: z72.enum(["store", "list", "deactivate"]).describe("Action to perform"),
-        title: z72.string().optional().describe("Short title for the procedure (store)"),
-        content: z72.string().max(500).optional().describe("The procedure content \u2014 clear, actionable instruction (store)"),
-        priority: z72.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default). p1 = standard. p2 = nice-to-have."),
-        domain: z72.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security"),
-        procedure_id: z72.string().optional().describe("UUID of the company procedure (deactivate)")
+        action: z73.enum(["store", "list", "deactivate"]).describe("Action to perform"),
+        title: z73.string().optional().describe("Short title for the procedure (store)"),
+        content: z73.string().max(500).optional().describe("The procedure content \u2014 clear, actionable instruction (store)"),
+        priority: z73.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default). p1 = standard. p2 = nice-to-have."),
+        domain: z73.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security"),
+        procedure_id: z73.string().optional().describe("UUID of the company procedure (deactivate)")
       }
     },
     async ({ action, title, content, priority, domain, procedure_id }) => {
@@ -25191,6 +25384,7 @@ var ACTION_TO_TOOL2 = {
   list_agent_sessions: "list_agent_sessions",
   session_kills: "get_session_kills",
   daemon_health: "get_daemon_health",
+  mcp_ping: "mcp_ping",
   auto_wake_status: "get_auto_wake_status",
   worker_gate: "get_worker_gate",
   memory_audit: "run_memory_audit",
@@ -25228,6 +25422,7 @@ function buildHandlers5() {
   registerListAgentSessions(localServer);
   registerGetSessionKills(localServer);
   registerGetDaemonHealth(localServer);
+  registerMcpPing(localServer);
   registerGetAutoWakeStatus(localServer);
   registerGetWorkerGate(localServer);
   registerRunMemoryAudit(localServer);
@@ -25256,44 +25451,44 @@ function registerConfig(server2) {
     title: "Config",
     description: "Consolidated COO/admin tool for runtime config, system health, licensing, triggers, orchestration import/export, and company procedures.",
     inputSchema: {
-      action: z73.enum(Object.keys(ACTION_TO_TOOL2)).describe("Admin/config operation"),
-      agent_id: z73.string().optional().describe("Agent id for set_agent_config/agent_spend/session queries"),
-      runtime: z73.string().optional().describe("Runtime for set_agent_config"),
-      model: z73.string().optional().describe("Model for set_agent_config"),
-      reasoning_effort: z73.string().optional().describe("Reasoning effort for Codex agents"),
-      dry_run: z73.boolean().optional().describe("Preview without applying where supported"),
-      fix: z73.boolean().optional().describe("Apply fixes for memory_audit where supported"),
-      verbose: z73.boolean().optional().describe("Verbose output where supported"),
-      project_name: z73.string().optional().describe("Project filter/name"),
-      since: z73.string().optional().describe("ISO lower-bound timestamp"),
-      limit: z73.coerce.number().optional().describe("Result limit"),
-      output_path: z73.string().optional().describe("Output path for export/backup"),
-      input_path: z73.string().optional().describe("Input path for import_orchestration"),
-      strategy: z73.enum(["merge", "replace"]).optional().describe("Import strategy; replace must still be additive-only per platform rules"),
-      license_key: z73.string().optional().describe("License key for activation/status"),
-      email: z73.string().optional().describe("Customer email for license creation"),
-      plan: z73.string().optional().describe("License plan"),
-      name: z73.string().optional().describe("Trigger/starter pack/procedure/client name"),
-      event: z73.string().optional().describe("Trigger event"),
-      conditions: z73.array(z73.record(z73.string(), z73.unknown())).optional().describe("Trigger conditions"),
-      actions: z73.array(z73.record(z73.string(), z73.unknown())).optional().describe("Trigger actions"),
-      enabled: z73.boolean().optional().describe("Trigger enabled flag"),
-      schedule: z73.string().optional().describe("Trigger schedule"),
-      query: z73.string().optional().describe("Trigger query or filter"),
-      skill_name: z73.string().optional().describe("Skill name for load_skill"),
-      pack_name: z73.string().optional().describe("Starter pack name"),
-      title: z73.string().optional().describe("Procedure title"),
-      content: z73.string().optional().describe("Procedure content"),
-      priority: z73.enum(["p0", "p1", "p2"]).optional().describe("Procedure priority"),
-      domain: z73.string().optional().describe("Procedure domain"),
-      procedure_id: z73.string().optional().describe("Procedure id for deactivate"),
-      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")
+      action: z74.enum(Object.keys(ACTION_TO_TOOL2)).describe("Admin/config operation"),
+      agent_id: z74.string().optional().describe("Agent id for set_agent_config/agent_spend/session queries"),
+      runtime: z74.string().optional().describe("Runtime for set_agent_config"),
+      model: z74.string().optional().describe("Model for set_agent_config"),
+      reasoning_effort: z74.string().optional().describe("Reasoning effort for Codex agents"),
+      dry_run: z74.boolean().optional().describe("Preview without applying where supported"),
+      fix: z74.boolean().optional().describe("Apply fixes for memory_audit where supported"),
+      verbose: z74.boolean().optional().describe("Verbose output where supported"),
+      project_name: z74.string().optional().describe("Project filter/name"),
+      since: z74.string().optional().describe("ISO lower-bound timestamp"),
+      limit: z74.coerce.number().optional().describe("Result limit"),
+      output_path: z74.string().optional().describe("Output path for export/backup"),
+      input_path: z74.string().optional().describe("Input path for import_orchestration"),
+      strategy: z74.enum(["merge", "replace"]).optional().describe("Import strategy; replace must still be additive-only per platform rules"),
+      license_key: z74.string().optional().describe("License key for activation/status"),
+      email: z74.string().optional().describe("Customer email for license creation"),
+      plan: z74.string().optional().describe("License plan"),
+      name: z74.string().optional().describe("Trigger/starter pack/procedure/client name"),
+      event: z74.string().optional().describe("Trigger event"),
+      conditions: z74.array(z74.record(z74.string(), z74.unknown())).optional().describe("Trigger conditions"),
+      actions: z74.array(z74.record(z74.string(), z74.unknown())).optional().describe("Trigger actions"),
+      enabled: z74.boolean().optional().describe("Trigger enabled flag"),
+      schedule: z74.string().optional().describe("Trigger schedule"),
+      query: z74.string().optional().describe("Trigger query or filter"),
+      skill_name: z74.string().optional().describe("Skill name for load_skill"),
+      pack_name: z74.string().optional().describe("Starter pack name"),
+      title: z74.string().optional().describe("Procedure title"),
+      content: z74.string().optional().describe("Procedure content"),
+      priority: z74.enum(["p0", "p1", "p2"]).optional().describe("Procedure priority"),
+      domain: z74.string().optional().describe("Procedure domain"),
+      procedure_id: z74.string().optional().describe("Procedure id for deactivate"),
+      subaction: z74.enum(["store", "list", "deactivate"]).optional().describe("Nested action for company_procedure/global_procedure"),
+      max_clusters: z74.coerce.number().optional().describe("Consolidation max clusters"),
+      force: z74.boolean().optional().describe("Force operation where supported"),
+      cloud_action: z74.enum(["status", "sync", "reupload"]).optional().describe("Nested operation for action=cloud_sync"),
+      confirm_local_db_source_of_truth: z74.string().optional().describe("Required for cloud_action=reupload; must exactly equal LOCAL DB IS SOURCE OF TRUTH"),
+      domain_name: z74.string().optional().describe("Client deployment domain"),
+      phase: z74.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;
@@ -25317,10 +25512,10 @@ function registerConfig(server2) {
 }
 
 // src/mcp/tools/wiki.ts
-import { z as z76 } from "zod";
+import { z as z77 } from "zod";
 
 // src/mcp/tools/list-wiki-pages.ts
-import { z as z74 } from "zod";
+import { z as z75 } from "zod";
 var FETCH_TIMEOUT_MS3 = 1e4;
 function registerListWikiPages(server2) {
   server2.registerTool(
@@ -25329,8 +25524,8 @@ function registerListWikiPages(server2) {
       title: "List Wiki Pages",
       description: "List documents in an exe-wiki workspace. Optionally filter by folder.",
       inputSchema: {
-        workspace: z74.string().describe('Wiki workspace slug (e.g., "hygo")'),
-        folder: z74.string().optional().describe("Filter by folder path")
+        workspace: z75.string().describe('Wiki workspace slug (e.g., "hygo")'),
+        folder: z75.string().optional().describe("Filter by folder path")
       }
     },
     async ({ workspace, folder }) => {
@@ -25419,7 +25614,7 @@ function registerListWikiPages(server2) {
 }
 
 // src/mcp/tools/get-wiki-page.ts
-import { z as z75 } from "zod";
+import { z as z76 } from "zod";
 var FETCH_TIMEOUT_MS4 = 1e4;
 function registerGetWikiPage(server2) {
   server2.registerTool(
@@ -25428,9 +25623,9 @@ function registerGetWikiPage(server2) {
       title: "Get Wiki Page",
       description: "Read a wiki page by document ID or title. Returns content, metadata, and folder path. Use title search when you know the page name but not the ID.",
       inputSchema: {
-        workspace: z75.string().describe('Wiki workspace slug (e.g., "hygo")'),
-        document_id: z75.string().optional().describe("Specific document ID (exact lookup)"),
-        title: z75.string().optional().describe("Search by title (fuzzy match)")
+        workspace: z76.string().describe('Wiki workspace slug (e.g., "hygo")'),
+        document_id: z76.string().optional().describe("Specific document ID (exact lookup)"),
+        title: z76.string().optional().describe("Search by title (fuzzy match)")
       }
     },
     async ({ workspace, document_id, title }) => {
@@ -25612,14 +25807,14 @@ function registerWiki(server2) {
       title: "Wiki",
       description: "Consolidated wiki domain tool. Actions: list, get. Wiki writes flow through raw data ingestion/projection into the curated wiki store; direct create/update MCP tools have been removed.",
       inputSchema: {
-        action: z76.enum(["list", "get"]).describe("Wiki read operation. Writes use raw-data ingestion/projection, not direct MCP writes."),
-        workspace: z76.string().optional().describe("Wiki workspace slug"),
-        title: z76.string().optional().describe("Fuzzy page title lookup for get"),
-        content: z76.string().optional().describe("Reserved; wiki writes use raw-data ingestion/projection"),
-        folder: z76.string().optional().describe("Optional folder path for list"),
-        document_id: z76.string().optional().describe("Document ID for get"),
-        mode: z76.enum(["replace", "append"]).optional().describe("Reserved; direct wiki updates are removed"),
-        section: z76.string().optional().describe("Reserved; direct wiki updates are removed")
+        action: z77.enum(["list", "get"]).describe("Wiki read operation. Writes use raw-data ingestion/projection, not direct MCP writes."),
+        workspace: z77.string().optional().describe("Wiki workspace slug"),
+        title: z77.string().optional().describe("Fuzzy page title lookup for get"),
+        content: z77.string().optional().describe("Reserved; wiki writes use raw-data ingestion/projection"),
+        folder: z77.string().optional().describe("Optional folder path for list"),
+        document_id: z77.string().optional().describe("Document ID for get"),
+        mode: z77.enum(["replace", "append"]).optional().describe("Reserved; direct wiki updates are removed"),
+        section: z77.string().optional().describe("Reserved; direct wiki updates are removed")
       }
     },
     async (input, extra) => {
@@ -25647,7 +25842,7 @@ init_active_agent();
 init_project_name();
 init_database();
 init_employees();
-import { z as z77 } from "zod";
+import { z as z78 } from "zod";
 function rowToBehavior2(r) {
   return {
     id: String(r.id),
@@ -25669,13 +25864,13 @@ function registerBehavior(server2) {
       title: "Behavior",
       description: "Manage behavioral patterns, corrections, and reusable procedures for employees. Actions: store (create new), list (query existing), deactivate (soft-delete, restricted).",
       inputSchema: {
-        action: z77.enum(["store", "list", "deactivate"]).describe("Action to perform"),
-        content: z77.string().max(500).optional().describe("The behavioral instruction \u2014 one clear sentence (store)"),
-        domain: z77.string().optional().describe("Category: workflow, code-style, tool-use, communication, architecture, testing"),
-        priority: z77.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always included. p1 = standard (default). p2 = nice-to-have."),
-        agent_id: z77.string().optional().describe("Employee name. Defaults to current agent. Pass 'all' to list everyone's (list only)."),
-        project_name: z77.string().optional().describe("Defaults to current project. Pass 'global' for a behavior that applies everywhere (store)."),
-        behavior_id: z77.string().optional().describe("UUID of the behavior (deactivate)")
+        action: z78.enum(["store", "list", "deactivate"]).describe("Action to perform"),
+        content: z78.string().max(500).optional().describe("The behavioral instruction \u2014 one clear sentence (store)"),
+        domain: z78.string().optional().describe("Category: workflow, code-style, tool-use, communication, architecture, testing"),
+        priority: z78.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always included. p1 = standard (default). p2 = nice-to-have."),
+        agent_id: z78.string().optional().describe("Employee name. Defaults to current agent. Pass 'all' to list everyone's (list only)."),
+        project_name: z78.string().optional().describe("Defaults to current project. Pass 'global' for a behavior that applies everywhere (store)."),
+        behavior_id: z78.string().optional().describe("UUID of the behavior (deactivate)")
       }
     },
     async ({ action, content, domain, priority, agent_id, project_name, behavior_id }) => {
@@ -25846,7 +26041,7 @@ Content: ${row.content}`
 }
 
 // src/mcp/tools/reminder.ts
-import { z as z78 } from "zod";
+import { z as z79 } from "zod";
 function registerReminder(server2) {
   server2.registerTool(
     "reminder",
@@ -25854,11 +26049,11 @@ function registerReminder(server2) {
       title: "Reminder",
       description: "Manage reminders for the founder. Shown in the boot brief every session. Actions: create (set new), list (view active), complete (mark done).",
       inputSchema: {
-        action: z78.enum(["create", "list", "complete"]).describe("Action to perform"),
-        text: z78.string().optional().describe("What to remind about (create)"),
-        due_date: z78.string().optional().describe("Optional due date \u2014 ISO date (2026-04-01) or null for persistent (create)"),
-        reminder_id: z78.string().optional().describe("Reminder UUID or text substring to match (complete)"),
-        include_completed: z78.boolean().optional().default(false).describe("Include completed reminders (list)")
+        action: z79.enum(["create", "list", "complete"]).describe("Action to perform"),
+        text: z79.string().optional().describe("What to remind about (create)"),
+        due_date: z79.string().optional().describe("Optional due date \u2014 ISO date (2026-04-01) or null for persistent (create)"),
+        reminder_id: z79.string().optional().describe("Reminder UUID or text substring to match (complete)"),
+        include_completed: z79.boolean().optional().default(false).describe("Include completed reminders (list)")
       }
     },
     async ({ action, text: text3, due_date, reminder_id, include_completed }) => {
@@ -25914,7 +26109,7 @@ function registerReminder(server2) {
 init_global_procedures();
 init_active_agent();
 init_employees();
-import { z as z79 } from "zod";
+import { z as z80 } from "zod";
 function registerStoreGlobalProcedure(server2) {
   server2.registerTool(
     "store_global_procedure",
@@ -25922,10 +26117,10 @@ function registerStoreGlobalProcedure(server2) {
       title: "Store Company Procedure (use global_procedure instead)",
       description: "DEPRECATED \u2014 use global_procedure with action='store'. Create a company procedure (customer-owned Layer 0 rule). RESTRICTED: only coordinator or founder sessions.",
       inputSchema: {
-        title: z79.string().describe("Short title for the procedure"),
-        content: z79.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
-        priority: z79.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default)."),
-        domain: z79.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security")
+        title: z80.string().describe("Short title for the procedure"),
+        content: z80.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
+        priority: z80.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default)."),
+        domain: z80.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security")
       }
     },
     async ({ title, content, priority, domain }) => {
@@ -26003,7 +26198,7 @@ init_global_procedures();
 init_active_agent();
 init_database();
 init_employees();
-import { z as z80 } from "zod";
+import { z as z81 } from "zod";
 function registerDeactivateGlobalProcedure(server2) {
   server2.registerTool(
     "deactivate_global_procedure",
@@ -26011,7 +26206,7 @@ function registerDeactivateGlobalProcedure(server2) {
       title: "Deactivate Company Procedure (use global_procedure instead)",
       description: "DEPRECATED \u2014 use global_procedure with action='deactivate'. Soft-delete a company procedure. RESTRICTED: only coordinator or founder sessions.",
       inputSchema: {
-        procedure_id: z80.string().describe("UUID of the company procedure to deactivate")
+        procedure_id: z81.string().describe("UUID of the company procedure to deactivate")
       }
     },
     async ({ procedure_id }) => {
@@ -26071,7 +26266,7 @@ init_store();
 init_active_agent();
 init_database();
 init_plan_limits();
-import { z as z81 } from "zod";
+import { z as z82 } from "zod";
 import crypto17 from "crypto";
 function registerStoreDecision(server2) {
   server2.registerTool(
@@ -26080,13 +26275,13 @@ function registerStoreDecision(server2) {
       title: "Store Decision",
       description: "Store an authoritative decision keyed by domain. Use this when a decision is made that should be canonical \u2014 future lookups via get_decision return the latest decision for that domain. Supports supersession chains.",
       inputSchema: {
-        domain: z81.string().describe(
+        domain: z82.string().describe(
           "Domain key, e.g. 'auth-strategy', 'db-migration-approach', 'api-versioning'"
         ),
-        decision: z81.string().describe("The decision text \u2014 what was decided"),
-        rationale: z81.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
-        supersedes: z81.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
-        project_name: z81.string().optional().describe("Project name")
+        decision: z82.string().describe("The decision text \u2014 what was decided"),
+        rationale: z82.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
+        supersedes: z82.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
+        project_name: z82.string().optional().describe("Project name")
       }
     },
     async ({ domain, decision, rationale, supersedes, project_name }) => {
@@ -26154,7 +26349,7 @@ Supersedes: ${supersedes}` : ""}`
 
 // src/mcp/tools/get-decision.ts
 init_database();
-import { z as z82 } from "zod";
+import { z as z83 } from "zod";
 function registerGetDecision(server2) {
   server2.registerTool(
     "get_decision",
@@ -26162,7 +26357,7 @@ function registerGetDecision(server2) {
       title: "Get Decision",
       description: "Retrieve the latest authoritative decision for a domain. Returns the current active decision and the supersession history.",
       inputSchema: {
-        domain: z82.string().describe(
+        domain: z83.string().describe(
           "Domain key to look up, e.g. 'auth-strategy', 'db-migration-approach'"
         )
       }
@@ -26225,16 +26420,16 @@ function registerGetDecision(server2) {
 }
 
 // src/mcp/tools/people-roster.ts
-import { z as z83 } from "zod";
+import { z as z84 } from "zod";
 
 // src/lib/people.ts
 init_config();
 import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync36, readFileSync as readFileSync29 } from "fs";
-import path45 from "path";
-var PEOPLE_PATH = path45.join(EXE_AI_DIR, "people.json");
+import { existsSync as existsSync38, readFileSync as readFileSync31 } from "fs";
+import path47 from "path";
+var PEOPLE_PATH = path47.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {
-  if (!existsSync36(PEOPLE_PATH)) return [];
+  if (!existsSync38(PEOPLE_PATH)) return [];
   try {
     const raw = await readFile5(PEOPLE_PATH, "utf-8");
     return JSON.parse(raw);
@@ -26243,7 +26438,7 @@ async function loadPeople() {
   }
 }
 async function savePeople(people) {
-  await mkdir5(path45.dirname(PEOPLE_PATH), { recursive: true });
+  await mkdir5(path47.dirname(PEOPLE_PATH), { recursive: true });
   await writeFile6(PEOPLE_PATH, JSON.stringify(people, null, 2) + "\n", "utf-8");
 }
 async function addPerson(person) {
@@ -26273,10 +26468,10 @@ function registerAddPerson(server2) {
       title: "Add Person",
       description: "Add or update a key human in the people roster. Used for co-founders, partners, customers \u2014 anyone agents need to know about.",
       inputSchema: {
-        name: z83.string().describe("Person's name"),
-        role: z83.string().describe("Their role (e.g. co-founder, customer, partner)"),
-        relationship: z83.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
-        notes: z83.string().optional().describe("Additional context about this person")
+        name: z84.string().describe("Person's name"),
+        role: z84.string().describe("Their role (e.g. co-founder, customer, partner)"),
+        relationship: z84.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
+        notes: z84.string().optional().describe("Additional context about this person")
       }
     },
     async ({ name, role, relationship, notes }) => {
@@ -26322,7 +26517,7 @@ function registerGetPerson(server2) {
       title: "Get Person",
       description: "Look up a specific person by name from the people roster.",
       inputSchema: {
-        name: z83.string().describe("Person's name to look up")
+        name: z84.string().describe("Person's name to look up")
       }
     },
     async ({ name }) => {
@@ -26346,10 +26541,10 @@ Notes: ${person.notes}` : ""}`
 }
 
 // src/mcp/tools/crm.ts
-import { z as z84 } from "zod";
+import { z as z85 } from "zod";
 
 // src/lib/exe-db-read.ts
-import path46 from "path";
+import path48 from "path";
 import os19 from "os";
 import { createRequire as createRequire5 } from "module";
 import { pathToFileURL as pathToFileURL5 } from "url";
@@ -26367,8 +26562,8 @@ async function getExeDbReadClient() {
         if (!Ctor2) throw new Error(`No PrismaClient export found at ${explicitPath}`);
         return new Ctor2();
       }
-      const exeDbRoot = process.env.EXE_DB_ROOT ?? path46.join(os19.homedir(), "exe-db");
-      const req = createRequire5(path46.join(exeDbRoot, "package.json"));
+      const exeDbRoot = process.env.EXE_DB_ROOT ?? path48.join(os19.homedir(), "exe-db");
+      const req = createRequire5(path48.join(exeDbRoot, "package.json"));
       const entry = req.resolve("@prisma/client");
       const mod = await import(pathToFileURL5(entry).href);
       const Ctor = mod.PrismaClient ?? mod.default?.PrismaClient;
@@ -26401,12 +26596,12 @@ function registerCrm(server2) {
     title: "CRM",
     description: "Read-only CRM access from exe-db crm schema. Actions: list_people, get_person, list_tables, describe_table.",
     inputSchema: {
-      action: z84.enum(["list_people", "get_person", "list_tables", "describe_table"]).describe("CRM read operation"),
-      id: z84.string().optional().describe("CRM row/person id for get_person"),
-      query: z84.string().optional().describe("Text search for list_people/get_person"),
-      table: z84.string().optional().describe("crm schema table name for describe_table"),
-      limit: z84.coerce.number().int().min(1).max(50).optional().describe("Max rows, capped at 50"),
-      offset: z84.coerce.number().int().min(0).optional().describe("Rows to skip")
+      action: z85.enum(["list_people", "get_person", "list_tables", "describe_table"]).describe("CRM read operation"),
+      id: z85.string().optional().describe("CRM row/person id for get_person"),
+      query: z85.string().optional().describe("Text search for list_people/get_person"),
+      table: z85.string().optional().describe("crm schema table name for describe_table"),
+      limit: z85.coerce.number().int().min(1).max(50).optional().describe("Max rows, capped at 50"),
+      offset: z85.coerce.number().int().min(0).optional().describe("Rows to skip")
     }
   }, async ({ action, id, query, table, limit, offset }) => {
     try {
@@ -26465,7 +26660,7 @@ function registerCrm(server2) {
 }
 
 // src/mcp/tools/raw-data.ts
-import { z as z85 } from "zod";
+import { z as z86 } from "zod";
 function text2(content, isError = false) {
   return { content: [{ type: "text", text: content }], ...isError ? { isError: true } : {} };
 }
@@ -26474,15 +26669,15 @@ function registerRawData(server2) {
     title: "Raw Data",
     description: "Read-only access to exe-db raw.raw_events landing pad. Actions: list_sources, query, get. Results are capped because raw payloads can consume many tokens.",
     inputSchema: {
-      action: z85.enum(["list_sources", "query", "get"]).describe("Raw data read operation"),
-      id: z85.string().optional().describe("raw.raw_events id for action=get"),
-      source: z85.string().optional().describe("Filter by raw source"),
-      event_type: z85.string().optional().describe("Filter by event_type"),
-      query: z85.string().optional().describe("Search payload/metadata text"),
-      processed: z85.boolean().optional().describe("Filter processed_at IS NULL/NOT NULL"),
-      limit: z85.coerce.number().int().min(1).max(50).optional().describe("Max rows, capped at 50"),
-      offset: z85.coerce.number().int().min(0).optional().describe("Rows to skip"),
-      include_payload: z85.boolean().optional().describe("Include full payload JSON. Default false to save tokens.")
+      action: z86.enum(["list_sources", "query", "get"]).describe("Raw data read operation"),
+      id: z86.string().optional().describe("raw.raw_events id for action=get"),
+      source: z86.string().optional().describe("Filter by raw source"),
+      event_type: z86.string().optional().describe("Filter by event_type"),
+      query: z86.string().optional().describe("Search payload/metadata text"),
+      processed: z86.boolean().optional().describe("Filter processed_at IS NULL/NOT NULL"),
+      limit: z86.coerce.number().int().min(1).max(50).optional().describe("Max rows, capped at 50"),
+      offset: z86.coerce.number().int().min(0).optional().describe("Rows to skip"),
+      include_payload: z86.boolean().optional().describe("Include full payload JSON. Default false to save tokens.")
     }
   }, async ({ action, id, source, event_type, query, processed, limit, offset, include_payload }) => {
     try {
@@ -26549,17 +26744,17 @@ init_active_agent();
 init_config();
 init_license();
 init_store();
-import { z as z86 } from "zod";
+import { z as z87 } from "zod";
 import crypto18 from "crypto";
 import { mkdir as mkdir6, writeFile as writeFile7 } from "fs/promises";
-import path47 from "path";
-var CLASSIFICATION = z86.enum([
+import path49 from "path";
+var CLASSIFICATION = z87.enum([
   "upstream_bug",
   "customer_customization",
   "emergency_hotfix",
   "unclear"
 ]);
-var SEVERITY = z86.enum(["p0", "p1", "p2", "p3"]);
+var SEVERITY = z87.enum(["p0", "p1", "p2", "p3"]);
 function slugify2(input) {
   return input.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "bug-report";
 }
@@ -26637,22 +26832,22 @@ function registerCreateBugReport(server2) {
       title: "Create Bug Report",
       description: "Classify and file an exe-os issue as upstream_bug, customer_customization, emergency_hotfix, or unclear. Writes a local report, stores memory, and optionally sends to AskExe support when a support endpoint is configured.",
       inputSchema: {
-        title: z86.string().min(3).describe("Short descriptive title"),
+        title: z87.string().min(3).describe("Short descriptive title"),
         classification: CLASSIFICATION.describe(
           "upstream_bug = platform defect; customer_customization = local preference; emergency_hotfix = temporary local patch; unclear = needs maintainer triage"
         ),
         severity: SEVERITY.default("p2").describe("p0 critical \u2192 p3 low"),
-        summary: z86.string().min(10).describe("What happened and why it matters"),
-        customer_impact: z86.string().optional().describe("How this affects the customer/founder"),
-        reproduction_steps: z86.array(z86.string()).optional().describe("Steps to reproduce"),
-        expected: z86.string().optional().describe("Expected behavior"),
-        actual: z86.string().optional().describe("Actual behavior"),
-        files_changed: z86.array(z86.string()).optional().describe("Files changed or suspected"),
-        workaround: z86.string().optional().describe("Temporary local workaround/hotfix, if any"),
-        local_patch_diff: z86.string().optional().describe("Small local diff or patch summary"),
-        package_version: z86.string().optional().describe("Installed @askexenow/exe-os version"),
-        project_name: z86.string().optional().describe("Project/customer context"),
-        send_upstream: z86.boolean().default(true).describe("Attempt to POST to configured AskExe support endpoint")
+        summary: z87.string().min(10).describe("What happened and why it matters"),
+        customer_impact: z87.string().optional().describe("How this affects the customer/founder"),
+        reproduction_steps: z87.array(z87.string()).optional().describe("Steps to reproduce"),
+        expected: z87.string().optional().describe("Expected behavior"),
+        actual: z87.string().optional().describe("Actual behavior"),
+        files_changed: z87.array(z87.string()).optional().describe("Files changed or suspected"),
+        workaround: z87.string().optional().describe("Temporary local workaround/hotfix, if any"),
+        local_patch_diff: z87.string().optional().describe("Small local diff or patch summary"),
+        package_version: z87.string().optional().describe("Installed @askexenow/exe-os version"),
+        project_name: z87.string().optional().describe("Project/customer context"),
+        send_upstream: z87.boolean().default(true).describe("Attempt to POST to configured AskExe support endpoint")
       }
     },
     async ({
@@ -26692,9 +26887,9 @@ function registerCreateBugReport(server2) {
         filesChanged: files_changed,
         projectName: project_name
       });
-      const outDir = path47.join(EXE_AI_DIR, "bug-reports");
+      const outDir = path49.join(EXE_AI_DIR, "bug-reports");
       await mkdir6(outDir, { recursive: true });
-      const reportPath = path47.join(outDir, `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}-${slugify2(title)}-${id.slice(0, 8)}.md`);
+      const reportPath = path49.join(outDir, `${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}-${slugify2(title)}-${id.slice(0, 8)}.md`);
       await writeFile7(reportPath, markdown, "utf-8");
       let vector = null;
       try {
@@ -26761,33 +26956,33 @@ Upstream status: ${upstreamStatus}`
 }
 
 // src/mcp/tools/code-context.ts
-import { z as z87 } from "zod";
+import { z as z88 } 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 path50 from "path";
+import { existsSync as existsSync39, mkdirSync as mkdirSync21, readFileSync as readFileSync32, statSync as statSync9, writeFileSync as writeFileSync23 } 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());
+  return path50.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 });
+  const dir = path50.join(EXE_AI_DIR, "code-context");
+  mkdirSync21(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`);
+  return path50.join(indexDir(), `${rootHash}.json`);
 }
 function currentBranch(projectRoot) {
   const result2 = spawnSync("git", ["branch", "--show-current"], {
@@ -26799,11 +26994,11 @@ function currentBranch(projectRoot) {
   return branch || "detached-or-unknown";
 }
 function shouldIgnore(relPath) {
-  const parts = relPath.split(path48.sep);
+  const parts = relPath.split(path50.sep);
   return parts.some((part) => IGNORE_SEGMENTS.has(part));
 }
 function isCodeFile(relPath) {
-  return CODE_EXTENSIONS.has(path48.extname(relPath).toLowerCase());
+  return CODE_EXTENSIONS.has(path50.extname(relPath).toLowerCase());
 }
 function listCodeFiles(projectRoot, maxFiles) {
   const git = spawnSync("git", ["ls-files", "*.ts", "*.tsx", "*.js", "*.jsx"], {
@@ -26845,7 +27040,7 @@ function parseImportPaths(importText) {
 }
 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 base = path50.posix.normalize(path50.posix.join(path50.posix.dirname(fromFile.replaceAll(path50.sep, "/")), importPath));
   const withoutKnownExt = base.replace(/\.(?:js|jsx|ts|tsx)$/, "");
   const candidates = [
     base,
@@ -26857,10 +27052,10 @@ function resolveImport(fromFile, importPath, allFiles) {
     `${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")
+    path50.posix.join(base, "index.ts"),
+    path50.posix.join(base, "index.tsx"),
+    path50.posix.join(base, "index.js"),
+    path50.posix.join(base, "index.jsx")
   ];
   return candidates.find((candidate) => allFiles.has(candidate)) ?? null;
 }
@@ -26869,9 +27064,9 @@ function symbolId(filePath, chunk) {
 }
 function loadIndex(projectRoot) {
   const file = getCodeContextIndexPath(projectRoot);
-  if (!existsSync37(file)) return null;
+  if (!existsSync39(file)) return null;
   try {
-    const parsed = JSON.parse(readFileSync30(file, "utf8"));
+    const parsed = JSON.parse(readFileSync32(file, "utf8"));
     if (parsed.version !== INDEX_VERSION || parsed.projectRoot !== projectRoot) return null;
     return parsed;
   } catch {
@@ -26879,18 +27074,18 @@ function loadIndex(projectRoot) {
   }
 }
 function saveIndex(index) {
-  writeFileSync22(getCodeContextIndexPath(index.projectRoot), JSON.stringify(index, null, 2));
+  writeFileSync23(getCodeContextIndexPath(index.projectRoot), JSON.stringify(index, null, 2));
 }
 function buildFileRecord(projectRoot, relPath, allFiles, previous) {
-  const absPath = path48.join(projectRoot, relPath);
+  const absPath = path50.join(projectRoot, relPath);
   let stat;
   try {
-    stat = statSync8(absPath);
+    stat = statSync9(absPath);
   } catch {
     return null;
   }
   if (!stat.isFile()) return null;
-  const source = readFileSync30(absPath, "utf8");
+  const source = readFileSync32(absPath, "utf8");
   const hash = hashText(source);
   if (previous && previous.hash === hash && previous.mtimeMs === stat.mtimeMs && previous.size === stat.size) {
     return previous;
@@ -26927,10 +27122,10 @@ function buildCodeContextIndex(options = {}) {
   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 allFiles = new Set(files.map((file) => file.replaceAll(path50.sep, "/")));
   const fileRecords = {};
   for (const rel of files) {
-    const normalized = rel.replaceAll(path48.sep, "/");
+    const normalized = rel.replaceAll(path50.sep, "/");
     const record = buildFileRecord(projectRoot, normalized, allFiles, previous?.files[normalized]);
     if (record) fileRecords[normalized] = record;
   }
@@ -26952,11 +27147,11 @@ function loadOrBuildCodeContextIndex(options = {}) {
     if (loaded) {
       const currentFiles = listCodeFiles(projectRoot, options.maxFiles ?? DEFAULT_MAX_FILES);
       const unchanged = currentFiles.every((rel) => {
-        const normalized = rel.replaceAll(path48.sep, "/");
+        const normalized = rel.replaceAll(path50.sep, "/");
         const existing = loaded.files[normalized];
         if (!existing) return false;
         try {
-          const stat = statSync8(path48.join(projectRoot, normalized));
+          const stat = statSync9(path50.join(projectRoot, normalized));
           return stat.mtimeMs === existing.mtimeMs && stat.size === existing.size;
         } catch {
           return false;
@@ -27059,7 +27254,7 @@ function traceCodeSymbol(symbolName, options = {}) {
 }
 function resolveTargetFile(index, input) {
   if (input.filePath) {
-    const normalized = input.filePath.replaceAll(path48.sep, "/").replace(/^\.\//, "");
+    const normalized = input.filePath.replaceAll(path50.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 };
@@ -27089,7 +27284,7 @@ function analyzeBlastRadius(input) {
       }
     }
   }
-  const targetBase = path48.basename(target.filePath).replace(/\.[^.]+$/, "").toLowerCase();
+  const targetBase = path50.basename(target.filePath).replace(/\.[^.]+$/, "").toLowerCase();
   const symbolLower = input.symbol?.toLowerCase();
   const tests = Object.keys(index.files).filter((file) => {
     const lower = file.toLowerCase();
@@ -27135,15 +27330,15 @@ function registerCodeContext(server2) {
     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")
+      action: z88.enum(["index", "search", "trace", "blast_radius", "stats"]).describe("Code context operation"),
+      project_root: z88.string().optional().describe("Repository root. Defaults to current working directory."),
+      query: z88.string().optional().describe("Search query for action=search"),
+      symbol: z88.string().optional().describe("Symbol/function/class/type name for trace or blast_radius"),
+      file_path: z88.string().optional().describe("File path for blast_radius"),
+      force: z88.boolean().optional().describe("Force rebuild before answering"),
+      limit: z88.coerce.number().int().min(1).max(100).optional().describe("Max results"),
+      depth: z88.coerce.number().int().min(1).max(5).optional().describe("Dependent traversal depth for blast_radius"),
+      max_files: z88.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 };
@@ -27180,9 +27375,9 @@ function registerCodeContext(server2) {
 }
 
 // src/mcp/tools/support-inbox.ts
-import { z as z88 } from "zod";
+import { z as z89 } from "zod";
 var DEFAULT_ENDPOINT = "https://askexe.com/admin/support/bug-reports";
-var STATUS = z88.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
+var STATUS = z89.enum(["open", "triaged", "fixed", "closed", "wontfix"]);
 function adminToken() {
   return process.env.ASKEXE_SUPPORT_ADMIN_TOKEN || process.env.EXE_SUPPORT_ADMIN_TOKEN;
 }
@@ -27221,9 +27416,9 @@ function registerListBugReports(server2) {
       title: "List Bug Reports",
       description: "AskExe-internal only: list incoming customer bug reports from the support inbox.",
       inputSchema: {
-        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)
+        status: z89.enum(["all", "open", "triaged", "fixed", "closed", "wontfix"]).default("open"),
+        severity: z89.enum(["p0", "p1", "p2", "p3"]).optional(),
+        limit: z89.number().int().min(1).max(100).default(25)
       }
     },
     async ({ status, severity, limit }) => {
@@ -27242,7 +27437,7 @@ function registerGetBugReport(server2) {
     {
       title: "Get Bug Report",
       description: "AskExe-internal only: fetch one customer bug report with full markdown payload.",
-      inputSchema: { id: z88.string().min(8) }
+      inputSchema: { id: z89.string().min(8) }
     },
     async ({ id }) => {
       const data = await requestJson(`${endpoint()}/${encodeURIComponent(id)}`);
@@ -27257,12 +27452,12 @@ function registerTriageBugReport(server2) {
       title: "Triage Bug Report",
       description: "AskExe-internal only: update bug report status and link task/commit/release metadata.",
       inputSchema: {
-        id: z88.string().min(8),
+        id: z89.string().min(8),
         status: STATUS.optional(),
-        triage_notes: z88.string().optional(),
-        linked_task_id: z88.string().optional(),
-        linked_commit: z88.string().optional(),
-        fixed_version: z88.string().optional()
+        triage_notes: z89.string().optional(),
+        linked_task_id: z89.string().optional(),
+        linked_commit: z89.string().optional(),
+        fixed_version: z89.string().optional()
       }
     },
     async ({ id, status, triage_notes, linked_task_id, linked_commit, fixed_version }) => {
@@ -27388,6 +27583,7 @@ var TOOL_CATEGORIES = {
   registerDeployClient: "admin",
   registerBackupVps: "admin",
   registerGetDaemonHealth: "admin",
+  registerMcpPing: "core",
   registerGetAutoWakeStatus: "admin",
   registerGetWorkerGate: "admin",
   registerRunMemoryAudit: "admin",
@@ -27425,6 +27621,7 @@ var CHIEF_OF_STAFF_READ_TOOLS = /* @__PURE__ */ new Set([
   "registerSearchEverything",
   "registerGetDecision",
   "registerGetIdentity",
+  "registerMcpPing",
   "registerListTasks",
   "registerGetTask",
   "registerListReminders",
@@ -27597,6 +27794,7 @@ function registerAllTools(server2) {
   if (exposeLegacyConfig) {
     gate("registerGetAgentSpend", registerGetAgentSpend);
   }
+  gate("registerMcpPing", registerMcpPing);
   if (exposeLegacyGraph) {
     gate("registerGetGraphStats", registerGetGraphStats);
     gate("registerGetEntityNeighbors", registerGetEntityNeighbors);
@@ -27758,16 +27956,16 @@ try {
     }
   }, 3e4);
   _ppidWatchdog.unref();
-  const MCP_VERSION_PATH = path49.join(os20.homedir(), ".exe-os", "mcp-version");
+  const MCP_VERSION_PATH = path51.join(os20.homedir(), ".exe-os", "mcp-version");
   let _currentMcpVersion = null;
   try {
-    _currentMcpVersion = existsSync38(MCP_VERSION_PATH) ? readFileSync31(MCP_VERSION_PATH, "utf8").trim() : null;
+    _currentMcpVersion = existsSync40(MCP_VERSION_PATH) ? readFileSync33(MCP_VERSION_PATH, "utf8").trim() : null;
   } catch {
   }
   const _versionWatchdog = setInterval(() => {
     try {
-      if (!existsSync38(MCP_VERSION_PATH)) return;
-      const diskVersion = readFileSync31(MCP_VERSION_PATH, "utf8").trim();
+      if (!existsSync40(MCP_VERSION_PATH)) return;
+      const diskVersion = readFileSync33(MCP_VERSION_PATH, "utf8").trim();
       if (_currentMcpVersion && diskVersion !== _currentMcpVersion) {
         process.stderr.write(
           `[exe-os] MCP version changed (${_currentMcpVersion} \u2192 ${diskVersion}). Hot-reloading...
@@ -27799,18 +27997,18 @@ try {
         `[exe-os] Periodic backfill: ${nullCount} NULL vectors \u2014 spawning job
 `
       );
-      const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path49.resolve(
-        path49.dirname(thisFile),
+      const thisFile = fileURLToPath6(import.meta.url);
+      const backfillPath = path51.resolve(
+        path51.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
-      if (existsSync38(backfillPath)) {
+      if (existsSync40(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path49.join(exeDir, "workers.log");
-        mkdirSync21(path49.dirname(logPath), { recursive: true });
+        const logPath = path51.join(exeDir, "workers.log");
+        mkdirSync22(path51.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
-          logFd = openSync3(logPath, "a");
+          logFd = openSync4(logPath, "a");
         } catch {
         }
         const child = spawn4(process.execPath, [backfillPath], {
@@ -27820,7 +28018,7 @@ try {
         child.unref();
         if (child.pid) registerWorkerPid2(child.pid);
         if (typeof logFd === "number") try {
-          closeSync3(logFd);
+          closeSync4(logFd);
         } catch {
         }
       } else {