@askexenow/exe-os 0.9.302 → 0.9.310

package/dist/{chunk-3YJMI422.js → chunk-TN2YCFQE.js}

@@ -5,13 +5,13 @@ import {
   notifyParentExe,
   resolveExeSession,
   sendIntercom
-} from "./chunk-OVKNFTCL.js";
+} from "./chunk-HED6D5KR.js";
 import {
   getTransport
 } from "./chunk-KOO3J5PV.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WHOT5NZ7.js";
+} from "./chunk-OR3TAZL3.js";
 import {
   getAgentRuntime
 } from "./chunk-QB5JOGPK.js";
@@ -22,7 +22,7 @@ import {
   isCoordinatorName,
   isMultiInstance,
   shouldAutoInstance
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/lib/tasks-notify.ts
 var VERIFY_DELAY_MS = 1e4;
@@ -68,7 +68,7 @@ async function dispatchTaskToEmployee(input) {
   let crossProject = false;
   if (input.projectName) {
     try {
-      const { assertSessionScope } = await import("./session-scope-E54VIYTJ.js");
+      const { assertSessionScope } = await import("./session-scope-JGDYAMJO.js");
       const check = assertSessionScope("dispatch_task", input.projectName);
       if (check.reason === "cross_session_denied") {
         crossProject = true;

package/dist/{chunk-YMSWCERY.js → chunk-U63BZI2B.js}

@@ -1,9 +1,9 @@
 import {
   fastDbInit
-} from "./chunk-KHZQVLNZ.js";
+} from "./chunk-QE7UVQDP.js";
 import {
   sessionScopeFilter
-} from "./chunk-OVKNFTCL.js";
+} from "./chunk-HED6D5KR.js";
 import {
   formatStatusAll,
   formatStatusDeep,
@@ -14,7 +14,7 @@ import {
   getClient,
   isCoordinatorRole,
   loadEmployees
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 import {
   isMainModule
 } from "./chunk-6Y4B3QF6.js";

package/dist/{chunk-KA5RK5HZ.js → chunk-V42BSVX6.js}

@@ -1,10 +1,10 @@
 import {
   initStore
-} from "./chunk-Y5ASPRP7.js";
+} from "./chunk-WBJXJ2R4.js";
 import {
   getClient,
   isInitialized
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/lib/schedules.ts
 import crypto from "crypto";

package/dist/{chunk-PJTRAFL4.js → chunk-V4BW5HFQ.js}

@@ -1,16 +1,16 @@
 import {
   extractMemoryGraph
-} from "./chunk-HNLBHP6P.js";
+} from "./chunk-ZZXADKAP.js";
 import {
   flushBatch,
   writeMemory
-} from "./chunk-Y5ASPRP7.js";
+} from "./chunk-WBJXJ2R4.js";
 import {
   extractKeywords
 } from "./chunk-CHCA3ZM2.js";
 import {
   getActiveAgent
-} from "./chunk-LE7CDIOA.js";
+} from "./chunk-BUOMSIXH.js";
 
 // src/mcp/tools/import-conversations.ts
 import { z } from "zod";

package/dist/{chunk-4FG6IX7U.js → chunk-VFSYVQX4.js}

@@ -1,7 +1,7 @@
 import {
   getCurrentSessionScope,
   strictSessionScopeFilter
-} from "./chunk-OVKNFTCL.js";
+} from "./chunk-HED6D5KR.js";
 import {
   getProjectName
 } from "./chunk-OPU3NYOO.js";

package/dist/chunk-VQRTO7IS.js

@@ -0,0 +1,290 @@
+// src/lib/daemon-health-log.ts
+import { appendFileSync, mkdirSync, existsSync, statSync, renameSync } from "fs";
+import path from "path";
+import os from "os";
+
+// src/lib/process-monitor.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+import v8 from "v8";
+var execFileAsync = promisify(execFile);
+var _lastCpuUsage = null;
+var _lastCpuTime = 0;
+function getDaemonCpuPercent() {
+  const now = Date.now();
+  const usage = process.cpuUsage(_lastCpuUsage ?? void 0);
+  if (_lastCpuTime === 0) {
+    _lastCpuUsage = process.cpuUsage();
+    _lastCpuTime = now;
+    return 0;
+  }
+  const elapsedMs = now - _lastCpuTime;
+  if (elapsedMs === 0) return 0;
+  const cpuMs = (usage.user + usage.system) / 1e3;
+  const percent = cpuMs / elapsedMs * 100;
+  _lastCpuUsage = process.cpuUsage();
+  _lastCpuTime = now;
+  return Math.round(percent * 10) / 10;
+}
+async function getProcessStats(pid) {
+  try {
+    const { stdout } = await execFileAsync(
+      "ps",
+      ["-p", String(pid), "-o", "pid=,ppid=,%cpu=,rss=,vsz=,etime=,args="],
+      { encoding: "utf8", timeout: 3e3 }
+    );
+    const output = stdout.trim();
+    if (!output) return null;
+    return parseProcessLine(output);
+  } catch {
+    return null;
+  }
+}
+async function getChildProcesses(parentPid) {
+  let output;
+  try {
+    const { stdout } = await execFileAsync(
+      "pgrep",
+      ["-P", String(parentPid)],
+      { encoding: "utf8", timeout: 3e3 }
+    );
+    output = stdout.trim();
+  } catch {
+    return [];
+  }
+  if (!output) return [];
+  const childPids = output.split("\n").map(Number).filter(Boolean);
+  const children = [];
+  for (const pid of childPids) {
+    const stats = await getProcessStats(pid);
+    if (stats) children.push(stats);
+    children.push(...await getChildProcesses(pid));
+  }
+  return children;
+}
+async function getOrphanedProcesses() {
+  const EXE_PATTERNS = [
+    "exe-os/dist",
+    "exe-mem/dist",
+    "@askexenow/exe-os"
+  ];
+  try {
+    const { stdout: output } = await execFileAsync(
+      "ps",
+      ["-eo", "pid,ppid,%cpu,rss,vsz,etime,args"],
+      { encoding: "utf8", timeout: 5e3, maxBuffer: 8 * 1024 * 1024 }
+    );
+    const orphans = [];
+    for (const line of output.split("\n").slice(1)) {
+      const stats = parseProcessLine(line.trim());
+      if (!stats) continue;
+      if (stats.ppid !== 1) continue;
+      if (stats.pid === process.pid) continue;
+      if (!EXE_PATTERNS.some((p) => stats.command.includes(p))) continue;
+      orphans.push(stats);
+    }
+    return orphans;
+  } catch {
+    return [];
+  }
+}
+function parseProcessLine(line) {
+  const match = line.match(/^\s*(\d+)\s+(\d+)\s+([\d.]+)\s+(\d+)\s+(\d+)\s+([\d:-]+)\s+(.+)$/);
+  if (!match) return null;
+  return {
+    pid: parseInt(match[1], 10),
+    ppid: parseInt(match[2], 10),
+    cpu: parseFloat(match[3]),
+    mem: Math.round(parseInt(match[4], 10) / 1024),
+    // RSS KB → MB
+    rss: Math.round(parseInt(match[4], 10) / 1024),
+    vsz: Math.round(parseInt(match[5], 10) / 1024),
+    elapsed: match[6],
+    command: match[7].slice(0, 200)
+  };
+}
+async function takeProcessSnapshot() {
+  const [daemon, children, orphans] = await Promise.all([
+    getProcessStats(process.pid),
+    getChildProcesses(process.pid),
+    getOrphanedProcesses()
+  ]);
+  const allProcs = [daemon, ...children].filter(Boolean);
+  const totalCpu = allProcs.reduce((sum, p) => sum + p.cpu, 0);
+  const totalMemMb = allProcs.reduce((sum, p) => sum + p.rss, 0);
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    daemon,
+    children,
+    orphans,
+    totalCpu: Math.round(totalCpu * 10) / 10,
+    totalMemMb
+  };
+}
+function formatSnapshotSummary(snap) {
+  return {
+    daemonCpu: snap.daemon?.cpu ?? 0,
+    daemonRssMb: snap.daemon?.rss ?? 0,
+    childCount: snap.children.length,
+    childTotalCpu: Math.round(snap.children.reduce((s, c) => s + c.cpu, 0) * 10) / 10,
+    childTotalRssMb: snap.children.reduce((s, c) => s + c.rss, 0),
+    orphanCount: snap.orphans.length,
+    orphanPids: snap.orphans.map((o) => o.pid),
+    totalCpu: snap.totalCpu,
+    totalMemMb: snap.totalMemMb
+  };
+}
+var CPU_ALERT_THRESHOLD_PCT = 80;
+var CPU_ALERT_SUSTAINED_SAMPLES = 3;
+var _highCpuSamples = 0;
+function checkCpuAlert(cpuPercent) {
+  if (cpuPercent >= CPU_ALERT_THRESHOLD_PCT) {
+    _highCpuSamples++;
+    if (_highCpuSamples >= CPU_ALERT_SUSTAINED_SAMPLES) {
+      return `Daemon CPU sustained at ${cpuPercent}% for ${_highCpuSamples} samples`;
+    }
+  } else {
+    _highCpuSamples = 0;
+  }
+  return null;
+}
+var HEAP_ALERT_THRESHOLD_PCT = 80;
+var HEAP_ALERT_SUSTAINED_SAMPLES = 6;
+var _highHeapSamples = 0;
+var _heapSizeLimit = null;
+function getHeapSizeLimit() {
+  if (_heapSizeLimit !== null) return _heapSizeLimit;
+  try {
+    _heapSizeLimit = v8.getHeapStatistics().heap_size_limit;
+  } catch {
+    _heapSizeLimit = 4 * 1024 * 1024 * 1024;
+  }
+  return _heapSizeLimit;
+}
+function checkHeapAlert() {
+  const mem = process.memoryUsage();
+  const limit = getHeapSizeLimit();
+  const usedPct = limit > 0 ? mem.heapUsed / limit * 100 : 0;
+  if (usedPct >= HEAP_ALERT_THRESHOLD_PCT) {
+    _highHeapSamples++;
+    if (_highHeapSamples >= HEAP_ALERT_SUSTAINED_SAMPLES) {
+      return `V8 heap pressure: ${Math.round(usedPct)}% of limit (${Math.round(mem.heapUsed / 1024 / 1024)}MB / ${Math.round(limit / 1024 / 1024)}MB) for ${_highHeapSamples} samples \u2014 OOM risk`;
+    }
+  } else {
+    _highHeapSamples = 0;
+  }
+  return null;
+}
+
+// src/lib/daemon-health-log.ts
+var LOG_DIR = path.join(os.homedir(), ".exe-os", "logs");
+var LOG_FILE = path.join(LOG_DIR, "daemon-health.log");
+var MAX_LOG_SIZE = 5 * 1024 * 1024;
+var dirChecked = false;
+function ensureDir() {
+  if (dirChecked) return;
+  if (!existsSync(LOG_DIR)) mkdirSync(LOG_DIR, { recursive: true });
+  dirChecked = true;
+}
+function maybeRotate() {
+  try {
+    if (!existsSync(LOG_FILE)) return;
+    const stat = statSync(LOG_FILE);
+    if (stat.size > MAX_LOG_SIZE) {
+      const rotated = `${LOG_FILE}.1`;
+      try {
+        renameSync(LOG_FILE, rotated);
+      } catch {
+      }
+    }
+  } catch {
+  }
+}
+function logDaemonHealth(entry) {
+  try {
+    ensureDir();
+    maybeRotate();
+    const record = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      event: entry.event,
+      pid: entry.pid,
+      msg: entry.message,
+      ...entry.data && { data: entry.data },
+      ...entry.stack && { stack: entry.stack }
+    };
+    appendFileSync(LOG_FILE, JSON.stringify(record) + "\n");
+  } catch {
+  }
+}
+function logBoot(extra) {
+  logDaemonHealth({
+    event: "boot",
+    pid: process.pid,
+    message: "Daemon starting",
+    data: {
+      nodeVersion: process.version,
+      platform: process.platform,
+      arch: process.arch,
+      totalMem: `${Math.round(os.totalmem() / 1024 / 1024 / 1024)}GB`,
+      freeMem: `${Math.round(os.freemem() / 1024 / 1024 / 1024)}GB`,
+      uptime: `${Math.round(os.uptime() / 3600)}h`,
+      ...extra
+    }
+  });
+}
+function logShutdown(reason, signal) {
+  logDaemonHealth({
+    event: signal ? "signal" : "shutdown",
+    pid: process.pid,
+    message: `Daemon shutting down: ${reason}`,
+    data: { reason, ...signal && { signal } }
+  });
+}
+function logCrash(error, event = "crash") {
+  const err = error instanceof Error ? error : new Error(String(error));
+  logDaemonHealth({
+    event,
+    pid: process.pid,
+    message: `FATAL: ${err.message}`,
+    stack: err.stack
+  });
+}
+async function logHeartbeat(data) {
+  const mem = process.memoryUsage();
+  let processData = {};
+  try {
+    const cpuPct = getDaemonCpuPercent();
+    const snapshot = await takeProcessSnapshot();
+    processData = formatSnapshotSummary(snapshot);
+    const cpuAlertMsg = checkCpuAlert(cpuPct);
+    if (cpuAlertMsg) {
+      logDaemonHealth({ event: "cpu_pressure", pid: process.pid, message: cpuAlertMsg, data: processData });
+    }
+    const heapAlertMsg = checkHeapAlert();
+    if (heapAlertMsg) {
+      logDaemonHealth({ event: "memory_pressure", pid: process.pid, message: heapAlertMsg, data: processData });
+    }
+  } catch {
+  }
+  logDaemonHealth({
+    event: "heartbeat",
+    pid: process.pid,
+    message: "alive",
+    data: {
+      rss: `${Math.round(mem.rss / 1024 / 1024)}MB`,
+      heapUsed: `${Math.round(mem.heapUsed / 1024 / 1024)}MB`,
+      heapTotal: `${Math.round(mem.heapTotal / 1024 / 1024)}MB`,
+      uptimeSec: Math.round(process.uptime()),
+      ...processData,
+      ...data
+    }
+  });
+}
+
+export {
+  logDaemonHealth,
+  logBoot,
+  logShutdown,
+  logCrash,
+  logHeartbeat
+};

package/dist/{chunk-OR7J7TIA.js → chunk-VT6P7FV4.js}

@@ -1,6 +1,6 @@
 import {
   createReminder
-} from "./chunk-ORNKGGFX.js";
+} from "./chunk-JNARUXDC.js";
 
 // src/mcp/tools/create-reminder.ts
 import { z } from "zod";

package/dist/{chunk-BEIYF4NS.js → chunk-W2J2RF5N.js}

@@ -1,6 +1,6 @@
 import {
   routeTask
-} from "./chunk-QNJPDIWY.js";
+} from "./chunk-4L4R6AQJ.js";
 import {
   createTaskCore,
   employeeSessionName,
@@ -9,11 +9,11 @@ import {
   isEmployeeAlive,
   sessionScopeFilter,
   updateTaskStatus
-} from "./chunk-OVKNFTCL.js";
+} from "./chunk-HED6D5KR.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 
 // src/runtime/orchestrator.ts
 var STALE_THRESHOLD_MS = 2 * 60 * 60 * 1e3;

package/dist/{chunk-Y5ASPRP7.js → chunk-WBJXJ2R4.js}

@@ -9,7 +9,7 @@ import {
   findScopedDuplicate,
   governMemoryRecord,
   schedulePostWriteMemoryHygiene
-} from "./chunk-PTDBHQX7.js";
+} from "./chunk-MQCTK6EF.js";
 import {
   orgBus
 } from "./chunk-MP2AFCGL.js";
@@ -18,7 +18,7 @@ import {
   ensureSchema,
   getClient,
   initTurso
-} from "./chunk-P3SIFDES.js";
+} from "./chunk-SCYWCWKY.js";
 import {
   EMBEDDING_DIM
 } from "./chunk-FXU7JOXK.js";
@@ -68,7 +68,7 @@ function recordShardFailure(project, error) {
       `[store] Shard circuit OPEN for "${project}" after ${state.failures} consecutive failures. Will retry in ${SHARD_CB_COOLDOWN_MS / 6e4}min. Last error: ${error}
 `
     );
-    void import("./orchestration-events-MB4QVHTD.js").then(({ recordOrchestrationEventBestEffort }) => {
+    void import("./orchestration-events-PZLLPCKY.js").then(({ recordOrchestrationEventBestEffort }) => {
       recordOrchestrationEventBestEffort({
         eventType: "shard.circuit_open",
         source: "store.recordShardFailure",
@@ -165,7 +165,7 @@ async function initStore(options) {
     );
     _nextVersion = (Number(vResult.rows[0]?.max_v) || 0) + 1;
     try {
-      const { loadGlobalProcedures } = await import("./global-procedures-POG4V6IK.js");
+      const { loadGlobalProcedures } = await import("./global-procedures-SYZZCGDS.js");
       await loadGlobalProcedures();
     } catch (e) {
       logStoreWarn("catch", e);
@@ -293,7 +293,7 @@ async function writeMemory(record) {
     founder_id: record.founder_id ?? null
   };
   try {
-    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-MOCWJK6S.js");
+    const { checkMemoryPoisoning } = await import("./memory-poisoning-defense-ECXSX7HK.js");
     const poisonResult = await checkMemoryPoisoning({
       memoryId: dbRow.id,
       vector: Array.isArray(dbRow.vector) ? dbRow.vector : void 0,
@@ -486,19 +486,19 @@ async function flushBatch() {
     }
     _nextVersion = baseVersion;
     try {
-      const { insertMemoryCardsForBatch } = await import("./memory-cards-BGI6MJRN.js");
+      const { insertMemoryCardsForBatch } = await import("./memory-cards-II67WFL2.js");
       await insertMemoryCardsForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { insertOntologyForBatch } = await import("./agentic-ontology-M7T72M6V.js");
+      const { insertOntologyForBatch } = await import("./agentic-ontology-6KBAXLSJ.js");
       await insertOntologyForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
     }
     try {
-      const { extractGraphForBatch } = await import("./memory-graph-extractor-DTRRNWHZ.js");
+      const { extractGraphForBatch } = await import("./memory-graph-extractor-PM4Q2KJG.js");
       await extractGraphForBatch(batch);
     } catch (e) {
       logStoreWarn("catch", e);
@@ -554,6 +554,12 @@ ${err.stack.split("\n").slice(1, 3).join("\n")}` : ""}` : String(err);
     _flushing = false;
   }
 }
+function buildStatusFilter(options, columnPrefix, indent, opts) {
+  const statusClause = options?.includeArchived ? "" : `${indent}AND COALESCE(${columnPrefix}status, 'active') = 'active'`;
+  const withDrafts = opts?.withDrafts ?? true;
+  const draftClause = !withDrafts || options?.includeDrafts ? "" : `${indent}AND (${columnPrefix}draft = 0 OR ${columnPrefix}draft IS NULL)`;
+  return { statusClause, draftClause, clause: statusClause + draftClause };
+}
 function buildWikiScopeFilter(options, columnPrefix) {
   const args = [];
   let clause = "";
@@ -602,10 +608,7 @@ async function searchMemories(queryVector, agentId, options) {
   } catch (e) {
     logStoreDebug("embedding_model column check failed", e);
   }
-  const statusFilter = options?.includeArchived ? "" : `
-               AND COALESCE(status, 'active') = 'active'`;
-  const draftFilter = options?.includeDrafts ? "" : `
-               AND (draft = 0 OR draft IS NULL)`;
+  const { statusClause: statusFilter, draftClause: draftFilter } = buildStatusFilter(options, "", "\n               ");
   let sql = `SELECT id, agent_id, agent_role, session_id, timestamp,
                     tool_name, project_name,
                     has_error, raw_text, vector, importance, status,
@@ -624,7 +627,7 @@ async function searchMemories(queryVector, agentId, options) {
     args.push(activeEmbeddingModel);
   }
   try {
-    const { founderScopeFilter } = await import("./founder-context-3SOKEW76.js");
+    const { founderScopeFilter } = await import("./founder-context-QCTMEK66.js");
     const founderFilter = founderScopeFilter(options?.founderId);
     sql += founderFilter.sql;
     args.push(...founderFilter.args.filter((a) => a !== null));
@@ -822,6 +825,7 @@ export {
   classifyTier,
   writeMemory,
   flushBatch,
+  buildStatusFilter,
   buildWikiScopeFilter,
   buildRawVisibilityFilter,
   searchMemories,

package/dist/chunk-WCGNCH3Q.js

@@ -0,0 +1,72 @@
+// src/lib/mcp-tool-surface.ts
+import { createHash } from "crypto";
+var SURFACE_MARKER_PREFIX = "surface-";
+function canonicalize(value, depth = 0) {
+  if (depth > 8) return "\u2026";
+  if (value === null || typeof value !== "object") {
+    return typeof value === "function" ? "fn" : value;
+  }
+  if (Array.isArray(value)) return value.map((v) => canonicalize(v, depth + 1));
+  const obj = value;
+  const out = {};
+  for (const key of Object.keys(obj).sort()) {
+    out[key] = canonicalize(obj[key], depth + 1);
+  }
+  return out;
+}
+function fingerprintSchema(inputSchema) {
+  if (!inputSchema || typeof inputSchema !== "object") return "";
+  const keys = Object.keys(inputSchema).sort();
+  let canonLen = 0;
+  try {
+    canonLen = JSON.stringify(canonicalize(inputSchema)).length;
+  } catch {
+    canonLen = 0;
+  }
+  return `${keys.join(",")}|${canonLen}`;
+}
+function computeToolSurfaceHash(registerFn) {
+  try {
+    const captured = [];
+    const fakeServer = {
+      registerTool(name, config, _handler) {
+        captured.push({ name, fp: fingerprintSchema(config?.inputSchema) });
+      }
+    };
+    registerFn(fakeServer);
+    if (captured.length === 0) return null;
+    captured.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    const canonical = captured.map((t) => `${t.name} ${t.fp}`).join("\n");
+    return createHash("sha256").update(canonical).digest("hex");
+  } catch {
+    return null;
+  }
+}
+var RELOAD_DEBOUNCE_MS = 5 * 60 * 1e3;
+function decideReload(baseline, disk, state, now, debounceMs = RELOAD_DEBOUNCE_MS) {
+  if (!baseline || !disk) {
+    return { reload: false, state: { firstChangeAt: null } };
+  }
+  if (disk === baseline) {
+    return { reload: false, state: { firstChangeAt: null } };
+  }
+  if (state.firstChangeAt === null) {
+    return { reload: false, state: { firstChangeAt: now } };
+  }
+  if (now - state.firstChangeAt >= debounceMs) {
+    return { reload: true, state: { firstChangeAt: null } };
+  }
+  return { reload: false, state };
+}
+function buildMcpVersionMarker(surfaceHash) {
+  if (surfaceHash) return `${SURFACE_MARKER_PREFIX}${surfaceHash}`;
+  return `deploy-${Date.now()}`;
+}
+
+export {
+  SURFACE_MARKER_PREFIX,
+  computeToolSurfaceHash,
+  RELOAD_DEBOUNCE_MS,
+  decideReload,
+  buildMcpVersionMarker
+};

package/dist/{chunk-2LJDLQNO.js → chunk-WJ2PZGRV.js}

@@ -1,6 +1,6 @@
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-WHOT5NZ7.js";
+} from "./chunk-OR3TAZL3.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-65DBIEM2.js";

package/dist/{chunk-AAPPSMPH.js → chunk-WZBUKC5N.js}

@@ -7,7 +7,7 @@ import {
 import {
   connectEmbedDaemon,
   embedBatchViaClient
-} from "./chunk-TCJEFW5V.js";
+} from "./chunk-PPXQE7AS.js";
 import {
   EXE_AI_DIR
 } from "./chunk-DFIOOK5R.js";

package/dist/{chunk-RO7EXVSJ.js → chunk-X4AFBL4N.js}

@@ -1,7 +1,7 @@
 import {
   executeAction,
   substituteTemplate
-} from "./chunk-XDE5IGBX.js";
+} from "./chunk-2NS3QRMJ.js";
 
 // src/automation/workflow-engine.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-BR74NYEF.js → chunk-XV5HRIXG.js}

@@ -1,7 +1,10 @@
+import {
+  IMessageAdapter
+} from "./chunk-FLSASUV3.js";
 import {
   createCRMWebhookHandler,
   parseTwentyWebhook
-} from "./chunk-WIL6LXNG.js";
+} from "./chunk-AC6DKMVS.js";
 import {
   WhatsAppAdapter
 } from "./chunk-ECSNSHZ7.js";
@@ -17,9 +20,6 @@ import {
 import {
   SlackAdapter
 } from "./chunk-ORCCI2VV.js";
-import {
-  IMessageAdapter
-} from "./chunk-FLSASUV3.js";
 import {
   BotRegistry,
   BotRuntime,
@@ -42,7 +42,7 @@ import {
   retryWithBackoff,
   routeMessage,
   validateGatewayConfig
-} from "./chunk-OZRO37JW.js";
+} from "./chunk-3KH6GXXX.js";
 import {
   OllamaProvider
 } from "./chunk-FWFFZGSC.js";