@askexenow/exe-os 0.9.372 → 0.9.374

package/dist/chunk-FTZET5YX.js

@@ -0,0 +1,313 @@
+// src/lib/stack-invariants.ts
+import { execFileSync } from "child_process";
+var EXPECTED_GOTRUE_COUNT = 1;
+function isGotrueImage(image) {
+  const normalized = image.toLowerCase();
+  const repo = (normalized.split("@")[0] ?? "").split(":")[0] ?? "";
+  return /(^|\/)gotrue$/.test(repo) || /(^|\/)supabase[/-]gotrue$/.test(repo) || /(^|\/)supabase[/-]auth$/.test(repo) || repo.endsWith("/gotrue");
+}
+function evaluateGotrueInvariant(containers) {
+  const instances = containers.filter((c) => isGotrueImage(c.image)).map((c) => c.name).sort();
+  if (instances.length === EXPECTED_GOTRUE_COUNT) {
+    return {
+      pass: true,
+      instances,
+      detail: `Exactly one GoTrue running (${instances[0]}) \u2014 invariant holds`
+    };
+  }
+  if (instances.length === 0) {
+    return {
+      pass: false,
+      instances,
+      detail: "\u{1F534} NO GoTrue container is running \u2014 auth is down for every product on this host"
+    };
+  }
+  return {
+    pass: false,
+    instances,
+    detail: `\u{1F534} ${instances.length} GoTrue containers running (${instances.join(", ")}) \u2014 exactly ONE may serve auth. Two GoTrues sharing a JWT audience and user table is a split-brain identity provider: sessions minted by one cannot be revoked by the other. Stop the extras; the survivor is the exe-os stack's \`gotrue\`. exe-create's instance is on hold until Q4 and is gated behind the \`exe-create-revival\` compose profile in AskExe/exe-db.`
+  };
+}
+function listRunningContainers() {
+  try {
+    const out = execFileSync(
+      "docker",
+      ["ps", "--format", "{{.Names}}	{{.Image}}"],
+      { encoding: "utf-8", timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }
+    );
+    return out.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => {
+      const [name = "", image = ""] = line.split("	");
+      return { name, image };
+    });
+  } catch {
+    return null;
+  }
+}
+function checkSingleGotrueInstance(containers = listRunningContainers()) {
+  if (containers === null) {
+    return {
+      pass: true,
+      instances: [],
+      available: false,
+      detail: "n/a \u2014 Docker not reachable from this host"
+    };
+  }
+  return { ...evaluateGotrueInvariant(containers), available: true };
+}
+var CANONICAL_SSO_COOKIE = "exe_access_token";
+var DEAD_SSO_COOKIES = ["exe_sso_token"];
+function stripHtmlComments(html) {
+  return html.replace(/<!--[\s\S]*?-->/g, "");
+}
+function evaluateSsoCookieContract(product, url, html) {
+  const source = stripHtmlComments(html);
+  const hasCookieGate = source.includes("document.cookie");
+  const deadCookiesFound = DEAD_SSO_COOKIES.filter((dead) => source.includes(dead));
+  const canonicalFound = source.includes(CANONICAL_SSO_COOKIE);
+  if (deadCookiesFound.length > 0) {
+    return {
+      product,
+      url,
+      pass: false,
+      severity: "violation",
+      detail: `\u{1F534} references RETIRED cookie ${deadCookiesFound.join(", ")} \u2014 nothing sets that name, so every visit bounces to auth.<apex> and back, forever. The canonical cookie is \`${CANONICAL_SSO_COOKIE}\`. Third occurrence of this exact bug (wiki f1bb40d8, crm 9f60e8e6, erp 3938ac3d).`,
+      deadCookiesFound,
+      canonicalFound
+    };
+  }
+  if (!hasCookieGate) {
+    return {
+      product,
+      url,
+      pass: true,
+      severity: "pass",
+      detail: "no client-side cookie gate (server-side or edge-gated) \u2014 n/a",
+      deadCookiesFound: [],
+      canonicalFound
+    };
+  }
+  if (!canonicalFound) {
+    return {
+      product,
+      url,
+      pass: true,
+      severity: "review",
+      detail: `\u{1F7E0} REVIEW: reads document.cookie but the canonical \`${CANONICAL_SSO_COOKIE}\` appears nowhere in the served document. Legitimate when the product gates on its OWN session cookie and bridges to GoTrue server-side (exe-crm gates on \`tokenPair\` and bridges via /api/auth/gotrue-callback). Confirm that is what this is, and not a gate on some third cookie name.`,
+      deadCookiesFound,
+      canonicalFound
+    };
+  }
+  return {
+    product,
+    url,
+    pass: true,
+    severity: "pass",
+    detail: `gates on \`${CANONICAL_SSO_COOKIE}\` \u2014 contract holds`,
+    deadCookiesFound,
+    canonicalFound
+  };
+}
+var SSO_EDGE_CONFIG_FILES = [
+  "deploy/compose/sso-edge/default.conf.template",
+  "deploy/compose/sso-edge/sso-redirect.conf",
+  "deploy/nginx/snippets/sso-redirect.conf",
+  "deploy/nginx/snippets/sso-redirect.README.md"
+];
+var SSO_GATE_COOKIE_VAR = "sso_gotrue_cookie";
+function extractSsoGateCookieNames(source, variable = SSO_GATE_COOKIE_VAR) {
+  const names = [];
+  const mapHeader = new RegExp(`map\\s+\\$http_cookie\\s+\\$${variable}\\s*\\{`, "g");
+  let header;
+  while ((header = mapHeader.exec(source)) !== null) {
+    let depth = 1;
+    let i = header.index + header[0].length;
+    for (; i < source.length && depth > 0; i++) {
+      if (source[i] === "{") depth++;
+      else if (source[i] === "}") depth--;
+    }
+    const body = source.slice(header.index + header[0].length, i - 1);
+    for (const arm of body.matchAll(/([A-Za-z0-9_.-]+)=\(/g)) {
+      const name = arm[1];
+      if (name && !names.includes(name)) names.push(name);
+    }
+  }
+  return names;
+}
+function evaluateSsoEdgeCookieGate(file, source) {
+  const cookieNames = extractSsoGateCookieNames(source);
+  if (cookieNames.length === 0) {
+    return {
+      file,
+      cookieNames,
+      severity: "pass",
+      detail: `no \`$${SSO_GATE_COOKIE_VAR}\` map declared \u2014 nothing to check`
+    };
+  }
+  const wrong = cookieNames.filter((n) => n !== CANONICAL_SSO_COOKIE);
+  if (wrong.length > 0) {
+    const retired = wrong.filter((n) => DEAD_SSO_COOKIES.includes(n));
+    return {
+      file,
+      cookieNames,
+      severity: "violation",
+      detail: `\u{1F534} the cross-app-logout gate reads ${wrong.map((n) => `\`${n}\``).join(", ")} but the only cookie the stack mints is \`${CANONICAL_SSO_COOKIE}\`` + (retired.length ? ` (${retired.join(", ")} is RETIRED)` : " (that name is never set by anything)") + `. Every request with a live app session is therefore treated as revoked and 401'd into an endless login bounce. Bug 21ae2388 \u2014 the fourth instance of this class. Fix the map regex in ${file}.`
+    };
+  }
+  return {
+    file,
+    cookieNames,
+    severity: "pass",
+    detail: `gate reads \`${CANONICAL_SSO_COOKIE}\` \u2014 contract holds`
+  };
+}
+var SSO_STATIC_MAP_SOURCE = "request_uri";
+var SSO_STATIC_QUERY_ANCHOR = "(?:[?#]|$)";
+var SSO_STATIC_PROBES = [
+  // ── must be exempt: real build output, or the app never boots ────────────
+  { uri: "/assets/index-a1b2c3.js", exempt: true, why: "Vite/wiki build output" },
+  { uri: "/assets/index-a1b2c3.js?v=9f2c", exempt: true, why: "cache-busted build output" },
+  { uri: "/assets/fonts/inter.woff2", exempt: true, why: "nested build output" },
+  { uri: "/static/js/main.4f2a.css", exempt: true, why: "CRA/Twenty build output" },
+  { uri: "/_next/static/chunks/main.js", exempt: true, why: "Next build output" },
+  { uri: "/favicon.ico", exempt: true, why: "browser-initiated root icon" },
+  // ── must NOT be exempt: protected app surface behind a catch-all proxy ───
+  { uri: "/uploads/customer.png", exempt: false, why: "customer upload \u2014 asset extension, private content" },
+  { uri: "/api/export.js", exempt: false, why: "API response dressed as a script" },
+  { uri: "/api/v1/report.css?scope=all", exempt: false, why: "API path, asset extension, query string" },
+  { uri: "/files/invoice-1041.png", exempt: false, why: "app-served file store" },
+  { uri: "/private/files/contract.png", exempt: false, why: "explicitly private file store" },
+  { uri: "/uploads/customer.png?v=1", exempt: false, why: "query string must not launder an upload" },
+  { uri: "/assets/../api/export.js", exempt: false, why: "raw traversal \u2014 normalizes into the API upstream" },
+  { uri: "/assets/%2e%2e/api/export.js", exempt: false, why: "encoded traversal" },
+  { uri: "/notes/report.jsx", exempt: false, why: "not an asset extension, not an asset prefix" },
+  { uri: "/reports/q3.png", exempt: false, why: "app content outside every build-output prefix" },
+  { uri: "/", exempt: false, why: "the document itself is always gated" },
+  { uri: "/api/documents", exempt: false, why: "plain API path" }
+];
+function undecorate(line) {
+  return line.replace(/^\s*#\s?/, "");
+}
+function parseStaticMapArms(body) {
+  const arms = [];
+  let defaultValue = "";
+  for (const raw of body.split("\n")) {
+    const line = undecorate(raw).trim();
+    const def = /^default\s+"([^"]*)"\s*;/.exec(line);
+    if (def) {
+      defaultValue = def[1] ?? "";
+      continue;
+    }
+    const arm = /^"~(\*?)([^"]*)"\s+"([^"]*)"\s*;/.exec(line);
+    if (arm) {
+      arms.push({
+        caseInsensitive: arm[1] === "*",
+        pattern: arm[2] ?? "",
+        value: arm[3] ?? ""
+      });
+    }
+  }
+  return { arms, defaultValue };
+}
+function extractSsoStaticMaps(source) {
+  const blocks = [];
+  const header = /map\s+\$([A-Za-z0-9_]+)\s+\$sso_is_static\s*\{/g;
+  let m;
+  while ((m = header.exec(source)) !== null) {
+    let depth = 1;
+    let i = m.index + m[0].length;
+    for (; i < source.length && depth > 0; i++) {
+      if (source[i] === "{") depth++;
+      else if (source[i] === "}") depth--;
+    }
+    const body = source.slice(m.index + m[0].length, i - 1);
+    blocks.push({ sourceVar: m[1] ?? "", body, ...parseStaticMapArms(body) });
+  }
+  return blocks;
+}
+function evaluateStaticMap(block, uri) {
+  for (const arm of block.arms) {
+    let re;
+    try {
+      re = new RegExp(arm.pattern, arm.caseInsensitive ? "i" : "");
+    } catch {
+      continue;
+    }
+    if (re.test(uri)) return arm.value;
+  }
+  return block.defaultValue;
+}
+function isSsoStaticExempt(source, uri) {
+  const [block] = extractSsoStaticMaps(source);
+  if (!block) return false;
+  return evaluateStaticMap(block, uri) !== "";
+}
+function evaluateSsoStaticExemption(file, source) {
+  const maps = extractSsoStaticMaps(source);
+  const sourceVars = maps.map((b) => b.sourceVar);
+  if (maps.length === 0) {
+    return {
+      file,
+      sourceVars,
+      severity: "pass",
+      detail: "no `$sso_is_static` map declared \u2014 nothing to check"
+    };
+  }
+  const wrongKey = sourceVars.filter((v) => v !== SSO_STATIC_MAP_SOURCE);
+  if (wrongKey.length > 0) {
+    return {
+      file,
+      sourceVars,
+      severity: "violation",
+      detail: `\u{1F534} the static-asset exemption is keyed on ${wrongKey.map((v) => `\`$${v}\``).join(", ")} instead of \`$${SSO_STATIC_MAP_SOURCE}\`. \`$sso_is_static\` is read inside the auth_request subrequest, where \`$uri\` is \`/_sso_gate\` and never the original request path \u2014 so the extension regex can never match and the exemption is completely inert. Every static asset is gated, the SPA is handed auth HTML in place of its JS, and the app boots blank. Bug 06a3daae. Fix the map key in ${file}.`
+    };
+  }
+  for (const block of maps) {
+    const leaks = SSO_STATIC_PROBES.filter(
+      (p) => !p.exempt && evaluateStaticMap(block, p.uri) !== ""
+    );
+    if (leaks.length > 0) {
+      return {
+        file,
+        sourceVars,
+        severity: "violation",
+        detail: `\u{1F534} the static-asset exemption is too wide \u2014 it exempts ${leaks.map((p) => `\`${p.uri}\` (${p.why})`).join(", ")}. The gate answers 204 BEFORE any cookie check and each app location is a catch-all \`proxy_pass\`, so these reach the app with no SSO at all and customer content is exposed by URL shape. Scope the exemption to the build-output path prefixes (/_next/static/, /_nuxt/, /assets/, /static/, /build/assets/, root icons) and keep the leading deny arms for /api/, /uploads/ and traversal. Fix the map in ${file}.`
+      };
+    }
+    const missed = SSO_STATIC_PROBES.filter(
+      (p) => p.exempt && evaluateStaticMap(block, p.uri) === ""
+    );
+    if (missed.length > 0) {
+      return {
+        file,
+        sourceVars,
+        severity: "violation",
+        detail: `\u{1F534} the static-asset exemption is too narrow \u2014 it gates ${missed.map((p) => `\`${p.uri}\` (${p.why})`).join(", ")}. The SPA sets its session cookie only after its JS runs, so serving auth HTML in place of build output leaves a blank page. Remember \`$${SSO_STATIC_MAP_SOURCE}\` carries the query string \u2014 arms need the \`${SSO_STATIC_QUERY_ANCHOR}\` anchor, not a bare \`$\`. Bug 06a3daae. Fix the map regex in ${file}.`
+      };
+    }
+  }
+  return {
+    file,
+    sourceVars,
+    severity: "pass",
+    detail: `exemption keyed on \`$${SSO_STATIC_MAP_SOURCE}\`, scoped to build-output prefixes; all ${SSO_STATIC_PROBES.length} probes classified correctly \u2014 contract holds`
+  };
+}
+
+export {
+  EXPECTED_GOTRUE_COUNT,
+  isGotrueImage,
+  evaluateGotrueInvariant,
+  listRunningContainers,
+  checkSingleGotrueInstance,
+  CANONICAL_SSO_COOKIE,
+  DEAD_SSO_COOKIES,
+  evaluateSsoCookieContract,
+  SSO_EDGE_CONFIG_FILES,
+  extractSsoGateCookieNames,
+  evaluateSsoEdgeCookieGate,
+  SSO_STATIC_MAP_SOURCE,
+  SSO_STATIC_QUERY_ANCHOR,
+  SSO_STATIC_PROBES,
+  isSsoStaticExempt,
+  evaluateSsoStaticExemption
+};

package/dist/chunk-GHR4ZPJ7.js

@@ -0,0 +1,70 @@
+// scripts/lib/resolve-image-labels.mjs
+import { spawnSync } from "child_process";
+var defaultRunner = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", timeout: 6e4 });
+function repositoryOf(ref) {
+  if (typeof ref !== "string") return ref;
+  const at = ref.indexOf("@");
+  if (at !== -1) return ref.slice(0, at);
+  const slash = ref.lastIndexOf("/");
+  const colon = ref.lastIndexOf(":");
+  if (colon > slash) return ref.slice(0, colon);
+  return ref;
+}
+function amd64ChildDigest(rawJson) {
+  let doc;
+  try {
+    doc = typeof rawJson === "string" ? JSON.parse(rawJson) : rawJson;
+  } catch {
+    return void 0;
+  }
+  if (!doc || !Array.isArray(doc.manifests)) return void 0;
+  const isLinuxAmd64 = (m) => m?.platform?.os === "linux" && m?.platform?.architecture === "amd64";
+  const anyAmd64 = (m) => m?.platform?.architecture === "amd64" && m?.platform?.os !== "unknown";
+  const pick = doc.manifests.find(isLinuxAmd64) ?? doc.manifests.find(anyAmd64);
+  const digest = pick?.digest;
+  return typeof digest === "string" && digest.length > 0 ? digest : void 0;
+}
+function resolvePlatformRef(imageRef, { runner } = {}) {
+  const run = runner ?? defaultRunner;
+  const res = run("docker", ["buildx", "imagetools", "inspect", imageRef, "--raw"]);
+  if (!res || res.status !== 0) return imageRef;
+  const raw = (res.stdout ?? "").toString();
+  const childDigest = amd64ChildDigest(raw);
+  if (!childDigest) return imageRef;
+  return `${repositoryOf(imageRef)}@${childDigest}`;
+}
+function readLabelOff(platformRef, label, { runner } = {}) {
+  const run = runner ?? defaultRunner;
+  for (const root of [".Image.Config.Labels", ".Config.Labels"]) {
+    const res = run("docker", [
+      "buildx",
+      "imagetools",
+      "inspect",
+      platformRef,
+      "--format",
+      `{{ index ${root} "${label}" }}`
+    ]);
+    if (!res || res.status !== 0) continue;
+    const out = (res.stdout ?? "").toString().trim();
+    if (out === "" || out === "<no value>") continue;
+    return out;
+  }
+  return void 0;
+}
+function resolveImageLabels(imageRef, labels, { runner } = {}) {
+  const platformRef = resolvePlatformRef(imageRef, { runner });
+  const out = {};
+  for (const label of labels) out[label] = readLabelOff(platformRef, label, { runner });
+  return out;
+}
+function readImageLabel(imageRef, label, opts = {}) {
+  return resolveImageLabels(imageRef, [label], opts)[label];
+}
+
+export {
+  repositoryOf,
+  amd64ChildDigest,
+  resolvePlatformRef,
+  resolveImageLabels,
+  readImageLabel
+};

package/dist/{chunk-MINXPXAB.js → chunk-GJI77VDO.js}

@@ -1,16 +1,16 @@
 import {
   extractMemoryGraph
-} from "./chunk-RIK5GRWI.js";
+} from "./chunk-LGS2V2XD.js";
 import {
   flushBatch,
   writeMemory
-} from "./chunk-OYQNNKNS.js";
+} from "./chunk-MXPNVSXI.js";
 import {
   extractKeywords
 } from "./chunk-CHCA3ZM2.js";
 import {
   getActiveAgent
-} from "./chunk-KYFFVTGO.js";
+} from "./chunk-55BEFF4V.js";
 
 // src/mcp/tools/import-conversations.ts
 import { z } from "zod";

package/dist/{chunk-AAMGHW5W.js → chunk-GLQEJOXE.js}

@@ -144,6 +144,7 @@ var TOOL_CATEGORIES = {
   // orchestration
   registerCreateTrigger: "orchestration",
   registerListTriggers: "orchestration",
+  registerDeleteTrigger: "orchestration",
   registerApplyStarterPack: "orchestration",
   registerLoadSkill: "orchestration",
   registerExportOrchestration: "orchestration",

package/dist/{chunk-ADNBOKYZ.js → chunk-GM7TLYOK.js}

@@ -8,6 +8,28 @@ var GRAPH_API_VERSION = "v21.0";
 var MAX_PARAM_LENGTH = 2e3;
 var MAX_TRIGGER_DEPTH = 3;
 var _currentTriggerDepth = 0;
+var TRIGGER_COOLDOWN_MS = (() => {
+  const raw = Number(process.env.EXE_TRIGGER_COOLDOWN_MS);
+  return Number.isFinite(raw) && raw >= 0 ? raw : 3e4;
+})();
+function triggerCooldownKey(triggerId, record) {
+  const rid = record?.["id"] ?? record?.["recordId"] ?? record?.["record_id"] ?? record?.["uuid"];
+  const recordPart = rid == null ? "_" : String(rid).slice(0, 200);
+  return `${triggerId}:${recordPart}`;
+}
+async function isTriggerFireAllowed(triggerId, record) {
+  if (TRIGGER_COOLDOWN_MS <= 0) return true;
+  try {
+    const { recordTriggerFire } = await import("./lib/database.js");
+    const { allowed } = await recordTriggerFire(
+      triggerCooldownKey(triggerId, record),
+      TRIGGER_COOLDOWN_MS
+    );
+    return allowed;
+  } catch {
+    return true;
+  }
+}
 var OUTBOUND_RATE_LIMIT_PER_HOUR = 100;
 var _outboundWindows = /* @__PURE__ */ new Map();
 function checkOutboundRateLimit(channel) {
@@ -32,17 +54,24 @@ function sanitizeExternalPayload(text) {
   sanitized = sanitized.replace(/you\s+are\s+now\s+/gi, "[filtered] ");
   return sanitized;
 }
+var UNSAFE_PATH_SEGMENTS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function resolveOwnPath(record, segments) {
+  let current = record;
+  for (const segment of segments) {
+    if (current == null || typeof current !== "object") return void 0;
+    if (UNSAFE_PATH_SEGMENTS.has(segment)) return void 0;
+    if (!Object.hasOwn(current, segment)) return void 0;
+    current = current[segment];
+  }
+  return current;
+}
 function substituteTemplate(template, record, sanitizeExternal = false) {
   return template.replace(
     /\{\{(\w+(?:\.\w+)*)\}\}/g,
     (_match, dotPath) => {
       const segments = dotPath.split(".");
       if (segments[0] === "record") segments.shift();
-      let current = record;
-      for (const seg of segments) {
-        if (current == null || typeof current !== "object") return "";
-        current = current[seg];
-      }
+      const current = resolveOwnPath(record, segments);
       if (current == null) return "";
       const value = String(current);
       return sanitizeExternal ? sanitizeExternalPayload(value) : value;
@@ -50,12 +79,7 @@ function substituteTemplate(template, record, sanitizeExternal = false) {
   );
 }
 function resolveFieldValue(record, field) {
-  let current = record;
-  for (const segment of field.split(".")) {
-    if (current == null || typeof current !== "object") return void 0;
-    current = current[segment];
-  }
-  return current;
+  return resolveOwnPath(record, field.split("."));
 }
 function evaluateCondition(condition, record) {
   const fieldValue = resolveFieldValue(record, condition.field);
@@ -114,6 +138,14 @@ function createNewTrigger(input) {
   saveTriggers(triggers);
   return trigger;
 }
+function deleteTrigger(triggerId) {
+  const triggers = loadTriggers();
+  const idx = triggers.findIndex((t) => t.id === triggerId);
+  if (idx === -1) return false;
+  triggers.splice(idx, 1);
+  saveTriggers(triggers);
+  return true;
+}
 async function executeSendWhatsapp(params) {
   if (!checkOutboundRateLimit("whatsapp")) {
     throw new Error(`Outbound rate limit exceeded for WhatsApp (max ${OUTBOUND_RATE_LIMIT_PER_HOUR}/hour)`);
@@ -266,14 +298,18 @@ To approve, manually run the action via MCP tools.`,
     baseDir: process.cwd()
   });
 }
+function resolveActionParams(action, record) {
+  const resolved = {};
+  for (const [key, val] of Object.entries(action.params)) {
+    resolved[key] = sanitizeParam(substituteTemplate(val, record, true));
+  }
+  return resolved;
+}
 async function executeAction(action, record, executor, triggerName) {
   if (executor) {
     return executor(action, record);
   }
-  const resolvedParams = {};
-  for (const [key, val] of Object.entries(action.params)) {
-    resolvedParams[key] = sanitizeParam(substituteTemplate(val, record));
-  }
+  const resolvedParams = resolveActionParams(action, record);
   if (action.requires_approval) {
     try {
       await routeToApproval(action, resolvedParams, triggerName ?? "Unknown trigger");
@@ -309,10 +345,9 @@ async function executeAction(action, record, executor, triggerName) {
         break;
       }
       case "mcp_tool":
-        console.log(
-          `[trigger-engine] mcp_tool action: ${JSON.stringify(resolvedParams)}`
+        throw new Error(
+          `mcp_tool trigger actions are not implemented \u2014 this action did nothing. Requested tool: ${resolvedParams.tool ?? resolvedParams.name ?? "(unspecified)"}. Use a supported action type (send_message, create_task, send_whatsapp, update_wiki, asana), or set requires_approval so the action is queued for a human instead.`
         );
-        break;
     }
     return { success: true };
   } catch (err) {
@@ -344,6 +379,12 @@ async function _processCRMEventInner(event, executor, triggersOverride) {
     if (!trigger.enabled) continue;
     if (trigger.event !== eventString && trigger.event !== "*") continue;
     if (!evaluateConditions(trigger.conditions, event.record)) continue;
+    if (!await isTriggerFireAllowed(trigger.id, event.record)) {
+      console.warn(
+        `[trigger-engine] Suppressed "${trigger.name}" on ${eventString}: re-fired within ${TRIGGER_COOLDOWN_MS}ms cooldown for the same record (loop guard).`
+      );
+      continue;
+    }
     const actionResults = [];
     for (const action of trigger.actions) {
       const result = await executeAction(action, event.record, executor, trigger.name);
@@ -376,6 +417,7 @@ export {
   substituteTemplate,
   loadTriggers,
   createNewTrigger,
+  deleteTrigger,
   executeAction,
   processCRMEvent,
   isScheduledTrigger

package/dist/{chunk-RUWWES2K.js → chunk-GNUAL43X.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-E23LNUWJ.js";
 import {
   getClient
-} from "./chunk-5DCCKHDY.js";
+} from "./chunk-TAMDAOCU.js";
 
 // src/lib/work-claims.ts
 var CLAIM_TTL_MINUTES = 90;
@@ -306,7 +306,7 @@ async function heartbeatClaims(holderSession, ttlMinutes = CLAIM_TTL_MINUTES) {
 }
 async function recordClaimEvent(eventType, sessionScope, agentId, payload, severity) {
   try {
-    const { recordOrchestrationEventBestEffort } = await import("./orchestration-events-GY5VP5LU.js");
+    const { recordOrchestrationEventBestEffort } = await import("./orchestration-events-N7LYMUGA.js");
     recordOrchestrationEventBestEffort({
       eventType,
       source: "work-claims",

package/dist/{chunk-QZL6E4UB.js → chunk-GOMQ7PVQ.js}

@@ -1,10 +1,10 @@
 import {
   enqueueMemory
-} from "./chunk-CDUB5Q6J.js";
+} from "./chunk-4IK2K3B3.js";
 import {
   isClientConnected,
   sendDaemonRequest
-} from "./chunk-UQUUNGTP.js";
+} from "./chunk-NUK7EEN5.js";
 
 // src/lib/memory-queue-client.ts
 async function writeMemoryViaDaemon(entry) {

package/dist/{chunk-GB3AHV5F.js → chunk-GQOEWNVM.js}

@@ -1,6 +1,6 @@
 import {
   EXE_AI_DIR
-} from "./chunk-QMSEL5YS.js";
+} from "./chunk-ZIG7VPJV.js";
 
 // src/lib/device-registry.ts
 import crypto from "crypto";