@askexenow/exe-os 0.9.0 → 0.9.2

package/dist/mcp/server.js

@@ -698,10 +698,10 @@ async function disposeEmbedder() {
 async function embedDirect(text) {
   const llamaCpp = await import("node-llama-cpp");
   const { MODELS_DIR: MODELS_DIR2 } = await Promise.resolve().then(() => (init_config(), config_exports));
-  const { existsSync: existsSync31 } = await import("fs");
-  const path38 = await import("path");
-  const modelPath = path38.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
-  if (!existsSync31(modelPath)) {
+  const { existsSync: existsSync32 } = await import("fs");
+  const path40 = await import("path");
+  const modelPath = path40.join(MODELS_DIR2, "jina-embeddings-v5-small-q4_k_m.gguf");
+  if (!existsSync32(modelPath)) {
     throw new Error(`Embedding model not found at ${modelPath}. Run '/exe-setup' to download it.`);
   }
   const llama = await llamaCpp.getLlama();
@@ -6108,7 +6108,7 @@ var init_agent_config = __esm({
     AGENT_CONFIG_PATH = path16.join(EXE_AI_DIR, "agent-config.json");
     KNOWN_RUNTIMES = {
       claude: ["claude-opus-4", "claude-sonnet-4", "claude-haiku-4.5"],
-      codex: ["gpt-5.4", "gpt-5.5", "o3", "o4-mini"],
+      codex: ["gpt-5.4", "gpt-5.5", "gpt-5.3-codex-spark", "o3", "o4-mini"],
       opencode: ["anthropic/claude-sonnet-4-6", "openai/gpt-5.4", "google/gemini-2.5-pro", "deepseek/deepseek-r3", "minimax/minimax-m2.5"]
     };
     RUNTIME_LABELS = {
@@ -6125,6 +6125,14 @@ var init_agent_config = __esm({
 });
 
 // src/lib/intercom-queue.ts
+var intercom_queue_exports = {};
+__export(intercom_queue_exports, {
+  clearQueueForAgent: () => clearQueueForAgent,
+  drainForSession: () => drainForSession,
+  drainQueue: () => drainQueue,
+  queueIntercom: () => queueIntercom,
+  readQueue: () => readQueue
+});
 import { readFileSync as readFileSync11, writeFileSync as writeFileSync8, renameSync as renameSync3, existsSync as existsSync13, mkdirSync as mkdirSync6 } from "fs";
 import path17 from "path";
 import os7 from "os";
@@ -6163,11 +6171,80 @@ function queueIntercom(targetSession, reason) {
   }
   writeQueue(queue);
 }
-var QUEUE_PATH, TTL_MS, INTERCOM_LOG;
+function drainQueue(isSessionBusy2, sendKeys) {
+  const queue = readQueue();
+  if (queue.length === 0) return { drained: 0, failed: 0 };
+  const remaining = [];
+  let drained = 0;
+  let failed = 0;
+  for (const item of queue) {
+    const age = Date.now() - new Date(item.queuedAt).getTime();
+    if (age > TTL_MS) {
+      logQueue(`EXPIRED \u2192 ${item.targetSession} (${Math.round(age / 6e4)}min old, reason: ${item.reason})`);
+      failed++;
+      continue;
+    }
+    try {
+      if (!isSessionBusy2(item.targetSession)) {
+        const success = sendKeys(item.targetSession);
+        if (success) {
+          logQueue(`DRAINED \u2192 ${item.targetSession} (after ${item.attempts} retries)`);
+          drained++;
+          continue;
+        }
+      }
+    } catch {
+    }
+    item.attempts++;
+    if (item.attempts >= MAX_RETRIES2) {
+      logQueue(`FAILED \u2192 ${item.targetSession} (${MAX_RETRIES2} retries exhausted, reason: ${item.reason})`);
+      failed++;
+      continue;
+    }
+    remaining.push(item);
+  }
+  writeQueue(remaining);
+  return { drained, failed };
+}
+function drainForSession(targetSession, sendKeys) {
+  const queue = readQueue();
+  const match = queue.findIndex((q) => q.targetSession === targetSession);
+  if (match < 0) return false;
+  const success = sendKeys(targetSession);
+  if (success) {
+    queue.splice(match, 1);
+    writeQueue(queue);
+    logQueue(`DRAINED \u2192 ${targetSession} (prompt-submit trigger)`);
+    return true;
+  }
+  return false;
+}
+function clearQueueForAgent(agentName) {
+  const queue = readQueue();
+  const before = queue.length;
+  const filtered = queue.filter((q) => !q.targetSession.startsWith(`${agentName}-`));
+  if (filtered.length < before) {
+    writeQueue(filtered);
+    logQueue(`CLEARED ${before - filtered.length} stale item(s) for ${agentName}`);
+  }
+}
+function logQueue(msg) {
+  const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [queue] ${msg}
+`;
+  process.stderr.write(`[intercom-queue] ${msg}
+`);
+  try {
+    const { appendFileSync: appendFileSync3 } = __require("fs");
+    appendFileSync3(INTERCOM_LOG, line);
+  } catch {
+  }
+}
+var QUEUE_PATH, MAX_RETRIES2, TTL_MS, INTERCOM_LOG;
 var init_intercom_queue = __esm({
   "src/lib/intercom-queue.ts"() {
     "use strict";
     QUEUE_PATH = path17.join(os7.homedir(), ".exe-os", "intercom-queue.json");
+    MAX_RETRIES2 = 5;
     TTL_MS = 60 * 60 * 1e3;
     INTERCOM_LOG = path17.join(os7.homedir(), ".exe-os", "intercom.log");
   }
@@ -7806,6 +7883,13 @@ ${input.result}` : `\u26A0\uFE0F ${warning}`;
     await client.execute("PRAGMA wal_checkpoint(PASSIVE)");
   } catch {
   }
+  if (input.status === "done" || input.status === "cancelled") {
+    try {
+      const { clearQueueForAgent: clearQueueForAgent2 } = await Promise.resolve().then(() => (init_intercom_queue(), intercom_queue_exports));
+      clearQueueForAgent2(String(row.assigned_to));
+    } catch {
+    }
+  }
   try {
     await writeCheckpoint({
       taskId,
@@ -9651,7 +9735,7 @@ async function deliverLocalMessage(messageId) {
     return true;
   } catch {
     const newRetryCount = msg.retryCount + 1;
-    if (newRetryCount >= MAX_RETRIES2) {
+    if (newRetryCount >= MAX_RETRIES3) {
       await markFailed(messageId, "session unavailable after 10 retries");
     } else {
       await client.execute({
@@ -9669,13 +9753,13 @@ async function markFailed(messageId, reason) {
     args: [(/* @__PURE__ */ new Date()).toISOString(), reason, messageId]
   });
 }
-var MAX_RETRIES2, _wsClientSend;
+var MAX_RETRIES3, _wsClientSend;
 var init_messaging = __esm({
   "src/lib/messaging.ts"() {
     "use strict";
     init_database();
     init_tmux_routing();
-    MAX_RETRIES2 = 10;
+    MAX_RETRIES3 = 10;
     _wsClientSend = null;
   }
 });
@@ -9733,7 +9817,7 @@ __export(consolidation_exports, {
   selectUnconsolidated: () => selectUnconsolidated,
   storeConsolidation: () => storeConsolidation
 });
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 async function selectUnconsolidated(client, limit = 200) {
   const result = await client.execute({
     sql: `SELECT id, agent_id, project_name, tool_name, raw_text, timestamp
@@ -9829,7 +9913,7 @@ async function consolidateCluster(cluster, model) {
   return textBlock?.text ?? "";
 }
 async function storeConsolidation(client, cluster, synthesisText, embedFn) {
-  const consolidatedId = randomUUID5();
+  const consolidatedId = randomUUID6();
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const rawText = `CONSOLIDATION [${cluster.dateRange}, ${cluster.projectName}]:
 
@@ -9854,7 +9938,7 @@ ${synthesisText}`;
   const linkStmts = sourceIds.map((sourceId) => ({
     sql: `INSERT INTO consolidations (id, consolidated_memory_id, source_memory_id, created_at)
           VALUES (?, ?, ?, ?)`,
-    args: [randomUUID5(), consolidatedId, sourceId, now]
+    args: [randomUUID6(), consolidatedId, sourceId, now]
   }));
   const placeholders = sourceIds.map(() => "?").join(",");
   const markStmt = {
@@ -10100,14 +10184,14 @@ __export(wiki_client_exports, {
   listDocuments: () => listDocuments,
   listWorkspaces: () => listWorkspaces
 });
-async function wikiFetch(config2, path38, method = "GET", body) {
-  const url = `${config2.baseUrl}/api/v1${path38}`;
+async function wikiFetch(config2, path40, method = "GET", body) {
+  const url = `${config2.baseUrl}/api/v1${path40}`;
   const headers = {
     Authorization: `Bearer ${config2.apiKey}`,
     "Content-Type": "application/json"
   };
   const controller = new AbortController();
-  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS2);
+  const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS3);
   try {
     let response;
     try {
@@ -10120,7 +10204,7 @@ async function wikiFetch(config2, path38, method = "GET", body) {
     } catch {
       clearTimeout(timeout);
       const retryController = new AbortController();
-      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS2);
+      const retryTimeout = setTimeout(() => retryController.abort(), REQUEST_TIMEOUT_MS3);
       try {
         await new Promise((r) => setTimeout(r, 500));
         response = await fetch(url, {
@@ -10134,7 +10218,7 @@ async function wikiFetch(config2, path38, method = "GET", body) {
       }
     }
     if (!response.ok) {
-      throw new Error(`Wiki API ${method} ${path38}: ${response.status} ${response.statusText}`);
+      throw new Error(`Wiki API ${method} ${path40}: ${response.status} ${response.statusText}`);
     }
     return response.json();
   } finally {
@@ -10224,12 +10308,12 @@ async function getChatHistory(client, workspaceSlug, limit = 50) {
     sentAt: h.sentAt ?? 0
   }));
 }
-var LOCAL_WIKI_URL, REQUEST_TIMEOUT_MS2;
+var LOCAL_WIKI_URL, REQUEST_TIMEOUT_MS3;
 var init_wiki_client = __esm({
   "src/lib/wiki-client.ts"() {
     "use strict";
     LOCAL_WIKI_URL = process.env.EXE_WIKI_URL || "http://localhost:3001";
-    REQUEST_TIMEOUT_MS2 = 8e3;
+    REQUEST_TIMEOUT_MS3 = 8e3;
   }
 });
 
@@ -10243,14 +10327,14 @@ __export(worker_gate_exports, {
   tryAcquireBackfillLock: () => tryAcquireBackfillLock,
   tryAcquireWorkerSlot: () => tryAcquireWorkerSlot
 });
-import { readdirSync as readdirSync9, writeFileSync as writeFileSync15, unlinkSync as unlinkSync8, mkdirSync as mkdirSync12, existsSync as existsSync24 } from "fs";
-import path31 from "path";
+import { readdirSync as readdirSync9, writeFileSync as writeFileSync17, unlinkSync as unlinkSync8, mkdirSync as mkdirSync14, existsSync as existsSync25 } from "fs";
+import path33 from "path";
 function tryAcquireWorkerSlot() {
   try {
-    mkdirSync12(WORKER_PID_DIR, { recursive: true });
+    mkdirSync14(WORKER_PID_DIR, { recursive: true });
     const reservationId = `res-${process.pid}-${Date.now()}`;
-    const reservationPath = path31.join(WORKER_PID_DIR, `${reservationId}.pid`);
-    writeFileSync15(reservationPath, String(process.pid));
+    const reservationPath = path33.join(WORKER_PID_DIR, `${reservationId}.pid`);
+    writeFileSync17(reservationPath, String(process.pid));
     const files = readdirSync9(WORKER_PID_DIR);
     let alive = 0;
     for (const f of files) {
@@ -10267,7 +10351,7 @@ function tryAcquireWorkerSlot() {
         alive++;
       } catch {
         try {
-          unlinkSync8(path31.join(WORKER_PID_DIR, f));
+          unlinkSync8(path33.join(WORKER_PID_DIR, f));
         } catch {
         }
       }
@@ -10290,21 +10374,21 @@ function tryAcquireWorkerSlot() {
 }
 function registerWorkerPid(pid) {
   try {
-    mkdirSync12(WORKER_PID_DIR, { recursive: true });
-    writeFileSync15(path31.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
+    mkdirSync14(WORKER_PID_DIR, { recursive: true });
+    writeFileSync17(path33.join(WORKER_PID_DIR, `worker-${pid}.pid`), String(pid));
   } catch {
   }
 }
 function cleanupWorkerPid() {
   try {
-    unlinkSync8(path31.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
+    unlinkSync8(path33.join(WORKER_PID_DIR, `worker-${process.pid}.pid`));
   } catch {
   }
 }
 function tryAcquireBackfillLock() {
   try {
-    mkdirSync12(WORKER_PID_DIR, { recursive: true });
-    if (existsSync24(BACKFILL_LOCK)) {
+    mkdirSync14(WORKER_PID_DIR, { recursive: true });
+    if (existsSync25(BACKFILL_LOCK)) {
       try {
         const pid = parseInt(
           __require("fs").readFileSync(BACKFILL_LOCK, "utf8").trim(),
@@ -10320,7 +10404,7 @@ function tryAcquireBackfillLock() {
       } catch {
       }
     }
-    writeFileSync15(BACKFILL_LOCK, String(process.pid));
+    writeFileSync17(BACKFILL_LOCK, String(process.pid));
     return true;
   } catch {
     return true;
@@ -10337,9 +10421,9 @@ var init_worker_gate = __esm({
   "src/lib/worker-gate.ts"() {
     "use strict";
     init_config();
-    WORKER_PID_DIR = path31.join(EXE_AI_DIR, "worker-pids");
+    WORKER_PID_DIR = path33.join(EXE_AI_DIR, "worker-pids");
     MAX_CONCURRENT_WORKERS = 3;
-    BACKFILL_LOCK = path31.join(WORKER_PID_DIR, "backfill.lock");
+    BACKFILL_LOCK = path33.join(WORKER_PID_DIR, "backfill.lock");
   }
 });
 
@@ -10362,8 +10446,8 @@ __export(crdt_sync_exports, {
   rebuildFromDb: () => rebuildFromDb
 });
 import * as Y from "yjs";
-import { readFileSync as readFileSync21, writeFileSync as writeFileSync16, existsSync as existsSync27, mkdirSync as mkdirSync13, unlinkSync as unlinkSync9 } from "fs";
-import path34 from "path";
+import { readFileSync as readFileSync24, writeFileSync as writeFileSync18, existsSync as existsSync28, mkdirSync as mkdirSync15, unlinkSync as unlinkSync9 } from "fs";
+import path36 from "path";
 import { homedir as homedir5 } from "os";
 function getStatePath() {
   return _statePathOverride ?? DEFAULT_STATE_PATH;
@@ -10375,9 +10459,9 @@ function initCrdtDoc() {
   if (doc) return doc;
   doc = new Y.Doc();
   const sp = getStatePath();
-  if (existsSync27(sp)) {
+  if (existsSync28(sp)) {
     try {
-      const state = readFileSync21(sp);
+      const state = readFileSync24(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -10519,10 +10603,10 @@ function persistState() {
   if (!doc) return;
   try {
     const sp = getStatePath();
-    const dir = path34.dirname(sp);
-    if (!existsSync27(dir)) mkdirSync13(dir, { recursive: true });
+    const dir = path36.dirname(sp);
+    if (!existsSync28(dir)) mkdirSync15(dir, { recursive: true });
     const state = Y.encodeStateAsUpdate(doc);
-    writeFileSync16(sp, Buffer.from(state));
+    writeFileSync18(sp, Buffer.from(state));
   } catch {
   }
 }
@@ -10563,7 +10647,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(homedir5(), ".exe-os", "crdt-state.bin");
     _statePathOverride = null;
     doc = null;
   }
@@ -10576,8 +10660,8 @@ init_database();
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn as spawn3 } from "child_process";
-import { existsSync as existsSync30, openSync as openSync3, mkdirSync as mkdirSync15, closeSync as closeSync3 } from "fs";
-import path37 from "path";
+import { existsSync as existsSync31, openSync as openSync3, mkdirSync as mkdirSync17, closeSync as closeSync3 } from "fs";
+import path39 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/mcp/tools/recall-my-memory.ts
@@ -11247,10 +11331,10 @@ function registerCreateTask(server2) {
         skipDispatch: true
       });
       try {
-        const { existsSync: existsSync31, mkdirSync: mkdirSync16, writeFileSync: writeFileSync18 } = await import("fs");
+        const { existsSync: existsSync32, mkdirSync: mkdirSync18, writeFileSync: writeFileSync20 } = await import("fs");
         const { identityPath: identityPath2 } = await Promise.resolve().then(() => (init_identity(), identity_exports));
         const idPath = identityPath2(assigned_to);
-        if (!existsSync31(idPath)) {
+        if (!existsSync32(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);
@@ -11259,8 +11343,8 @@ function registerCreateTask(server2) {
             const template = getTemplateForTitle2(emp.role);
             if (template) {
               const dir = (await import("path")).dirname(idPath);
-              if (!existsSync31(dir)) mkdirSync16(dir, { recursive: true });
-              writeFileSync18(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
+              if (!existsSync32(dir)) mkdirSync18(dir, { recursive: true });
+              writeFileSync20(idPath, template.replace(/^agent_id: \w+/m, `agent_id: ${assigned_to}`), "utf-8");
             }
           }
         }
@@ -14605,9 +14689,9 @@ var HostingerApiClient = class {
     }
     this.lastRequestTime = Date.now();
   }
-  async request(method, path38, body) {
+  async request(method, path40, body) {
     await this.rateLimit();
-    const url = `${this.baseUrl}${path38}`;
+    const url = `${this.baseUrl}${path40}`;
     const headers = {
       Authorization: `Bearer ${this.apiKey}`,
       "Content-Type": "application/json",
@@ -14645,13 +14729,123 @@ var HostingerError = class extends Error {
   }
 };
 
+// src/lib/cloudflare-dns.ts
+var CLOUDFLARE_API_BASE_URL = "https://api.cloudflare.com/client/v4";
+var DNS_RECORD_TYPE_A = "A";
+var DEFAULT_PROXIED = true;
+var DEFAULT_TTL = 1;
+var REQUEST_TIMEOUT_MS2 = 3e4;
+var UNKNOWN_ERROR_CODE = "unknown";
+async function createARecord(cfApiToken, zoneId, domain, ip, opts) {
+  const proxied = opts?.proxied ?? DEFAULT_PROXIED;
+  const ttl = opts?.ttl ?? DEFAULT_TTL;
+  const response = await requestCloudflare(cfApiToken, zoneId, {
+    method: "POST",
+    body: {
+      type: DNS_RECORD_TYPE_A,
+      name: domain,
+      content: ip,
+      proxied,
+      ttl
+    }
+  });
+  return mapDnsRecord(response);
+}
+async function requestCloudflare(cfApiToken, zoneId, options) {
+  const response = await fetch(buildUrl(zoneId, options.path, options.query), {
+    method: options.method,
+    headers: buildHeaders(cfApiToken),
+    body: options.body ? JSON.stringify(options.body) : void 0,
+    signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS2)
+  });
+  const envelope = await parseEnvelope(response);
+  if (!response.ok || !envelope.success) {
+    throw toCloudflareError(response, envelope);
+  }
+  return envelope.result;
+}
+function buildUrl(zoneId, path40 = "/dns_records", query) {
+  const normalizedPath = path40.startsWith("/") ? path40 : `/${path40}`;
+  const url = new URL(
+    `${CLOUDFLARE_API_BASE_URL}/zones/${zoneId}${normalizedPath}`
+  );
+  if (query) {
+    url.search = query.toString();
+  }
+  return url.toString();
+}
+function buildHeaders(cfApiToken) {
+  return {
+    Authorization: `Bearer ${cfApiToken}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+}
+async function parseEnvelope(response) {
+  try {
+    return await response.json();
+  } catch {
+    return {
+      success: false,
+      errors: [
+        {
+          code: UNKNOWN_ERROR_CODE,
+          message: `HTTP ${response.status}: ${response.statusText}`
+        }
+      ],
+      messages: [],
+      result: null
+    };
+  }
+}
+function toCloudflareError(response, envelope) {
+  const firstError = envelope.errors[0];
+  const errorCode = String(firstError?.code ?? UNKNOWN_ERROR_CODE);
+  const message = firstError?.message ?? `HTTP ${response.status}: ${response.statusText}`;
+  return new CloudflareError(response.status, errorCode, message);
+}
+function mapDnsRecord(record) {
+  return {
+    recordId: record.id,
+    name: record.name,
+    ip: record.content,
+    proxied: record.proxied
+  };
+}
+var CloudflareError = class extends Error {
+  status;
+  errorCode;
+  constructor(status, errorCode, message) {
+    super(message);
+    this.name = "CloudflareError";
+    this.status = status;
+    this.errorCode = errorCode;
+  }
+};
+
 // src/mcp/tools/deploy-client.ts
 init_config();
 var execFileAsync = promisify(execFile);
 var POLL_INTERVAL_MS = 1e4;
 var POLL_MAX_ATTEMPTS = 60;
+var DEFAULT_VPS_TEMPLATE = "ubuntu-24.04";
+var DNS_PROXIED_OPTIONS = { proxied: true };
+var DEPLOYED_STATUS = "deployed";
+var PLAYBOOK_COMPLETE_HEALTH_PENDING_STATUS = "playbook_complete_health_pending";
+var ACTIVE_INVENTORY_STATUS = "active";
+var PROVISIONING_INVENTORY_STATUS = "provisioning";
 async function executeDeployment(params, client) {
-  const { client_name, domain, region, plan, ssl_email, apiKey } = params;
+  const {
+    client_name,
+    domain,
+    region,
+    plan,
+    ssl_email,
+    user_id,
+    apiKey,
+    cfApiToken,
+    cfZoneId
+  } = params;
   const hostinger = client ?? new HostingerApiClient(apiKey);
   const hostname = `exe-${client_name.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
   process.stderr.write(`[deploy_client] Provisioning VPS: ${hostname} (${plan}, ${region})...
@@ -14660,7 +14854,7 @@ async function executeDeployment(params, client) {
     hostname,
     plan,
     region,
-    os_template: "ubuntu-24.04"
+    os_template: DEFAULT_VPS_TEMPLATE
   });
   process.stderr.write(`[deploy_client] VPS created (ID: ${created.id}). Waiting for ready state...
 `);
@@ -14668,9 +14862,27 @@ async function executeDeployment(params, client) {
   process.stderr.write(`[deploy_client] VPS ready at ${vps.ip_address}. Running Ansible playbook...
 `);
   const playbookResult = await runAnsiblePlaybook(vps.ip_address, domain, ssl_email, client_name);
+  const dnsRecordId = await createDnsRecordIfConfigured({
+    domain,
+    ipAddress: vps.ip_address,
+    cfApiToken,
+    cfZoneId
+  });
   process.stderr.write(`[deploy_client] Playbook complete. Verifying health...
 `);
   const healthy = await verifyHealth(domain);
+  const status = healthy ? DEPLOYED_STATUS : PLAYBOOK_COMPLETE_HEALTH_PENDING_STATUS;
+  process.stderr.write("[deploy_client] Recording VPS inventory...\n");
+  const inventory = buildInventoryRecord({
+    userId: user_id,
+    clientName: client_name,
+    vpsId: vps.id,
+    ipAddress: vps.ip_address,
+    domain,
+    region: vps.region,
+    plan: vps.plan,
+    healthy
+  });
   return {
     vps_id: vps.id,
     hostname: vps.hostname,
@@ -14680,8 +14892,10 @@ async function executeDeployment(params, client) {
     plan: vps.plan,
     ssh_port: vps.ssh_port,
     ssh_access: `ssh exeai@${vps.ip_address}`,
-    status: healthy ? "deployed" : "playbook_complete_health_pending",
-    ansible_output: playbookResult
+    status,
+    ansible_output: playbookResult,
+    dns_record_id: dnsRecordId,
+    inventory
   };
 }
 function registerDeployClient(server2) {
@@ -14695,12 +14909,15 @@ function registerDeployClient(server2) {
         domain: z37.string().min(1).describe("Domain name for the deployment (e.g., client.exe.ai)"),
         region: z37.string().default("jakarta").describe("VPS region (default: jakarta)"),
         plan: z37.string().default("kvm-2").describe("Hostinger VPS plan (default: kvm-2)"),
-        ssl_email: z37.string().email().describe("Email for Let's Encrypt SSL certificate")
+        ssl_email: z37.string().email().describe("Email for Let's Encrypt SSL certificate"),
+        user_id: z37.string().min(1).describe("User/customer ID for inventory tracking")
       }
     },
-    async ({ client_name, domain, region, plan, ssl_email }) => {
+    async ({ client_name, domain, region, plan, ssl_email, user_id }) => {
       const config2 = await loadConfig();
       const apiKey = config2.hostinger?.apiKey;
+      const cfApiToken = config2.cloudflare?.apiToken;
+      const cfZoneId = config2.cloudflare?.zoneId;
       if (!apiKey) {
         return {
           content: [
@@ -14718,7 +14935,10 @@ function registerDeployClient(server2) {
           region,
           plan,
           ssl_email,
-          apiKey
+          user_id,
+          apiKey,
+          cfApiToken,
+          cfZoneId
         });
         return {
           content: [
@@ -14816,10 +15036,467 @@ async function verifyHealth(domain) {
     return false;
   }
 }
+async function createDnsRecordIfConfigured(params) {
+  const { domain, ipAddress, cfApiToken, cfZoneId } = params;
+  if (!cfApiToken || !cfZoneId) {
+    process.stderr.write(
+      `[deploy_client] Warning: Cloudflare config missing. Skipping DNS setup for ${domain}; configure cloudflare.apiToken and cloudflare.zoneId to automate this step.
+`
+    );
+    return void 0;
+  }
+  process.stderr.write(`[deploy_client] Setting up DNS: ${domain} \u2192 ${ipAddress}...
+`);
+  const dnsResult = await createARecord(
+    cfApiToken,
+    cfZoneId,
+    domain,
+    ipAddress,
+    DNS_PROXIED_OPTIONS
+  );
+  return dnsResult.recordId;
+}
+function buildInventoryRecord(params) {
+  const { userId, clientName, vpsId, ipAddress, domain, region, plan, healthy } = params;
+  return {
+    user_id: userId,
+    client_name: clientName,
+    hostinger_vps_id: vpsId,
+    ip_address: ipAddress,
+    domain,
+    region,
+    plan,
+    status: healthy ? ACTIVE_INVENTORY_STATUS : PROVISIONING_INVENTORY_STATUS
+  };
+}
+
+// src/mcp/tools/export-orchestration.ts
+init_active_agent();
+import { mkdirSync as mkdirSync13, writeFileSync as writeFileSync15 } from "fs";
+import path29 from "path";
+import { z as z38 } from "zod";
+
+// src/lib/orchestration-package.ts
+init_database();
+init_identity();
+init_platform_procedures();
+import { randomUUID as randomUUID5 } from "crypto";
+import { copyFileSync, existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync18, writeFileSync as writeFileSync14 } from "fs";
+import os11 from "os";
+import path28 from "path";
+var PACKAGE_VERSION = "1.0";
+var ROSTER_FILENAME = "exe-employees.json";
+var ROSTER_BACKUP_FILENAME = "exe-employees.json.bak";
+var EXE_OS_DIRNAME = ".exe-os";
+var DEFAULT_BEHAVIOR_PRIORITY = "p1";
+var DEFAULT_PROCEDURE_PRIORITY = "p0";
+var DEFAULT_IDENTITY_UPDATED_BY = "orchestration-import";
+function ensureObject(value, label) {
+  if (value == null || Array.isArray(value) || typeof value !== "object") {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function ensureString(value, label) {
+  if (typeof value !== "string") {
+    throw new Error(`${label} must be a string`);
+  }
+  return value;
+}
+function ensureOptionalString(value, label) {
+  if (value == null) return void 0;
+  return ensureString(value, label);
+}
+function ensureNullableString(value, label) {
+  if (value == null) return null;
+  return ensureString(value, label);
+}
+function ensurePriority(value, label, fallback) {
+  if (value == null) return fallback;
+  if (value === "p0" || value === "p1" || value === "p2") {
+    return value;
+  }
+  throw new Error(`${label} must be one of: p0, p1, p2`);
+}
+function validateRosterEntry(value, index) {
+  const record = ensureObject(value, `roster[${index}]`);
+  return {
+    name: ensureString(record.name, `roster[${index}].name`),
+    role: ensureString(record.role, `roster[${index}].role`),
+    systemPrompt: ensureString(record.systemPrompt, `roster[${index}].systemPrompt`),
+    createdAt: typeof record.createdAt === "string" ? record.createdAt : "",
+    templateName: ensureOptionalString(record.templateName, `roster[${index}].templateName`),
+    templateVersion: typeof record.templateVersion === "number" ? record.templateVersion : void 0
+  };
+}
+function validateBehaviorEntry(value, index) {
+  const record = ensureObject(value, `behaviors[${index}]`);
+  return {
+    agent_id: ensureString(record.agent_id, `behaviors[${index}].agent_id`),
+    project_name: ensureNullableString(record.project_name, `behaviors[${index}].project_name`),
+    domain: ensureNullableString(record.domain, `behaviors[${index}].domain`),
+    content: ensureString(record.content, `behaviors[${index}].content`),
+    priority: ensurePriority(record.priority, `behaviors[${index}].priority`, DEFAULT_BEHAVIOR_PRIORITY)
+  };
+}
+function validateProcedureEntry(value, index) {
+  const record = ensureObject(value, `procedures[${index}]`);
+  return {
+    title: ensureString(record.title, `procedures[${index}].title`),
+    content: ensureString(record.content, `procedures[${index}].content`),
+    priority: ensurePriority(record.priority, `procedures[${index}].priority`, DEFAULT_PROCEDURE_PRIORITY),
+    domain: ensureNullableString(record.domain, `procedures[${index}].domain`)
+  };
+}
+function getRosterPath() {
+  return path28.join(os11.homedir(), EXE_OS_DIRNAME, ROSTER_FILENAME);
+}
+function getBackupPath() {
+  return path28.join(os11.homedir(), EXE_OS_DIRNAME, ROSTER_BACKUP_FILENAME);
+}
+function readRosterFile() {
+  const rosterPath = getRosterPath();
+  if (!existsSync22(rosterPath)) return [];
+  const raw = readFileSync18(rosterPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  if (!Array.isArray(parsed)) {
+    throw new Error("Roster file must contain a JSON array");
+  }
+  return parsed.map((entry, index) => validateRosterEntry(entry, index));
+}
+function writeRosterFile(roster) {
+  if (roster.length === 0) {
+    throw new Error("Refusing to write empty roster \u2014 this would delete all employees");
+  }
+  const rosterPath = getRosterPath();
+  mkdirSync12(path28.dirname(rosterPath), { recursive: true });
+  if (existsSync22(rosterPath)) {
+    const currentRoster = readRosterFile();
+    if (roster.length < currentRoster.length) {
+      throw new Error(
+        `Refusing to write roster with ${roster.length} entries \u2014 current roster has ${currentRoster.length}. Import would delete ${currentRoster.length - roster.length} employee(s). Use merge strategy instead, or add the missing entries to the package.`
+      );
+    }
+    copyFileSync(rosterPath, getBackupPath());
+  }
+  writeFileSync14(rosterPath, `${JSON.stringify(roster, null, 2)}
+`, "utf-8");
+}
+function buildImportedRosterEntries(roster, timestamp) {
+  return roster.map((entry) => ({
+    name: entry.name,
+    role: entry.role,
+    systemPrompt: entry.systemPrompt,
+    createdAt: timestamp,
+    ...entry.templateName != null ? { templateName: entry.templateName } : {},
+    ...entry.templateVersion != null ? { templateVersion: entry.templateVersion } : {}
+  }));
+}
+async function insertBehaviors(behaviors, timestamp) {
+  const client = getClient();
+  for (const behavior of behaviors) {
+    await client.execute({
+      sql: `INSERT INTO behaviors (id, agent_id, project_name, domain, priority, content, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID5(),
+        behavior.agent_id,
+        behavior.project_name,
+        behavior.domain,
+        behavior.priority,
+        behavior.content,
+        timestamp,
+        timestamp
+      ]
+    });
+  }
+  return behaviors.length;
+}
+async function insertProcedures(procedures, timestamp, options) {
+  const client = getClient();
+  const skipTitles = options?.skipTitles ?? /* @__PURE__ */ new Set();
+  let inserted = 0;
+  for (const procedure of procedures) {
+    if (skipTitles.has(procedure.title) || PLATFORM_PROCEDURE_TITLES.has(procedure.title)) {
+      continue;
+    }
+    await client.execute({
+      sql: `INSERT INTO global_procedures (id, title, content, priority, domain, active, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, 1, ?, ?)`,
+      args: [
+        randomUUID5(),
+        procedure.title,
+        procedure.content,
+        procedure.priority,
+        procedure.domain,
+        timestamp,
+        timestamp
+      ]
+    });
+    skipTitles.add(procedure.title);
+    inserted += 1;
+  }
+  return inserted;
+}
+async function replaceBehaviorsAndProcedures(behaviors, procedures, timestamp) {
+  const client = getClient();
+  await client.execute({
+    sql: "UPDATE behaviors SET active = 0, updated_at = ? WHERE active = 1",
+    args: [timestamp]
+  });
+  await client.execute({
+    sql: "UPDATE global_procedures SET active = 0, updated_at = ? WHERE active = 1",
+    args: [timestamp]
+  });
+  return {
+    behaviors: await insertBehaviors(behaviors, timestamp),
+    procedures: await insertProcedures(procedures, timestamp)
+  };
+}
+async function mergeRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const existingNames = new Set(currentRoster.map((entry) => entry.name.toLowerCase()));
+  const additions = buildImportedRosterEntries(
+    importedRoster.filter((entry) => !existingNames.has(entry.name.toLowerCase())),
+    timestamp
+  );
+  if (additions.length > 0) {
+    writeRosterFile([...currentRoster, ...additions]);
+  }
+  return additions.length;
+}
+async function replaceRosterEntries(importedRoster, timestamp) {
+  const currentRoster = readRosterFile();
+  const importedByName = new Map(
+    buildImportedRosterEntries(importedRoster, timestamp).map((entry) => [entry.name.toLowerCase(), entry])
+  );
+  const merged = currentRoster.map((existing) => {
+    const imported = importedByName.get(existing.name.toLowerCase());
+    if (imported) {
+      importedByName.delete(existing.name.toLowerCase());
+      return imported;
+    }
+    return existing;
+  });
+  for (const newEntry of importedByName.values()) {
+    merged.push(newEntry);
+  }
+  writeRosterFile(merged);
+  return importedRoster.length;
+}
+async function importIdentities(identities, updatedBy) {
+  const entries = Object.entries(identities);
+  for (const [agentId, content] of entries) {
+    await updateIdentity(agentId, content, updatedBy);
+  }
+  return entries.length;
+}
+async function getActiveProcedureTitles() {
+  const client = getClient();
+  const result = await client.execute({
+    sql: "SELECT title FROM global_procedures WHERE active = 1",
+    args: []
+  });
+  return new Set(result.rows.map((row) => String(row.title)));
+}
+async function exportOrchestration(createdBy) {
+  const client = getClient();
+  const roster = readRosterFile().map((entry) => ({
+    ...entry,
+    createdAt: ""
+  }));
+  const identities = {};
+  for (const identitySummary of listIdentities()) {
+    const identity = getIdentity(identitySummary.agentId);
+    if (identity?.raw) {
+      identities[identitySummary.agentId] = identity.raw;
+    }
+  }
+  const behaviorResult = await client.execute({
+    sql: "SELECT agent_id, project_name, domain, content, priority FROM behaviors WHERE active = 1",
+    args: []
+  });
+  const procedureResult = await client.execute({
+    sql: "SELECT title, content, priority, domain FROM global_procedures WHERE active = 1",
+    args: []
+  });
+  const behaviors = behaviorResult.rows.map((row) => ({
+    agent_id: String(row.agent_id),
+    project_name: row.project_name == null ? null : String(row.project_name),
+    domain: row.domain == null ? null : String(row.domain),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "behaviors.priority", DEFAULT_BEHAVIOR_PRIORITY)
+  }));
+  const procedures = procedureResult.rows.map((row) => ({
+    title: String(row.title),
+    content: String(row.content),
+    priority: ensurePriority(row.priority, "procedures.priority", DEFAULT_PROCEDURE_PRIORITY),
+    domain: row.domain == null ? null : String(row.domain)
+  })).filter((procedure) => !PLATFORM_PROCEDURE_TITLES.has(procedure.title));
+  return {
+    version: PACKAGE_VERSION,
+    created_by: createdBy,
+    created_at: (/* @__PURE__ */ new Date()).toISOString(),
+    roster,
+    identities,
+    behaviors,
+    procedures
+  };
+}
+async function importOrchestration(pkg, strategy) {
+  const validated = validatePackage(pkg);
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const updatedBy = validated.created_by || DEFAULT_IDENTITY_UPDATED_BY;
+  const rosterCount = strategy === "replace" ? await replaceRosterEntries(validated.roster, timestamp) : await mergeRosterEntries(validated.roster, timestamp);
+  const identityCount = await importIdentities(validated.identities, updatedBy);
+  if (strategy === "replace") {
+    const replaced = await replaceBehaviorsAndProcedures(
+      validated.behaviors,
+      validated.procedures,
+      timestamp
+    );
+    return {
+      imported: {
+        roster: rosterCount,
+        identities: identityCount,
+        behaviors: replaced.behaviors,
+        procedures: replaced.procedures
+      }
+    };
+  }
+  const existingProcedureTitles = await getActiveProcedureTitles();
+  const behaviorCount = await insertBehaviors(validated.behaviors, timestamp);
+  const procedureCount = await insertProcedures(
+    validated.procedures,
+    timestamp,
+    { skipTitles: existingProcedureTitles }
+  );
+  return {
+    imported: {
+      roster: rosterCount,
+      identities: identityCount,
+      behaviors: behaviorCount,
+      procedures: procedureCount
+    }
+  };
+}
+function validatePackage(data) {
+  const record = ensureObject(data, "package");
+  const version = ensureString(record.version, "version");
+  if (version !== PACKAGE_VERSION) {
+    throw new Error(`Unsupported orchestration package version: ${version}`);
+  }
+  if (!Array.isArray(record.roster)) {
+    throw new Error("roster is required and must be an array");
+  }
+  if (record.identities == null || Array.isArray(record.identities) || typeof record.identities !== "object") {
+    throw new Error("identities is required and must be an object");
+  }
+  if (!Array.isArray(record.behaviors)) {
+    throw new Error("behaviors is required and must be an array");
+  }
+  if (!Array.isArray(record.procedures)) {
+    throw new Error("procedures is required and must be an array");
+  }
+  const identities = Object.entries(record.identities).reduce(
+    (acc, [agentId, content]) => {
+      acc[agentId] = ensureString(content, `identities.${agentId}`);
+      return acc;
+    },
+    {}
+  );
+  return {
+    version: PACKAGE_VERSION,
+    created_by: ensureString(record.created_by, "created_by"),
+    created_at: ensureString(record.created_at, "created_at"),
+    roster: record.roster.map((entry, index) => validateRosterEntry(entry, index)),
+    identities,
+    behaviors: record.behaviors.map((entry, index) => validateBehaviorEntry(entry, index)),
+    procedures: record.procedures.map((entry, index) => validateProcedureEntry(entry, index))
+  };
+}
+
+// src/mcp/tools/export-orchestration.ts
+init_store();
+function registerExportOrchestration(server2) {
+  server2.registerTool(
+    "export_orchestration",
+    {
+      title: "Export Orchestration",
+      description: "Export roster, identities, behaviors, and customer procedures to a JSON package.",
+      inputSchema: {
+        output_path: z38.string().describe("File path to write the JSON package")
+      }
+    },
+    async ({ output_path }) => {
+      try {
+        await initStore();
+        const pkg = await exportOrchestration(getActiveAgent().agentId);
+        mkdirSync13(path29.dirname(output_path), { recursive: true });
+        writeFileSync15(output_path, `${JSON.stringify(pkg, null, 2)}
+`, "utf-8");
+        return {
+          content: [{
+            type: "text",
+            text: `Exported ${pkg.roster.length} roster entries, ${Object.keys(pkg.identities).length} identities, ${pkg.behaviors.length} behaviors, ${pkg.procedures.length} procedures to ${output_path}`
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to export orchestration: ${err instanceof Error ? err.message : String(err)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/tools/import-orchestration.ts
+import { readFileSync as readFileSync19 } from "fs";
+import { z as z39 } from "zod";
+init_store();
+function registerImportOrchestration(server2) {
+  server2.registerTool(
+    "import_orchestration",
+    {
+      title: "Import Orchestration",
+      description: "Import roster, identities, behaviors, and procedures from an orchestration package.",
+      inputSchema: {
+        package_path: z39.string().describe("Path to the orchestration package JSON file"),
+        merge_strategy: z39.enum(["replace", "merge"]).default("merge").describe("How to apply the package: replace existing data or merge additively")
+      }
+    },
+    async ({ package_path, merge_strategy }) => {
+      try {
+        await initStore();
+        const raw = readFileSync19(package_path, "utf-8");
+        const pkg = validatePackage(JSON.parse(raw));
+        const result = await importOrchestration(pkg, merge_strategy);
+        return {
+          content: [{
+            type: "text",
+            text: `Imported ${result.imported.roster} roster entries, ${result.imported.identities} identities, ${result.imported.behaviors} behaviors, ${result.imported.procedures} procedures using ${merge_strategy} strategy`
+          }]
+        };
+      } catch (err) {
+        return {
+          content: [{
+            type: "text",
+            text: `Failed to import orchestration: ${err instanceof Error ? err.message : String(err)}`
+          }],
+          isError: true
+        };
+      }
+    }
+  );
+}
 
 // src/mcp/tools/query-conversations.ts
 init_database();
-import { z as z38 } from "zod";
+import { z as z40 } from "zod";
 function registerQueryConversations(server2) {
   server2.registerTool(
     "query_conversations",
@@ -14827,14 +15504,14 @@ function registerQueryConversations(server2) {
       title: "Query Conversations",
       description: "Search across all adapter messages by content, sender, date range, or platform. Returns messages with source attribution (platform, sender, timestamp).",
       inputSchema: {
-        query: z38.string().optional().describe("Full-text search query across message content and responses"),
-        sender: z38.string().optional().describe("Filter by sender ID or name (partial match)"),
-        platform: z38.string().optional().describe("Filter by platform: whatsapp, signal, telegram, discord, imessage, slack, email, webchat"),
-        after: z38.string().optional().describe("Filter messages after this ISO 8601 date (e.g. 2026-04-01)"),
-        before: z38.string().optional().describe("Filter messages before this ISO 8601 date (e.g. 2026-04-15)"),
-        channel_id: z38.string().optional().describe("Filter by channel/chat ID"),
-        thread_id: z38.string().optional().describe("Filter by conversation thread ID"),
-        limit: z38.number().int().min(1).max(100).optional().default(25).describe("Max results to return (default 25, max 100)")
+        query: z40.string().optional().describe("Full-text search query across message content and responses"),
+        sender: z40.string().optional().describe("Filter by sender ID or name (partial match)"),
+        platform: z40.string().optional().describe("Filter by platform: whatsapp, signal, telegram, discord, imessage, slack, email, webchat"),
+        after: z40.string().optional().describe("Filter messages after this ISO 8601 date (e.g. 2026-04-01)"),
+        before: z40.string().optional().describe("Filter messages before this ISO 8601 date (e.g. 2026-04-15)"),
+        channel_id: z40.string().optional().describe("Filter by channel/chat ID"),
+        thread_id: z40.string().optional().describe("Filter by conversation thread ID"),
+        limit: z40.number().int().min(1).max(100).optional().default(25).describe("Max results to return (default 25, max 100)")
       }
     },
     async (params) => {
@@ -14941,19 +15618,19 @@ function registerQueryConversations(server2) {
 }
 
 // src/mcp/tools/load-skill.ts
-import { z as z39 } from "zod";
-import { readFileSync as readFileSync18, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
-import path28 from "path";
+import { z as z41 } from "zod";
+import { readFileSync as readFileSync20, readdirSync as readdirSync8, statSync as statSync3 } from "fs";
+import path30 from "path";
 import { homedir as homedir2 } from "os";
-var SKILLS_DIR = path28.join(homedir2(), ".claude", "skills");
+var SKILLS_DIR = path30.join(homedir2(), ".claude", "skills");
 function listAvailableSkills() {
   try {
     const entries = readdirSync8(SKILLS_DIR);
     return entries.filter((entry) => {
       try {
-        const entryPath = path28.join(SKILLS_DIR, entry);
+        const entryPath = path30.join(SKILLS_DIR, entry);
         if (!statSync3(entryPath).isDirectory()) return false;
-        const skillFile = path28.join(entryPath, "SKILL.md");
+        const skillFile = path30.join(entryPath, "SKILL.md");
         statSync3(skillFile);
         return true;
       } catch {
@@ -14971,7 +15648,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: z39.string().describe(
+        skill_name: z41.string().describe(
           "Skill to load (e.g. 'seo', 'code-reviewer', 'frontend-design'). Pass 'list' to see all available skills."
         )
       }
@@ -14996,10 +15673,10 @@ ${skills.map((s) => `- ${s}`).join("\n")}`
           }]
         };
       }
-      const sanitized = path28.basename(skill_name);
-      const skillFile = path28.join(SKILLS_DIR, sanitized, "SKILL.md");
+      const sanitized = path30.basename(skill_name);
+      const skillFile = path30.join(SKILLS_DIR, sanitized, "SKILL.md");
       try {
-        const content = readFileSync18(skillFile, "utf-8");
+        const content = readFileSync20(skillFile, "utf-8");
         return {
           content: [{
             type: "text",
@@ -15028,7 +15705,7 @@ ${available.map((s) => `- ${s}`).join("\n")}` : "\n\nNo skills found in ~/.claud
 // src/mcp/tools/consolidate-memories.ts
 init_database();
 init_active_agent();
-import { z as z40 } from "zod";
+import { z as z42 } from "zod";
 function registerConsolidateMemories(server2) {
   server2.registerTool(
     "consolidate_memories",
@@ -15036,8 +15713,8 @@ function registerConsolidateMemories(server2) {
       title: "Consolidate Memories",
       description: "Trigger content-aware memory consolidation. Groups recent memories by project, uses LLM to extract key facts, decisions, and patterns, then stores a high-importance summary and archives the originals. Runs automatically during idle time, but can be triggered manually when you want to compress your working memory.",
       inputSchema: {
-        max_clusters: z40.coerce.number().optional().default(5).describe("Maximum number of clusters to consolidate (default 5)"),
-        model: z40.string().optional().describe("LLM model for summarization (defaults to config value)")
+        max_clusters: z42.coerce.number().optional().default(5).describe("Maximum number of clusters to consolidate (default 5)"),
+        model: z42.string().optional().describe("LLM model for summarization (defaults to config value)")
       }
     },
     async ({ max_clusters, model }) => {
@@ -15093,7 +15770,7 @@ Consolidated summaries stored as tier-1 (importance=9) memories.`
 init_global_procedures();
 init_active_agent();
 init_employees();
-import { z as z41 } from "zod";
+import { z as z43 } from "zod";
 function registerStoreGlobalProcedure(server2) {
   server2.registerTool(
     "store_global_procedure",
@@ -15101,10 +15778,10 @@ function registerStoreGlobalProcedure(server2) {
       title: "Store Global Procedure",
       description: "Create an organization-wide procedure (Layer 0) that supersedes identity, expertise, and experience. Use for hard rules that every employee must follow. RESTRICTED: only coordinator or founder sessions.",
       inputSchema: {
-        title: z41.string().describe("Short title for the procedure"),
-        content: z41.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
-        priority: z41.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default). p1 = standard. p2 = nice-to-have."),
-        domain: z41.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security")
+        title: z43.string().describe("Short title for the procedure"),
+        content: z43.string().max(500).describe("The procedure content \u2014 clear, actionable instruction"),
+        priority: z43.enum(["p0", "p1", "p2"]).optional().describe("Priority tier. p0 = always (default). p1 = standard. p2 = nice-to-have."),
+        domain: z43.string().optional().describe("Category: workflow, code-style, communication, architecture, testing, security")
       }
     },
     async ({ title, content, priority, domain }) => {
@@ -15182,7 +15859,7 @@ init_global_procedures();
 init_active_agent();
 init_database();
 init_employees();
-import { z as z42 } from "zod";
+import { z as z44 } from "zod";
 function registerDeactivateGlobalProcedure(server2) {
   server2.registerTool(
     "deactivate_global_procedure",
@@ -15190,7 +15867,7 @@ function registerDeactivateGlobalProcedure(server2) {
       title: "Deactivate Global Procedure",
       description: "Soft-delete a global procedure by setting active = 0. RESTRICTED: only coordinator or founder sessions. Use list_global_procedures to find the procedure ID first.",
       inputSchema: {
-        procedure_id: z42.string().describe("UUID of the global procedure to deactivate")
+        procedure_id: z44.string().describe("UUID of the global procedure to deactivate")
       }
     },
     async ({ procedure_id }) => {
@@ -15245,7 +15922,7 @@ Content: ${row.content}`
 }
 
 // src/mcp/tools/search-everything.ts
-import { z as z43 } from "zod";
+import { z as z45 } from "zod";
 
 // src/lib/unified-search.ts
 var DEFAULT_LIMIT = 10;
@@ -15412,11 +16089,11 @@ function registerSearchEverything(server2) {
       title: "Search Everything",
       description: "Search across all data stores \u2014 memories, conversations, and wiki \u2014 in one query. Returns merged results sorted by relevance with entity links.",
       inputSchema: {
-        query: z43.string().describe("What to search for across all data stores"),
-        sources: z43.array(z43.enum(["memory", "conversations", "wiki"])).optional().describe(
+        query: z45.string().describe("What to search for across all data stores"),
+        sources: z45.array(z45.enum(["memory", "conversations", "wiki"])).optional().describe(
           "Which sources to search (default: all). Options: memory, conversations, wiki"
         ),
-        limit: z43.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results to return (default 10, max 50)")
+        limit: z45.coerce.number().int().min(1).max(50).optional().default(10).describe("Max results to return (default 10, max 50)")
       }
     },
     async (params) => {
@@ -15477,7 +16154,7 @@ init_store();
 init_active_agent();
 init_database();
 init_plan_limits();
-import { z as z44 } from "zod";
+import { z as z46 } from "zod";
 import crypto14 from "crypto";
 function registerStoreDecision(server2) {
   server2.registerTool(
@@ -15486,13 +16163,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: z44.string().describe(
+        domain: z46.string().describe(
           "Domain key, e.g. 'auth-strategy', 'db-migration-approach', 'api-versioning'"
         ),
-        decision: z44.string().describe("The decision text \u2014 what was decided"),
-        rationale: z44.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
-        supersedes: z44.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
-        project_name: z44.string().optional().describe("Project name")
+        decision: z46.string().describe("The decision text \u2014 what was decided"),
+        rationale: z46.string().optional().describe("Why this decision was made \u2014 constraints, trade-offs, context"),
+        supersedes: z46.string().optional().describe("UUID of the decision this supersedes (previous decision for this domain)"),
+        project_name: z46.string().optional().describe("Project name")
       }
     },
     async ({ domain, decision, rationale, supersedes, project_name }) => {
@@ -15560,7 +16237,7 @@ Supersedes: ${supersedes}` : ""}`
 
 // src/mcp/tools/get-decision.ts
 init_database();
-import { z as z45 } from "zod";
+import { z as z47 } from "zod";
 function registerGetDecision(server2) {
   server2.registerTool(
     "get_decision",
@@ -15568,7 +16245,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: z45.string().describe(
+        domain: z47.string().describe(
           "Domain key to look up, e.g. 'auth-strategy', 'db-migration-approach'"
         )
       }
@@ -15631,15 +16308,15 @@ function registerGetDecision(server2) {
 }
 
 // src/mcp/tools/get-agent-spend.ts
-import { z as z46 } from "zod";
+import { z as z48 } from "zod";
 
 // src/lib/token-spend.ts
 init_database();
 import { readdir } from "fs/promises";
 import { createReadStream } from "fs";
 import { createInterface } from "readline";
-import path29 from "path";
-import os11 from "os";
+import path31 from "path";
+import os12 from "os";
 var MODEL_PRICING = {
   // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
   "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
@@ -15687,18 +16364,18 @@ async function getAgentSpend(period = "7d") {
   for (const row of result.rows) {
     sessionAgent.set(row.session_uuid, row.agent_id);
   }
-  const claudeDir = path29.join(os11.homedir(), ".claude", "projects");
+  const claudeDir = path31.join(os12.homedir(), ".claude", "projects");
   let projectDirs = [];
   try {
     const entries = await readdir(claudeDir);
-    projectDirs = entries.map((e) => path29.join(claudeDir, e));
+    projectDirs = entries.map((e) => path31.join(claudeDir, e));
   } catch {
     return [];
   }
   const agentTotals = /* @__PURE__ */ new Map();
   for (const [sessionUuid, agentId] of sessionAgent) {
     for (const dir of projectDirs) {
-      const jsonlPath = path29.join(dir, `${sessionUuid}.jsonl`);
+      const jsonlPath = path31.join(dir, `${sessionUuid}.jsonl`);
       try {
         const usage = await extractSessionUsage(jsonlPath);
         if (usage.input === 0 && usage.output === 0) continue;
@@ -15793,8 +16470,8 @@ function registerGetAgentSpend(server2) {
       title: "Get Agent Spend",
       description: "Get per-agent token spend attribution. Shows input, output, and cache tokens consumed by each agent over a time period, with estimated cost.",
       inputSchema: {
-        period: z46.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query"),
-        agent_id: z46.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'yoshi')")
+        period: z48.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query"),
+        agent_id: z48.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'yoshi')")
       }
     },
     async ({ period, agent_id }) => {
@@ -15860,7 +16537,7 @@ function registerGetAgentSpend(server2) {
 // src/mcp/tools/get-graph-stats.ts
 init_database();
 init_graph_query();
-import { z as z47 } from "zod";
+import { z as z49 } from "zod";
 function registerGetGraphStats(server2) {
   server2.registerTool(
     "get_graph_stats",
@@ -15868,7 +16545,7 @@ function registerGetGraphStats(server2) {
       title: "Get Graph Stats",
       description: "Get knowledge graph summary statistics: entity count, relationship count, and entity type breakdown.",
       inputSchema: {
-        _dummy: z47.string().optional().describe("Unused \u2014 no input required")
+        _dummy: z49.string().optional().describe("Unused \u2014 no input required")
       }
     },
     async () => {
@@ -15910,7 +16587,7 @@ function registerGetGraphStats(server2) {
 // src/mcp/tools/get-entity-neighbors.ts
 init_database();
 init_graph_query();
-import { z as z48 } from "zod";
+import { z as z50 } from "zod";
 function registerGetEntityNeighbors(server2) {
   server2.registerTool(
     "get_entity_neighbors",
@@ -15918,7 +16595,7 @@ function registerGetEntityNeighbors(server2) {
       title: "Get Entity Neighbors",
       description: "Get connected entities for a given entity name. Returns neighbors with relationship types, directions, and weights.",
       inputSchema: {
-        entity_name: z48.string().describe("Name of the entity to find neighbors for")
+        entity_name: z50.string().describe("Name of the entity to find neighbors for")
       }
     },
     async ({ entity_name }) => {
@@ -15987,7 +16664,7 @@ function registerGetEntityNeighbors(server2) {
 // src/mcp/tools/get-hot-entities.ts
 init_database();
 init_graph_query();
-import { z as z49 } from "zod";
+import { z as z51 } from "zod";
 var PERIOD_MS = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
@@ -16000,8 +16677,8 @@ function registerGetHotEntities(server2) {
       title: "Get Hot Entities",
       description: "Get trending entities \u2014 those with the most new relationships in a time period. Surfaces what's most active in the knowledge graph.",
       inputSchema: {
-        period: z49.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to look back"),
-        limit: z49.number().int().min(1).max(50).default(10).describe("Max entities to return")
+        period: z51.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to look back"),
+        limit: z51.number().int().min(1).max(50).default(10).describe("Max entities to return")
       }
     },
     async ({ period, limit }) => {
@@ -16049,7 +16726,7 @@ function registerGetHotEntities(server2) {
 
 // src/mcp/tools/export-graph.ts
 init_database();
-import { z as z50 } from "zod";
+import { z as z52 } from "zod";
 
 // src/lib/graph-export.ts
 async function loadGraphData(client) {
@@ -16262,7 +16939,7 @@ function registerExportGraph(server2) {
       title: "Export Graph",
       description: "Export the knowledge graph as a markdown report (inline) or an interactive HTML visualization (writes file, returns path).",
       inputSchema: {
-        format: z50.enum(["html", "markdown"]).default("markdown").describe("Export format: markdown (inline) or html (file)")
+        format: z52.enum(["html", "markdown"]).default("markdown").describe("Export format: markdown (inline) or html (file)")
       }
     },
     async ({ format }) => {
@@ -16276,12 +16953,12 @@ function registerExportGraph(server2) {
         }
         const html = await exportGraphHTML(client);
         const fs = await import("fs");
-        const path38 = await import("path");
-        const os13 = await import("os");
-        const outDir = path38.join(os13.homedir(), ".exe-os", "exports");
+        const path40 = await import("path");
+        const os14 = await import("os");
+        const outDir = path40.join(os14.homedir(), ".exe-os", "exports");
         fs.mkdirSync(outDir, { recursive: true });
         const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19);
-        const filePath = path38.join(outDir, `graph-${timestamp}.html`);
+        const filePath = path40.join(outDir, `graph-${timestamp}.html`);
         fs.writeFileSync(filePath, html, "utf-8");
         return {
           content: [
@@ -16312,7 +16989,7 @@ Open in a browser to explore interactively.`
 
 // src/mcp/tools/find-similar-trajectories.ts
 init_skill_learning();
-import { z as z51 } from "zod";
+import { z as z53 } from "zod";
 function registerFindSimilarTrajectories(server2) {
   server2.registerTool(
     "find_similar_trajectories",
@@ -16320,7 +16997,7 @@ function registerFindSimilarTrajectories(server2) {
       title: "Find Similar Trajectories",
       description: 'Find past task trajectories that match a described tool sequence. Input a comma-separated tool sequence (e.g. "Read, Edit, Bash, Read") to find similar past workflows.',
       inputSchema: {
-        description: z51.string().describe(
+        description: z53.string().describe(
           'Tool sequence to match \u2014 comma-separated tool names (e.g. "Read, Grep, Edit, Bash:npm, Bash:git")'
         )
       }
@@ -16391,7 +17068,7 @@ ${withSkill.length} trajectory(s) already extracted into skill(s).`
 
 // src/mcp/tools/get-session-kills.ts
 init_session_kill_telemetry();
-import { z as z52 } from "zod";
+import { z as z54 } from "zod";
 var PERIOD_MS2 = {
   "24h": 24 * 60 * 60 * 1e3,
   "7d": 7 * 24 * 60 * 60 * 1e3,
@@ -16407,7 +17084,7 @@ function registerGetSessionKills(server2) {
       title: "Get Session Kills",
       description: "Get session kill telemetry: how many idle/TTL sessions were killed, tokens saved, and estimated cost savings over a time period.",
       inputSchema: {
-        period: z52.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query")
+        period: z54.enum(["24h", "7d", "30d"]).default("7d").describe("Time period to query")
       }
     },
     async ({ period }) => {
@@ -16447,7 +17124,7 @@ function registerGetSessionKills(server2) {
 
 // src/mcp/tools/list-agent-sessions.ts
 init_session_registry();
-import { z as z53 } from "zod";
+import { z as z55 } from "zod";
 function registerListAgentSessions(server2) {
   server2.registerTool(
     "list_agent_sessions",
@@ -16455,7 +17132,7 @@ function registerListAgentSessions(server2) {
       title: "List Agent Sessions",
       description: "List all registered agent sessions with their agent ID, project, PID, and registration time.",
       inputSchema: {
-        _placeholder: z53.string().optional().describe("No input required")
+        _placeholder: z55.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16501,11 +17178,11 @@ function registerListAgentSessions(server2) {
 }
 
 // src/mcp/tools/get-daemon-health.ts
-import { z as z54 } from "zod";
-import { existsSync as existsSync22, readFileSync as readFileSync19 } from "fs";
-import path30 from "path";
+import { z as z56 } from "zod";
+import { existsSync as existsSync23, readFileSync as readFileSync21 } from "fs";
+import path32 from "path";
 import { homedir as homedir3 } from "os";
-var PID_PATH2 = path30.join(homedir3(), ".exe-os", "exed.pid");
+var PID_PATH2 = path32.join(homedir3(), ".exe-os", "exed.pid");
 function formatUptime(seconds) {
   const h = Math.floor(seconds / 3600);
   const m = Math.floor(seconds % 3600 / 60);
@@ -16516,8 +17193,8 @@ function formatUptime(seconds) {
 }
 function isDaemonAlive() {
   try {
-    if (!existsSync22(PID_PATH2)) return { alive: false, pid: null };
-    const pid = parseInt(readFileSync19(PID_PATH2, "utf8").trim(), 10);
+    if (!existsSync23(PID_PATH2)) return { alive: false, pid: null };
+    const pid = parseInt(readFileSync21(PID_PATH2, "utf8").trim(), 10);
     if (isNaN(pid) || pid <= 0) return { alive: false, pid: null };
     process.kill(pid, 0);
     return { alive: true, pid };
@@ -16532,7 +17209,7 @@ function registerGetDaemonHealth(server2) {
       title: "Get Daemon Health",
       description: "Check the embedding daemon (exed) health: whether it's running, its PID, uptime, and requests served.",
       inputSchema: {
-        _placeholder: z54.string().optional().describe("No input required")
+        _placeholder: z56.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16584,14 +17261,14 @@ function registerGetDaemonHealth(server2) {
 // src/mcp/tools/get-auto-wake-status.ts
 init_database();
 init_session_registry();
-import { z as z55 } from "zod";
+import { z as z57 } 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 readFileSync20, writeFileSync as writeFileSync14 } from "fs";
+import { existsSync as existsSync24, readFileSync as readFileSync22, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join2 } from "path";
 var IDLE_NUDGE_DEDUP_MS = Number(process.env.EXE_NUDGE_INTERVAL_MS) || 6e4;
@@ -16612,7 +17289,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: z55.string().optional().describe("No input required")
+        _placeholder: z57.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16693,16 +17370,16 @@ function registerGetAutoWakeStatus(server2) {
 // src/mcp/tools/get-worker-gate.ts
 init_worker_gate();
 init_config();
-import { z as z56 } from "zod";
-import { readdirSync as readdirSync10, existsSync as existsSync25 } from "fs";
-import path32 from "path";
-var WORKER_PID_DIR2 = path32.join(EXE_AI_DIR, "worker-pids");
+import { z as z58 } from "zod";
+import { readdirSync as readdirSync10, existsSync as existsSync26 } from "fs";
+import path34 from "path";
+var WORKER_PID_DIR2 = path34.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 (!existsSync26(WORKER_PID_DIR2)) return { alive: 0, stale: 0, reservations: 0 };
     const files = readdirSync10(WORKER_PID_DIR2);
     for (const f of files) {
       if (!f.endsWith(".pid")) continue;
@@ -16731,7 +17408,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: z56.string().optional().describe("No input required")
+        _placeholder: z58.string().optional().describe("No input required")
       }
     },
     async () => {
@@ -16767,12 +17444,12 @@ function registerGetWorkerGate(server2) {
 
 // src/mcp/tools/run-memory-audit.ts
 init_database();
-import { z as z57 } from "zod";
+import { z as z59 } from "zod";
 
 // src/bin/exe-doctor.ts
 init_store();
 init_database();
-import os12 from "os";
+import os13 from "os";
 
 // src/lib/is-main.ts
 import { realpathSync } from "fs";
@@ -16790,10 +17467,10 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/exe-doctor.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync27, readFileSync as readFileSync23 } from "fs";
 import { spawn as spawn2 } from "child_process";
-import path33 from "path";
-import { randomUUID as randomUUID6 } from "crypto";
+import path35 from "path";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/lib/conflict-detector.ts
 var DEFAULT_MAX_PAIRS = 100;
@@ -17195,13 +17872,53 @@ async function auditOrphanedProjects(client) {
   for (const row of result.rows) {
     const name = row.project_name;
     const count = Number(row.cnt);
-    const exists = existsSync26(path33.join(home, name)) || existsSync26(path33.join(home, "..", name)) || existsSync26(path33.join(process.cwd(), "..", name));
+    const exists = existsSync27(path35.join(home, name)) || existsSync27(path35.join(home, "..", name)) || existsSync27(path35.join(process.cwd(), "..", name));
     if (!exists) {
       orphans.push({ project_name: name, count });
     }
   }
   return orphans;
 }
+function auditHookHealth() {
+  const logPath = path35.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "",
+    ".exe-os",
+    "logs",
+    "hooks.log"
+  );
+  if (!existsSync27(logPath)) {
+    return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
+  }
+  let content;
+  try {
+    content = readFileSync23(logPath, "utf-8");
+  } catch {
+    return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
+  }
+  const lines = content.split("\n").filter(Boolean);
+  const totalLines = lines.length;
+  const recent = lines.slice(-200);
+  const oneHourAgo = new Date(Date.now() - 36e5).toISOString();
+  let errorsLastHour = 0;
+  const patternCounts = /* @__PURE__ */ new Map();
+  for (const line of recent) {
+    const isError = /error|Error|ERR|FAIL|throw|exception|TypeError|ReferenceError|SyntaxError/i.test(line);
+    if (!isError) continue;
+    const tsMatch = line.match(/(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/);
+    if (tsMatch && tsMatch[1] >= oneHourAgo) {
+      errorsLastHour++;
+    } else if (!tsMatch) {
+      errorsLastHour++;
+    }
+    const patternMatch = line.match(/((?:TypeError|ReferenceError|SyntaxError|Error):[^\n]{0,80})/);
+    if (patternMatch) {
+      const p = patternMatch[1];
+      patternCounts.set(p, (patternCounts.get(p) ?? 0) + 1);
+    }
+  }
+  const topPatterns = [...patternCounts.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5).map(([pattern, count]) => ({ pattern, count }));
+  return { logExists: true, totalLines, errorsLastHour, topPatterns };
+}
 async function runAudit(client, flags) {
   const [stats, nullVectors, duplicates, bloated, fts, orphanedProjects, conflicts] = await Promise.all([
     auditStats(client, flags),
@@ -17213,7 +17930,8 @@ async function runAudit(client, flags) {
     detectConflicts(client, flags.project, flags.agent)
   ]);
   const duplicateCount = duplicates.reduce((sum, d) => sum + d.delete_ids.length, 0);
-  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts };
+  const hookHealth = auditHookHealth();
+  return { stats, nullVectors, duplicates, duplicateCount, bloated, fts, orphanedProjects, conflicts, hookHealth };
 }
 function indicator(value, warn) {
   if (value === 0) return "\u{1F7E2}";
@@ -17248,7 +17966,7 @@ function formatReport(report, flags) {
     }
     lines.push("");
   }
-  const totalMemGB = os12.totalmem() / (1024 * 1024 * 1024);
+  const totalMemGB = os13.totalmem() / (1024 * 1024 * 1024);
   const isLowMemSystem = totalMemGB <= 8;
   if (isLowMemSystem && report.nullVectors > 0) {
     lines.push(`\u{1F7E2} Null vectors:     ${fmtNum(report.nullVectors)} / ${fmtNum(s.total)} (expected \u2014 8GB system, keyword search mode)`);
@@ -17281,6 +17999,17 @@ function formatReport(report, flags) {
   } else {
     lines.push("\u{1F7E2} Conflicts:        none detected");
   }
+  const hh = report.hookHealth;
+  if (!hh.logExists) {
+    lines.push("\u{1F7E0} Hook logs:        no log file (run installer to enable stderr capture)");
+  } else if (hh.errorsLastHour === 0) {
+    lines.push(`\u{1F7E2} Hook logs:        ${fmtNum(hh.totalLines)} lines, 0 errors in last hour`);
+  } else {
+    lines.push(`\u{1F534} Hook logs:        ${fmtNum(hh.errorsLastHour)} errors in last hour (${fmtNum(hh.totalLines)} total lines)`);
+    for (const p of hh.topPatterns) {
+      lines.push(`                     ${p.count}x: ${p.pattern}`);
+    }
+  }
   lines.push("");
   if (flags.verbose) {
     if (report.duplicates.length > 0) {
@@ -17359,7 +18088,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);
@@ -17415,7 +18144,7 @@ async function fixBloated(client, bloated, dryRun) {
                tool_name, project_name, has_error, raw_text, vector, version, consolidated)
             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 0, 0)`,
       args: [
-        randomUUID6(),
+        randomUUID7(),
         row.agent_id,
         row.agent_role,
         row.session_id,
@@ -17519,8 +18248,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: z57.string().optional().describe("Filter audit to a specific agent"),
-        project_name: z57.string().optional().describe("Filter audit to a specific project")
+        agent_id: z59.string().optional().describe("Filter audit to a specific agent"),
+        project_name: z59.string().optional().describe("Filter audit to a specific project")
       }
     },
     async ({ agent_id, project_name }) => {
@@ -17553,13 +18282,13 @@ function registerRunMemoryAudit(server2) {
 }
 
 // src/mcp/tools/cloud-sync.ts
-import { z as z58 } from "zod";
+import { z as z60 } from "zod";
 
 // src/lib/cloud-sync.ts
 init_database();
-import { readFileSync as readFileSync22, writeFileSync as writeFileSync17, existsSync as existsSync28, readdirSync as readdirSync11, mkdirSync as mkdirSync14, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync19, existsSync as existsSync29, readdirSync as readdirSync11, mkdirSync as mkdirSync16, appendFileSync as appendFileSync2, unlinkSync as unlinkSync10, openSync as openSync2, closeSync as closeSync2 } from "fs";
 import crypto16 from "crypto";
-import path35 from "path";
+import path37 from "path";
 import { homedir as homedir6 } from "os";
 
 // src/lib/crypto.ts
@@ -17633,7 +18362,7 @@ function sqlSafe(v) {
 }
 function logError(msg) {
   try {
-    const logPath = path35.join(homedir6(), ".exe-os", "workers.log");
+    const logPath = path37.join(homedir6(), ".exe-os", "workers.log");
     appendFileSync2(logPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${msg}
 `);
   } catch {
@@ -17642,24 +18371,24 @@ function logError(msg) {
 var LOCALHOST_PATTERNS = /^(localhost|127\.0\.0\.1|\[::1\])$/i;
 var FETCH_TIMEOUT_MS4 = 3e4;
 var PUSH_BATCH_SIZE = 5e3;
-var ROSTER_LOCK_PATH = 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;
 async function withRosterLock(fn) {
   try {
     const fd = openSync2(ROSTER_LOCK_PATH, "wx");
     closeSync2(fd);
-    writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
+    writeFileSync19(ROSTER_LOCK_PATH, String(Date.now()));
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts2 = parseInt(readFileSync22(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");
         }
         unlinkSync10(ROSTER_LOCK_PATH);
         const fd = openSync2(ROSTER_LOCK_PATH, "wx");
         closeSync2(fd);
-        writeFileSync17(ROSTER_LOCK_PATH, String(Date.now()));
+        writeFileSync19(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");
@@ -17678,21 +18407,21 @@ async function withRosterLock(fn) {
   }
 }
 async function fetchWithRetry(url, init) {
-  const MAX_RETRIES3 = 3;
+  const MAX_RETRIES4 = 3;
   const BASE_DELAY_MS2 = 200;
   let lastError;
-  for (let attempt = 0; attempt <= MAX_RETRIES3; attempt++) {
+  for (let attempt = 0; attempt <= MAX_RETRIES4; attempt++) {
     try {
       const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS4);
       const resp = await fetch(url, { ...init, signal });
-      if (resp && resp.status >= 500 && attempt < MAX_RETRIES3) {
+      if (resp && resp.status >= 500 && attempt < MAX_RETRIES4) {
         await new Promise((r) => setTimeout(r, BASE_DELAY_MS2 * Math.pow(2, attempt)));
         continue;
       }
       return resp;
     } catch (err) {
       lastError = err;
-      if (attempt === MAX_RETRIES3) throw err;
+      if (attempt === MAX_RETRIES4) throw err;
       await new Promise((r) => setTimeout(r, BASE_DELAY_MS2 * Math.pow(2, attempt)));
     }
   }
@@ -18033,8 +18762,8 @@ async function cloudSync(config2) {
   try {
     const employees = await loadEmployees();
     rosterResult.employees = employees.length;
-    const idDir = path35.join(EXE_AI_DIR, "identity");
-    if (existsSync28(idDir)) {
+    const idDir = path37.join(EXE_AI_DIR, "identity");
+    if (existsSync29(idDir)) {
       rosterResult.identities = readdirSync11(idDir).filter((f) => f.endsWith(".md")).length;
     }
   } catch {
@@ -18052,49 +18781,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 (!existsSync28(ROSTER_DELETIONS_PATH)) return [];
-    const deletions = JSON.parse(readFileSync22(ROSTER_DELETIONS_PATH, "utf-8"));
-    writeFileSync17(ROSTER_DELETIONS_PATH, "[]");
+    if (!existsSync29(ROSTER_DELETIONS_PATH)) return [];
+    const deletions = JSON.parse(readFileSync25(ROSTER_DELETIONS_PATH, "utf-8"));
+    writeFileSync19(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 (existsSync28(rosterPath)) {
+  if (existsSync29(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync22(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync25(rosterPath, "utf-8"));
     } catch {
     }
   }
   const identities = {};
-  if (existsSync28(identityDir)) {
+  if (existsSync29(identityDir)) {
     for (const file of readdirSync11(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync22(path35.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync25(path37.join(identityDir, file), "utf-8");
       } catch {
       }
     }
   }
   let config2;
-  if (existsSync28(configPath)) {
+  if (existsSync29(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync22(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync25(configPath, "utf-8"));
     } catch {
     }
   }
   let agentConfig;
-  const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
-  if (existsSync28(agentConfigPath)) {
+  const agentConfigPath = path37.join(EXE_AI_DIR, "agent-config.json");
+  if (existsSync29(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync22(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
     } catch {
     }
   }
@@ -18170,23 +18899,23 @@ 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 (existsSync28(cfgPath)) {
+  if (existsSync29(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync22(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync25(cfgPath, "utf-8"));
     } catch {
     }
   }
   const merged = { ...remoteConfig, ...local };
-  const dir = path35.dirname(cfgPath);
-  if (!existsSync28(dir)) mkdirSync14(dir, { recursive: true });
-  writeFileSync17(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
+  const dir = path37.dirname(cfgPath);
+  if (!existsSync29(dir)) mkdirSync16(dir, { recursive: true });
+  writeFileSync19(cfgPath, JSON.stringify(merged, null, 2), "utf-8");
 }
 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;
@@ -18207,15 +18936,15 @@ async function mergeRosterFromRemote(remote, paths) {
       ) ?? lookupKey;
       const remoteIdentity = remote.identities[matchedKey];
       if (remoteIdentity) {
-        if (!existsSync28(identityDir)) mkdirSync14(identityDir, { recursive: true });
-        const idPath = path35.join(identityDir, `${remoteEmp.name}.md`);
+        if (!existsSync29(identityDir)) mkdirSync16(identityDir, { recursive: true });
+        const idPath = path37.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync28(idPath) ? readFileSync22(idPath, "utf-8") : null;
+          localIdentity = existsSync29(idPath) ? readFileSync25(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
-          writeFileSync17(idPath, remoteIdentity, "utf-8");
+          writeFileSync19(idPath, remoteIdentity, "utf-8");
           identitiesUpdated++;
         }
       }
@@ -18241,16 +18970,16 @@ 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 (existsSync28(agentConfigPath)) {
+        if (existsSync29(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync22(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync25(agentConfigPath, "utf-8"));
           } catch {
           }
         }
         const merged = { ...remote.agentConfig, ...local };
-        writeFileSync17(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
+        writeFileSync19(agentConfigPath, JSON.stringify(merged, null, 2) + "\n", "utf-8");
       } catch {
       }
     }
@@ -18684,7 +19413,7 @@ function registerCloudSync(server2) {
       title: "Cloud Sync",
       description: "Trigger a cloud sync cycle \u2014 pulls remote changes then pushes local. Reports pushed/pulled counts for memories, behaviors, graph, tasks, and more.",
       inputSchema: {
-        force: z58.boolean().default(false).describe("Force sync even if recently synced")
+        force: z60.boolean().default(false).describe("Force sync even if recently synced")
       }
     },
     async () => {
@@ -18737,7 +19466,7 @@ function registerCloudSync(server2) {
 
 // src/mcp/tools/get-memory-cardinality.ts
 init_database();
-import { z as z59 } from "zod";
+import { z as z61 } from "zod";
 function registerGetMemoryCardinality(server2) {
   server2.registerTool(
     "get_memory_cardinality",
@@ -18745,7 +19474,7 @@ function registerGetMemoryCardinality(server2) {
       title: "Get Memory Cardinality",
       description: "Get memory counts: total active memories and per-project breakdown. Optionally filter by agent.",
       inputSchema: {
-        agent_id: z59.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'exe')")
+        agent_id: z61.string().optional().describe("Filter to a specific agent (e.g. 'tom', 'exe')")
       }
     },
     async ({ agent_id }) => {
@@ -18828,7 +19557,7 @@ function registerGetMemoryCardinality(server2) {
 init_database();
 init_consolidation();
 init_config();
-import { z as z60 } from "zod";
+import { z as z62 } from "zod";
 function registerRunConsolidation(server2) {
   server2.registerTool(
     "run_consolidation",
@@ -18836,7 +19565,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: z60.boolean().default(true).describe("Preview mode \u2014 show what would be consolidated without doing it")
+        dry_run: z62.boolean().default(true).describe("Preview mode \u2014 show what would be consolidated without doing it")
       }
     },
     async ({ dry_run }) => {
@@ -18905,7 +19634,7 @@ function registerRunConsolidation(server2) {
 
 // src/mcp/tools/get-license-status.ts
 init_license();
-import { z as z61 } from "zod";
+import { z as z63 } from "zod";
 var FEATURES = [
   "cloud_sync",
   "external_agents",
@@ -18919,7 +19648,7 @@ function registerGetLicenseStatus(server2) {
       title: "Get License Status",
       description: "Get current license status: plan, validity, feature gates, limits, and expiry.",
       inputSchema: {
-        _dummy: z61.string().optional().describe("Unused \u2014 no input required")
+        _dummy: z63.string().optional().describe("Unused \u2014 no input required")
       }
     },
     async () => {
@@ -18971,16 +19700,16 @@ function registerGetLicenseStatus(server2) {
 }
 
 // src/mcp/tools/people-roster.ts
-import { z as z62 } from "zod";
+import { z as z64 } from "zod";
 
 // src/lib/people.ts
 init_config();
 import { readFile as readFile5, writeFile as writeFile6, mkdir as mkdir5 } from "fs/promises";
-import { existsSync as existsSync29, readFileSync as readFileSync23 } from "fs";
-import path36 from "path";
-var PEOPLE_PATH = path36.join(EXE_AI_DIR, "people.json");
+import { existsSync as existsSync30, readFileSync as readFileSync26 } from "fs";
+import path38 from "path";
+var PEOPLE_PATH = path38.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {
-  if (!existsSync29(PEOPLE_PATH)) return [];
+  if (!existsSync30(PEOPLE_PATH)) return [];
   try {
     const raw = await readFile5(PEOPLE_PATH, "utf-8");
     return JSON.parse(raw);
@@ -18989,7 +19718,7 @@ async function loadPeople() {
   }
 }
 async function savePeople(people) {
-  await mkdir5(path36.dirname(PEOPLE_PATH), { recursive: true });
+  await mkdir5(path38.dirname(PEOPLE_PATH), { recursive: true });
   await writeFile6(PEOPLE_PATH, JSON.stringify(people, null, 2) + "\n", "utf-8");
 }
 async function addPerson(person) {
@@ -19019,10 +19748,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: z62.string().describe("Person's name"),
-        role: z62.string().describe("Their role (e.g. co-founder, customer, partner)"),
-        relationship: z62.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
-        notes: z62.string().optional().describe("Additional context about this person")
+        name: z64.string().describe("Person's name"),
+        role: z64.string().describe("Their role (e.g. co-founder, customer, partner)"),
+        relationship: z64.string().describe("Relationship to the organization (e.g. co-founder, early adopter, investor)"),
+        notes: z64.string().optional().describe("Additional context about this person")
       }
     },
     async ({ name, role, relationship, notes }) => {
@@ -19068,7 +19797,7 @@ function registerGetPerson(server2) {
       title: "Get Person",
       description: "Look up a specific person by name from the people roster.",
       inputSchema: {
-        name: z62.string().describe("Person's name to look up")
+        name: z64.string().describe("Person's name to look up")
       }
     },
     async ({ name }) => {
@@ -19096,7 +19825,7 @@ init_active_agent();
 init_agent_config();
 init_runtime_table();
 init_employees();
-import { z as z63 } from "zod";
+import { z as z65 } from "zod";
 function registerSetAgentConfig(server2) {
   server2.registerTool(
     "set_agent_config",
@@ -19104,9 +19833,9 @@ function registerSetAgentConfig(server2) {
       title: "Set Agent Config",
       description: "Set or view per-agent runtime + model configuration. Controls which runtime (claude, codex, opencode) and model each agent uses when dispatched. COO-only. Omit runtime/model to view current config for an agent or all agents.",
       inputSchema: {
-        agent_id: z63.string().optional().describe("Agent name, or 'default' for org-wide default. Omit to view all agents."),
-        runtime: z63.string().optional().describe(`Runtime: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`),
-        model: z63.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, anthropic/claude-sonnet-4-6)")
+        agent_id: z65.string().optional().describe("Agent name, or 'default' for org-wide default. Omit to view all agents."),
+        runtime: z65.string().optional().describe(`Runtime: ${Object.keys(KNOWN_RUNTIMES).join(", ")}`),
+        model: z65.string().optional().describe("Model name (e.g. claude-opus-4, gpt-5.4, anthropic/claude-sonnet-4-6)")
       }
     },
     async ({ agent_id, runtime, model }) => {
@@ -19299,6 +20028,8 @@ registerListWikiPages(server);
 registerGetWikiPage(server);
 registerUpdateWikiPage(server);
 registerDeployClient(server);
+registerExportOrchestration(server);
+registerImportOrchestration(server);
 registerQueryConversations(server);
 registerLoadSkill(server);
 registerConsolidateMemories(server);
@@ -19390,14 +20121,14 @@ try {
 `
       );
       const thisFile = fileURLToPath5(import.meta.url);
-      const backfillPath = path37.resolve(
-        path37.dirname(thisFile),
+      const backfillPath = path39.resolve(
+        path39.dirname(thisFile),
         "../bin/backfill-vectors.js"
       );
-      if (existsSync30(backfillPath)) {
+      if (existsSync31(backfillPath)) {
         const { EXE_AI_DIR: exeDir } = await Promise.resolve().then(() => (init_config(), config_exports));
-        const logPath = path37.join(exeDir, "workers.log");
-        mkdirSync15(path37.dirname(logPath), { recursive: true });
+        const logPath = path39.join(exeDir, "workers.log");
+        mkdirSync17(path39.dirname(logPath), { recursive: true });
         let logFd = "ignore";
         try {
           logFd = openSync3(logPath, "a");