@askexenow/exe-os 0.9.0 → 0.9.1

package/dist/mcp/server.js

@@ -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;
   }
 });
@@ -10107,7 +10191,7 @@ async function wikiFetch(config2, path38, method = "GET", body) {
     "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, {
@@ -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;
   }
 });
 
@@ -10362,7 +10446,7 @@ __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 { readFileSync as readFileSync22, writeFileSync as writeFileSync16, existsSync as existsSync27, mkdirSync as mkdirSync13, unlinkSync as unlinkSync9 } from "fs";
 import path34 from "path";
 import { homedir as homedir5 } from "os";
 function getStatePath() {
@@ -10377,7 +10461,7 @@ function initCrdtDoc() {
   const sp = getStatePath();
   if (existsSync27(sp)) {
     try {
-      const state = readFileSync21(sp);
+      const state = readFileSync22(sp);
       Y.applyUpdate(doc, new Uint8Array(state));
     } catch {
       console.warn("[crdt-sync] WARN: corrupted state file, rebuilding from DB");
@@ -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, path38 = "/dns_records", query) {
+  const normalizedPath = path38.startsWith("/") ? path38 : `/${path38}`;
+  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,6 +15036,39 @@ 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/query-conversations.ts
 init_database();
@@ -16790,7 +17043,7 @@ function isMainModule(importMetaUrl) {
 }
 
 // src/bin/exe-doctor.ts
-import { existsSync as existsSync26 } from "fs";
+import { existsSync as existsSync26, readFileSync as readFileSync21 } from "fs";
 import { spawn as spawn2 } from "child_process";
 import path33 from "path";
 import { randomUUID as randomUUID6 } from "crypto";
@@ -17202,6 +17455,46 @@ async function auditOrphanedProjects(client) {
   }
   return orphans;
 }
+function auditHookHealth() {
+  const logPath = path33.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "",
+    ".exe-os",
+    "logs",
+    "hooks.log"
+  );
+  if (!existsSync26(logPath)) {
+    return { logExists: false, totalLines: 0, errorsLastHour: 0, topPatterns: [] };
+  }
+  let content;
+  try {
+    content = readFileSync21(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 +17506,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}";
@@ -17281,6 +17575,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) {
@@ -17557,7 +17862,7 @@ import { z as z58 } 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 readFileSync23, 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 crypto16 from "crypto";
 import path35 from "path";
 import { homedir as homedir6 } from "os";
@@ -17652,7 +17957,7 @@ async function withRosterLock(fn) {
   } catch (err) {
     if (err.code === "EEXIST") {
       try {
-        const ts2 = parseInt(readFileSync22(ROSTER_LOCK_PATH, "utf-8"), 10);
+        const ts2 = parseInt(readFileSync23(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");
         }
@@ -17678,21 +17983,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)));
     }
   }
@@ -18056,7 +18361,7 @@ var ROSTER_DELETIONS_PATH = path35.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"));
+    const deletions = JSON.parse(readFileSync23(ROSTER_DELETIONS_PATH, "utf-8"));
     writeFileSync17(ROSTER_DELETIONS_PATH, "[]");
     return deletions;
   } catch {
@@ -18070,7 +18375,7 @@ function buildRosterBlob(paths) {
   let roster = [];
   if (existsSync28(rosterPath)) {
     try {
-      roster = JSON.parse(readFileSync22(rosterPath, "utf-8"));
+      roster = JSON.parse(readFileSync23(rosterPath, "utf-8"));
     } catch {
     }
   }
@@ -18078,7 +18383,7 @@ function buildRosterBlob(paths) {
   if (existsSync28(identityDir)) {
     for (const file of readdirSync11(identityDir).filter((f) => f.endsWith(".md"))) {
       try {
-        identities[file] = readFileSync22(path35.join(identityDir, file), "utf-8");
+        identities[file] = readFileSync23(path35.join(identityDir, file), "utf-8");
       } catch {
       }
     }
@@ -18086,7 +18391,7 @@ function buildRosterBlob(paths) {
   let config2;
   if (existsSync28(configPath)) {
     try {
-      config2 = JSON.parse(readFileSync22(configPath, "utf-8"));
+      config2 = JSON.parse(readFileSync23(configPath, "utf-8"));
     } catch {
     }
   }
@@ -18094,7 +18399,7 @@ function buildRosterBlob(paths) {
   const agentConfigPath = path35.join(EXE_AI_DIR, "agent-config.json");
   if (existsSync28(agentConfigPath)) {
     try {
-      agentConfig = JSON.parse(readFileSync22(agentConfigPath, "utf-8"));
+      agentConfig = JSON.parse(readFileSync23(agentConfigPath, "utf-8"));
     } catch {
     }
   }
@@ -18174,7 +18479,7 @@ function mergeConfig(remoteConfig, configPath) {
   let local = {};
   if (existsSync28(cfgPath)) {
     try {
-      local = JSON.parse(readFileSync22(cfgPath, "utf-8"));
+      local = JSON.parse(readFileSync23(cfgPath, "utf-8"));
     } catch {
     }
   }
@@ -18211,7 +18516,7 @@ async function mergeRosterFromRemote(remote, paths) {
         const idPath = path35.join(identityDir, `${remoteEmp.name}.md`);
         let localIdentity = null;
         try {
-          localIdentity = existsSync28(idPath) ? readFileSync22(idPath, "utf-8") : null;
+          localIdentity = existsSync28(idPath) ? readFileSync23(idPath, "utf-8") : null;
         } catch {
         }
         if (localIdentity !== remoteIdentity) {
@@ -18245,7 +18550,7 @@ async function mergeRosterFromRemote(remote, paths) {
         let local = {};
         if (existsSync28(agentConfigPath)) {
           try {
-            local = JSON.parse(readFileSync22(agentConfigPath, "utf-8"));
+            local = JSON.parse(readFileSync23(agentConfigPath, "utf-8"));
           } catch {
           }
         }
@@ -18976,7 +19281,7 @@ import { z as z62 } 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 { existsSync as existsSync29, readFileSync as readFileSync24 } from "fs";
 import path36 from "path";
 var PEOPLE_PATH = path36.join(EXE_AI_DIR, "people.json");
 async function loadPeople() {