lua-cli 3.43.0 → 3.45.0

package/dist/workflow-builder.d.ts

@@ -357,7 +357,11 @@ export declare type LuaWorkflowBuildCode = 'duplicate-step-id' | 'unknown-step-r
 */
 | 'approval-inside-container' | 'node-type-unsupported-in-container' | 'empty-graph' | 'ephemeral-role-too-long' | 'role-ref-and-inline' | 'approver-excludes-only-candidate' | 'four-eyes-requires-editable' | 'escalation-chain-not-terminal' | 'escalation-chain-too-long'
 /** LUA-973: `remindAfterHours` is not a number of hours in 1..720 (`validateApprovalReminder`). */
-| 'remind-after-invalid' | 'editable-path-invalid' | 'env-template-secret-key' | 'invalid-envelope' | 'invalid-step' | 'invalid-step-id' | 'invalid-workflow-name' | 'schedule-input-required' | 'schedule-input-invalid' | 'hitl-duration-defaulted' | 'WORKFLOW_UNPLACED_STEP';
+| 'remind-after-invalid'
+/** BAC-2062: the builder mirror of the BAC-619 validator codes: a `waitForSignal` name a delivery refuses. */
+| 'signal-name-invalid'
+/** BAC-2062: a numeric approval / waitForSignal `timeoutHours` outside 1..720. */
+| 'timeout-hours-out-of-range' | 'editable-path-invalid' | 'env-template-secret-key' | 'invalid-envelope' | 'invalid-step' | 'invalid-step-id' | 'invalid-workflow-name' | 'schedule-input-required' | 'schedule-input-invalid' | 'hitl-duration-defaulted' | 'WORKFLOW_UNPLACED_STEP';
 
 export declare interface LuaWorkflowBuilder {
     then(step: StepRef): this;
@@ -448,7 +452,10 @@ export declare interface LuaWorkflowConfig {
      * marketplace template freezes from this schedule: `'installer'` (the default when absent — every install's
      * fires run as the person who installed, who gets the run card in their inbox) or `'system'` (the frozen copy
      * runs user-less and unwatched — no inbox card for its runs; the install response says so). On this agent the
-     * schedule runs as you either way.
+     * schedule runs as you, unless the platform has enabled author system schedules: then `'system'` makes this
+     * agent's own schedule run as the agent (`system:<agentId>`), like a template copy's, with you recorded as the
+     * deployer who scheduled it (the schedule stops if you lose access to the agent). A manual run ("Run now")
+     * always runs as the person who starts it.
      */
     schedule?: JobSchedule & {
         runAs?: 'installer' | 'system';

package/dist/workflow-builder.js

@@ -548,7 +548,20 @@ 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"
 };
 function isSupervisionOp(op) {
   return typeof op === "string" && Object.prototype.hasOwnProperty.call(SUPERVISION_OPS, op);
@@ -729,8 +742,165 @@ 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"
   }
 };
+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)
@@ -1806,7 +1976,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,
@@ -4163,6 +4335,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 +4661,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 +8340,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 +8380,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 = [
@@ -11309,6 +11511,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 +11542,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 +11645,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 +12323,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 +16075,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 +16108,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 +16174,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) {