lua-cli 3.44.0 → 3.46.0

package/dist/workflow-builder.js

@@ -84,8 +84,8 @@ function workflowJobTargetTemplatePath(binding) {
 __name(workflowJobTargetTemplatePath, "workflowJobTargetTemplatePath");
 __name2(workflowJobTargetTemplatePath, "workflowJobTargetTemplatePath");
 function isWorkflowJobTargetTemplate(target) {
-  const agentId = target?.agentId;
-  return !!agentId && typeof agentId === "object";
+  const agentId2 = target?.agentId;
+  return !!agentId2 && typeof agentId2 === "object";
 }
 __name(isWorkflowJobTargetTemplate, "isWorkflowJobTargetTemplate");
 __name2(isWorkflowJobTargetTemplate, "isWorkflowJobTargetTemplate");
@@ -107,12 +107,12 @@ function workflowJobTargetProblem(target, plugins, luaApi) {
   if (target === void 0) return null;
   if (!target || typeof target !== "object" || Array.isArray(target)) return "target must be { agentId }";
   const keys = Object.keys(target);
-  const agentId = target.agentId;
+  const agentId2 = target.agentId;
   if (keys.length !== 1 || !("agentId" in target)) return "target must be exactly { agentId }";
-  if (typeof agentId === "string") {
-    if (!agentId.trim() || agentId.length > 256) return "target must be exactly { agentId: <non-empty string> }";
-    if (agentId.includes("${")) return "a run-input target is written template('${initData.<path>}'), never a string with ${\u2026}";
-  } else if (workflowJobTargetTemplatePath(agentId) === null) {
+  if (typeof agentId2 === "string") {
+    if (!agentId2.trim() || agentId2.length > 256) return "target must be exactly { agentId: <non-empty string> }";
+    if (agentId2.includes("${")) return "a run-input target is written template('${initData.<path>}'), never a string with ${\u2026}";
+  } else if (workflowJobTargetTemplatePath(agentId2) === null) {
     return "target.agentId must be a static id or template('${initData.<path>}') \u2014 exactly one initData placeholder, no default";
   }
   const hasPlugins = Array.isArray(plugins) && plugins.length > 0;
@@ -140,25 +140,25 @@ function readInitDataPath(root, path) {
 __name(readInitDataPath, "readInitDataPath");
 __name2(readInitDataPath, "readInitDataPath");
 function renderWorkflowJobTarget(target, initData) {
-  const agentId = target?.agentId;
-  if (target === void 0 || target === null || agentId === void 0) return {
+  const agentId2 = target?.agentId;
+  if (target === void 0 || target === null || agentId2 === void 0) return {
     ok: true,
     agentId: void 0,
     templated: false
   };
-  if (typeof agentId === "string") {
-    if (!agentId.trim() || agentId.includes("${")) return {
+  if (typeof agentId2 === "string") {
+    if (!agentId2.trim() || agentId2.includes("${")) return {
       ok: false,
       reason: "invalid",
       message: "target.agentId is invalid"
     };
     return {
       ok: true,
-      agentId,
+      agentId: agentId2,
       templated: false
     };
   }
-  const path = workflowJobTargetTemplatePath(agentId);
+  const path = workflowJobTargetTemplatePath(agentId2);
   if (path === null) return {
     ok: false,
     reason: "invalid",
@@ -196,6 +196,7 @@ import { z } from "zod";
 import { z as z2 } from "zod";
 import { z as z3 } from "zod";
 import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var __defProp3 = Object.defineProperty;
 var __name3 = /* @__PURE__ */ __name((target, value3) => __defProp3(target, "name", { value: value3, configurable: true }), "__name");
 var PLUMBING_THREAD_CHANNELS = [
@@ -433,8 +434,8 @@ function isPlatformInvocationCaller(v) {
 }
 __name(isPlatformInvocationCaller, "isPlatformInvocationCaller");
 __name3(isPlatformInvocationCaller, "isPlatformInvocationCaller");
-function supervisionSubjectId(agentId) {
-  return `agent:${agentId}`;
+function supervisionSubjectId(agentId2) {
+  return `agent:${agentId2}`;
 }
 __name(supervisionSubjectId, "supervisionSubjectId");
 __name3(supervisionSubjectId, "supervisionSubjectId");
@@ -548,7 +549,27 @@ var SUPERVISION_OPS = {
   * agentId }`) to its env. `act`, on a turn whose platform-picked user is the target's owner, never overwriting a
   * key (`LUA_SECRET_ATTACH_EXISTING_ENABLED`).
   */
-  "secrets.attach": "act"
+  "secrets.attach": "act",
+  /**
+  * SV (LUA-1080) — `Agents.deployed(id)`: what the target serves RIGHT NOW, read from each primitive's live pointer
+  * (skills with their tools, the published persona, pre/postprocessors), with version ids comparable to an agent
+  * version snapshot. Works whether or not the target has a promoted agent version. Metadata and hashes only.
+  */
+  "primitives.deployed": "observe",
+  // [WD]
+  /**
+  * WD (watchdog grant) — `Agents.versions(id).rollback(version, { expectActive })`: restore a version of the target
+  * that was ACTIVE before, is OLDER than the active one and was active within the last 7 days. CAS on the active
+  * version; only from a workflow step the watchdog grant names. Held only by a watchdog grant.
+  */
+  "versions.rollback": "rollback",
+  // [JR]
+  /**
+  * JR (BAC-2011) — `Agents.jobs(id).register({ versionId, jobId })`: register a job that is pinned in a STAGED version of
+  * the target (`snapshot.jobs[]`) so the promote activates and schedules it. Mongo-only marker write; EventBridge stays
+  * on the post-promote reconcile. Release-class: needs `register-job` AND `release` on the grant, from a signed step.
+  */
+  "jobs.register": "register-job"
 };
 function isSupervisionOp(op) {
   return typeof op === "string" && Object.prototype.hasOwnProperty.call(SUPERVISION_OPS, op);
@@ -729,8 +750,171 @@ var SUPERVISION_OPS_WAVE2 = {
     gate: "act",
     targeted: true,
     item: "SV"
+  },
+  /** SV (LUA-1080) — `Agents.deployed(id)`: the target's deployed primitives (live pointers, no agent version needed). */
+  "primitives.deployed": {
+    gate: "observe",
+    targeted: true,
+    item: "SV"
+  },
+  /** WD — `Agents.versions(id).rollback(version, { expectActive })` (watchdog grant only). */
+  "versions.rollback": {
+    gate: "rollback",
+    targeted: true,
+    item: "WD"
+  },
+  /** JR (BAC-2011) — `Agents.jobs(id).register({ versionId, jobId })`: a job pinned in a STAGED version (`register-job`). */
+  "jobs.register": {
+    gate: "register-job",
+    targeted: true,
+    item: "JR"
   }
 };
+var SUPERVISION_WATCHDOG_OPS = {
+  logs: "observe",
+  "runs.list": "observe",
+  "runs.get": "observe",
+  "data.get": "observe",
+  "data.query": "observe",
+  "versions.list": "observe",
+  "versions.get": "observe",
+  "versions.diff": "observe",
+  "versions.rollback": "rollback"
+};
+function isSupervisionWatchdogOp(op) {
+  return typeof op === "string" && Object.prototype.hasOwnProperty.call(SUPERVISION_WATCHDOG_OPS, op);
+}
+__name(isSupervisionWatchdogOp, "isSupervisionWatchdogOp");
+__name3(isSupervisionWatchdogOp, "isSupervisionWatchdogOp");
+var SUPERVISION_WATCHDOG_ERRORS = {
+  /** A watchdog holder called an op outside {@link SUPERVISION_WATCHDOG_OPS}. */
+  OP_REFUSED: "supervision_watchdog_op_refused",
+  /** See {@link SupervisionRollbackRefusalReason}. */
+  ROLLBACK_NEVER_ACTIVE: "supervision_rollback_never_active",
+  ROLLBACK_NOT_OLDER: "supervision_rollback_not_older",
+  ROLLBACK_NOT_IN_LINEAGE: "supervision_rollback_not_in_lineage",
+  ROLLBACK_AFTER_ROLLBACK: "supervision_rollback_after_rollback",
+  ROLLBACK_AFTER_BACKWARD_PROMOTE: "supervision_rollback_after_backward_promote",
+  ROLLBACK_TOO_OLD: "supervision_rollback_too_old",
+  /** `expectActive` is not the active version (CAS). */
+  ROLLBACK_CONFLICT: "supervision_rollback_conflict",
+  /** The promote failed part-way and its compensation restored the previous active version. */
+  ROLLBACK_INCOMPLETE: "supervision_rollback_incomplete",
+  /** The promote failed part-way AND its compensation failed: the Agents DB may have moved (manual triage). */
+  ROLLBACK_INCOMPLETE_UNCOMPENSATED: "supervision_rollback_incomplete_uncompensated"
+};
+var SUPERVISION_ROLLBACK_REFUSAL_CODES = {
+  never_active: SUPERVISION_WATCHDOG_ERRORS.ROLLBACK_NEVER_ACTIVE,
+  not_older: SUPERVISION_WATCHDOG_ERRORS.ROLLBACK_NOT_OLDER,
+  not_in_lineage: SUPERVISION_WATCHDOG_ERRORS.ROLLBACK_NOT_IN_LINEAGE,
+  after_rollback: SUPERVISION_WATCHDOG_ERRORS.ROLLBACK_AFTER_ROLLBACK,
+  after_backward_promote: SUPERVISION_WATCHDOG_ERRORS.ROLLBACK_AFTER_BACKWARD_PROMOTE,
+  too_old: SUPERVISION_WATCHDOG_ERRORS.ROLLBACK_TOO_OLD
+};
+function isSupervisionRollbackRefusalReason(v) {
+  return typeof v === "string" && Object.prototype.hasOwnProperty.call(SUPERVISION_ROLLBACK_REFUSAL_CODES, v);
+}
+__name(isSupervisionRollbackRefusalReason, "isSupervisionRollbackRefusalReason");
+__name3(isSupervisionRollbackRefusalReason, "isSupervisionRollbackRefusalReason");
+var SUPERVISION_ROLLBACK_LINEAGE_MAX = 25;
+function supervisionRollbackTargetRefusal(target, expectActive, window) {
+  if (target.status !== "superseded" || !target.promotedAt || target.compensationFailed === true) {
+    return {
+      reason: "never_active",
+      message: `Version ${target.version} was never fully the active version (status ${target.status ?? "unknown"})`
+    };
+  }
+  if (typeof expectActive !== "number" || !(target.version < expectActive)) {
+    return {
+      reason: "not_older",
+      message: `Version ${target.version} is not older than the active version ${expectActive ?? "none"}`
+    };
+  }
+  if (window) {
+    if (target.supersededVia === "rollback" || target.promotedVia === "rollback") {
+      return {
+        reason: "after_rollback",
+        message: `Version ${target.version} was retired or restored by a rollback`
+      };
+    }
+    if (target.supersededVia !== "promote" && target.supersededVia !== "scoped") {
+      return {
+        reason: "not_in_lineage",
+        message: `Version ${target.version} has no forward-promote history`
+      };
+    }
+    const ended = target.supersededAt ? new Date(target.supersededAt).getTime() : NaN;
+    if (!Number.isFinite(ended) || ended < window.now - window.windowMs) {
+      return {
+        reason: "too_old",
+        message: `Version ${target.version} was last active outside the ${Math.round(window.windowMs / 864e5)}-day window`
+      };
+    }
+  }
+  return null;
+}
+__name(supervisionRollbackTargetRefusal, "supervisionRollbackTargetRefusal");
+__name3(supervisionRollbackTargetRefusal, "supervisionRollbackTargetRefusal");
+function supervisionRollbackRefusal(input) {
+  const { target, active, lineage, expectActive, windowMs, now } = input;
+  const pre = supervisionRollbackTargetRefusal(target, expectActive);
+  if (pre) return pre;
+  if (!active || active.version !== expectActive) {
+    return {
+      reason: "not_older",
+      message: `Version ${expectActive ?? "none"} is not the active version`
+    };
+  }
+  if (active.promotedVia === "rollback") {
+    return {
+      reason: "after_rollback",
+      message: `The active version ${active.version} was restored by a rollback; a watchdog does not roll back twice in a row`
+    };
+  }
+  let previous = active;
+  for (const step3 of lineage.slice(0, SUPERVISION_ROLLBACK_LINEAGE_MAX)) {
+    const label = `version ${step3.version}`;
+    if (step3.supersededVia === "rollback" || step3.promotedVia === "rollback") {
+      return {
+        reason: "after_rollback",
+        message: `The rollback lineage crosses ${label}, which a rollback retired or restored`
+      };
+    }
+    if (step3.supersededVia !== "promote" && step3.supersededVia !== "scoped") {
+      return {
+        reason: "not_in_lineage",
+        message: `The rollback lineage stops at ${label} (no forward-promote history)`
+      };
+    }
+    if (step3.compensationFailed === true || step3.status !== "superseded" || !step3.promotedAt) {
+      return {
+        reason: "not_in_lineage",
+        message: `The rollback lineage stops at ${label} (not fully served)`
+      };
+    }
+    if (!(step3.version < previous.version)) {
+      return {
+        reason: "after_backward_promote",
+        message: `Version ${previous.version} was promoted BACK over ${label}; a watchdog never reaches behind that`
+      };
+    }
+    const ended = step3.supersededAt ? new Date(step3.supersededAt).getTime() : NaN;
+    if (!Number.isFinite(ended) || ended < now - windowMs) {
+      return {
+        reason: "too_old",
+        message: `The rollback lineage reaches ${label}, last active outside the ${Math.round(windowMs / 864e5)}-day window`
+      };
+    }
+    if (step3.version === target.version && (!target.id || !step3.id || step3.id === target.id)) return null;
+    previous = step3;
+  }
+  return {
+    reason: "not_in_lineage",
+    message: `Version ${target.version} is not in the active version's recent forward-promote lineage`
+  };
+}
+__name(supervisionRollbackRefusal, "supervisionRollbackRefusal");
+__name3(supervisionRollbackRefusal, "supervisionRollbackRefusal");
 var SUPERVISION_UNTARGETED_OPS = [
   "agents.list",
   ...Object.entries(SUPERVISION_OPS_WAVE2).filter(([, contract]) => !contract.targeted).map(([op]) => op)
@@ -1516,9 +1700,9 @@ function isAgentConnectionMountMode(value3) {
 }
 __name(isAgentConnectionMountMode, "isAgentConnectionMountMode");
 __name3(isAgentConnectionMountMode, "isAgentConnectionMountMode");
-function agentConnectionBindingFor(bindings, agentId) {
-  if (!Array.isArray(bindings) || !agentId) return void 0;
-  return bindings.find((entry) => !!entry && typeof entry === "object" && entry.agentId === agentId);
+function agentConnectionBindingFor(bindings, agentId2) {
+  if (!Array.isArray(bindings) || !agentId2) return void 0;
+  return bindings.find((entry) => !!entry && typeof entry === "object" && entry.agentId === agentId2);
 }
 __name(agentConnectionBindingFor, "agentConnectionBindingFor");
 __name3(agentConnectionBindingFor, "agentConnectionBindingFor");
@@ -1806,7 +1990,9 @@ var SECRET_REQUEST_ERRORS = {
   /** `secrets.attach` would set an env key the agent already has: never overwritten (remove or rotate it first). */
   KEY_EXISTS: "secret_key_exists",
   /** A request held for an existing agent submitted on the public token page: its owner submits it signed in. */
-  OWNER_SUBMIT_REQUIRED: "secret_submit_requires_owner"
+  OWNER_SUBMIT_REQUIRED: "secret_submit_requires_owner",
+  /** LUA-1079 — `requestSecret` with `pendingFor` on a client that did not declare the pending card capability. */
+  PENDING_CARD_UNSUPPORTED: "secret_pending_card_unsupported"
 };
 var SECRET_OUTCOME_STATUSES = [
   ...SECRET_TEST_RESULTS,
@@ -2088,8 +2274,8 @@ function describeConnectionRequest(input) {
 }
 __name(describeConnectionRequest, "describeConnectionRequest");
 __name3(describeConnectionRequest, "describeConnectionRequest");
-function operationDailyCapKey(agentId, connectionId, currency, utcDay) {
-  return `opcap:${agentId}:${connectionId}:${currency.toUpperCase()}:${utcDay}`;
+function operationDailyCapKey(agentId2, connectionId, currency, utcDay) {
+  return `opcap:${agentId2}:${connectionId}:${currency.toUpperCase()}:${utcDay}`;
 }
 __name(operationDailyCapKey, "operationDailyCapKey");
 __name3(operationDailyCapKey, "operationDailyCapKey");
@@ -2146,7 +2332,7 @@ function parseCapAmount(value3) {
 }
 __name(parseCapAmount, "parseCapAmount");
 __name3(parseCapAmount, "parseCapAmount");
-function parseAgentConnectionOperationLimits(agentId, value3) {
+function parseAgentConnectionOperationLimits(agentId2, value3) {
   if (!isPlainObject(value3)) return {
     ok: false,
     error: "limits must be an object"
@@ -2159,7 +2345,7 @@ function parseAgentConnectionOperationLimits(agentId, value3) {
     };
   }
   const limits = {
-    agentId
+    agentId: agentId2
   };
   if (value3.caps !== void 0 && value3.caps !== null) {
     const caps = value3.caps;
@@ -2247,17 +2433,17 @@ function parseAgentConnectionOperationLimits(agentId, value3) {
 }
 __name(parseAgentConnectionOperationLimits, "parseAgentConnectionOperationLimits");
 __name3(parseAgentConnectionOperationLimits, "parseAgentConnectionOperationLimits");
-function findAgentConnectionOperationLimits(stored, agentId) {
-  if (!agentId || stored === void 0 || stored === null) return void 0;
+function findAgentConnectionOperationLimits(stored, agentId2) {
+  if (!agentId2 || stored === void 0 || stored === null) return void 0;
   if (!Array.isArray(stored)) return {
-    agentId,
+    agentId: agentId2,
     unreadable: true
   };
-  const entry = stored.find((row) => isPlainObject(row) && row.agentId === agentId);
+  const entry = stored.find((row) => isPlainObject(row) && row.agentId === agentId2);
   if (!entry) return void 0;
-  const parsed = parseAgentConnectionOperationLimits(agentId, entry);
+  const parsed = parseAgentConnectionOperationLimits(agentId2, entry);
   return parsed.ok ? parsed.limits : {
-    agentId,
+    agentId: agentId2,
     unreadable: true
   };
 }
@@ -3034,9 +3220,9 @@ function evalCaseThreadId(runId, caseId) {
 }
 __name(evalCaseThreadId, "evalCaseThreadId");
 __name3(evalCaseThreadId, "evalCaseThreadId");
-function evalMonthlyCapKey(agentId, at = /* @__PURE__ */ new Date()) {
+function evalMonthlyCapKey(agentId2, at = /* @__PURE__ */ new Date()) {
   const yyyymm = `${at.getUTCFullYear()}${String(at.getUTCMonth() + 1).padStart(2, "0")}`;
-  return `evalcap:${agentId}:${yyyymm}`;
+  return `evalcap:${agentId2}:${yyyymm}`;
 }
 __name(evalMonthlyCapKey, "evalMonthlyCapKey");
 __name3(evalMonthlyCapKey, "evalMonthlyCapKey");
@@ -3141,8 +3327,8 @@ function normalizedHandoverName(name) {
 }
 __name(normalizedHandoverName, "normalizedHandoverName");
 __name3(normalizedHandoverName, "normalizedHandoverName");
-function handoverAgentIdSuffix(agentId) {
-  return agentId.slice(-6);
+function handoverAgentIdSuffix(agentId2) {
+  return agentId2.slice(-6);
 }
 __name(handoverAgentIdSuffix, "handoverAgentIdSuffix");
 __name3(handoverAgentIdSuffix, "handoverAgentIdSuffix");
@@ -3589,11 +3775,11 @@ function parseThreadFollowUpInput(input) {
 }
 __name(parseThreadFollowUpInput, "parseThreadFollowUpInput");
 __name3(parseThreadFollowUpInput, "parseThreadFollowUpInput");
-function threadFollowUpRateKeys(agentId, threadId, nowMs) {
+function threadFollowUpRateKeys(agentId2, threadId, nowMs) {
   const hour = Math.floor(nowMs / 36e5);
   return {
-    perThread: `thread-followup:${agentId}:${threadId}:${hour}`,
-    perAgent: `thread-followup:${agentId}:${hour}`
+    perThread: `thread-followup:${agentId2}:${threadId}:${hour}`,
+    perAgent: `thread-followup:${agentId2}:${hour}`
   };
 }
 __name(threadFollowUpRateKeys, "threadFollowUpRateKeys");
@@ -4163,6 +4349,26 @@ var CHANNEL_SETTING_GROUPS = {
   welcome: "Welcome and Home page",
   takeover: "Human takeover"
 };
+var THREAD_SCOPING_NOUN = {
+  front: "Front conversation",
+  messagebird: "MessageBird conversation",
+  imessage: "iMessage chat"
+};
+function threadScopingSetting(type) {
+  const noun = THREAD_SCOPING_NOUN[type];
+  return {
+    key: `${type}.threadScoping`,
+    group: "conversations",
+    label: `One conversation per ${noun}`,
+    help: `Each ${noun} is its own conversation with its own history.`,
+    effect: "Off: every message from the same person shares one conversation.",
+    type: "boolean",
+    default: false,
+    confirm: "Changing this starts fresh conversations for ones that are already open. Earlier history isn't carried over."
+  };
+}
+__name(threadScopingSetting, "threadScopingSetting");
+__name3(threadScopingSetting, "threadScopingSetting");
 var TAKEOVER_CHANNEL_TYPES = [
   "whatsapp",
   "instagram",
@@ -4469,7 +4675,10 @@ var SLACK_SETTINGS = [
 var CHANNEL_SETTINGS = {
   ...Object.fromEntries(TAKEOVER_CHANNEL_TYPES.map((type) => [
     type,
-    type === "email" ? EMAIL_SETTINGS : takeoverSettings(type)
+    type === "email" ? EMAIL_SETTINGS : type === "front" || type === "messagebird" || type === "imessage" ? [
+      ...takeoverSettings(type),
+      threadScopingSetting(type)
+    ] : takeoverSettings(type)
   ])),
   slack: SLACK_SETTINGS
 };
@@ -8145,6 +8354,12 @@ function workflowOrgSlotKey(orgId, kind) {
 __name(workflowOrgSlotKey, "workflowOrgSlotKey");
 __name3(workflowOrgSlotKey, "workflowOrgSlotKey");
 var WORKFLOW_CONNECTION_KEY_RE = /^[a-z][a-z0-9_-]{0,63}$/;
+var WORKFLOW_AGENT_APP_CONNECTION_PREFIX = "agentapp_";
+function isWorkflowAgentAppConnectionId(id2) {
+  return typeof id2 === "string" && id2.startsWith(WORKFLOW_AGENT_APP_CONNECTION_PREFIX) && /^[A-Za-z0-9_-]{1,128}$/.test(id2);
+}
+__name(isWorkflowAgentAppConnectionId, "isWorkflowAgentAppConnectionId");
+__name3(isWorkflowAgentAppConnectionId, "isWorkflowAgentAppConnectionId");
 var WORKFLOW_JOB_MODEL_SOURCE_LABELS = {
   stamp: "lease stamp",
   initData: "run input",
@@ -8179,6 +8394,7 @@ var WORKFLOW_RUN_NOTIFICATION_SUSPENDED_KINDS = [
   ...WORKFLOW_RUN_GATE_KINDS
 ];
 var WORKFLOW_SIGNAL_PAYLOAD_MAX_BYTES = 64 * 1024;
+var WORKFLOW_SIGNAL_NAME_RE = /^[a-zA-Z0-9_.-]{1,64}$/;
 var WORKFLOW_SUSPEND_DEFAULT_TIMEOUT_HOURS = 168;
 var WORKFLOW_RESOLVE_OUTPUT_MAX_BYTES = 256 * 1024;
 var SCHEDULE_HEALTH_NOTIFY_CHANNELS = [
@@ -8385,8 +8601,8 @@ function scheduleHealthView(health, state3) {
 }
 __name(scheduleHealthView, "scheduleHealthView");
 __name3(scheduleHealthView, "scheduleHealthView");
-function scheduleHealthSourceId(agentId, jobId) {
-  return `schedule-health:${agentId}:${jobId}`;
+function scheduleHealthSourceId(agentId2, jobId) {
+  return `schedule-health:${agentId2}:${jobId}`;
 }
 __name(scheduleHealthSourceId, "scheduleHealthSourceId");
 __name3(scheduleHealthSourceId, "scheduleHealthSourceId");
@@ -9745,7 +9961,7 @@ function evidenceDays(from, to) {
 __name(evidenceDays, "evidenceDays");
 __name3(evidenceDays, "evidenceDays");
 function summarizeEvidence(input) {
-  const { agentId, from, to } = input;
+  const { agentId: agentId2, from, to } = input;
   const windowDays = evidenceDays(from, to);
   const readable = /* @__PURE__ */ __name3((s) => s === "ok" || s === "empty", "readable");
   const covered = /* @__PURE__ */ __name3((d) => readable(d.sources?.messages) && readable(d.sources?.analyses), "covered");
@@ -9819,7 +10035,7 @@ function summarizeEvidence(input) {
   const short = wordRows.reduce((a, h) => a + h.short, 0);
   const long = wordRows.reduce((a, h) => a + h.long, 0);
   return {
-    agentId,
+    agentId: agentId2,
     window: {
       from,
       to,
@@ -10577,7 +10793,7 @@ function classifyConnectionOperation(op) {
 __name(classifyConnectionOperation, "classifyConnectionOperation");
 __name3(classifyConnectionOperation, "classifyConnectionOperation");
 function connectionSendPolicyIsActive(policy) {
-  return Boolean(policy) && (policy.allowSend === false || Array.isArray(policy.recipientAllowlist));
+  return !!policy && (policy.allowSend === false || Array.isArray(policy.recipientAllowlist));
 }
 __name(connectionSendPolicyIsActive, "connectionSendPolicyIsActive");
 __name3(connectionSendPolicyIsActive, "connectionSendPolicyIsActive");
@@ -10613,8 +10829,9 @@ function evaluateConnectionSendPolicy(policy, op) {
       classification
     };
   }
-  if (Array.isArray(policy.recipientAllowlist)) {
-    const denied = classification.recipients.filter((email) => !allowlistAdmits(policy.recipientAllowlist, email));
+  const allowlist = policy.recipientAllowlist;
+  if (Array.isArray(allowlist)) {
+    const denied = classification.recipients.filter((email) => !allowlistAdmits(allowlist, email));
     if (denied.length > 0 || classification.recipientsUnknown) {
       return {
         allowed: false,
@@ -10668,10 +10885,605 @@ function isPaymentRequiredChatErrorEnvelope(data) {
 }
 __name(isPaymentRequiredChatErrorEnvelope, "isPaymentRequiredChatErrorEnvelope");
 __name3(isPaymentRequiredChatErrorEnvelope, "isPaymentRequiredChatErrorEnvelope");
+var CUSTOM_MCP_CONNECTION_ID_PREFIX = "mcp_";
+var CUSTOM_MCP_SOURCE = "custom";
+var CUSTOM_MCP_TRANSPORT = "streamable-http";
+var CUSTOM_MCP_CONNECTION_ID_PATTERN = /^mcp_[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+function isCustomMcpConnectionId(id2) {
+  return typeof id2 === "string" && id2.startsWith(CUSTOM_MCP_CONNECTION_ID_PREFIX);
+}
+__name(isCustomMcpConnectionId, "isCustomMcpConnectionId");
+__name3(isCustomMcpConnectionId, "isCustomMcpConnectionId");
+var customMcpConnectionIdSchema = z5.string().regex(CUSTOM_MCP_CONNECTION_ID_PATTERN);
+var CONNECTION_BACKED_MCP_SOURCES = [
+  "unifiedto",
+  CUSTOM_MCP_SOURCE
+];
+function isConnectionBackedMcpSource(source) {
+  return typeof source === "string" && CONNECTION_BACKED_MCP_SOURCES.includes(source);
+}
+__name(isConnectionBackedMcpSource, "isConnectionBackedMcpSource");
+__name3(isConnectionBackedMcpSource, "isConnectionBackedMcpSource");
+var CUSTOM_MCP_REFERENCE_ID_PATTERN = /^mcpx_[0-9a-f]{12}$/;
+var customMcpReferenceIdSchema = z5.string().regex(CUSTOM_MCP_REFERENCE_ID_PATTERN);
+function newCustomMcpReferenceId() {
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(6));
+  return `mcpx_${Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+}
+__name(newCustomMcpReferenceId, "newCustomMcpReferenceId");
+__name3(newCustomMcpReferenceId, "newCustomMcpReferenceId");
+var CUSTOM_MCP_AUTH_KINDS = [
+  "none",
+  "headers",
+  "oauth"
+];
+var customMcpAuthKindSchema = z5.enum(CUSTOM_MCP_AUTH_KINDS);
+var CUSTOM_MCP_OAUTH_REGISTRATIONS = [
+  "cimd",
+  "dcr",
+  "manual"
+];
+var customMcpOAuthRegistrationSchema = z5.enum(CUSTOM_MCP_OAUTH_REGISTRATIONS);
+var CUSTOM_MCP_HEALTH_STATES = [
+  "ok",
+  "failing",
+  "needs_sign_in",
+  "auth_rejected"
+];
+var customMcpHealthStateSchema = z5.enum(CUSTOM_MCP_HEALTH_STATES);
+var CUSTOM_MCP_FAILURE_STEPS = [
+  "url",
+  "reach",
+  "auth_challenge",
+  "resource_metadata",
+  "authorization_server_metadata",
+  "pkce",
+  "client_registration",
+  "authorize",
+  "token_exchange",
+  "list_tools"
+];
+var customMcpFailureStepSchema = z5.enum(CUSTOM_MCP_FAILURE_STEPS);
+var CUSTOM_MCP_CONNECT_STEPS = [
+  "url",
+  "reach",
+  "auth_challenge",
+  "list_tools"
+];
+var customMcpConnectStepSchema = z5.enum(CUSTOM_MCP_CONNECT_STEPS);
+var customMcpFailureCodeSchema = z5.string().regex(/^[a-z0-9_]{1,64}$/);
+var WORKFLOW_KEY_MAX_LENGTH = 64;
+function customMcpWorkflowKey(displayName) {
+  const slug = displayName.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  if (!slug) return `s-${fnv1a32(displayName.trim())}`;
+  return (/^[a-z]/.test(slug) ? slug : `s-${slug}`).slice(0, WORKFLOW_KEY_MAX_LENGTH);
+}
+__name(customMcpWorkflowKey, "customMcpWorkflowKey");
+__name3(customMcpWorkflowKey, "customMcpWorkflowKey");
+function fnv1a32(value3) {
+  let hash = 2166136261;
+  for (const char of value3) {
+    hash ^= char.codePointAt(0) ?? 0;
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+__name(fnv1a32, "fnv1a32");
+__name3(fnv1a32, "fnv1a32");
+var CUSTOM_MCP_URL_MAX_LENGTH = 2048;
+var CUSTOM_MCP_DISPLAY_NAME_MAX_LENGTH = 120;
+var CUSTOM_MCP_MAX_HEADERS = 20;
+var CUSTOM_MCP_HEADER_NAME_MAX_LENGTH = 128;
+var CUSTOM_MCP_HEADER_VALUE_MAX_LENGTH = 8192;
+var CUSTOM_MCP_MAX_TOOLS = 500;
+var CUSTOM_MCP_TOOL_NAME_MAX_LENGTH = 256;
+var CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH = 1024;
+var CUSTOM_MCP_MIN_TIMEOUT_MS = 1e3;
+var CUSTOM_MCP_MAX_TIMEOUT_MS = 12e4;
+var CUSTOM_MCP_OAUTH_PENDING_TTL_MS = 15 * 6e4;
+var isoDateTime = z5.string().datetime({
+  offset: true
+});
+var agentId = z5.string().min(1).max(128);
+var nonNegativeInt = z5.number().int().min(0);
+var customMcpUrlInputSchema = z5.string().trim().min(1).max(CUSTOM_MCP_URL_MAX_LENGTH);
+var customMcpDisplayNameSchema = z5.string().trim().min(1).max(CUSTOM_MCP_DISPLAY_NAME_MAX_LENGTH);
+var customMcpTimeoutSchema = z5.number().int().min(CUSTOM_MCP_MIN_TIMEOUT_MS).max(CUSTOM_MCP_MAX_TIMEOUT_MS);
+var CUSTOM_MCP_RESERVED_HEADER_NAMES = [
+  "accept",
+  "connection",
+  "content-length",
+  "content-type",
+  "host",
+  "keep-alive",
+  "last-event-id",
+  "mcp-protocol-version",
+  "mcp-session-id",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+];
+var HEADER_NAME = /^[A-Za-z][A-Za-z0-9!#$%&'*+.^_`|~-]*$/;
+var HEADER_VALUE_FORBIDDEN = /[\u0000-\u0008\u000a-\u001f\u007f]/;
+var customMcpHeaderNameSchema = z5.string().min(1).max(CUSTOM_MCP_HEADER_NAME_MAX_LENGTH).regex(HEADER_NAME, "Not a valid HTTP header name").refine((name) => !CUSTOM_MCP_RESERVED_HEADER_NAMES.includes(name.toLowerCase()), "This header is set by Lua");
+var headerValue = z5.string().min(1).max(CUSTOM_MCP_HEADER_VALUE_MAX_LENGTH).refine((value3) => !HEADER_VALUE_FORBIDDEN.test(value3), "Header values cannot contain line breaks");
+function addCaseDuplicateIssues(names, ctx, path) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const name of names) {
+    const lower2 = name.toLowerCase();
+    if (seen.has(lower2)) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path,
+        message: `Header "${name}" is listed twice`
+      });
+    }
+    seen.add(lower2);
+  }
+}
+__name(addCaseDuplicateIssues, "addCaseDuplicateIssues");
+__name3(addCaseDuplicateIssues, "addCaseDuplicateIssues");
+var customMcpHeadersSchema = z5.record(customMcpHeaderNameSchema, headerValue).superRefine((headers, ctx) => {
+  const names = Object.keys(headers);
+  if (names.length > CUSTOM_MCP_MAX_HEADERS) {
+    ctx.addIssue({
+      code: z5.ZodIssueCode.custom,
+      message: `At most ${CUSTOM_MCP_MAX_HEADERS} headers`
+    });
+  }
+  addCaseDuplicateIssues(names, ctx, []);
+});
+var customMcpHeadersPatchSchema = z5.object({
+  set: customMcpHeadersSchema.optional(),
+  remove: z5.array(customMcpHeaderNameSchema).max(CUSTOM_MCP_MAX_HEADERS).optional()
+}).strict().superRefine((patch, ctx) => {
+  const set = Object.keys(patch.set ?? {});
+  const remove = patch.remove ?? [];
+  if (!set.length && !remove.length) {
+    ctx.addIssue({
+      code: z5.ZodIssueCode.custom,
+      message: "Nothing to change"
+    });
+  }
+  addCaseDuplicateIssues(remove, ctx, [
+    "remove"
+  ]);
+  const setLower = new Set(set.map((name) => name.toLowerCase()));
+  for (const name of remove) {
+    if (setLower.has(name.toLowerCase())) {
+      ctx.addIssue({
+        code: z5.ZodIssueCode.custom,
+        path: [
+          "remove"
+        ],
+        message: `Header "${name}" is both set and removed`
+      });
+    }
+  }
+});
+var customMcpToolNameSchema = z5.string().min(1).max(CUSTOM_MCP_TOOL_NAME_MAX_LENGTH);
+var customMcpToolSchema = z5.object({
+  name: customMcpToolNameSchema,
+  title: z5.string().max(CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH).optional(),
+  description: z5.string().max(CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH).optional()
+});
+var customMcpServerInfoSchema = z5.object({
+  name: z5.string().max(CUSTOM_MCP_TOOL_NAME_MAX_LENGTH),
+  version: z5.string().max(128).optional(),
+  title: z5.string().max(CUSTOM_MCP_TOOL_NAME_MAX_LENGTH).optional()
+});
+function toCustomMcpToolSnapshot(tools) {
+  const snapshot = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    if (snapshot.length >= CUSTOM_MCP_MAX_TOOLS) break;
+    const name = tool.name;
+    if (typeof name !== "string" || !name || name.length > CUSTOM_MCP_TOOL_NAME_MAX_LENGTH || seen.has(name)) continue;
+    seen.add(name);
+    snapshot.push({
+      name,
+      ...typeof tool.title === "string" && tool.title ? {
+        title: tool.title.slice(0, CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH)
+      } : {},
+      ...typeof tool.description === "string" && tool.description ? {
+        description: tool.description.slice(0, CUSTOM_MCP_TOOL_TEXT_MAX_LENGTH)
+      } : {}
+    });
+  }
+  return snapshot;
+}
+__name(toCustomMcpToolSnapshot, "toCustomMcpToolSnapshot");
+__name3(toCustomMcpToolSnapshot, "toCustomMcpToolSnapshot");
+var customMcpToolSelectionSchema = z5.object({
+  allowAll: z5.boolean(),
+  enabled: z5.array(customMcpToolNameSchema).max(CUSTOM_MCP_MAX_TOOLS)
+}).strict().refine((selection) => new Set(selection.enabled).size === selection.enabled.length, {
+  path: [
+    "enabled"
+  ],
+  message: "Tool names must be unique"
+});
+function customMcpRuntimeToolFilter(selection) {
+  return selection.allowAll ? void 0 : {
+    allow: [
+      ...selection.enabled
+    ]
+  };
+}
+__name(customMcpRuntimeToolFilter, "customMcpRuntimeToolFilter");
+__name3(customMcpRuntimeToolFilter, "customMcpRuntimeToolFilter");
+var customMcpToolsResponseSchema = z5.object({
+  allowAll: z5.boolean(),
+  tools: z5.array(customMcpToolSchema.extend({
+    enabled: z5.boolean()
+  })),
+  serverInfo: customMcpServerInfoSchema.optional(),
+  refreshedAt: isoDateTime.optional()
+});
+var customMcpFailureSchema = z5.object({
+  step: customMcpFailureStepSchema,
+  code: customMcpFailureCodeSchema,
+  /** Plain words for the person connecting. */
+  message: z5.string().max(500),
+  httpStatus: z5.number().int().min(100).max(599).optional(),
+  referenceId: customMcpReferenceIdSchema
+});
+var customMcpHealthSchema = z5.object({
+  state: customMcpHealthStateSchema,
+  checkedAt: isoDateTime.optional(),
+  lastOkAt: isoDateTime.optional(),
+  lastFailureAt: isoDateTime.optional(),
+  consecutiveFailures: nonNegativeInt,
+  lastFailure: customMcpFailureSchema.omit({
+    message: true
+  }).optional()
+});
+var customMcpErrorBodySchema = z5.object({
+  code: z5.string(),
+  message: z5.string(),
+  failure: customMcpFailureSchema.optional(),
+  callbackUrl: z5.string().url().optional(),
+  retryAfterSeconds: z5.number().int().positive().optional()
+});
+var customMcpConnectionBlockSchema = z5.object({
+  authKind: customMcpAuthKindSchema,
+  /** `URL.host`, port included. */
+  host: z5.string(),
+  /** Host plus a masked path; never the URL. */
+  urlDisplay: z5.string(),
+  /** Names only, for the edit form. Present on `headers` connections. */
+  headerNames: z5.array(z5.string()).optional(),
+  /** The workflow connection key that names this server: {@link customMcpWorkflowKey} of its display name. */
+  workflowKey: z5.string().regex(WORKFLOW_CONNECTION_KEY_RE).optional(),
+  health: customMcpHealthSchema,
+  toolCount: nonNegativeInt,
+  enabledToolCount: nonNegativeInt
+});
+var customMcpConnectionViewSchema = z5.object({
+  id: customMcpConnectionIdSchema,
+  displayName: z5.string(),
+  ownerType: z5.enum([
+    "user",
+    "agent"
+  ]),
+  agentId: z5.string().optional(),
+  customMcp: customMcpConnectionBlockSchema
+});
+var customMcpConnectionResponseSchema = z5.object({
+  connection: customMcpConnectionViewSchema
+});
+var customMcpProbeBodySchema = z5.object({
+  url: customMcpUrlInputSchema,
+  headers: customMcpHeadersSchema.optional()
+}).strict();
+var customMcpOAuthDiscoverySchema = z5.object({
+  issuer: z5.string().url(),
+  scopes: z5.array(z5.string()),
+  /** `manual_required`: neither CIMD nor DCR; the person registers a client with `callbackUrl`. */
+  registration: z5.enum([
+    "cimd",
+    "dcr",
+    "manual_required"
+  ]),
+  callbackUrl: z5.string().url()
+});
+var customMcpProbeResponseSchema = z5.discriminatedUnion("outcome", [
+  z5.object({
+    outcome: z5.literal("connected"),
+    authKind: z5.enum([
+      "none",
+      "headers"
+    ]),
+    serverInfo: customMcpServerInfoSchema,
+    tools: z5.array(customMcpToolSchema)
+  }),
+  /** The server challenged and publishes usable OAuth metadata. */
+  z5.object({
+    outcome: z5.literal("sign_in_required"),
+    oauth: customMcpOAuthDiscoverySchema
+  }),
+  /** The server challenged without usable OAuth and no headers were sent. */
+  z5.object({
+    outcome: z5.literal("credentials_required"),
+    httpStatus: z5.number().int()
+  })
+]);
+var createFields = {
+  url: customMcpUrlInputSchema,
+  displayName: customMcpDisplayNameSchema,
+  timeout: customMcpTimeoutSchema.optional(),
+  /** Defaults to allow-all. */
+  tools: customMcpToolSelectionSchema.optional()
+};
+var mountAgentField = {
+  mountAgentId: agentId.optional()
+};
+function createBody(extra) {
+  return z5.discriminatedUnion("authKind", [
+    z5.object({
+      authKind: z5.literal("none"),
+      ...createFields,
+      ...extra
+    }).strict(),
+    z5.object({
+      authKind: z5.literal("headers"),
+      headers: customMcpHeadersSchema.refine((headers) => Object.keys(headers).length > 0, "Add a header"),
+      ...createFields,
+      ...extra
+    }).strict()
+  ]);
+}
+__name(createBody, "createBody");
+__name3(createBody, "createBody");
+var customMcpCreateAgentBodySchema = createBody({});
+var customMcpCreateUserBodySchema = createBody(mountAgentField);
+var customMcpOAuthClientSchema = z5.object({
+  clientId: z5.string().trim().min(1).max(512),
+  clientSecret: z5.string().min(1).max(2048).optional()
+}).strict();
+var startFields = {
+  successRedirect: z5.string().max(CUSTOM_MCP_URL_MAX_LENGTH),
+  failureRedirect: z5.string().max(CUSTOM_MCP_URL_MAX_LENGTH),
+  state: z5.string().max(256),
+  client: customMcpOAuthClientSchema.optional()
+};
+function startBody(extra) {
+  return z5.union([
+    z5.object({
+      url: customMcpUrlInputSchema,
+      displayName: customMcpDisplayNameSchema,
+      ...startFields,
+      ...extra
+    }).strict(),
+    /** Sign in again. `url` only after `REAUTH_REQUIRED`; otherwise the stored URL is used. */
+    z5.object({
+      targetConnectionId: customMcpConnectionIdSchema,
+      url: customMcpUrlInputSchema.optional(),
+      ...startFields
+    }).strict()
+  ]);
+}
+__name(startBody, "startBody");
+__name3(startBody, "startBody");
+var customMcpOAuthStartAgentBodySchema = startBody({});
+var customMcpOAuthStartUserBodySchema = startBody(mountAgentField);
+var customMcpOAuthStartResponseSchema = z5.object({
+  authUrl: z5.string().url(),
+  pendingId: z5.string().min(1),
+  expiresAt: isoDateTime,
+  registration: customMcpOAuthRegistrationSchema
+});
+var nonce = z5.string().regex(/^[A-Za-z0-9_-]{32,128}$/);
+var customMcpOAuthSuccessRedirectQuerySchema = z5.object({
+  state: z5.string(),
+  id: z5.string().min(1),
+  nonce
+});
+var CUSTOM_MCP_OAUTH_CALLBACK_ERRORS = [
+  "access_denied",
+  "authorize",
+  "token_exchange",
+  "expired"
+];
+var customMcpOAuthFailureRedirectQuerySchema = z5.object({
+  state: z5.string(),
+  error: z5.enum(CUSTOM_MCP_OAUTH_CALLBACK_ERRORS),
+  ref: customMcpReferenceIdSchema
+});
+var customMcpOAuthFinalizeBodySchema = z5.object({
+  pendingId: z5.string().min(1).max(128),
+  nonce,
+  tools: customMcpToolSelectionSchema.optional()
+}).strict();
+var customMcpCimdDocumentSchema = z5.object({
+  client_id: z5.string().url(),
+  client_name: z5.string(),
+  client_uri: z5.string().url().optional(),
+  logo_uri: z5.string().url().optional(),
+  redirect_uris: z5.array(z5.string().url()).min(1),
+  grant_types: z5.array(z5.enum([
+    "authorization_code",
+    "refresh_token"
+  ])),
+  response_types: z5.array(z5.literal("code")),
+  token_endpoint_auth_method: z5.literal("none")
+});
+var customMcpPatchBodySchema = z5.object({
+  displayName: customMcpDisplayNameSchema.optional(),
+  url: customMcpUrlInputSchema.optional(),
+  headers: customMcpHeadersPatchSchema.optional(),
+  timeout: customMcpTimeoutSchema.optional()
+}).strict().refine((body) => Object.values(body).some((value3) => value3 !== void 0), {
+  message: "Nothing to change"
+});
+var customMcpCredentialRequestSchema = z5.object({
+  mode: z5.enum([
+    "mount",
+    "room_personal"
+  ]),
+  connectionId: customMcpConnectionIdSchema,
+  agentId,
+  /** The server rejected this token version: refresh unless it is already stale. */
+  rejectedTokenVersion: nonNegativeInt.optional()
+}).strict();
+var customMcpCredentialAuthSchema = z5.discriminatedUnion("kind", [
+  z5.object({
+    kind: z5.literal("none")
+  }),
+  z5.object({
+    kind: z5.literal("headers"),
+    headers: z5.record(z5.string(), z5.string())
+  }),
+  z5.object({
+    kind: z5.literal("oauth"),
+    accessToken: z5.string().min(1),
+    tokenVersion: nonNegativeInt,
+    /** At least {@link CUSTOM_MCP_ACCESS_TOKEN_MIN_REMAINING_MS} away. */
+    expiresAt: isoDateTime
+  })
+]);
+var customMcpCredentialResponseSchema = z5.object({
+  connectionId: customMcpConnectionIdSchema,
+  credentialGeneration: nonNegativeInt,
+  url: z5.string().url(),
+  auth: customMcpCredentialAuthSchema
+});
+var CUSTOM_MCP_CREDENTIAL_ERRORS = {
+  /** 403. Not mounted on this agent, or the room grant is no longer current. */
+  NOT_MOUNTED: "NOT_MOUNTED",
+  /** 404. */
+  NOT_FOUND: "NOT_FOUND",
+  /** 409. Paused by its owner. */
+  PAUSED: "PAUSED",
+  /** 409. The refresh token is gone or was refused; the owner must sign in again. */
+  NEEDS_SIGN_IN: "NEEDS_SIGN_IN",
+  /** 503. The token endpoint failed; retry later. */
+  REFRESH_UNAVAILABLE: "REFRESH_UNAVAILABLE"
+};
+var customMcpCredentialErrorBodySchema = z5.object({
+  code: z5.nativeEnum(CUSTOM_MCP_CREDENTIAL_ERRORS),
+  message: z5.string()
+});
+var customMcpHealthReportSchema = z5.object({
+  reports: z5.array(z5.object({
+    connectionId: customMcpConnectionIdSchema,
+    agentId,
+    credentialGeneration: nonNegativeInt,
+    tokenVersion: nonNegativeInt.optional(),
+    outcome: z5.enum([
+      "ok",
+      "failure"
+    ]),
+    failure: z5.object({
+      step: customMcpConnectStepSchema,
+      code: customMcpFailureCodeSchema,
+      httpStatus: z5.number().int().min(100).max(599).optional(),
+      referenceId: customMcpReferenceIdSchema
+    }).strict().optional(),
+    observedAt: isoDateTime
+  }).strict().refine((report) => report.outcome === "failure" === (report.failure !== void 0), {
+    path: [
+      "failure"
+    ],
+    message: "A failure report carries `failure`; an ok report does not"
+  })).min(1).max(50)
+}).strict();
+var customMcpProbeRequestSchema = z5.object({
+  url: z5.string().url().max(CUSTOM_MCP_URL_MAX_LENGTH),
+  auth: z5.discriminatedUnion("kind", [
+    z5.object({
+      kind: z5.literal("none")
+    }).strict(),
+    z5.object({
+      kind: z5.literal("headers"),
+      headers: customMcpHeadersSchema
+    }).strict(),
+    z5.object({
+      kind: z5.literal("bearer"),
+      accessToken: z5.string().min(1)
+    }).strict()
+  ]),
+  timeout: customMcpTimeoutSchema.optional(),
+  referenceId: customMcpReferenceIdSchema
+}).strict();
+var customMcpProbeResultSchema = z5.discriminatedUnion("ok", [
+  z5.object({
+    ok: z5.literal(true),
+    serverInfo: customMcpServerInfoSchema,
+    tools: z5.array(customMcpToolSchema).max(CUSTOM_MCP_MAX_TOOLS),
+    protocolVersion: z5.string().optional()
+  }),
+  z5.object({
+    ok: z5.literal(false),
+    step: customMcpConnectStepSchema,
+    code: customMcpFailureCodeSchema,
+    httpStatus: z5.number().int().min(100).max(599).optional(),
+    /** The 401/403 challenge, raw, for lua-api's OAuth discovery. */
+    wwwAuthenticate: z5.string().max(4096).optional()
+  })
+]);
+var customMcpOriginUrlSchema = z5.string().url().refine((value3) => {
+  try {
+    const url = new URL(value3);
+    return url.protocol === "https:" && url.pathname === "/" && !url.search && !url.hash && !url.username && !url.password;
+  } catch {
+    return false;
+  }
+}, "Origin only");
+var customMcpServerProjectionSchema = z5.object({
+  name: z5.string().min(1),
+  runtimeKey: z5.string().min(1),
+  transport: z5.literal(CUSTOM_MCP_TRANSPORT),
+  source: z5.literal(CUSTOM_MCP_SOURCE),
+  url: customMcpOriginUrlSchema,
+  connectionId: customMcpConnectionIdSchema,
+  connectionLabel: z5.string(),
+  /** The connection's owner kind, for the dashboard's "Personal" label. */
+  ownerType: z5.enum([
+    "user",
+    "agent"
+  ]),
+  authKind: customMcpAuthKindSchema,
+  credentialGeneration: nonNegativeInt,
+  tools: z5.object({
+    allow: z5.array(z5.string())
+  }).optional(),
+  timeout: z5.number().int().positive()
+});
+var customMcpMountUpsertBodySchema = z5.object({
+  source: z5.literal(CUSTOM_MCP_SOURCE),
+  transport: z5.literal(CUSTOM_MCP_TRANSPORT),
+  url: customMcpOriginUrlSchema,
+  connectionId: customMcpConnectionIdSchema,
+  connectionLabel: z5.string(),
+  ownerType: z5.enum([
+    "user",
+    "agent"
+  ]),
+  authKind: customMcpAuthKindSchema,
+  credentialGeneration: nonNegativeInt,
+  tools: z5.object({
+    allow: z5.array(customMcpToolNameSchema).max(CUSTOM_MCP_MAX_TOOLS)
+  }).strict().optional(),
+  timeout: customMcpTimeoutSchema.optional()
+}).strict();
+function maskMcpServerHeaders(server) {
+  const { headers, ...rest } = server;
+  const headerNames = Object.keys(headers ?? {});
+  return {
+    ...rest,
+    headerNames,
+    headersSet: headerNames.length > 0
+  };
+}
+__name(maskMcpServerHeaders, "maskMcpServerHeaders");
+__name3(maskMcpServerHeaders, "maskMcpServerHeaders");
 
 // ../workflow-graph/dist/index.mjs
 import { createHash } from "crypto";
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 import { z as z22 } from "zod";
 import { createHash as createHash2 } from "crypto";
 var __defProp4 = Object.defineProperty;
@@ -10966,8 +11778,8 @@ var rows = /* @__PURE__ */ __name4((s, path, page) => ({
 var fromKnowledge = /* @__PURE__ */ __name4((k) => ({
   knowledge: k
 }), "fromKnowledge");
-var SideEffectsSchema = z5.enum(WORKFLOW_SIDE_EFFECTS);
-var JobResourcesSchema = z5.enum(WORKFLOW_JOB_RESOURCES);
+var SideEffectsSchema = z6.enum(WORKFLOW_SIDE_EFFECTS);
+var JobResourcesSchema = z6.enum(WORKFLOW_JOB_RESOURCES);
 var WORKFLOW_MODEL_TEMPLATE_ROOT = "initData";
 var WORKFLOW_MODEL_TEMPLATE_RE = /^\$\{\s*initData\.([A-Za-z0-9_.\-[\]]+)\s*(?:\|([^}]*))?\}$/;
 var PATH_SEGMENT_RE = /^[A-Za-z0-9_-]+(?:\[(?:0|[1-9]\d*)\])*$/;
@@ -11309,6 +12121,8 @@ __name(validateApproverBlock, "validateApproverBlock");
 __name4(validateApproverBlock, "validateApproverBlock");
 var APPROVAL_REMIND_AFTER_HOURS_MIN = 1;
 var APPROVAL_REMIND_AFTER_HOURS_MAX = 720;
+var APPROVAL_TIMEOUT_HOURS_MIN = 1;
+var APPROVAL_TIMEOUT_HOURS_MAX = 720;
 function validateApprovalReminder(node, path) {
   if (node.remindAfterHours === void 0) return [];
   const h = node.remindAfterHours;
@@ -11338,6 +12152,21 @@ function validateApprovalReminder(node, path) {
 }
 __name(validateApprovalReminder, "validateApprovalReminder");
 __name4(validateApprovalReminder, "validateApprovalReminder");
+function validateHitlTimeoutHours(node, path) {
+  const h = node.timeoutHours;
+  if (typeof h !== "number") return [];
+  if (Number.isFinite(h) && h >= APPROVAL_TIMEOUT_HOURS_MIN && h <= APPROVAL_TIMEOUT_HOURS_MAX) return [];
+  return [
+    {
+      code: "timeout-hours-out-of-range",
+      path: `${path}.timeoutHours`,
+      severity: "error",
+      message: `timeoutHours must be a number of hours in [${APPROVAL_TIMEOUT_HOURS_MIN}, ${APPROVAL_TIMEOUT_HOURS_MAX}] (got ${h})`
+    }
+  ];
+}
+__name(validateHitlTimeoutHours, "validateHitlTimeoutHours");
+__name4(validateHitlTimeoutHours, "validateHitlTimeoutHours");
 function firstAskDeadline(node) {
   const head = Array.isArray(node.onTimeout) ? node.onTimeout[0] : node.onTimeout;
   if (typeof head === "object" && head !== null && "escalateTo" in head) {
@@ -11426,6 +12255,11 @@ function sleepUntilUnsupportedMessage(id2) {
 }
 __name(sleepUntilUnsupportedMessage, "sleepUntilUnsupportedMessage");
 __name4(sleepUntilUnsupportedMessage, "sleepUntilUnsupportedMessage");
+function signalNameInvalidMessage(id2, name) {
+  return `waitForSignal "${id2}" signal "${name}" must match /${WORKFLOW_SIGNAL_NAME_RE.source}/ (the names a delivery accepts)`;
+}
+__name(signalNameInvalidMessage, "signalNameInvalidMessage");
+__name4(signalNameInvalidMessage, "signalNameInvalidMessage");
 function armSubrunUnsupportedMessage(id2, workflowId) {
   return `the engine does not execute the implicit \`${workflowId}\` arm subrun (node "${id2}") \u2014 a [map, step] container arm is the step itself with the map as its \`input\` since lua-cli 3.32.4; re-run \`lua compile\` with the current CLI (a hand-written artifact: put the map on the arm node's \`input\` and drop the \`workflow\` wrapper)`;
 }
@@ -12099,10 +12933,13 @@ function validateLuaExtensions(g, caps = WORKFLOW_CAPS_DEFAULT, opts = {
       const w = node;
       checkId(w.id, path);
       if (typeof w.signal !== "string" || w.signal.length === 0) err("invalid-envelope", "waitForSignal.signal is required", `${path}.signal`, w.id);
+      else if (!WORKFLOW_SIGNAL_NAME_RE.test(w.signal)) err("signal-name-invalid", signalNameInvalidMessage(w.id, w.signal), `${path}.signal`, w.id);
+      for (const r of validateHitlTimeoutHours(w, path)) err(r.code, r.message, r.path, w.id);
       return;
     }
     const a = node;
     checkId(a.id, path);
+    for (const r of validateHitlTimeoutHours(a, path)) err(r.code, r.message, r.path, a.id);
     if ((a.approver ?? "creator") === "creator" && a.excludeInitiator === true) {
       err("approver-excludes-only-candidate", "approver:'creator' with excludeInitiator:true always excludes the only candidate", path, a.id);
     }
@@ -15848,6 +16685,9 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     for (const r of validateApprovalReminder(opts, `approval("${id2}")`)) {
       if (r.severity === "error") throw new LuaWorkflowBuildError("remind-after-invalid", `"${id2}": ${r.message}`);
     }
+    for (const r of validateHitlTimeoutHours(opts, `approval("${id2}")`)) {
+      throw new LuaWorkflowBuildError("timeout-hours-out-of-range", `"${id2}": ${r.message}`);
+    }
     if (typeof opts.details === "function") throw new LuaWorkflowBuildError("closure-binding", `approval("${id2}").details must be template(...)`);
     this.recordEnvRefs(opts.details, opts.timeoutHours, opts.approver);
     const node = defined({
@@ -15878,6 +16718,10 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
   waitForSignal(id2, opts) {
     this.assertId(id2, "waitForSignal()");
     if (!opts || typeof opts.signal !== "string" || opts.signal.length === 0) throw new LuaWorkflowBuildError("invalid-envelope", `waitForSignal("${id2}") needs a signal name`);
+    if (!WORKFLOW_SIGNAL_NAME_RE.test(opts.signal)) throw new LuaWorkflowBuildError("signal-name-invalid", signalNameInvalidMessage(id2, opts.signal));
+    for (const r of validateHitlTimeoutHours(opts, `waitForSignal("${id2}")`)) {
+      throw new LuaWorkflowBuildError("timeout-hours-out-of-range", `"${id2}": ${r.message}`);
+    }
     this.recordEnvRefs(opts.timeoutHours);
     const node = defined({
       type: "waitForSignal",
@@ -15940,7 +16784,7 @@ var WorkflowBuilderImpl = class WorkflowBuilderImpl2 {
     if (this.mapCount >= 2 && this.unnamedMaps > 0) {
       this.warnings.push({
         code: "map-id-required",
-        message: `${this.unnamedMaps} of ${this.mapCount} map() calls have no explicit id \u2014 positional ids renumber on insert; pass { id } (error at push)`
+        message: `${this.unnamedMaps} of ${this.mapCount} map() calls have no explicit id \u2014 positional ids renumber on insert; pass { id } to every map() to keep step ids stable`
       });
     }
     if (graphHasHitl(graph, this.steps) && this.config.budget?.maxDurationSeconds === void 0) {