@automagik/omni 2.260727.2 → 2.260728.2

package/dist/index.js

@@ -8187,6 +8187,74 @@ var init_types2 = __esm(() => {
     "voice.user_left_channel"
   ];
 });
+// ../core/src/events/envelope.ts
+function classifyEnvelope(metadata) {
+  if (metadata === null || metadata === undefined)
+    return { world: "legacy" };
+  const { envelopeVersion, tenantId } = metadata;
+  if (envelopeVersion === undefined || envelopeVersion === null) {
+    if (tenantId !== undefined && tenantId !== null) {
+      return { world: "quarantine", reason: "malformed_envelope" };
+    }
+    return { world: "legacy" };
+  }
+  if (typeof envelopeVersion !== "number" || !KNOWN_ENVELOPE_VERSIONS.has(envelopeVersion)) {
+    return { world: "quarantine", reason: "unknown_version" };
+  }
+  if (tenantId === undefined || tenantId === null || tenantId === "") {
+    return { world: "quarantine", reason: "missing_tenant" };
+  }
+  if (typeof tenantId !== "string" || !UUID.test(tenantId)) {
+    return { world: "quarantine", reason: "invalid_tenant" };
+  }
+  return { world: "tenant", tenantId, envelopeVersion };
+}
+function stampTenantEnvelope(metadata, tenantId) {
+  if (typeof tenantId !== "string" || !UUID.test(tenantId)) {
+    throw new Error(`stampTenantEnvelope: refusing to stamp a non-UUID tenant (${String(tenantId)})`);
+  }
+  return { ...metadata, envelopeVersion: CURRENT_ENVELOPE_VERSION, tenantId };
+}
+function isStampableTenantId(tenantId) {
+  return typeof tenantId === "string" && UUID.test(tenantId);
+}
+function setEnvelopeTenantResolver(resolver) {
+  ambientTenantResolver = resolver;
+}
+function resolveAmbientTenantId() {
+  if (!ambientTenantResolver)
+    return null;
+  try {
+    const tenantId = ambientTenantResolver();
+    return isStampableTenantId(tenantId) ? tenantId : null;
+  } catch {
+    return null;
+  }
+}
+function setEnvelopeInstanceTenantResolver(resolver) {
+  instanceOwnerTenantResolver = resolver;
+}
+function resolveInstanceOwnerTenantId(instanceId) {
+  if (!instanceOwnerTenantResolver || !instanceId)
+    return null;
+  try {
+    const tenantId = instanceOwnerTenantResolver(instanceId);
+    return isStampableTenantId(tenantId) ? tenantId : null;
+  } catch {
+    return null;
+  }
+}
+function resolvePublishTenantId(explicitTenantId, instanceId) {
+  if (isStampableTenantId(explicitTenantId))
+    return explicitTenantId;
+  return resolveAmbientTenantId() ?? resolveInstanceOwnerTenantId(instanceId);
+}
+var CURRENT_ENVELOPE_VERSION = 1, KNOWN_ENVELOPE_VERSIONS, UUID, ambientTenantResolver = null, instanceOwnerTenantResolver = null;
+var init_envelope = __esm(() => {
+  KNOWN_ENVELOPE_VERSIONS = new Set([CURRENT_ENVELOPE_VERSION]);
+  UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+});
+
 // ../../node_modules/.bun/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/src/version.js
 var require_version = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
@@ -30595,7 +30663,8 @@ function createSubscription(options) {
     maxRetries = DEFAULT_CONSUMER_CONFIG.maxRetries,
     retryDelayMs = DEFAULT_CONSUMER_CONFIG.retryDelayMs,
     concurrency = 1,
-    onDeadLetter
+    onDeadLetter,
+    onQuarantine
   } = options;
   const subscriptionId = crypto.randomUUID();
   const abortController = new AbortController;
@@ -30647,6 +30716,25 @@ function createSubscription(options) {
       msg.term();
       return;
     }
+    const classification = classifyEnvelope(event.metadata);
+    if (classification.world === "quarantine") {
+      log3.error("Envelope quarantined by consumer validation", {
+        subscriptionId,
+        eventType: event.type,
+        eventId: event.id,
+        reason: classification.reason,
+        tenantId: event.metadata.tenantId ?? null
+      });
+      if (onQuarantine) {
+        try {
+          await onQuarantine(event, classification);
+        } catch (qError) {
+          log3.error("Quarantine handler failed", { subscriptionId, error: String(qError) });
+        }
+      }
+      msg.term();
+      return;
+    }
     try {
       const validation = eventRegistry.validate(event.type, event.payload);
       if (!validation.success) {
@@ -30761,6 +30849,7 @@ class SubscriptionManager {
 var import_api, log3, ValidationError;
 var init_subscription = __esm(() => {
   init_logger();
+  init_envelope();
   init_consumer();
   init_registry();
   import_api = __toESM(require_src(), 1);
@@ -30867,6 +30956,7 @@ class NatsEventBus {
     await this.ensureConnected();
     const eventId = crypto.randomUUID();
     const timestamp = Date.now();
+    const tenantId = resolvePublishTenantId(metadata?.tenantId, metadata?.instanceId);
     const event = {
       id: eventId,
       type,
@@ -30881,7 +30971,8 @@ class NatsEventBus {
         traceId: metadata?.traceId ?? eventId,
         source: metadata?.source ?? this.config.serviceName,
         ingestMode: metadata?.ingestMode,
-        timings: metadata?.timings
+        timings: metadata?.timings,
+        ...tenantId ? { envelopeVersion: CURRENT_ENVELOPE_VERSION, tenantId } : {}
       }
     };
     let subject;
@@ -31018,6 +31109,17 @@ class NatsEventBus {
           retryCount,
           timestamp: Date.now()
         }, { source: this.config.serviceName });
+      },
+      onQuarantine: async (event, classification) => {
+        await this.publishGeneric("system.dead_letter", {
+          originalEventId: event.id,
+          originalEventType: event.type,
+          error: `envelope_quarantined:${classification.reason}`,
+          retryCount: 0,
+          timestamp: Date.now(),
+          quarantineReason: classification.reason,
+          tenantId: event.metadata.tenantId
+        }, { source: this.config.serviceName });
       }
     });
     this.subscriptionManager.add(subscription);
@@ -31148,6 +31250,7 @@ async function connectEventBus(config2) {
 var import_api2, import_nats, log4, DEFAULTS, ENSURE_CONNECTED_WAIT_MS = 5000;
 var init_client = __esm(() => {
   init_logger();
+  init_envelope();
   init_consumer();
   init_registry();
   init_streams();
@@ -31360,6 +31463,7 @@ function estimateCompletion(progress) {
 // ../core/src/events/index.ts
 var init_events = __esm(() => {
   init_types2();
+  init_envelope();
   init_nats();
   init_dead_letter();
   init_payload_store();
@@ -35900,6 +36004,32 @@ var require_prom_client = __commonJS((exports) => {
   exports.AggregatorRegistry = require_cluster();
 });
 
+// ../core/src/metrics/tenant-labels.ts
+import { createHash as createHash3 } from "crypto";
+function configureTenantLabelBuckets(count) {
+  if (!Number.isInteger(count) || count < 1) {
+    throw new Error(`tenant-labels: bucket count must be a positive integer, got ${count}`);
+  }
+  bucketCount = count;
+}
+function tenantLabelBucketCount() {
+  return bucketCount;
+}
+function boundedTenantLabel(tenantId) {
+  if (!tenantId)
+    return TENANTLESS_LABEL;
+  const digest = createHash3("sha256").update(tenantId).digest();
+  const bucket = digest.readUInt32BE(0) % bucketCount;
+  return `t${bucket}`;
+}
+function resetTenantLabelConfig() {
+  bucketCount = DEFAULT_TENANT_LABEL_BUCKETS;
+}
+var DEFAULT_TENANT_LABEL_BUCKETS = 128, TENANTLESS_LABEL = "none", bucketCount;
+var init_tenant_labels = __esm(() => {
+  bucketCount = DEFAULT_TENANT_LABEL_BUCKETS;
+});
+
 // ../core/src/metrics/index.ts
 function getRegistry() {
   return registry;
@@ -35913,9 +36043,14 @@ async function getMetricsText() {
 async function getMetricsJson() {
   return registry.getMetricsAsJSON();
 }
-function recordEventProcessed(eventType, status, durationSeconds) {
+function recordEventProcessed(eventType, status, durationSeconds, tenantId) {
   eventsProcessed.inc({ event_type: eventType, status });
   eventProcessingDuration.observe({ event_type: eventType }, durationSeconds);
+  if (tenantId)
+    recordTenantEventProcessed(tenantId, eventType, status);
+}
+function recordTenantEventProcessed(tenantId, eventType, status) {
+  tenantEventsProcessed.inc({ tenant_bucket: boundedTenantLabel(tenantId), event_type: eventType, status });
 }
 function recordDeadLetterOp(operation, result) {
   deadLetterOperations.inc({ operation, result });
@@ -35964,9 +36099,11 @@ function recordOpenClawReconnect(providerId) {
 async function resetMetrics() {
   registry.resetMetrics();
 }
-var import_prom_client, registry, eventsProcessed, eventProcessingDuration, deadLettersPending, deadLetterOperations, payloadStorageSize, payloadOperations, natsConnectionStatus, natsMessagesPublished, natsMessagesReceived, natsPublishLatency, natsPendingMessages, dbPoolSize, dbQueries, dbQueryDuration, dbErrors, appUptime, httpActiveConnections, httpRequests, httpRequestDuration, scheduledJobRuns, scheduledJobDuration, scheduledJobNextRun, openclawWsState, openclawTriggerDuration, openclawTriggerErrors, openclawReconnects, openclawTimeToFirstDelta, openclawCircuitBreakerState;
+var import_prom_client, registry, eventsProcessed, tenantEventsProcessed, eventProcessingDuration, deadLettersPending, deadLetterOperations, payloadStorageSize, payloadOperations, natsConnectionStatus, natsMessagesPublished, natsMessagesReceived, natsPublishLatency, natsPendingMessages, dbPoolSize, dbQueries, dbQueryDuration, dbErrors, appUptime, httpActiveConnections, httpRequests, httpRequestDuration, scheduledJobRuns, scheduledJobDuration, scheduledJobNextRun, openclawWsState, openclawTriggerDuration, openclawTriggerErrors, openclawReconnects, openclawTimeToFirstDelta, openclawCircuitBreakerState;
 var init_metrics = __esm(() => {
+  init_tenant_labels();
   import_prom_client = __toESM(require_prom_client(), 1);
+  init_tenant_labels();
   registry = new import_prom_client.Registry;
   eventsProcessed = new import_prom_client.Counter({
     name: "omni_events_processed_total",
@@ -35974,6 +36111,12 @@ var init_metrics = __esm(() => {
     labelNames: ["event_type", "status"],
     registers: [registry]
   });
+  tenantEventsProcessed = new import_prom_client.Counter({
+    name: "omni_tenant_events_processed_total",
+    help: "Events processed, labelled by bounded/redacted tenant bucket (never a raw tenant id)",
+    labelNames: ["tenant_bucket", "event_type", "status"],
+    registers: [registry]
+  });
   eventProcessingDuration = new import_prom_client.Histogram({
     name: "omni_event_processing_duration_seconds",
     help: "Event processing duration in seconds",
@@ -36140,6 +36283,226 @@ var init_metrics = __esm(() => {
   });
 });
 
+// ../core/src/observability/tenant-observability.ts
+function keyIsSecret(key) {
+  const lower = key.toLowerCase();
+  return SECRET_KEY_SUBSTRINGS.some((needle) => lower.includes(needle));
+}
+function looksLikeHighEntropyToken(value) {
+  if (value.length < 24)
+    return false;
+  if (!/^[A-Za-z0-9._~+/=-]+$/.test(value))
+    return false;
+  return /[A-Za-z]/.test(value) && /[0-9]/.test(value);
+}
+function valueLooksSecret(value) {
+  if (typeof value !== "string")
+    return false;
+  if (UUID2.test(value))
+    return false;
+  if (SECRET_VALUE_PATTERNS.some((re) => re.test(value)))
+    return true;
+  if (JWT_VALUE.test(value))
+    return true;
+  return looksLikeHighEntropyToken(value);
+}
+function redactSecrets(metadata) {
+  const out = {};
+  for (const [key, value] of Object.entries(metadata)) {
+    if (PRESERVE_KEYS.has(key)) {
+      out[key] = value;
+      continue;
+    }
+    if (keyIsSecret(key))
+      continue;
+    if (valueLooksSecret(value))
+      continue;
+    out[key] = value;
+  }
+  return out;
+}
+function buildTenantAuditFields(input) {
+  if (typeof input.tenantId !== "string" || !UUID2.test(input.tenantId)) {
+    throw new Error("tenant-observability: tenantId must be a well-formed UUID");
+  }
+  if (typeof input.actorCredentialId !== "string" || input.actorCredentialId.length === 0) {
+    throw new Error("tenant-observability: actorCredentialId must be a non-empty string");
+  }
+  const fields = {
+    tenantId: input.tenantId,
+    actorCredentialId: input.actorCredentialId,
+    ...input.requestId ? { requestId: input.requestId } : {}
+  };
+  return fields;
+}
+function buildTenantAuditRecord(input, extraMetadata = {}) {
+  const identity = buildTenantAuditFields(input);
+  const scrubbed = redactSecrets(extraMetadata);
+  for (const dotted of DOTTED_IDENTITY_KEYS)
+    delete scrubbed[dotted];
+  return { ...scrubbed, ...identity };
+}
+function tenantTraceAttributes(fields) {
+  return {
+    "tenant.id": fields.tenantId,
+    "actor.credential_id": fields.actorCredentialId,
+    ...fields.requestId ? { "request.id": fields.requestId } : {}
+  };
+}
+var UUID2, PRESERVE_KEYS, SECRET_KEY_SUBSTRINGS, SECRET_VALUE_PATTERNS, JWT_VALUE, DOTTED_IDENTITY_KEYS;
+var init_tenant_observability = __esm(() => {
+  UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+  PRESERVE_KEYS = new Set(["tenantId", "actorCredentialId", "requestId", "instanceId"]);
+  SECRET_KEY_SUBSTRINGS = [
+    "secret",
+    "password",
+    "passwd",
+    "apikey",
+    "api_key",
+    "api-key",
+    "privatekey",
+    "private_key",
+    "private-key",
+    "plaintext",
+    "plain_text",
+    "plain-text",
+    "bearer",
+    "authorization",
+    "auth_token",
+    "authtoken",
+    "access_key",
+    "accesskey",
+    "signing_key",
+    "session_secret",
+    "session_key",
+    "webhook_secret",
+    "keyhash",
+    "key_hash",
+    "cookie",
+    "signature",
+    "token",
+    "refresh_token",
+    "key",
+    "credentials",
+    "jwt"
+  ];
+  SECRET_VALUE_PATTERNS = [/omni_sk_/i, /-----BEGIN [A-Z ]*PRIVATE KEY-----/];
+  JWT_VALUE = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+  DOTTED_IDENTITY_KEYS = ["tenant.id", "actor.credential_id", "request.id"];
+});
+
+// ../core/src/observability/index.ts
+var init_observability = __esm(() => {
+  init_tenant_observability();
+});
+
+// ../core/src/secrets/tenant-secret-box.ts
+import { createCipheriv, createDecipheriv, hkdfSync, randomBytes as randomBytes2 } from "crypto";
+function setTenantSecretMasterKey(key) {
+  if (key === null) {
+    masterKey = null;
+    return;
+  }
+  if (key.length < DEK_BYTES) {
+    throw new TenantSecretError(`master key must be at least ${DEK_BYTES} bytes`);
+  }
+  masterKey = Buffer.from(key);
+}
+function isTenantSecretSealingEnabled() {
+  return masterKey !== null;
+}
+function requireKey() {
+  if (masterKey === null)
+    throw new TenantSecretUnconfiguredError;
+  return masterKey;
+}
+function requireTenant(tenantId) {
+  if (typeof tenantId !== "string" || !UUID3.test(tenantId)) {
+    throw new TenantSecretError(`refusing a non-UUID tenant (${String(tenantId)})`);
+  }
+}
+function deriveDek(key, tenantId) {
+  const derived = hkdfSync("sha256", key, Buffer.from(tenantId, "utf8"), Buffer.from(DEK_INFO, "utf8"), DEK_BYTES);
+  return Buffer.from(derived);
+}
+function sealTenantSecret(tenantId, plaintext) {
+  const key = requireKey();
+  requireTenant(tenantId);
+  const dek = deriveDek(key, tenantId);
+  const iv = randomBytes2(IV_BYTES);
+  const cipher = createCipheriv(CIPHER, dek, iv);
+  cipher.setAAD(Buffer.from(tenantId, "utf8"));
+  const ct = Buffer.concat([cipher.update(Buffer.from(plaintext, "utf8")), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return {
+    v: SECRET_BOX_VERSION,
+    alg: "A256GCM",
+    kdf: "HKDF-SHA256",
+    t: tenantId,
+    iv: iv.toString("base64"),
+    ct: ct.toString("base64"),
+    tag: tag.toString("base64")
+  };
+}
+function openTenantSecret(tenantId, sealed) {
+  const key = requireKey();
+  requireTenant(tenantId);
+  if (!isSealedSecret(sealed)) {
+    throw new TenantSecretError("value is not a sealed secret");
+  }
+  if (sealed.v !== SECRET_BOX_VERSION) {
+    throw new TenantSecretError(`unknown sealed-secret version (${String(sealed.v)})`);
+  }
+  if (sealed.t !== tenantId) {
+    throw new TenantSecretError("tenant mismatch");
+  }
+  const dek = deriveDek(key, tenantId);
+  try {
+    const decipher = createDecipheriv(CIPHER, dek, Buffer.from(sealed.iv, "base64"));
+    decipher.setAAD(Buffer.from(tenantId, "utf8"));
+    decipher.setAuthTag(Buffer.from(sealed.tag, "base64"));
+    const pt = Buffer.concat([decipher.update(Buffer.from(sealed.ct, "base64")), decipher.final()]);
+    return pt.toString("utf8");
+  } catch {
+    throw new TenantSecretError("authentication failed (wrong tenant or tampered secret)");
+  }
+}
+function sealTenantSecretJson(tenantId, value) {
+  return sealTenantSecret(tenantId, JSON.stringify(value));
+}
+function openTenantSecretJson(tenantId, sealed) {
+  return JSON.parse(openTenantSecret(tenantId, sealed));
+}
+function isSealedSecret(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const s = value;
+  return typeof s.v === "number" && s.alg === "A256GCM" && s.kdf === "HKDF-SHA256" && typeof s.t === "string" && typeof s.iv === "string" && typeof s.ct === "string" && typeof s.tag === "string";
+}
+var SECRET_BOX_VERSION = 1, CIPHER = "aes-256-gcm", IV_BYTES = 12, DEK_BYTES = 32, DEK_INFO = "omni-tenant-secret-box:v1:dek", UUID3, TenantSecretError, TenantSecretUnconfiguredError, masterKey = null;
+var init_tenant_secret_box = __esm(() => {
+  UUID3 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  TenantSecretError = class TenantSecretError extends Error {
+    code = "tenant_secret_denied";
+    constructor(reason) {
+      super(`tenant-secret-box: ${reason}`);
+      this.name = "TenantSecretError";
+    }
+  };
+  TenantSecretUnconfiguredError = class TenantSecretUnconfiguredError extends Error {
+    code = "tenant_secret_unconfigured";
+    constructor() {
+      super("tenant-secret-box: no master key configured (sealing disabled)");
+      this.name = "TenantSecretUnconfiguredError";
+    }
+  };
+});
+
+// ../core/src/secrets/index.ts
+var init_secrets = __esm(() => {
+  init_tenant_secret_box();
+});
+
 // ../core/src/automations/types.ts
 var CONDITION_OPERATORS, ACTION_TYPES, AUTOMATION_DEBOUNCE_MODES, AUTOMATION_LOG_STATUSES;
 var init_types6 = __esm(() => {
@@ -36424,6 +36787,568 @@ var init_templates = __esm(() => {
   TEMPLATE_REGEX = /\{\{([^}]+)\}\}/g;
 });
 
+// ../core/src/egress/policy.ts
+import { isIP } from "net";
+function isAllowedClass(destinationClass) {
+  return destinationClass === "approved-public";
+}
+function schemesFor(policy) {
+  return policy.approvedSchemes && policy.approvedSchemes.length > 0 ? policy.approvedSchemes : DEFAULT_SCHEMES;
+}
+function portFor(url) {
+  if (url.port) {
+    const parsed = Number.parseInt(url.port, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  if (url.protocol === "https:")
+    return 443;
+  if (url.protocol === "http:")
+    return 80;
+  return null;
+}
+function portsFor(policy) {
+  return policy.approvedPorts && policy.approvedPorts.length > 0 ? policy.approvedPorts : DEFAULT_PORTS;
+}
+function hostMatchesSuffix(host, suffix) {
+  const s = suffix.toLowerCase().replace(/^\.+/, "").replace(/\.+$/, "");
+  if (s.length === 0)
+    return false;
+  return host === s || host.endsWith(`.${s}`);
+}
+function isApprovedHost(host, policy) {
+  return policy.approvedHostSuffixes.some((suffix) => hostMatchesSuffix(host, suffix));
+}
+function parseIpv4Part(part) {
+  if (part.length === 0)
+    return null;
+  let value;
+  if (/^0x[0-9a-f]+$/i.test(part))
+    value = Number.parseInt(part.slice(2), 16);
+  else if (/^0[0-7]+$/.test(part))
+    value = Number.parseInt(part, 8);
+  else if (/^[0-9]+$/.test(part))
+    value = Number.parseInt(part, 10);
+  else
+    return null;
+  return Number.isNaN(value) ? null : value;
+}
+function canonicalizeIpv4(host) {
+  const parts = host.split(".");
+  const looksNumeric = parts.every((p2) => /^(0x[0-9a-f]+|[0-9]+)$/i.test(p2));
+  if (!looksNumeric)
+    return null;
+  if (parts.length > 4)
+    return { invalid: true };
+  const values2 = parts.map(parseIpv4Part);
+  if (values2.some((v2) => v2 === null))
+    return { invalid: true };
+  const nums = values2;
+  let ip32;
+  if (nums.length === 1) {
+    ip32 = nums[0];
+    if (ip32 > 4294967295)
+      return { invalid: true };
+  } else {
+    const leading = nums.slice(0, -1);
+    const last = nums[nums.length - 1];
+    if (leading.some((n2) => n2 > 255))
+      return { invalid: true };
+    const maxLast = 2 ** (8 * (4 - leading.length));
+    if (last >= maxLast)
+      return { invalid: true };
+    ip32 = last;
+    for (let i = 0;i < leading.length; i++) {
+      ip32 += leading[i] * 2 ** (8 * (3 - i));
+    }
+  }
+  if (ip32 < 0 || ip32 > 4294967295)
+    return { invalid: true };
+  const a = ip32 >>> 24 & 255;
+  const b3 = ip32 >>> 16 & 255;
+  const c2 = ip32 >>> 8 & 255;
+  const d2 = ip32 & 255;
+  return { ipv4: `${a}.${b3}.${c2}.${d2}` };
+}
+function ipv4ToInt(address) {
+  const octets = address.split(".");
+  if (octets.length !== 4)
+    return null;
+  let value = 0;
+  for (const octet of octets) {
+    if (!/^[0-9]{1,3}$/.test(octet))
+      return null;
+    const n2 = Number.parseInt(octet, 10);
+    if (n2 > 255)
+      return null;
+    value = value * 256 + n2;
+  }
+  return value >>> 0;
+}
+function cidr(base, bits) {
+  const lo = ipv4ToInt(base);
+  const size2 = 2 ** (32 - bits);
+  return [lo, lo + size2 - 1];
+}
+function classifyIpv4(address) {
+  const value = ipv4ToInt(address);
+  if (value === null)
+    return "invalid-ip-encoding";
+  for (const [lo, hi, cls] of RESERVED_IPV4) {
+    if (value >= lo && value <= hi)
+      return cls;
+  }
+  return null;
+}
+function mappedSuffixToIpv4(suffix) {
+  if (suffix.includes("."))
+    return isIP(suffix) === 4 ? suffix : null;
+  const hextets = suffix.split(":");
+  if (hextets.length !== 2)
+    return null;
+  const hi = Number.parseInt(hextets[0], 16);
+  const lo = Number.parseInt(hextets[1], 16);
+  if (Number.isNaN(hi) || Number.isNaN(lo) || hi > 65535 || lo > 65535)
+    return null;
+  return `${hi >> 8 & 255}.${hi & 255}.${lo >> 8 & 255}.${lo & 255}`;
+}
+function hextetsToIpv4(hi, lo) {
+  return `${hi >> 8 & 255}.${hi & 255}.${lo >> 8 & 255}.${lo & 255}`;
+}
+function ipv6ToHextets(normalized) {
+  const parseGroups = (groups) => {
+    const out = [];
+    for (let i = 0;i < groups.length; i++) {
+      const g3 = groups[i];
+      if (g3.includes(".")) {
+        if (i !== groups.length - 1)
+          return null;
+        const octets = g3.split(".").map((o) => Number.parseInt(o, 10));
+        if (octets.length !== 4 || octets.some((n2) => Number.isNaN(n2) || n2 < 0 || n2 > 255))
+          return null;
+        out.push(octets[0] << 8 | octets[1]);
+        out.push(octets[2] << 8 | octets[3]);
+      } else {
+        const n2 = Number.parseInt(g3, 16);
+        if (Number.isNaN(n2) || n2 < 0 || n2 > 65535)
+          return null;
+        out.push(n2);
+      }
+    }
+    return out;
+  };
+  const dc = normalized.indexOf("::");
+  if (dc >= 0) {
+    const before = normalized.slice(0, dc);
+    const after = normalized.slice(dc + 2);
+    const head = before === "" ? [] : before.split(":");
+    const tail = after === "" ? [] : after.split(":");
+    const h2 = parseGroups(head);
+    const t = parseGroups(tail);
+    if (h2 === null || t === null)
+      return null;
+    const fill = 8 - h2.length - t.length;
+    if (fill < 0)
+      return null;
+    return [...h2, ...new Array(fill).fill(0), ...t];
+  }
+  const g2 = parseGroups(normalized.split(":"));
+  if (g2 === null || g2.length !== 8)
+    return null;
+  return g2;
+}
+function classifyIpv6Transition(normalized) {
+  const hextets = ipv6ToHextets(normalized);
+  if (hextets === null)
+    return;
+  const [h0, h1, h2, h3, h4, h5, h6, h7] = hextets;
+  if (h0 === 8194) {
+    return classifyIpv4(hextetsToIpv4(h1, h2));
+  }
+  if (h0 === 100 && h1 === 65435 && h2 === 0 && h3 === 0 && h4 === 0 && h5 === 0) {
+    return classifyIpv4(hextetsToIpv4(h6, h7));
+  }
+  if (h0 === 8193 && h1 === 0) {
+    const server = classifyIpv4(hextetsToIpv4(h2, h3));
+    if (server !== null)
+      return server;
+    const client = classifyIpv4(hextetsToIpv4(h6 ^ 65535, h7 ^ 65535));
+    if (client !== null)
+      return client;
+    return null;
+  }
+  return;
+}
+function classifyIpv6(address) {
+  const normalized = address.toLowerCase().replace(/^\[|\]$/g, "");
+  if (normalized === "::" || normalized === "::0" || normalized === "0:0:0:0:0:0:0:0")
+    return "unspecified";
+  if (normalized === "::1")
+    return "loopback";
+  const mappedFfff = /^::ffff:([0-9a-f:.]+)$/.exec(normalized);
+  const compat = /^::([0-9a-f]{1,4}:[0-9a-f]{1,4}|\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})$/.exec(normalized);
+  const suffix = mappedFfff?.[1] ?? compat?.[1];
+  if (suffix) {
+    const v4 = mappedSuffixToIpv4(suffix);
+    if (v4) {
+      const inner = classifyIpv4(v4);
+      return inner ?? "ipv4-mapped-ipv6";
+    }
+  }
+  const transition = classifyIpv6Transition(normalized);
+  if (transition !== undefined)
+    return transition;
+  const firstHextet = normalized.split(":", 1)[0] ?? "";
+  if (firstHextet.startsWith("fc") || firstHextet.startsWith("fd"))
+    return "ipv6-ula";
+  if (/^fe[89ab]/.test(firstHextet))
+    return "link-local";
+  if (firstHextet.startsWith("ff"))
+    return "multicast";
+  return null;
+}
+function classifyResolvedAddress(address) {
+  const family = isIP(address);
+  if (family === 4)
+    return classifyIpv4(address);
+  if (family === 6)
+    return classifyIpv6(address);
+  return "invalid-ip-encoding";
+}
+function decide(allowed, destinationClass, reason, policy, host) {
+  return { allowed, destinationClass, reason, policyVersion: policy.policyVersion, host };
+}
+function classifyUrl(url, policy) {
+  if (!schemesFor(policy).includes(url.protocol)) {
+    return decide(false, "unapproved-scheme", `scheme ${url.protocol} is not approved`, policy, url.hostname);
+  }
+  if (url.username !== "" || url.password !== "") {
+    return decide(false, "credentialed-url", "URL carries userinfo credentials", policy, url.hostname);
+  }
+  const port = portFor(url);
+  if (port === null || !portsFor(policy).includes(port)) {
+    return decide(false, "unapproved-port", `port ${url.port || "(default)"} is not approved`, policy, url.hostname);
+  }
+  const host = url.hostname.replace(/^\[|\]$/g, "").toLowerCase();
+  if (host.length === 0) {
+    return decide(false, "malformed-url", "URL has no host", policy, host);
+  }
+  return classifyHost(host, policy);
+}
+function classifyHost(host, policy) {
+  if (isIP(host) !== 0) {
+    const literalClass = classifyResolvedAddress(host);
+    if (literalClass !== null) {
+      return decide(false, literalClass, `literal IP ${host} is in a ${literalClass} range`, policy, host);
+    }
+    return approvedOrDenied(isApprovedHost(host, policy), "literal IP", host, policy);
+  }
+  const canon = canonicalizeIpv4(host);
+  if (canon !== null) {
+    if ("invalid" in canon) {
+      return decide(false, "invalid-ip-encoding", `host ${host} is a malformed numeric address`, policy, host);
+    }
+    const literalClass = classifyResolvedAddress(canon.ipv4);
+    if (literalClass !== null) {
+      return decide(false, literalClass, `host ${host} canonicalises to ${canon.ipv4} (${literalClass})`, policy, host);
+    }
+    const approved = isApprovedHost(canon.ipv4, policy) || isApprovedHost(host, policy);
+    return approvedOrDenied(approved, "numeric IP", host, policy);
+  }
+  return approvedOrDenied(isApprovedHost(host, policy), "host", host, policy);
+}
+function approvedOrDenied(approved, kind, host, policy) {
+  return approved ? decide(true, "approved-public", `approved ${kind} (allowlist match; DNS pending for names)`, policy, host) : decide(false, "not-approved", `${kind} ${host} is not on the tenant allowlist`, policy, host);
+}
+var DEFAULT_SCHEMES, DEFAULT_PORTS, RESERVED_IPV4;
+var init_policy = __esm(() => {
+  DEFAULT_SCHEMES = ["https:"];
+  DEFAULT_PORTS = [443];
+  RESERVED_IPV4 = [
+    [...cidr("0.0.0.0", 8), "unspecified"],
+    [...cidr("10.0.0.0", 8), "private-rfc1918"],
+    [...cidr("127.0.0.0", 8), "loopback"],
+    [...cidr("100.64.0.0", 10), "cgnat"],
+    [...cidr("169.254.0.0", 16), "link-local"],
+    [...cidr("172.16.0.0", 12), "private-rfc1918"],
+    [...cidr("192.168.0.0", 16), "private-rfc1918"],
+    [...cidr("192.88.99.0", 24), "reserved"],
+    [...cidr("192.0.0.0", 24), "reserved"],
+    [...cidr("192.0.2.0", 24), "reserved"],
+    [...cidr("198.18.0.0", 15), "reserved"],
+    [...cidr("198.51.100.0", 24), "reserved"],
+    [...cidr("203.0.113.0", 24), "reserved"],
+    [...cidr("224.0.0.0", 4), "multicast"],
+    [...cidr("240.0.0.0", 4), "reserved"]
+  ];
+});
+
+// ../core/src/egress/broker.ts
+import { lookup } from "dns/promises";
+import { isIP as isIP2 } from "net";
+function hostMatchesSuffix2(hostname, suffix) {
+  const h2 = hostname.toLowerCase();
+  const s = suffix.toLowerCase().replace(/^\.+/, "");
+  return h2 === s || h2.endsWith(`.${s}`);
+}
+function nextHopHeaders(request, currentUrl, nextUrl) {
+  const headers = new Headers(request.headers ?? {});
+  const sameOrigin = nextUrl.origin === currentUrl.origin;
+  const preserved = Boolean(request.preserveAuthRedirectHostSuffixes?.some((suffix) => hostMatchesSuffix2(currentUrl.hostname, suffix) && hostMatchesSuffix2(nextUrl.hostname, suffix)));
+  if (!sameOrigin && !preserved) {
+    for (const header2 of CROSS_ORIGIN_CREDENTIAL_HEADERS)
+      headers.delete(header2);
+  }
+  return headers;
+}
+
+class Semaphore {
+  max;
+  active = 0;
+  waiters = [];
+  constructor(max) {
+    this.max = max;
+  }
+  async acquire() {
+    if (this.active < this.max) {
+      this.active += 1;
+      return;
+    }
+    await new Promise((resolve2) => this.waiters.push(resolve2));
+    this.active += 1;
+  }
+  release() {
+    this.active -= 1;
+    const next = this.waiters.shift();
+    if (next)
+      next();
+  }
+}
+
+class TenantEgressBroker {
+  resolveAddresses;
+  transport;
+  audit;
+  limits;
+  semaphore;
+  constructor(options = {}) {
+    this.resolveAddresses = options.resolveAddresses ?? defaultLookup;
+    this.transport = options.transport ?? defaultTransport;
+    this.audit = options.audit ?? (() => {});
+    this.limits = { ...DEFAULT_EGRESS_LIMITS, ...options.limits };
+    this.semaphore = new Semaphore(this.limits.maxConcurrency);
+  }
+  record(context, decision, outcome, hops) {
+    this.audit({
+      tenantId: context.tenantId,
+      actorCredentialId: context.actorCredentialId,
+      integration: context.integration,
+      destinationClass: decision.destinationClass,
+      policyVersion: decision.policyVersion,
+      outcome,
+      host: decision.host,
+      redirectHops: hops,
+      reason: decision.reason
+    });
+  }
+  async validateDestination(url, policy, context, hops) {
+    const decision = classifyUrl(url, policy);
+    if (!decision.allowed) {
+      this.record(context, decision, "blocked", hops);
+      throw new EgressBlockedError(decision.destinationClass, decision.reason);
+    }
+    const host = decision.host;
+    const canon = canonicalizeIpv4(host);
+    const isLiteralIp = isIP2(host) !== 0 || canon !== null && "ipv4" in canon;
+    if (!isLiteralIp) {
+      let addresses;
+      try {
+        addresses = await this.resolveAddresses(host);
+      } catch (error2) {
+        throw new EgressLimitError(`DNS resolution failed for host: ${error2 instanceof Error ? error2.message : "unknown"}`);
+      }
+      if (addresses.length === 0) {
+        throw new EgressLimitError("DNS resolution returned no addresses");
+      }
+      for (const { address } of addresses) {
+        const addrClass = classifyResolvedAddress(address);
+        if (addrClass !== null) {
+          const blocked = {
+            allowed: false,
+            destinationClass: addrClass,
+            reason: `host ${host} resolves to a ${addrClass} address`,
+            policyVersion: policy.policyVersion,
+            host
+          };
+          this.record(context, blocked, "blocked", hops);
+          throw new EgressBlockedError(addrClass, blocked.reason);
+        }
+      }
+    }
+    return decision;
+  }
+  async send(request, policy, context) {
+    await this.semaphore.acquire();
+    try {
+      let currentUrl = new URL(request.url);
+      let lastDecision = await this.validateDestination(currentUrl, policy, context, 0);
+      let headers = new Headers(request.headers ?? {});
+      for (let hop = 0;hop <= this.limits.maxRedirects; hop++) {
+        const response = await this.transport(currentUrl.toString(), {
+          method: request.method ?? "GET",
+          headers,
+          body: request.body ?? undefined,
+          redirect: "manual",
+          signal: AbortSignal.timeout(this.limits.timeoutMs)
+        });
+        if (response.status < 300 || response.status >= 400) {
+          this.enforceBodyLimit(response);
+          this.record(context, lastDecision, "allowed", hop);
+          return response;
+        }
+        const location = response.headers.get("location");
+        if (!location) {
+          this.enforceBodyLimit(response);
+          this.record(context, lastDecision, "allowed", hop);
+          return response;
+        }
+        const nextUrl = new URL(location, currentUrl);
+        lastDecision = await this.validateDestination(nextUrl, policy, context, hop + 1);
+        headers = nextHopHeaders(request, currentUrl, nextUrl);
+        currentUrl = nextUrl;
+      }
+      const exhausted = {
+        allowed: false,
+        destinationClass: lastDecision.destinationClass,
+        reason: "too many redirects",
+        policyVersion: policy.policyVersion,
+        host: lastDecision.host
+      };
+      this.record(context, exhausted, "error", this.limits.maxRedirects);
+      throw new EgressLimitError("too many redirects");
+    } catch (error2) {
+      if (!(error2 instanceof EgressBlockedError) && !(error2 instanceof EgressLimitError)) {
+        this.audit({
+          tenantId: context.tenantId,
+          actorCredentialId: context.actorCredentialId,
+          integration: context.integration,
+          destinationClass: "approved-public",
+          policyVersion: policy.policyVersion,
+          outcome: "error",
+          host: safeHost(request.url),
+          redirectHops: 0,
+          reason: error2 instanceof Error ? error2.name : "transport error"
+        });
+      }
+      throw error2;
+    } finally {
+      this.semaphore.release();
+    }
+  }
+  enforceBodyLimit(response) {
+    const declared = response.headers.get("content-length");
+    if (declared) {
+      const length = Number.parseInt(declared, 10);
+      if (!Number.isNaN(length) && length > this.limits.maxResponseBytes) {
+        throw new EgressLimitError(`response body ${length} exceeds ${this.limits.maxResponseBytes} bytes`);
+      }
+    }
+  }
+  async readBounded(response) {
+    const cap = this.limits.maxResponseBytes;
+    const reader = response.body?.getReader();
+    if (!reader)
+      return new Uint8Array(0);
+    const chunks = [];
+    let total = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done)
+        break;
+      if (value) {
+        total += value.byteLength;
+        if (total > cap) {
+          await reader.cancel();
+          throw new EgressLimitError(`response body exceeds ${cap} bytes`);
+        }
+        chunks.push(value);
+      }
+    }
+    const out = new Uint8Array(total);
+    let offset = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return out;
+  }
+}
+function safeHost(url) {
+  try {
+    return new URL(url).hostname.toLowerCase();
+  } catch {
+    return "(unparseable)";
+  }
+}
+function setEgressPolicyResolver(resolver) {
+  egressPolicyResolver = resolver;
+}
+function resolveEgressPolicy(context) {
+  if (!egressPolicyResolver)
+    return null;
+  try {
+    return egressPolicyResolver(context) ?? null;
+  } catch {
+    return { policyVersion: -1, approvedHostSuffixes: [] };
+  }
+}
+async function brokeredFetch(input, init, broker = sharedBroker) {
+  const { egress, ...rest } = init;
+  const policy = resolveEgressPolicy(egress);
+  if (!policy) {
+    return fetch(input, rest);
+  }
+  return broker.send({
+    url: input,
+    method: typeof rest.method === "string" ? rest.method : undefined,
+    headers: rest.headers,
+    body: rest.body ?? null
+  }, policy, egress);
+}
+var defaultLookup = async (hostname) => lookup(hostname, { all: true }), defaultTransport = (url, init) => fetch(url, init), DEFAULT_EGRESS_LIMITS, EgressBlockedError, EgressLimitError, CROSS_ORIGIN_CREDENTIAL_HEADERS, egressPolicyResolver = null, sharedBroker;
+var init_broker = __esm(() => {
+  init_policy();
+  DEFAULT_EGRESS_LIMITS = {
+    timeoutMs: 1e4,
+    maxRedirects: 3,
+    maxResponseBytes: 8 * 1024 * 1024,
+    maxConcurrency: 16
+  };
+  EgressBlockedError = class EgressBlockedError extends Error {
+    code = "egress_blocked";
+    destinationClass;
+    constructor(destinationClass, reason) {
+      super(`egress blocked (${destinationClass}): ${reason}`);
+      this.name = "EgressBlockedError";
+      this.destinationClass = destinationClass;
+    }
+  };
+  EgressLimitError = class EgressLimitError extends Error {
+    code = "egress_limit";
+    constructor(reason) {
+      super(`egress limit exceeded: ${reason}`);
+      this.name = "EgressLimitError";
+    }
+  };
+  CROSS_ORIGIN_CREDENTIAL_HEADERS = ["authorization", "cookie", "proxy-authorization"];
+  sharedBroker = new TenantEgressBroker;
+});
+
+// ../core/src/egress/index.ts
+var init_egress = __esm(() => {
+  init_policy();
+  init_broker();
+});
+
 // ../core/src/automations/actions.ts
 function buildWebhookHeaders(config2, context) {
   const headers = { "Content-Type": "application/json" };
@@ -36438,18 +37363,23 @@ async function parseWebhookResponse(response) {
   const contentType = response.headers.get("content-type") ?? "";
   return contentType.includes("application/json") ? response.json() : response.text();
 }
-async function executeWebhookAction(config2, context, _deps) {
+async function executeWebhookAction(config2, context, _deps, trustedTenantId) {
   try {
     const url = substituteTemplate(config2.url, context);
     const method = config2.method ?? "POST";
     const headers = buildWebhookHeaders(config2, context);
     const body = config2.bodyTemplate ? substituteTemplate(config2.bodyTemplate, context) : JSON.stringify(context.payload);
     logger2.debug(`Webhook ${method} ${url}`, { method, url, waitForResponse: config2.waitForResponse });
-    const response = await fetch(url, {
+    const response = await brokeredFetch(url, {
       method,
       headers,
       body: method !== "GET" ? body : undefined,
-      signal: AbortSignal.timeout(config2.timeoutMs ?? 30000)
+      signal: AbortSignal.timeout(config2.timeoutMs ?? 30000),
+      egress: {
+        tenantId: trustedTenantId ?? resolveAmbientTenantId() ?? "(unbound)",
+        actorCredentialId: null,
+        integration: "automations.webhook"
+      }
     });
     if (!config2.waitForResponse) {
       return {
@@ -36469,7 +37399,7 @@ async function executeWebhookAction(config2, context, _deps) {
     };
   }
 }
-async function executeSendMessageAction(config2, context, deps) {
+async function executeSendMessageAction(config2, context, deps, trustedTenantId) {
   try {
     if (!deps.sendMessage) {
       return {
@@ -36490,7 +37420,7 @@ async function executeSendMessageAction(config2, context, deps) {
       return { success: false, error: "content is empty" };
     }
     logger2.debug("Sending message", { instanceId, to, contentLength: content.length });
-    await deps.sendMessage(instanceId, to, content);
+    await deps.sendMessage(instanceId, to, content, trustedTenantId);
     return {
       success: true,
       result: { instanceId, to, contentLength: content.length }
@@ -36504,7 +37434,7 @@ async function executeSendMessageAction(config2, context, deps) {
     };
   }
 }
-async function executeEmitEventAction(config2, context, deps) {
+async function executeEmitEventAction(config2, context, deps, trustedTenantId) {
   try {
     if (!deps.eventBus) {
       return {
@@ -36522,7 +37452,8 @@ async function executeEmitEventAction(config2, context, deps) {
     logger2.debug("Emitting event", { eventType });
     const result = await deps.eventBus.publishGeneric(eventType, payload, {
       correlationId: context.payload.correlationId ?? undefined,
-      source: "automation"
+      source: "automation",
+      ...trustedTenantId ? { tenantId: trustedTenantId } : {}
     });
     return {
       success: true,
@@ -36614,7 +37545,7 @@ function extractAgentCallContext(config2, context) {
     }
   };
 }
-async function executeCallAgentAction(config2, context, deps) {
+async function executeCallAgentAction(config2, context, deps, trustedTenantId) {
   if (!deps.callAgent) {
     return { success: false, error: "callAgent dependency not provided" };
   }
@@ -36630,7 +37561,7 @@ async function executeCallAgentAction(config2, context, deps) {
     agentId: config2.agentId
   });
   try {
-    const result = await deps.callAgent(agentContext, config2);
+    const result = await deps.callAgent(agentContext, config2, trustedTenantId);
     logger2.info("Agent call completed", {
       runId: result.metadata.runId,
       status: result.metadata.status,
@@ -36651,24 +37582,24 @@ async function executeCallAgentAction(config2, context, deps) {
     return { success: false, error: errorMessage };
   }
 }
-async function executeAction(action, context, deps) {
+async function executeAction(action, context, deps, trustedTenantId) {
   const start = Date.now();
   let result;
   switch (action.type) {
     case "webhook":
-      result = await executeWebhookAction(action.config, context, deps);
+      result = await executeWebhookAction(action.config, context, deps, trustedTenantId);
       break;
     case "send_message":
-      result = await executeSendMessageAction(action.config, context, deps);
+      result = await executeSendMessageAction(action.config, context, deps, trustedTenantId);
       break;
     case "emit_event":
-      result = await executeEmitEventAction(action.config, context, deps);
+      result = await executeEmitEventAction(action.config, context, deps, trustedTenantId);
       break;
     case "log":
       result = await executeLogAction(action.config, context, deps);
       break;
     case "call_agent":
-      result = await executeCallAgentAction(action.config, context, deps);
+      result = await executeCallAgentAction(action.config, context, deps, trustedTenantId);
       break;
     default:
       result = { success: false, error: `Unknown action type: ${action.type}` };
@@ -36682,7 +37613,7 @@ async function executeAction(action, context, deps) {
     durationMs
   };
 }
-async function executeActions(actions, context, deps) {
+async function executeActions(actions, context, deps, trustedTenantId) {
   const results = [];
   const variables = { ...context.variables };
   for (const action of actions) {
@@ -36690,7 +37621,7 @@ async function executeActions(actions, context, deps) {
       ...context,
       variables
     };
-    const result = await executeAction(action, actionContext, deps);
+    const result = await executeAction(action, actionContext, deps, trustedTenantId);
     results.push(result);
     if (action.type === "webhook" && action.config.responseAs && result.status === "success" && result.result) {
       variables[action.config.responseAs] = result.result;
@@ -36704,12 +37635,19 @@ async function executeActions(actions, context, deps) {
 }
 var logger2;
 var init_actions = __esm(() => {
+  init_egress();
+  init_envelope();
   init_logger();
   init_templates();
   logger2 = createLogger("automations:actions");
 });
 
 // ../core/src/automations/debounce.ts
+function stampsEqual(a, b3) {
+  if (a === null || b3 === null)
+    return a === b3;
+  return a.tenantId === b3.tenantId && a.envelopeVersion === b3.envelopeVersion;
+}
 function buildConversationKey(instanceId, personId) {
   return `${instanceId}:${personId}`;
 }
@@ -36726,12 +37664,21 @@ class DebounceManager {
     this.config = config2;
     this.callback = callback;
   }
-  addMessage(key, message2, from, instanceId) {
+  addMessage(key, message2, from, instanceId, stamp = null) {
     if (this.config.mode === "none") {
-      this.callback(key, [message2], from, instanceId);
+      this.callback(key, [message2], from, instanceId, stamp);
       return;
     }
     let window2 = this.windows.get(key);
+    if (window2 && !stampsEqual(window2.stamp, stamp)) {
+      logger3.warn("Debounce window stamp changed \u2014 flushing old window before starting a new one", {
+        key,
+        oldTenant: window2.stamp?.tenantId ?? null,
+        newTenant: stamp?.tenantId ?? null
+      });
+      this.fireWindow(key);
+      window2 = undefined;
+    }
     if (!window2) {
       window2 = {
         messages: [],
@@ -36739,7 +37686,8 @@ class DebounceManager {
         lastActivityAt: Date.now(),
         timer: null,
         from,
-        instanceId
+        instanceId,
+        stamp
       };
       this.windows.set(key, window2);
     }
@@ -36807,9 +37755,9 @@ class DebounceManager {
       clearTimeout(window2.timer);
     }
     this.windows.delete(key);
-    const { messages: messages2, from, instanceId } = window2;
+    const { messages: messages2, from, instanceId, stamp } = window2;
     logger3.debug("Debounce window fired", { key, messageCount: messages2.length });
-    this.callback(key, messages2, from, instanceId);
+    this.callback(key, messages2, from, instanceId, stamp);
   }
   flushAll() {
     for (const key of this.windows.keys()) {
@@ -36860,7 +37808,8 @@ class AutomationEngine {
       eventBus,
       sendMessage: deps.sendMessage,
       callAgent: deps.callAgent,
-      staleIdleTimeoutGate: deps.staleIdleTimeoutGate
+      staleIdleTimeoutGate: deps.staleIdleTimeoutGate,
+      releaseIdleTimeoutClaim: deps.releaseIdleTimeoutClaim
     };
     this.automations = automations.filter((a) => a.enabled);
     await this.reconcileSubscriptions();
@@ -36999,15 +37948,17 @@ class AutomationEngine {
   }
   async shouldSkipStaleIdleTimeout(event) {
     if (event.type !== "chat.idle_timeout" || !this.deps.staleIdleTimeoutGate)
-      return false;
+      return { skip: false };
     const payload = event.payload;
     const chatId = payload?.chatId;
     const payloadInstanceId = payload?.instanceId ?? event.metadata.instanceId;
     if (!chatId || !payloadInstanceId)
-      return false;
+      return { skip: false };
     const eventSequenceIndex = typeof payload?.sequenceIndex === "number" ? payload.sequenceIndex : null;
     try {
-      const verdict = await this.deps.staleIdleTimeoutGate(chatId, payloadInstanceId, eventSequenceIndex);
+      const classification = classifyEnvelope(event.metadata);
+      const trustedTenantId = classification.world === "tenant" ? classification.tenantId : null;
+      const verdict = await this.deps.staleIdleTimeoutGate(chatId, payloadInstanceId, eventSequenceIndex, trustedTenantId);
       if (verdict.skip) {
         logger4.info("Skipping stale chat.idle_timeout event", {
           eventId: event.id,
@@ -37016,8 +37967,9 @@ class AutomationEngine {
           eventSequenceIndex,
           reason: verdict.reason ?? "unknown"
         });
-        return true;
+        return { skip: true };
       }
+      return { skip: false, ...verdict.claimToken ? { claimToken: verdict.claimToken } : {} };
     } catch (err2) {
       logger4.warn("staleIdleTimeoutGate threw, proceeding without skip", {
         eventId: event.id,
@@ -37025,7 +37977,19 @@ class AutomationEngine {
         error: err2 instanceof Error ? err2.message : String(err2)
       });
     }
-    return false;
+    return { skip: false };
+  }
+  async releaseIdleTimeoutClaim(claimToken, event) {
+    if (!this.deps.releaseIdleTimeoutClaim)
+      return;
+    try {
+      await this.deps.releaseIdleTimeoutClaim(claimToken);
+    } catch (err2) {
+      logger4.warn("releaseIdleTimeoutClaim failed", {
+        eventId: event.id,
+        error: err2 instanceof Error ? err2.message : String(err2)
+      });
+    }
   }
   async handleEvent(event) {
     const eventType = event.type;
@@ -37034,7 +37998,8 @@ class AutomationEngine {
     if (matchingAutomations.length === 0) {
       return;
     }
-    if (await this.shouldSkipStaleIdleTimeout(event)) {
+    const gate = await this.shouldSkipStaleIdleTimeout(event);
+    if (gate.skip) {
       return;
     }
     logger4.debug(`Processing event ${eventType} for ${matchingAutomations.length} automation(s)`, {
@@ -37042,12 +38007,18 @@ class AutomationEngine {
       instanceId
     });
     const sortedAutomations = [...matchingAutomations].sort((a, b3) => b3.priority - a.priority);
-    for (const automation of sortedAutomations) {
-      if (automation.debounce && automation.debounce.mode !== "none") {
-        await this.handleDebounced(automation, event);
-      } else {
-        await this.handleImmediate(automation, event);
+    try {
+      for (const automation of sortedAutomations) {
+        if (automation.debounce && automation.debounce.mode !== "none") {
+          await this.handleDebounced(automation, event);
+        } else {
+          await this.handleImmediate(automation, event);
+        }
       }
+    } catch (err2) {
+      if (gate.claimToken)
+        await this.releaseIdleTimeoutClaim(gate.claimToken, event);
+      throw err2;
     }
   }
   async handleDebounced(automation, event) {
@@ -37068,6 +38039,12 @@ class AutomationEngine {
       manager.handlePresenceEvent(key, event.type);
       return;
     }
+    const classification = classifyEnvelope(event.metadata);
+    if (classification.world === "quarantine") {
+      await this.handleImmediate(automation, event);
+      return;
+    }
+    const stamp = classification.world === "tenant" ? { envelopeVersion: classification.envelopeVersion, tenantId: classification.tenantId } : null;
     const content = payload.content;
     const message2 = {
       type: content?.type ?? "unknown",
@@ -37075,7 +38052,7 @@ class AutomationEngine {
       timestamp: event.timestamp,
       payload
     };
-    manager.addMessage(key, message2, from, instanceId);
+    manager.addMessage(key, message2, from, instanceId, stamp);
   }
   async handleImmediate(automation, event) {
     const instanceId = event.metadata.instanceId ?? "global";
@@ -37083,7 +38060,7 @@ class AutomationEngine {
     await this.queueExecution(automation, event, context, instanceId);
   }
   setupDebounceManager(automation) {
-    const callback = async (key, messages2, from, instanceId) => {
+    const callback = async (key, messages2, from, instanceId, stamp) => {
       const lastMessage = messages2[messages2.length - 1];
       if (!lastMessage) {
         logger4.warn("Debounce callback fired with empty messages array", { key });
@@ -37106,7 +38083,8 @@ class AutomationEngine {
         payload: lastMessage.payload,
         metadata: {
           correlationId: generateId(),
-          instanceId
+          instanceId,
+          ...stamp ? { envelopeVersion: stamp.envelopeVersion, tenantId: stamp.tenantId } : {}
         },
         timestamp: Date.now()
       };
@@ -37157,7 +38135,28 @@ class AutomationEngine {
   async executeAutomation(automation, event, context, queue) {
     const start = Date.now();
     queue.activeCount++;
+    const classification = classifyEnvelope(event.metadata);
+    const trustedTenantId = classification.world === "tenant" ? classification.tenantId : null;
     try {
+      if (classification.world === "quarantine") {
+        logger4.error("Refusing to execute automation for a quarantine-class envelope", {
+          automationId: automation.id,
+          eventId: event.id,
+          reason: classification.reason
+        });
+        const result2 = {
+          automationId: automation.id,
+          automationName: automation.name,
+          eventId: event.id,
+          status: "failed",
+          conditionsMatched: false,
+          actionsExecuted: [],
+          error: `refused quarantine-class envelope (${classification.reason})`,
+          executionTimeMs: Date.now() - start
+        };
+        await this.logExecution(result2, null);
+        return result2;
+      }
       const conditionPayload = {
         ...event.metadata,
         ...event.payload
@@ -37173,10 +38172,10 @@ class AutomationEngine {
           actionsExecuted: [],
           executionTimeMs: Date.now() - start
         };
-        await this.logExecution(result2);
+        await this.logExecution(result2, trustedTenantId);
         return result2;
       }
-      const actionsExecuted = await executeActions(automation.actions, context, this.deps);
+      const actionsExecuted = await executeActions(automation.actions, context, this.deps, trustedTenantId);
       const allSucceeded = actionsExecuted.every((a) => a.status === "success");
       const status = allSucceeded ? "success" : "failed";
       const result = {
@@ -37188,7 +38187,7 @@ class AutomationEngine {
         actionsExecuted,
         executionTimeMs: Date.now() - start
       };
-      await this.logExecution(result);
+      await this.logExecution(result, trustedTenantId);
       return result;
     } catch (error2) {
       const errorMessage = error2 instanceof Error ? error2.message : "Unknown error";
@@ -37202,7 +38201,7 @@ class AutomationEngine {
         error: errorMessage,
         executionTimeMs: Date.now() - start
       };
-      await this.logExecution(result);
+      await this.logExecution(result, trustedTenantId);
       return result;
     } finally {
       queue.activeCount--;
@@ -37215,7 +38214,7 @@ class AutomationEngine {
       }
     }
   }
-  async logExecution(result) {
+  async logExecution(result, trustedTenantId = null) {
     if (this.logger) {
       await this.logger({
         automationId: result.automationId,
@@ -37225,7 +38224,7 @@ class AutomationEngine {
         actionsExecuted: result.actionsExecuted,
         error: result.error,
         executionTimeMs: result.executionTimeMs
-      });
+      }, trustedTenantId);
     }
     logger4.info("Automation executed", {
       automationId: result.automationId,
@@ -37272,6 +38271,7 @@ function createAutomationEngine(config2) {
 }
 var logger4, QueueFullError;
 var init_engine = __esm(() => {
+  init_envelope();
   init_ids();
   init_logger();
   init_actions();
@@ -37432,7 +38432,8 @@ async function armSequence(deps, input) {
   try {
     await deps.eventBus.publish("follow_up.armed", payload, {
       instanceId: input.instanceId,
-      ...input.agentId ? { agentId: input.agentId } : {}
+      ...input.agentId ? { agentId: input.agentId } : {},
+      ...input.tenantId ? { tenantId: input.tenantId } : {}
     });
   } catch (err2) {
     deps.logger.warn("follow-up lifecycle: failed to emit follow_up.armed", {
@@ -37465,7 +38466,8 @@ async function disarmSequence(deps, input) {
   try {
     await deps.eventBus.publish("follow_up.disarmed", payload, {
       instanceId: input.instanceId,
-      ...input.agentId ? { agentId: input.agentId } : {}
+      ...input.agentId ? { agentId: input.agentId } : {},
+      ...input.tenantId ? { tenantId: input.tenantId } : {}
     });
   } catch (err2) {
     deps.logger.warn("follow-up lifecycle: failed to emit follow_up.disarmed", {
@@ -37494,6 +38496,13 @@ function resolveFollowUpConfig(inputs) {
 function renderSyntheticPrompt(template, context) {
   return template.replace(/\{\{\s*minutes\s*\}\}/g, String(context.minutes)).replace(/\{\{\s*sequenceIndex\s*\}\}/g, String(context.sequenceIndex)).replace(/\{\{\s*attemptNumber\s*\}\}/g, String(context.sequenceIndex + 1)).replace(/\{\{\s*totalAttempts\s*\}\}/g, String(context.totalAttempts)).replace(/\{\{\s*chatName\s*\}\}/g, context.chatName ?? "");
 }
+function rowEventMetadata(row) {
+  return {
+    instanceId: row.instanceId,
+    ...row.agentId ? { agentId: row.agentId } : {},
+    ...row.tenantId ? { tenantId: row.tenantId } : {}
+  };
+}
 async function sweepFollowUps(deps) {
   const limit = deps.batchLimit ?? DEFAULT_BATCH_LIMIT;
   const clock = deps.now ?? (() => new Date);
@@ -37557,10 +38566,7 @@ async function processRow(row, now, deps, stats) {
     syntheticPrompt,
     ...row.chatName ? { chatName: row.chatName } : {}
   };
-  await deps.eventBus.publish("chat.idle_timeout", idlePayload, {
-    instanceId: row.instanceId,
-    ...row.agentId ? { agentId: row.agentId } : {}
-  });
+  await deps.eventBus.publish("chat.idle_timeout", idlePayload, rowEventMetadata(row));
   const firedPayload = {
     chatId: row.chatId,
     instanceId: row.instanceId,
@@ -37569,10 +38575,7 @@ async function processRow(row, now, deps, stats) {
     firedAt: now.getTime(),
     syntheticPrompt
   };
-  await deps.eventBus.publish("follow_up.fired", firedPayload, {
-    instanceId: row.instanceId,
-    ...row.agentId ? { agentId: row.agentId } : {}
-  });
+  await deps.eventBus.publish("follow_up.fired", firedPayload, rowEventMetadata(row));
   const nextFireAtMs = computeNextFireAt(row.sequenceConfig, row.sequenceIndex, now.getTime());
   const nextIndex = row.sequenceIndex + 1;
   if (nextFireAtMs === null) {
@@ -37602,10 +38605,7 @@ async function processRow(row, now, deps, stats) {
     sequenceIndex: nextIndex,
     nextFireAt: nextFireAtMs
   };
-  await deps.eventBus.publish("follow_up.armed", armedPayload, {
-    instanceId: row.instanceId,
-    ...row.agentId ? { agentId: row.agentId } : {}
-  });
+  await deps.eventBus.publish("follow_up.armed", armedPayload, rowEventMetadata(row));
   stats.fired += 1;
 }
 async function disarm(deps, row, reason, now) {
@@ -37620,10 +38620,7 @@ async function emitDisarmed(deps, row, reason, sequenceIndex) {
     sequenceIndex,
     reason
   };
-  await deps.eventBus.publish("follow_up.disarmed", payload, {
-    instanceId: row.instanceId,
-    ...row.agentId ? { agentId: row.agentId } : {}
-  });
+  await deps.eventBus.publish("follow_up.disarmed", payload, rowEventMetadata(row));
 }
 async function emitSkipped(deps, row, reason) {
   const payload = {
@@ -37634,10 +38631,7 @@ async function emitSkipped(deps, row, reason) {
     reason
   };
   try {
-    await deps.eventBus.publish("follow_up.skipped", payload, {
-      instanceId: row.instanceId,
-      ...row.agentId ? { agentId: row.agentId } : {}
-    });
+    await deps.eventBus.publish("follow_up.skipped", payload, rowEventMetadata(row));
   } catch (err2) {
     deps.logger.error("follow-up sweeper: failed to emit follow_up.skipped", {
       id: row.id,
@@ -37874,12 +38868,12 @@ function buildProviderRequestContext(context) {
 var OMNI_EXECUTION_CONTEXT_EXTENSION_URI = "https://omni.dev/extensions/execution-context/v1";
 
 // ../core/src/providers/trace-context.ts
-import { createHash as createHash3 } from "crypto";
+import { createHash as createHash4 } from "crypto";
 function isNonZeroHex(value) {
   return value.length > 0 && !/^0+$/.test(value);
 }
 function hashHex(value, length) {
-  return createHash3("sha256").update(value).digest("hex").slice(0, length);
+  return createHash4("sha256").update(value).digest("hex").slice(0, length);
 }
 function normalizeTraceId(value) {
   const lower = value.toLowerCase();
@@ -64753,7 +65747,7 @@ var init_a2a_provider = __esm(() => {
 });
 
 // ../core/src/providers/nats-genie-provider.ts
-import { createHash as createHash5 } from "crypto";
+import { createHash as createHash6 } from "crypto";
 import { mkdir, writeFile } from "fs/promises";
 import { homedir as homedir10 } from "os";
 import { join as join16 } from "path";
@@ -64985,7 +65979,7 @@ class NatsGenieProvider {
     return metadata;
   }
   safeHash(value) {
-    return createHash5("sha256").update(value).digest("hex").slice(0, 12);
+    return createHash6("sha256").update(value).digest("hex").slice(0, 12);
   }
   buildMessage(context) {
     let message2 = "";
@@ -65704,21 +66698,39 @@ __export(exports_src, {
   updateOpenClawCircuitBreaker: () => updateOpenClawCircuitBreaker,
   updateNatsStatus: () => updateNatsStatus,
   updateDbPoolMetrics: () => updateDbPoolMetrics,
+  tenantTraceAttributes: () => tenantTraceAttributes,
+  tenantLabelBucketCount: () => tenantLabelBucketCount,
+  tenantEventsProcessed: () => tenantEventsProcessed,
   sweepFollowUps: () => sweepFollowUps,
   substituteTemplateObject: () => substituteTemplateObject,
   substituteTemplate: () => substituteTemplate,
+  stampsEqual: () => stampsEqual,
+  stampTenantEnvelope: () => stampTenantEnvelope,
   shouldStoreStage: () => shouldStoreStage,
+  setTenantSecretMasterKey: () => setTenantSecretMasterKey,
+  setEnvelopeTenantResolver: () => setEnvelopeTenantResolver,
+  setEnvelopeInstanceTenantResolver: () => setEnvelopeInstanceTenantResolver,
+  setEgressPolicyResolver: () => setEgressPolicyResolver,
+  sealTenantSecretJson: () => sealTenantSecretJson,
+  sealTenantSecret: () => sealTenantSecret,
   scheduledJobRuns: () => scheduledJobRuns,
   scheduledJobNextRun: () => scheduledJobNextRun,
   scheduledJobDuration: () => scheduledJobDuration,
   rootLogger: () => rootLogger,
   resolveResetConfig: () => resolveResetConfig,
+  resolvePublishTenantId: () => resolvePublishTenantId,
+  resolveInstanceOwnerTenantId: () => resolveInstanceOwnerTenantId,
   resolveFollowUpConfig: () => resolveFollowUpConfig,
+  resolveEgressPolicy: () => resolveEgressPolicy,
+  resolveAmbientTenantId: () => resolveAmbientTenantId,
+  resetTenantLabelConfig: () => resetTenantLabelConfig,
   resetScheduler: () => resetScheduler,
   resetMetrics: () => resetMetrics,
   resetJourneyTracker: () => resetJourneyTracker,
   renderSyntheticPrompt: () => renderSyntheticPrompt,
   registerSchemas: () => registerSchemas,
+  redactSecrets: () => redactSecrets,
+  recordTenantEventProcessed: () => recordTenantEventProcessed,
   recordScheduledJob: () => recordScheduledJob,
   recordPayloadOp: () => recordPayloadOp,
   recordOpenClawTrigger: () => recordOpenClawTrigger,
@@ -65742,6 +66754,8 @@ __export(exports_src, {
   openclawTimeToFirstDelta: () => openclawTimeToFirstDelta,
   openclawReconnects: () => openclawReconnects,
   openclawCircuitBreakerState: () => openclawCircuitBreakerState,
+  openTenantSecretJson: () => openTenantSecretJson,
+  openTenantSecret: () => openTenantSecret,
   ok: () => ok,
   natsPublishLatency: () => natsPublishLatency,
   natsPendingMessages: () => natsPendingMessages,
@@ -65750,11 +66764,15 @@ __export(exports_src, {
   natsConnectionStatus: () => natsConnectionStatus,
   matchesPattern: () => matchesPattern,
   isValidUuid: () => isValidUuid,
+  isTenantSecretSealingEnabled: () => isTenantSecretSealingEnabled,
   isSystemEvent: () => isSystemEvent,
+  isStampableTenantId: () => isStampableTenantId,
+  isSealedSecret: () => isSealedSecret,
   isProviderSchemaSupported: () => isProviderSchemaSupported,
   isOmniError: () => isOmniError,
   isCustomEvent: () => isCustomEvent,
   isCoreEvent: () => isCoreEvent,
+  isAllowedClass: () => isAllowedClass,
   intervalMinutesForIndex: () => intervalMinutesForIndex,
   httpRequests: () => httpRequests,
   httpRequestDuration: () => httpRequestDuration,
@@ -65825,15 +66843,22 @@ __export(exports_src, {
   createAgUiProvider: () => createAgUiProvider,
   createA2AProvider: () => createA2AProvider,
   connectEventBus: () => connectEventBus,
+  configureTenantLabelBuckets: () => configureTenantLabelBuckets,
   configureLogging: () => configureLogging,
   computeNextFireAt: () => computeNextFireAt,
   computeInitialFireAt: () => computeInitialFireAt,
   compressPayload: () => compressPayload,
+  classifyUrl: () => classifyUrl,
+  classifyResolvedAddress: () => classifyResolvedAddress,
+  classifyEnvelope: () => classifyEnvelope,
   checkSessionReset: () => checkSessionReset,
   channelSupportsTypingIndicator: () => channelSupportsTypingIndicator,
   channelHasMessagingWindow: () => channelHasMessagingWindow,
+  canonicalizeIpv4: () => canonicalizeIpv4,
   calculateNextAutoRetryAt: () => calculateNextAutoRetryAt,
   calculateBackoffDelay: () => calculateBackoffDelay,
+  buildTenantAuditRecord: () => buildTenantAuditRecord,
+  buildTenantAuditFields: () => buildTenantAuditFields,
   buildSubscribePattern: () => buildSubscribePattern,
   buildSubject: () => buildSubject,
   buildProviderRequestContext: () => buildProviderRequestContext,
@@ -65841,6 +66866,8 @@ __export(exports_src, {
   buildOmniEnv: () => buildOmniEnv,
   buildConversationKey: () => buildConversationKey,
   buildConsumerConfig: () => buildConsumerConfig,
+  brokeredFetch: () => brokeredFetch,
+  boundedTenantLabel: () => boundedTenantLabel,
   armSequence: () => armSequence,
   appUptime: () => appUptime,
   agentStateKey: () => agentStateKey,
@@ -65854,6 +66881,10 @@ __export(exports_src, {
   UpdateAgentSchema: () => UpdateAgentSchema,
   UpdateAgentRouteSchema: () => UpdateAgentRouteSchema,
   TimestampSchema: () => TimestampSchema,
+  TenantSecretUnconfiguredError: () => TenantSecretUnconfiguredError,
+  TenantSecretError: () => TenantSecretError,
+  TenantEgressBroker: () => TenantEgressBroker,
+  TENANTLESS_LABEL: () => TENANTLESS_LABEL,
   SystemEventSchemas: () => SystemEventSchemas,
   SupersedeModeSchema: () => SupersedeModeSchema,
   SubscriptionManager: () => SubscriptionManager,
@@ -65866,6 +66897,7 @@ __export(exports_src, {
   STREAM_CONFIGS: () => STREAM_CONFIGS,
   SPLIT_DELAY_MODES: () => SPLIT_DELAY_MODES,
   SETTING_VALUE_TYPES: () => SETTING_VALUE_TYPES,
+  SECRET_BOX_VERSION: () => SECRET_BOX_VERSION,
   RuleTypeSchema: () => RuleTypeSchema,
   ReplyFilterModeSchema: () => ReplyFilterModeSchema,
   RULE_TYPES: () => RULE_TYPES,
@@ -65899,6 +66931,7 @@ __export(exports_src, {
   ListAgentRoutesQuerySchema: () => ListAgentRoutesQuerySchema,
   LinkIdentityToAgentSchema: () => LinkIdentityToAgentSchema,
   LinkIdentitySchema: () => LinkIdentitySchema,
+  KNOWN_ENVELOPE_VERSIONS: () => KNOWN_ENVELOPE_VERSIONS,
   JourneyTracker: () => JourneyTracker,
   JobStatusSchema: () => JobStatusSchema,
   JOURNEY_STAGES: () => JOURNEY_STAGES,
@@ -65925,6 +66958,8 @@ __export(exports_src, {
   EventRegistry: () => EventRegistry,
   EventQuerySchema: () => EventQuerySchema,
   EmailSchema: () => EmailSchema,
+  EgressLimitError: () => EgressLimitError,
+  EgressBlockedError: () => EgressBlockedError,
   ERROR_CODES: () => ERROR_CODES,
   ED25519_PKCS8_PREFIX: () => ED25519_PKCS8_PREFIX,
   DisarmReasonSchema: () => DisarmReasonSchema,
@@ -65932,6 +66967,7 @@ __export(exports_src, {
   DebounceModeSchema: () => DebounceModeSchema,
   DebounceManager: () => DebounceManager,
   DEFAULT_TYPING_INDICATOR_MS: () => DEFAULT_TYPING_INDICATOR_MS,
+  DEFAULT_TENANT_LABEL_BUCKETS: () => DEFAULT_TENANT_LABEL_BUCKETS,
   DEFAULT_STORAGE_CONFIG: () => DEFAULT_STORAGE_CONFIG,
   DEFAULT_RETENTION_DAYS: () => DEFAULT_RETENTION_DAYS,
   DEFAULT_RESET_CONFIG: () => DEFAULT_RESET_CONFIG,
@@ -65939,6 +66975,7 @@ __export(exports_src, {
   DEFAULT_IDLE_MINUTES: () => DEFAULT_IDLE_MINUTES,
   DEFAULT_HOOK_TIMEOUT_MS: () => DEFAULT_HOOK_TIMEOUT_MS,
   DEFAULT_HOOK_PRIORITY: () => DEFAULT_HOOK_PRIORITY,
+  DEFAULT_EGRESS_LIMITS: () => DEFAULT_EGRESS_LIMITS,
   DEFAULT_DAILY_HOUR: () => DEFAULT_DAILY_HOUR,
   DEFAULT_CONSUMER_CONFIG: () => DEFAULT_CONSUMER_CONFIG,
   DEFAULT_CACHE_CONFIG: () => DEFAULT_CACHE_CONFIG,
@@ -65960,6 +66997,7 @@ __export(exports_src, {
   ClaudeCodeAgentProvider: () => ClaudeCodeAgentProvider,
   ChannelTypeSchema: () => ChannelTypeSchema,
   ChannelError: () => ChannelError,
+  CURRENT_ENVELOPE_VERSION: () => CURRENT_ENVELOPE_VERSION,
   CORE_EVENT_TYPES: () => CORE_EVENT_TYPES,
   CONTENT_TYPES: () => CONTENT_TYPES,
   CONDITION_OPERATORS: () => CONDITION_OPERATORS,
@@ -66005,12 +67043,15 @@ var init_src2 = __esm(() => {
   init_errors3();
   init_ids();
   init_metrics();
+  init_observability();
+  init_secrets();
   init_automations();
   init_reset();
   init_providers();
   init_cache();
   init_tracing();
   init_hooks();
+  init_egress();
 });
 
 // ../../node_modules/.bun/drizzle-orm@0.38.4+db1fc555b1037084/node_modules/drizzle-orm/entity.js
@@ -67648,7 +68689,7 @@ var init_char = __esm(() => {
 });
 
 // ../../node_modules/.bun/drizzle-orm@0.38.4+db1fc555b1037084/node_modules/drizzle-orm/pg-core/columns/cidr.js
-function cidr(name) {
+function cidr2(name) {
   return new PgCidrBuilder(name ?? "");
 }
 var PgCidrBuilder, PgCidr;
@@ -68758,7 +69799,7 @@ function getPgColumnBuilders() {
     bigserial,
     boolean,
     char,
-    cidr,
+    cidr: cidr2,
     customType,
     date,
     doublePrecision,
@@ -73575,15 +74616,6 @@ var init_client3 = __esm(() => {
   init_schema2();
 });
 
-// ../db/src/migrate.ts
-var log19;
-var init_migrate = __esm(() => {
-  init_src2();
-  init_client3();
-  log19 = createLogger("db:migrate");
-  if (false) {}
-});
-
 // ../db/src/tenancy-ownership.ts
 var TENANT_OWNERSHIP_SPECS, TENANT_TABLES, OWNERSHIP_ROOT_TABLES, COMPOSITE_FK_TARGETS, SPLIT_DESTINATIONS, G2_NEW_TABLES;
 var init_tenancy_ownership = __esm(() => {
@@ -73982,8 +75014,23 @@ var init_tenancy_ownership = __esm(() => {
   ];
 });
 
+// ../db/src/online-ddl.ts
+var init_online_ddl = __esm(() => {
+  init_tenancy_ownership();
+});
+
+// ../db/src/migrate.ts
+var log19;
+var init_migrate = __esm(() => {
+  init_src2();
+  init_client3();
+  init_online_ddl();
+  log19 = createLogger("db:migrate");
+  if (false) {}
+});
+
 // ../db/src/tenancy-rls.ts
-var G1_TENANT_PLANE_TABLES, AUTH_PLANE_READABLE_TABLES, RLS_EXCLUSIONS, RLS_TENANT_TABLES;
+var G1_TENANT_PLANE_TABLES, AUTH_PLANE_READABLE_TABLES, RLS_EXCLUSIONS, RLS_TENANT_TABLES, TENANT_CONTEXT_FUNCTION = "omni_current_tenant_id", AUTH_PLANE_FUNCTION = "omni_is_auth_plane", AUTH_PLANE_ROW_FUNCTION = "omni_auth_plane_row_visible", TENANCY_FUNCTION_SCHEMA = "public", QUALIFIED_TENANT_CONTEXT_FUNCTION, QUALIFIED_AUTH_PLANE_FUNCTION, QUALIFIED_AUTH_PLANE_ROW_FUNCTION;
 var init_tenancy_rls = __esm(() => {
   init_tenancy_ownership();
   G1_TENANT_PLANE_TABLES = [
@@ -74012,6 +75059,9 @@ var init_tenancy_rls = __esm(() => {
     }
   ];
   RLS_TENANT_TABLES = [...TENANT_TABLES, ...G1_TENANT_PLANE_TABLES];
+  QUALIFIED_TENANT_CONTEXT_FUNCTION = `${TENANCY_FUNCTION_SCHEMA}.${TENANT_CONTEXT_FUNCTION}`;
+  QUALIFIED_AUTH_PLANE_FUNCTION = `${TENANCY_FUNCTION_SCHEMA}.${AUTH_PLANE_FUNCTION}`;
+  QUALIFIED_AUTH_PLANE_ROW_FUNCTION = `${TENANCY_FUNCTION_SCHEMA}.${AUTH_PLANE_ROW_FUNCTION}`;
 });
 
 // ../db/src/tenancy-roles.ts
@@ -74040,6 +75090,7 @@ var init_verify_schema = () => {};
 var init_src3 = __esm(() => {
   init_client3();
   init_migrate();
+  init_online_ddl();
   init_tenancy_rls();
   init_tenancy_roles();
   init_tenancy_startup();
@@ -74047,6 +75098,12 @@ var init_src3 = __esm(() => {
   init_schema2();
 });
 
+// ../api/src/tenancy/feature-flag.ts
+function isMultitenancyEnabled(env2 = process.env) {
+  return env2[MULTITENANCY_FLAG_ENV] === "true";
+}
+var MULTITENANCY_FLAG_ENV = "OMNI_MULTITENANCY_ENABLED";
+
 // ../api/src/cache/memory-cache.ts
 class MemoryCache {
   store = new Map;
@@ -74164,7 +75221,12 @@ var init_memory_cache = __esm(() => {
 });
 
 // ../api/src/cache/cache-keys.ts
-var CacheKeys, CacheTTL, apiKeyCache, accessCache;
+function authCacheTtlMs(legacyTtlMs) {
+  if (!isMultitenancyEnabled())
+    return legacyTtlMs;
+  return Math.min(legacyTtlMs, AUTH_CACHE_INVALIDATION_CEILING_SECONDS * 1000);
+}
+var AUTH_CACHE_INVALIDATION_CEILING_SECONDS = 15, CacheKeys, CacheTTL, apiKeyCache, accessCache;
 var init_cache_keys = __esm(() => {
   init_memory_cache();
   CacheKeys = {
@@ -74275,7 +75337,7 @@ class ApiKeyService {
       outboundRecipientAllowlist: apiKey.outboundRecipientAllowlist,
       profileOverrides: apiKey.profileOverrides ?? null
     };
-    await apiKeyCache.set(cacheKey, cachedData, CacheTTL.API_KEY);
+    await apiKeyCache.set(cacheKey, cachedData, authCacheTtlMs(CacheTTL.API_KEY));
     this.updateUsageAsync(apiKey.id, ip);
     return {
       id: apiKey.id,
@@ -78001,12 +79063,12 @@ var require_envelope = __commonJS((exports) => {
   function createEnvelope(headers, items = []) {
     return [headers, items];
   }
-  function addItemToEnvelope(envelope, newItem) {
-    const [headers, items] = envelope;
+  function addItemToEnvelope(envelope2, newItem) {
+    const [headers, items] = envelope2;
     return [headers, [...items, newItem]];
   }
-  function forEachEnvelopeItem(envelope, callback) {
-    const envelopeItems = envelope[1];
+  function forEachEnvelopeItem(envelope2, callback) {
+    const envelopeItems = envelope2[1];
     for (const envelopeItem of envelopeItems) {
       const envelopeItemType = envelopeItem[0].type;
       const result = callback(envelopeItem, envelopeItemType);
@@ -78016,8 +79078,8 @@ var require_envelope = __commonJS((exports) => {
     }
     return false;
   }
-  function envelopeContainsItemType(envelope, types8) {
-    return forEachEnvelopeItem(envelope, (_2, type) => types8.includes(type));
+  function envelopeContainsItemType(envelope2, types8) {
+    return forEachEnvelopeItem(envelope2, (_2, type) => types8.includes(type));
   }
   function encodeUTF8(input) {
     const carrier$1 = carrier.getSentryCarrier(worldwide.GLOBAL_OBJ);
@@ -78027,8 +79089,8 @@ var require_envelope = __commonJS((exports) => {
     const carrier$1 = carrier.getSentryCarrier(worldwide.GLOBAL_OBJ);
     return carrier$1.decodePolyfill ? carrier$1.decodePolyfill(input) : new TextDecoder().decode(input);
   }
-  function serializeEnvelope(envelope) {
-    const [envHeaders, items] = envelope;
+  function serializeEnvelope(envelope2) {
+    const [envHeaders, items] = envelope2;
     let parts = JSON.stringify(envHeaders);
     function append(next) {
       if (typeof parts === "string") {
@@ -78165,7 +79227,7 @@ var require_envelope2 = __commonJS((exports) => {
   var dynamicSamplingContext = require_dynamicSamplingContext();
   var beforeSendSpan = require_beforeSendSpan();
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var shouldIgnoreSpan = require_should_ignore_span();
   var spanUtils = require_spanUtils();
   function _enhanceEventWithSdkInfo(event, newSdkInfo) {
@@ -78187,23 +79249,23 @@ var require_envelope2 = __commonJS((exports) => {
     return event;
   }
   function createSessionEnvelope(session3, dsn$1, metadata, tunnel) {
-    const sdkInfo = envelope.getSdkMetadataForEnvelopeHeader(metadata);
+    const sdkInfo = envelope2.getSdkMetadataForEnvelopeHeader(metadata);
     const envelopeHeaders = {
       sent_at: new Date().toISOString(),
       ...sdkInfo && { sdk: sdkInfo },
       ...!!tunnel && dsn$1 && { dsn: dsn.dsnToString(dsn$1) }
     };
     const envelopeItem = "aggregates" in session3 ? [{ type: "sessions" }, session3] : [{ type: "session" }, session3.toJSON()];
-    return envelope.createEnvelope(envelopeHeaders, [envelopeItem]);
+    return envelope2.createEnvelope(envelopeHeaders, [envelopeItem]);
   }
   function createEventEnvelope(event, dsn2, metadata, tunnel) {
-    const sdkInfo = envelope.getSdkMetadataForEnvelopeHeader(metadata);
+    const sdkInfo = envelope2.getSdkMetadataForEnvelopeHeader(metadata);
     const eventType = event.type && event.type !== "replay_event" ? event.type : "event";
     _enhanceEventWithSdkInfo(event, metadata?.sdk);
-    const envelopeHeaders = envelope.createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn2);
+    const envelopeHeaders = envelope2.createEventEnvelopeHeaders(event, sdkInfo, tunnel, dsn2);
     delete event.sdkProcessingMetadata;
     const eventItem = [{ type: eventType }, event];
-    return envelope.createEnvelope(envelopeHeaders, [eventItem]);
+    return envelope2.createEnvelope(envelopeHeaders, [eventItem]);
   }
   function createSpanEnvelope(spans, client) {
     function dscHasRequiredProps(dsc2) {
@@ -78239,10 +79301,10 @@ var require_envelope2 = __commonJS((exports) => {
     for (const span of filteredSpans) {
       const spanJson = convertToSpanJSON(span);
       if (spanJson) {
-        items.push(envelope.createSpanEnvelopeItem(spanJson));
+        items.push(envelope2.createSpanEnvelopeItem(spanJson));
       }
     }
-    return envelope.createEnvelope(headers, items);
+    return envelope2.createEnvelope(headers, items);
   }
   exports._enhanceEventWithSdkInfo = _enhanceEventWithSdkInfo;
   exports.createEventEnvelope = createEventEnvelope;
@@ -78347,7 +79409,7 @@ var require_sentrySpan = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var currentScopes = require_currentScopes();
   var debugBuild = require_debug_build();
-  var envelope = require_envelope2();
+  var envelope2 = require_envelope2();
   var semanticAttributes = require_semanticAttributes();
   var debugLogger = require_debug_logger();
   var propagationContext = require_propagationContext();
@@ -78511,7 +79573,7 @@ var require_sentrySpan = __commonJS((exports) => {
       }
       if (this._isStandaloneSpan) {
         if (this._sampled) {
-          sendSpanEnvelope(envelope.createSpanEnvelope([this], client));
+          sendSpanEnvelope(envelope2.createSpanEnvelope([this], client));
         } else {
           debugBuild.DEBUG_BUILD && debugLogger.debug.log("[Tracing] Discarding standalone span because its trace was not chosen to be sampled.");
           if (client) {
@@ -78588,17 +79650,17 @@ var require_sentrySpan = __commonJS((exports) => {
   function isStandaloneSpan(span) {
     return span instanceof SentrySpan && span.isStandaloneSpan();
   }
-  function sendSpanEnvelope(envelope2) {
+  function sendSpanEnvelope(envelope3) {
     const client = currentScopes.getClient();
     if (!client) {
       return;
     }
-    const spanItems = envelope2[1];
+    const spanItems = envelope3[1];
     if (!spanItems || spanItems.length === 0) {
       client.recordDroppedEvent("before_send", "span");
       return;
     }
-    client.sendEnvelope(envelope2);
+    client.sendEnvelope(envelope3);
   }
   exports.SentrySpan = SentrySpan;
 });
@@ -80656,7 +81718,7 @@ var require_isBrowser = __commonJS((exports) => {
 var require_envelope3 = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var isBrowser = require_isBrowser();
   function createLogContainerEnvelopeItem(items, inferUserData) {
     const inferSetting = inferUserData ? "auto" : "never";
@@ -80686,7 +81748,7 @@ var require_envelope3 = __commonJS((exports) => {
     if (!!tunnel && !!dsn$1) {
       headers.dsn = dsn.dsnToString(dsn$1);
     }
-    return envelope.createEnvelope(headers, [createLogContainerEnvelopeItem(logs, inferUserData)]);
+    return envelope2.createEnvelope(headers, [createLogContainerEnvelopeItem(logs, inferUserData)]);
   }
   exports.createLogContainerEnvelopeItem = createLogContainerEnvelopeItem;
   exports.createLogEnvelope = createLogEnvelope;
@@ -80707,7 +81769,7 @@ var require_internal = __commonJS((exports) => {
   var timestampSequence = require_timestampSequence();
   var traceInfo = require_trace_info();
   var constants = require_constants2();
-  var envelope = require_envelope3();
+  var envelope2 = require_envelope3();
   var MAX_LOG_BUFFER_SIZE = 100;
   function setLogAttribute(logAttributes, key, value, setEvenIfPresent = true) {
     if (value && (!logAttributes[key] || setEvenIfPresent)) {
@@ -80805,7 +81867,7 @@ var require_internal = __commonJS((exports) => {
       return;
     }
     const clientOptions = client.getOptions();
-    const envelope$1 = envelope.createLogEnvelope(logBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), clientOptions.sendDefaultPii);
+    const envelope$1 = envelope2.createLogEnvelope(logBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), clientOptions.sendDefaultPii);
     _getBufferMap().set(client, []);
     client.emit("flushLogs");
     client.sendEnvelope(envelope$1);
@@ -80826,7 +81888,7 @@ var require_internal = __commonJS((exports) => {
 var require_envelope4 = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var isBrowser = require_isBrowser();
   function createMetricContainerEnvelopeItem(items, inferUserData) {
     const inferSetting = inferUserData ? "auto" : "never";
@@ -80856,7 +81918,7 @@ var require_envelope4 = __commonJS((exports) => {
     if (!!tunnel && !!dsn$1) {
       headers.dsn = dsn.dsnToString(dsn$1);
     }
-    return envelope.createEnvelope(headers, [createMetricContainerEnvelopeItem(metrics2, inferUserData)]);
+    return envelope2.createEnvelope(headers, [createMetricContainerEnvelopeItem(metrics2, inferUserData)]);
   }
   exports.createMetricContainerEnvelopeItem = createMetricContainerEnvelopeItem;
   exports.createMetricEnvelope = createMetricEnvelope;
@@ -80875,7 +81937,7 @@ var require_internal2 = __commonJS((exports) => {
   var time3 = require_time();
   var timestampSequence = require_timestampSequence();
   var traceInfo = require_trace_info();
-  var envelope = require_envelope4();
+  var envelope2 = require_envelope4();
   var MAX_METRIC_BUFFER_SIZE = 1000;
   function setMetricAttribute(metricAttributes, key, value, setEvenIfPresent = true) {
     if (value && (setEvenIfPresent || !(key in metricAttributes))) {
@@ -80976,7 +82038,7 @@ var require_internal2 = __commonJS((exports) => {
       return;
     }
     const clientOptions = client.getOptions();
-    const envelope$1 = envelope.createMetricEnvelope(metricBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), clientOptions.sendDefaultPii);
+    const envelope$1 = envelope2.createMetricEnvelope(metricBuffer, clientOptions._metadata, clientOptions.tunnel, client.getDsn(), clientOptions.sendDefaultPii);
     _getBufferMap().set(client, []);
     client.emit("flushMetrics");
     client.sendEnvelope(envelope$1);
@@ -81120,7 +82182,7 @@ var require_base = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var debugBuild = require_debug_build();
   var debugLogger = require_debug_logger();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var promisebuffer = require_promisebuffer();
   var ratelimit = require_ratelimit();
   var DEFAULT_TRANSPORT_BUFFER_SIZE = 64;
@@ -81129,8 +82191,8 @@ var require_base = __commonJS((exports) => {
     const flush = (timeout) => buffer3.drain(timeout);
     function send(envelope$1) {
       const filteredEnvelopeItems = [];
-      envelope.forEachEnvelopeItem(envelope$1, (item, type) => {
-        const dataCategory = envelope.envelopeItemTypeToDataCategory(type);
+      envelope2.forEachEnvelopeItem(envelope$1, (item, type) => {
+        const dataCategory = envelope2.envelopeItemTypeToDataCategory(type);
         if (ratelimit.isRateLimited(rateLimits, dataCategory)) {
           options3.recordDroppedEvent("ratelimit_backoff", dataCategory);
         } else {
@@ -81140,17 +82202,17 @@ var require_base = __commonJS((exports) => {
       if (filteredEnvelopeItems.length === 0) {
         return Promise.resolve({});
       }
-      const filteredEnvelope = envelope.createEnvelope(envelope$1[0], filteredEnvelopeItems);
+      const filteredEnvelope = envelope2.createEnvelope(envelope$1[0], filteredEnvelopeItems);
       const recordEnvelopeLoss = (reason) => {
-        if (envelope.envelopeContainsItemType(filteredEnvelope, ["client_report"])) {
+        if (envelope2.envelopeContainsItemType(filteredEnvelope, ["client_report"])) {
           debugBuild.DEBUG_BUILD && debugLogger.debug.warn(`Dropping client report. Will not send outcomes (reason: ${reason}).`);
           return;
         }
-        envelope.forEachEnvelopeItem(filteredEnvelope, (item, type) => {
-          options3.recordDroppedEvent(reason, envelope.envelopeItemTypeToDataCategory(type));
+        envelope2.forEachEnvelopeItem(filteredEnvelope, (item, type) => {
+          options3.recordDroppedEvent(reason, envelope2.envelopeItemTypeToDataCategory(type));
         });
       };
-      const requestTask = () => makeRequest({ body: envelope.serializeEnvelope(filteredEnvelope) }).then((response) => {
+      const requestTask = () => makeRequest({ body: envelope2.serializeEnvelope(filteredEnvelope) }).then((response) => {
         if (response.statusCode === 413) {
           debugBuild.DEBUG_BUILD && debugLogger.debug.error("Sentry responded with status code 413. Envelope was discarded due to exceeding size limits.");
           recordEnvelopeLoss("send_error");
@@ -81188,7 +82250,7 @@ var require_base = __commonJS((exports) => {
 // ../../node_modules/.bun/@sentry+core@10.52.0/node_modules/@sentry/core/build/cjs/utils/clientreport.js
 var require_clientreport = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var time3 = require_time();
   function createClientReportEnvelope(discarded_events, dsn, timestamp3) {
     const clientReportItem = [
@@ -81198,7 +82260,7 @@ var require_clientreport = __commonJS((exports) => {
         discarded_events
       }
     ];
-    return envelope.createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);
+    return envelope2.createEnvelope(dsn ? { dsn } : {}, [clientReportItem]);
   }
   exports.createClientReportEnvelope = createClientReportEnvelope;
 });
@@ -81283,7 +82345,7 @@ var require_client = __commonJS((exports) => {
   var constants = require_constants();
   var currentScopes = require_currentScopes();
   var debugBuild = require_debug_build();
-  var envelope = require_envelope2();
+  var envelope2 = require_envelope2();
   var integration = require_integration();
   var internal = require_internal();
   var internal$1 = require_internal2();
@@ -81488,7 +82550,7 @@ var require_client = __commonJS((exports) => {
     }
     sendEvent(event, hint = {}) {
       this.emit("beforeSendEvent", event, hint);
-      let env2 = envelope.createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
+      let env2 = envelope2.createEventEnvelope(event, this._dsn, this._options._metadata, this._options.tunnel);
       for (const attachment of hint.attachments || []) {
         env2 = envelope$1.addItemToEnvelope(env2, envelope$1.createAttachmentEnvelopeItem(attachment));
       }
@@ -81514,7 +82576,7 @@ var require_client = __commonJS((exports) => {
         session4.environment = session4.environment || clientEnvironmentOption;
       }
       this.emit("beforeSendSession", session4);
-      const env2 = envelope.createSessionEnvelope(session4, this._dsn, this._options._metadata, this._options.tunnel);
+      const env2 = envelope2.createSessionEnvelope(session4, this._dsn, this._options._metadata, this._options.tunnel);
       this.sendEnvelope(env2);
     }
     recordDroppedEvent(reason, category, count = 1) {
@@ -81538,11 +82600,11 @@ var require_client = __commonJS((exports) => {
         callbacks.forEach((callback) => callback(...rest));
       }
     }
-    async sendEnvelope(envelope2) {
-      this.emit("beforeEnvelope", envelope2);
+    async sendEnvelope(envelope3) {
+      this.emit("beforeEnvelope", envelope3);
       if (this._isEnabled() && this._transport) {
         try {
-          return await this._transport.send(envelope2);
+          return await this._transport.send(envelope3);
         } catch (reason) {
           debugBuild.DEBUG_BUILD && debugLogger.debug.error("Error while sending envelope:", reason);
           return {};
@@ -81753,8 +82815,8 @@ Reason: ${reason}`);
         return;
       }
       debugBuild.DEBUG_BUILD && debugLogger.debug.log("Sending outcomes:", outcomes);
-      const envelope2 = clientreport.createClientReportEnvelope(outcomes, this._options.tunnel && dsn.dsnToString(this._dsn));
-      this.sendEnvelope(envelope2);
+      const envelope3 = clientreport.createClientReportEnvelope(outcomes, this._options.tunnel && dsn.dsnToString(this._dsn));
+      this.sendEnvelope(envelope3);
     }
   }
   function getDataCategoryByType(type) {
@@ -81891,7 +82953,7 @@ Reason: ${reason}`);
 var require_checkin = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   function createCheckInEnvelope(checkIn, dynamicSamplingContext, metadata, tunnel, dsn$1) {
     const headers = {
       sent_at: new Date().toISOString()
@@ -81909,7 +82971,7 @@ var require_checkin = __commonJS((exports) => {
       headers.trace = dynamicSamplingContext;
     }
     const item = createCheckInEnvelopeItem(checkIn);
-    return envelope.createEnvelope(headers, [item]);
+    return envelope2.createEnvelope(headers, [item]);
   }
   function createCheckInEnvelopeItem(checkIn) {
     const checkInHeaders = {
@@ -82162,9 +83224,9 @@ var require_server_runtime_client = __commonJS((exports) => {
           trace: traceContext
         };
       }
-      const envelope = checkin.createCheckInEnvelope(serializedCheckIn, dynamicSamplingContext, this.getSdkMetadata(), tunnel, this.getDsn());
+      const envelope2 = checkin.createCheckInEnvelope(serializedCheckIn, dynamicSamplingContext, this.getSdkMetadata(), tunnel, this.getDsn());
       debugBuild.DEBUG_BUILD && debugLogger.debug.log("Sending checkin:", checkIn.monitorSlug, checkIn.status);
-      this.sendEnvelope(envelope);
+      this.sendEnvelope(envelope2);
       return id;
     }
     registerCleanup(callback) {
@@ -82263,7 +83325,7 @@ var require_offline = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var debugBuild = require_debug_build();
   var debugLogger = require_debug_logger();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var ratelimit = require_ratelimit();
   var timer2 = require_timer();
   var MIN_DELAY = 100;
@@ -82282,7 +83344,7 @@ var require_offline = __commonJS((exports) => {
       let retryDelay = START_DELAY;
       let flushTimer;
       function shouldQueue(env2, error2, retryDelay2) {
-        if (envelope.envelopeContainsItemType(env2, ["client_report"])) {
+        if (envelope2.envelopeContainsItemType(env2, ["client_report"])) {
           return false;
         }
         if (options3.shouldStore) {
@@ -82314,7 +83376,7 @@ var require_offline = __commonJS((exports) => {
         retryDelay = Math.min(retryDelay * 2, MAX_DELAY);
       }
       async function send(envelope$1, isRetry = false) {
-        if (!isRetry && envelope.envelopeContainsItemType(envelope$1, ["replay_event", "replay_recording"])) {
+        if (!isRetry && envelope2.envelopeContainsItemType(envelope$1, ["replay_event", "replay_recording"])) {
           await store.push(envelope$1);
           flushIn(MIN_DELAY);
           return {};
@@ -82377,11 +83439,11 @@ var require_multiplexed = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var api = require_api();
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var MULTIPLEXED_TRANSPORT_EXTRA_KEY = "MULTIPLEXED_TRANSPORT_EXTRA_KEY";
   function eventFromEnvelope(env2, types8) {
     let event;
-    envelope.forEachEnvelopeItem(env2, (item, type) => {
+    envelope2.forEachEnvelopeItem(env2, (item, type) => {
       if (types8.includes(type)) {
         event = Array.isArray(item) ? item[1] : undefined;
       }
@@ -82394,18 +83456,18 @@ var require_multiplexed = __commonJS((exports) => {
       const transport = createTransport(options3);
       return {
         ...transport,
-        send: async (envelope2) => {
-          const event = eventFromEnvelope(envelope2, ["event", "transaction", "profile", "replay_event"]);
+        send: async (envelope3) => {
+          const event = eventFromEnvelope(envelope3, ["event", "transaction", "profile", "replay_event"]);
           if (event) {
             event.release = release;
           }
-          return transport.send(envelope2);
+          return transport.send(envelope3);
         }
       };
     };
   }
   function overrideDsn(envelope$1, dsn2) {
-    return envelope.createEnvelope(dsn2 ? {
+    return envelope2.createEnvelope(dsn2 ? {
       ...envelope$1[0],
       dsn: dsn2
     } : envelope$1[0], envelope$1[1]);
@@ -82435,12 +83497,12 @@ var require_multiplexed = __commonJS((exports) => {
         }
         return [dsn$1, transport];
       }
-      async function send(envelope2) {
+      async function send(envelope3) {
         function getEvent(types8) {
           const eventTypes2 = types8?.length ? types8 : ["event"];
-          return eventFromEnvelope(envelope2, eventTypes2);
+          return eventFromEnvelope(envelope3, eventTypes2);
         }
-        const transports = actualMatcher({ envelope: envelope2, getEvent }).map((result) => {
+        const transports = actualMatcher({ envelope: envelope3, getEvent }).map((result) => {
           if (typeof result === "string") {
             return getTransport(result, undefined);
           } else {
@@ -82448,7 +83510,7 @@ var require_multiplexed = __commonJS((exports) => {
           }
         }).filter((t) => !!t);
         const transportsWithFallback = transports.length ? transports : [["", fallbackTransport]];
-        const results = await Promise.all(transportsWithFallback.map(([dsn2, transport]) => transport.send(overrideDsn(envelope2, dsn2))));
+        const results = await Promise.all(transportsWithFallback.map(([dsn2, transport]) => transport.send(overrideDsn(envelope3, dsn2))));
         return results[0];
       }
       async function flush(timeout) {
@@ -82565,7 +83627,7 @@ var require_tunnel = __commonJS((exports) => {
   var api = require_api();
   var debugLogger = require_debug_logger();
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   async function handleTunnelRequest(options3) {
     const { request, allowedDsns } = options3;
     if (allowedDsns.length === 0) {
@@ -82574,7 +83636,7 @@ var require_tunnel = __commonJS((exports) => {
     const body = new Uint8Array(await request.arrayBuffer());
     let envelopeHeader;
     try {
-      [envelopeHeader] = envelope.parseEnvelope(body);
+      [envelopeHeader] = envelope2.parseEnvelope(body);
     } catch {
       return new Response("Invalid envelope", { status: 400 });
     }
@@ -83439,13 +84501,13 @@ var require_moduleMetadata = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var integration = require_integration();
   var metadata = require_metadata();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var moduleMetadataIntegration = integration.defineIntegration(() => {
     return {
       name: "ModuleMetadata",
       setup(client) {
         client.on("beforeEnvelope", (envelope$1) => {
-          envelope.forEachEnvelopeItem(envelope$1, (item, type) => {
+          envelope2.forEachEnvelopeItem(envelope$1, (item, type) => {
             if (type === "event") {
               const event = Array.isArray(item) ? item[1] : undefined;
               if (event) {
@@ -83541,7 +84603,7 @@ var require_getIpAddress = __commonJS((exports) => {
       }
       return acc.concat(val);
     }, []);
-    const ipAddress = flattenedHeaderValues.find((ip) => ip !== null && isIP(ip));
+    const ipAddress = flattenedHeaderValues.find((ip) => ip !== null && isIP3(ip));
     return ipAddress || null;
   }
   function parseForwardedHeader(value) {
@@ -83555,7 +84617,7 @@ var require_getIpAddress = __commonJS((exports) => {
     }
     return null;
   }
-  function isIP(str) {
+  function isIP3(str) {
     const regex2 = /(?:^(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}$)|(?:^(?:(?:[a-fA-F\d]{1,4}:){7}(?:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){6}(?:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|:[a-fA-F\d]{1,4}|:)|(?:[a-fA-F\d]{1,4}:){5}(?::(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,2}|:)|(?:[a-fA-F\d]{1,4}:){4}(?:(?::[a-fA-F\d]{1,4}){0,1}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,3}|:)|(?:[a-fA-F\d]{1,4}:){3}(?:(?::[a-fA-F\d]{1,4}){0,2}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,4}|:)|(?:[a-fA-F\d]{1,4}:){2}(?:(?::[a-fA-F\d]{1,4}){0,3}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,5}|:)|(?:[a-fA-F\d]{1,4}:){1}(?:(?::[a-fA-F\d]{1,4}){0,4}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,6}|:)|(?::(?:(?::[a-fA-F\d]{1,4}){0,5}:(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)(?:\\.(?:25[0-5]|2[0-4]\d|1\d\d|[1-9]\d|\d)){3}|(?::[a-fA-F\d]{1,4}){1,7}|:)))(?:%[0-9a-zA-Z]{1,})?$)/;
     return regex2.test(str);
   }
@@ -85416,14 +86478,14 @@ var require_third_party_errors_filter = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var integration = require_integration();
   var metadata = require_metadata();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var stacktrace = require_stacktrace();
   var thirdPartyErrorFilterIntegration = integration.defineIntegration((options3) => {
     return {
       name: "ThirdPartyErrorsFilter",
       setup(client) {
         client.on("beforeEnvelope", (envelope$1) => {
-          envelope.forEachEnvelopeItem(envelope$1, (item, type) => {
+          envelope2.forEachEnvelopeItem(envelope$1, (item, type) => {
             if (type === "event") {
               const event = Array.isArray(item) ? item[1] : undefined;
               if (event) {
@@ -91199,13 +92261,13 @@ var require_langgraph = __commonJS((exports) => {
 var require_envelope5 = __commonJS((exports) => {
   Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
   var dsn = require_dsn();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var isBrowser = require_isBrowser();
   function createStreamedSpanEnvelope(serializedSpans, dsc, client) {
     const options3 = client.getOptions();
     const dsn$1 = client.getDsn();
     const tunnel = options3.tunnel;
-    const sdk = envelope.getSdkMetadataForEnvelopeHeader(options3._metadata);
+    const sdk = envelope2.getSdkMetadataForEnvelopeHeader(options3._metadata);
     const headers = {
       sent_at: new Date().toISOString(),
       ...dscHasRequiredProps(dsc) && { trace: dsc },
@@ -91223,7 +92285,7 @@ var require_envelope5 = __commonJS((exports) => {
         items: serializedSpans
       }
     ];
-    return envelope.createEnvelope(headers, [spanContainer]);
+    return envelope2.createEnvelope(headers, [spanContainer]);
   }
   function dscHasRequiredProps(dsc) {
     return !!dsc.trace_id && !!dsc.public_key;
@@ -91257,7 +92319,7 @@ var require_spanBuffer = __commonJS((exports) => {
   var debugLogger = require_debug_logger();
   var timer2 = require_timer();
   var dynamicSamplingContext = require_dynamicSamplingContext();
-  var envelope = require_envelope5();
+  var envelope2 = require_envelope5();
   var estimateSize = require_estimateSize();
   var MAX_SPANS_PER_ENVELOPE = 1000;
   var MAX_TRACE_WEIGHT_IN_BYTES = 5000000;
@@ -91329,7 +92391,7 @@ var require_spanBuffer = __commonJS((exports) => {
         const { _segmentSpan, ...cleanSpanJSON } = spanJSON;
         return cleanSpanJSON;
       });
-      const envelope$1 = envelope.createStreamedSpanEnvelope(cleanedSpans, dsc, this._client);
+      const envelope$1 = envelope2.createStreamedSpanEnvelope(cleanedSpans, dsc, this._client);
       debugBuild.DEBUG_BUILD && debugLogger.debug.log(`Sending span envelope for trace ${traceId} with ${cleanedSpans.length} spans`);
       this._client.sendEnvelope(envelope$1).then(null, (reason) => {
         debugBuild.DEBUG_BUILD && debugLogger.debug.error("Error while sending streamed span envelope:", reason);
@@ -92163,7 +93225,7 @@ var require_cjs = __commonJS((exports) => {
   var time3 = require_time();
   var tracing2 = require_tracing();
   var env2 = require_env();
-  var envelope = require_envelope();
+  var envelope2 = require_envelope();
   var clientreport = require_clientreport();
   var ratelimit = require_ratelimit();
   var baggage = require_baggage();
@@ -92535,17 +93597,17 @@ var require_cjs = __commonJS((exports) => {
   exports.shouldContinueTrace = tracing2.shouldContinueTrace;
   exports.getSDKSource = env2.getSDKSource;
   exports.isBrowserBundle = env2.isBrowserBundle;
-  exports.addItemToEnvelope = envelope.addItemToEnvelope;
-  exports.createAttachmentEnvelopeItem = envelope.createAttachmentEnvelopeItem;
-  exports.createEnvelope = envelope.createEnvelope;
-  exports.createEventEnvelopeHeaders = envelope.createEventEnvelopeHeaders;
-  exports.createSpanEnvelopeItem = envelope.createSpanEnvelopeItem;
-  exports.envelopeContainsItemType = envelope.envelopeContainsItemType;
-  exports.envelopeItemTypeToDataCategory = envelope.envelopeItemTypeToDataCategory;
-  exports.forEachEnvelopeItem = envelope.forEachEnvelopeItem;
-  exports.getSdkMetadataForEnvelopeHeader = envelope.getSdkMetadataForEnvelopeHeader;
-  exports.parseEnvelope = envelope.parseEnvelope;
-  exports.serializeEnvelope = envelope.serializeEnvelope;
+  exports.addItemToEnvelope = envelope2.addItemToEnvelope;
+  exports.createAttachmentEnvelopeItem = envelope2.createAttachmentEnvelopeItem;
+  exports.createEnvelope = envelope2.createEnvelope;
+  exports.createEventEnvelopeHeaders = envelope2.createEventEnvelopeHeaders;
+  exports.createSpanEnvelopeItem = envelope2.createSpanEnvelopeItem;
+  exports.envelopeContainsItemType = envelope2.envelopeContainsItemType;
+  exports.envelopeItemTypeToDataCategory = envelope2.envelopeItemTypeToDataCategory;
+  exports.forEachEnvelopeItem = envelope2.forEachEnvelopeItem;
+  exports.getSdkMetadataForEnvelopeHeader = envelope2.getSdkMetadataForEnvelopeHeader;
+  exports.parseEnvelope = envelope2.parseEnvelope;
+  exports.serializeEnvelope = envelope2.serializeEnvelope;
   exports.createClientReportEnvelope = clientreport.createClientReportEnvelope;
   exports.DEFAULT_RETRY_AFTER = ratelimit.DEFAULT_RETRY_AFTER;
   exports.disabledUntil = ratelimit.disabledUntil;
@@ -104387,12 +105449,12 @@ var require_spotlight = __commonJS((exports) => {
       return;
     }
     let failedRequests = 0;
-    client.on("beforeEnvelope", (envelope) => {
+    client.on("beforeEnvelope", (envelope2) => {
       if (failedRequests > 3) {
         core.debug.warn("[Spotlight] Disabled Sentry -> Spotlight integration due to too many failed requests");
         return;
       }
-      const serializedEnvelope = core.serializeEnvelope(envelope);
+      const serializedEnvelope = core.serializeEnvelope(envelope2);
       core.suppressTracing(() => {
         const req = http.request({
           method: "POST",
@@ -115790,16 +116852,16 @@ var require_tracingChannel = __commonJS((exports) => {
   var debugBuild = require_debug_build_ntZrglYX();
   function tracingChannel(channelNameOrInstance, transformStart) {
     const channel2 = node_diagnostics_channel.tracingChannel(channelNameOrInstance);
-    let lookup;
+    let lookup2;
     try {
       const contextManager = api.context._getContextManager();
-      lookup = contextManager.getAsyncLocalStorageLookup();
+      lookup2 = contextManager.getAsyncLocalStorageLookup();
     } catch {}
-    if (!lookup) {
+    if (!lookup2) {
       debugBuild.DEBUG_BUILD && core.logger.warn("[TracingChannel] Could not access OpenTelemetry AsyncLocalStorage, context propagation will not work.");
       return channel2;
     }
-    const otelStorage = lookup.asyncLocalStorage;
+    const otelStorage = lookup2.asyncLocalStorage;
     channel2.start.bindStore(otelStorage, (data2) => {
       const span = transformStart(data2);
       data2._sentrySpan = span;
@@ -126250,7 +127312,7 @@ import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "@automagik/omni",
-  version: "2.260727.2",
+  version: "2.260728.2",
   description: "LLM-optimized CLI for Omni",
   type: "module",
   bin: {
@@ -134834,7 +135896,6 @@ async function promptAdminConfirmation() {
 async function handleAdminCreate(options) {
   if (process.env.OMNI_DB_ENFORCEMENT === "on") {
     error("refusing to create an admin (god) key while OMNI_DB_ENFORCEMENT=on \u2014 a plaintext data-plane key with " + "every scope is not an admissible bootstrap under enforcement. Create a platform-class credential and " + "delegate a tenant-scoped key from it instead.", undefined, 1);
-    return;
   }
   if (!process.stdin.isTTY) {
     error("admin keys require a TTY \u2014 run this command interactively", undefined, 1);