@desplega.ai/agent-swarm 1.158.0 → 1.160.0

package/dist/{cli-fgqxwrpv.js → cli-tpq83z89.js}

@@ -9,9 +9,17 @@ import {
 import {
   getApiKey
 } from "./cli-f14fvzag.js";
+import {
+  DEFAULT_MODEL,
+  resolveCredential
+} from "./cli-12tszpk9.js";
+import {
+  DEFAULT_OPENROUTER_BASE_URL,
+  getOpenRouterBaseUrl
+} from "./cli-3dpj7atn.js";
 import {
   embedScript
-} from "./cli-987hg0aa.js";
+} from "./cli-0jwe9034.js";
 import {
   calculatePKCECodeChallenge,
   ensureAuthorizationTokenOrThrow,
@@ -23,11 +31,17 @@ import {
   oauthAppRowToProviderConfig,
   updateAuthorizationTokens,
   upsertAuthorization
-} from "./cli-53sz8gkz.js";
+} from "./cli-6cs6wzxt.js";
+import {
+  getSlackApp
+} from "./cli-azhgzetg.js";
 import {
   CredentialBroker,
   DEFAULT_CREDENTIAL_BINDINGS,
+  claimApprovalCancellationNotification,
+  completeApprovalCancellationNotificationClaim,
   computeContentHash,
+  createTaskExtended,
   decryptSecret,
   encryptSecret,
   getDb,
@@ -36,18 +50,30 @@ import {
   getLeadAgent,
   getMcpServerById,
   getResolvedConfig,
+  getTaskById,
   init_credential_broker,
   init_crypto,
   init_date_utils,
   init_db,
   normalizeDateRequired,
   placeholderForConfigKey,
+  releaseApprovalCancellationNotificationClaim,
   upsertSwarmConfig
-} from "./cli-47m6dkd3.js";
+} from "./cli-qydf22qq.js";
 import {
+  TERMINAL_TASK_STATUSES,
   defaultAssetKey,
-  init_key
-} from "./cli-4198qc9v.js";
+  init_key,
+  init_types
+} from "./cli-ktmyrtpn.js";
+import {
+  init_resolver,
+  resolveTemplate
+} from "./cli-ptr8h7kp.js";
+import {
+  getAppUrl,
+  init_constants
+} from "./cli-dv6cdjs2.js";
 import {
   init_env_flag,
   isEnvFlagEnabled
@@ -351,8 +377,8 @@ var require_luxon = __commonJS(function(exports) {
   }
 
   class InvalidUnitError extends LuxonError {
-    constructor(unit) {
-      super(`Invalid unit ${unit}`);
+    constructor(unit2) {
+      super(`Invalid unit ${unit2}`);
     }
   }
 
@@ -981,16 +1007,16 @@ var require_luxon = __commonJS(function(exports) {
         this.rtf = getCachedRTF(intl, opts);
       }
     }
-    format(count, unit) {
+    format(count, unit2) {
       if (this.rtf) {
-        return this.rtf.format(count, unit);
+        return this.rtf.format(count, unit2);
       } else {
-        return formatRelativeTime(unit, count, this.opts.numeric, this.opts.style !== "long");
+        return formatRelativeTime(unit2, count, this.opts.numeric, this.opts.style !== "long");
       }
     }
-    formatToParts(count, unit) {
+    formatToParts(count, unit2) {
       if (this.rtf) {
-        return this.rtf.formatToParts(count, unit);
+        return this.rtf.formatToParts(count, unit2);
       } else {
         return [];
       }
@@ -1459,8 +1485,8 @@ var require_luxon = __commonJS(function(exports) {
   }
   var nonLeapLadder = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
   var leapLadder = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
-  function unitOutOfRange(unit, value) {
-    return new Invalid("unit out of range", `you specified ${value} (of type ${typeof value}) as a ${unit}, which is invalid`);
+  function unitOutOfRange(unit2, value) {
+    return new Invalid("unit out of range", `you specified ${value} (of type ${typeof value}) as a ${unit2}, which is invalid`);
   }
   function dayOfWeek(year, month, day) {
     const d = new Date(Date.UTC(year, month - 1, day));
@@ -1928,7 +1954,7 @@ var require_luxon = __commonJS(function(exports) {
   function eraForDateTime(dt, length) {
     return eras(length)[dt.year < 0 ? 0 : 1];
   }
-  function formatRelativeTime(unit, count, numeric = "always", narrow = false) {
+  function formatRelativeTime(unit2, count, numeric = "always", narrow = false) {
     const units = {
       years: ["year", "yr."],
       quarters: ["quarter", "qtr."],
@@ -1939,19 +1965,19 @@ var require_luxon = __commonJS(function(exports) {
       minutes: ["minute", "min."],
       seconds: ["second", "sec."]
     };
-    const lastable = ["hours", "minutes", "seconds"].indexOf(unit) === -1;
+    const lastable = ["hours", "minutes", "seconds"].indexOf(unit2) === -1;
     if (numeric === "auto" && lastable) {
-      const isDay = unit === "days";
+      const isDay = unit2 === "days";
       switch (count) {
         case 1:
-          return isDay ? "tomorrow" : `next ${units[unit][0]}`;
+          return isDay ? "tomorrow" : `next ${units[unit2][0]}`;
         case -1:
-          return isDay ? "yesterday" : `last ${units[unit][0]}`;
+          return isDay ? "yesterday" : `last ${units[unit2][0]}`;
         case 0:
-          return isDay ? "today" : `this ${units[unit][0]}`;
+          return isDay ? "today" : `this ${units[unit2][0]}`;
       }
     }
-    const isInPast = Object.is(count, -0) || count < 0, fmtValue = Math.abs(count), singular = fmtValue === 1, lilUnits = units[unit], fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit][0] : unit;
+    const isInPast = Object.is(count, -0) || count < 0, fmtValue = Math.abs(count), singular = fmtValue === 1, lilUnits = units[unit2], fmtUnit = narrow ? singular ? lilUnits[1] : lilUnits[2] || lilUnits[1] : singular ? units[unit2][0] : unit2;
     return isInPast ? `${fmtValue} ${fmtUnit} ago` : `in ${fmtValue} ${fmtUnit}`;
   }
   function stringifyTokens(splits, tokenToString) {
@@ -2612,9 +2638,9 @@ var require_luxon = __commonJS(function(exports) {
   function durationToMillis(matrix, vals) {
     var _vals$milliseconds;
     let sum = (_vals$milliseconds = vals.milliseconds) != null ? _vals$milliseconds : 0;
-    for (const unit of reverseUnits.slice(1)) {
-      if (vals[unit]) {
-        sum += vals[unit] * matrix[unit]["milliseconds"];
+    for (const unit2 of reverseUnits.slice(1)) {
+      if (vals[unit2]) {
+        sum += vals[unit2] * matrix[unit2]["milliseconds"];
       }
     }
     return sum;
@@ -2728,7 +2754,7 @@ var require_luxon = __commonJS(function(exports) {
         });
       }
     }
-    static normalizeUnit(unit) {
+    static normalizeUnit(unit2) {
       const normalized = {
         year: "years",
         years: "years",
@@ -2748,9 +2774,9 @@ var require_luxon = __commonJS(function(exports) {
         seconds: "seconds",
         millisecond: "milliseconds",
         milliseconds: "milliseconds"
-      }[unit ? unit.toLowerCase() : unit];
+      }[unit2 ? unit2.toLowerCase() : unit2];
       if (!normalized)
-        throw new InvalidUnitError(unit);
+        throw new InvalidUnitError(unit2);
       return normalized;
     }
     static isDuration(o) {
@@ -2773,8 +2799,8 @@ var require_luxon = __commonJS(function(exports) {
       if (!this.isValid)
         return INVALID$2;
       const showZeros = opts.showZeros !== false;
-      const l2 = orderedUnits$1.map((unit) => {
-        const val = this.values[unit];
+      const l2 = orderedUnits$1.map((unit2) => {
+        const val = this.values[unit2];
         if (isUndefined(val) || val === 0 && !showZeros) {
           return null;
         }
@@ -2782,7 +2808,7 @@ var require_luxon = __commonJS(function(exports) {
           style: "unit",
           unitDisplay: "long",
           ...opts,
-          unit: unit.slice(0, -1)
+          unit: unit2.slice(0, -1)
         }).format(val);
       }).filter((n2) => n2);
       return this.loc.listFormatter({
@@ -2892,8 +2918,8 @@ var require_luxon = __commonJS(function(exports) {
         values: result
       }, true);
     }
-    get(unit) {
-      return this[Duration.normalizeUnit(unit)];
+    get(unit2) {
+      return this[Duration.normalizeUnit(unit2)];
     }
     set(values) {
       if (!this.isValid)
@@ -2923,8 +2949,8 @@ var require_luxon = __commonJS(function(exports) {
       };
       return clone$1(this, opts);
     }
-    as(unit) {
-      return this.isValid ? this.shiftTo(unit).get(unit) : NaN;
+    as(unit2) {
+      return this.isValid ? this.shiftTo(unit2).get(unit2) : NaN;
     }
     normalize() {
       if (!this.isValid)
@@ -3168,13 +3194,13 @@ var require_luxon = __commonJS(function(exports) {
     get invalidExplanation() {
       return this.invalid ? this.invalid.explanation : null;
     }
-    length(unit = "milliseconds") {
-      return this.isValid ? this.toDuration(...[unit]).get(unit) : NaN;
+    length(unit2 = "milliseconds") {
+      return this.isValid ? this.toDuration(...[unit2]).get(unit2) : NaN;
     }
-    count(unit = "milliseconds", opts) {
+    count(unit2 = "milliseconds", opts) {
       if (!this.isValid)
         return NaN;
-      const start = this.start.startOf(unit, opts);
+      const start = this.start.startOf(unit2, opts);
       let end;
       if (opts != null && opts.useLocaleWeeks) {
         end = this.end.reconfigure({
@@ -3183,11 +3209,11 @@ var require_luxon = __commonJS(function(exports) {
       } else {
         end = this.end;
       }
-      end = end.startOf(unit, opts);
-      return Math.floor(end.diff(start, unit).get(unit)) + (end.valueOf() !== this.end.valueOf());
+      end = end.startOf(unit2, opts);
+      return Math.floor(end.diff(start, unit2).get(unit2)) + (end.valueOf() !== this.end.valueOf());
     }
-    hasSame(unit) {
-      return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit) : false;
+    hasSame(unit2) {
+      return this.isValid ? this.isEmpty() || this.e.minus(1).hasSame(this.s, unit2) : false;
     }
     isEmpty() {
       return this.s.valueOf() === this.e.valueOf();
@@ -3370,11 +3396,11 @@ var require_luxon = __commonJS(function(exports) {
         return INVALID$1;
       return `${this.s.toFormat(dateFormat)}${separator}${this.e.toFormat(dateFormat)}`;
     }
-    toDuration(unit, opts) {
+    toDuration(unit2, opts) {
       if (!this.isValid) {
         return Duration.invalid(this.invalidReason);
       }
-      return this.e.diff(this.s, unit, opts);
+      return this.e.diff(this.s, unit2, opts);
     }
     mapEndpoints(mapFn) {
       return Interval.fromDateTimes(mapFn(this.s), mapFn(this.e));
@@ -3475,17 +3501,17 @@ var require_luxon = __commonJS(function(exports) {
     const results = {};
     const earlier = cursor;
     let lowestOrder, highWater;
-    for (const [unit, differ] of differs) {
-      if (units.indexOf(unit) >= 0) {
-        lowestOrder = unit;
-        results[unit] = differ(cursor, later);
+    for (const [unit2, differ] of differs) {
+      if (units.indexOf(unit2) >= 0) {
+        lowestOrder = unit2;
+        results[unit2] = differ(cursor, later);
         highWater = earlier.plus(results);
         if (highWater > later) {
-          results[unit]--;
+          results[unit2]--;
           cursor = earlier.plus(results);
           if (cursor > later) {
             highWater = cursor;
-            results[unit]--;
+            results[unit2]--;
             cursor = earlier.plus(results);
           }
         } else {
@@ -3670,11 +3696,11 @@ var require_luxon = __commonJS(function(exports) {
           return literal2(t);
       }
     };
-    const unit = unitate(token) || {
+    const unit2 = unitate(token) || {
       invalidReason: MISSING_FTP
     };
-    unit.token = token;
-    return unit;
+    unit2.token = token;
+    return unit2;
   }
   var partTypeStyleToTokenVal = {
     year: {
@@ -4152,7 +4178,7 @@ var require_luxon = __commonJS(function(exports) {
   var orderedUnits = ["year", "month", "day", "hour", "minute", "second", "millisecond"];
   var orderedWeekUnits = ["weekYear", "weekNumber", "weekday", "hour", "minute", "second", "millisecond"];
   var orderedOrdinalUnits = ["year", "ordinal", "hour", "minute", "second", "millisecond"];
-  function normalizeUnit(unit) {
+  function normalizeUnit(unit2) {
     const normalized = {
       year: "year",
       years: "year",
@@ -4178,13 +4204,13 @@ var require_luxon = __commonJS(function(exports) {
       weekyear: "weekYear",
       weekyears: "weekYear",
       ordinal: "ordinal"
-    }[unit.toLowerCase()];
+    }[unit2.toLowerCase()];
     if (!normalized)
-      throw new InvalidUnitError(unit);
+      throw new InvalidUnitError(unit2);
     return normalized;
   }
-  function normalizeUnitWithLocalWeeks(unit) {
-    switch (unit.toLowerCase()) {
+  function normalizeUnitWithLocalWeeks(unit2) {
+    switch (unit2.toLowerCase()) {
       case "localweekday":
       case "localweekdays":
         return "localWeekday";
@@ -4195,7 +4221,7 @@ var require_luxon = __commonJS(function(exports) {
       case "localweekyears":
         return "localWeekYear";
       default:
-        return normalizeUnit(unit);
+        return normalizeUnit(unit2);
     }
   }
   function guessOffsetForZone(zone) {
@@ -4243,27 +4269,27 @@ var require_luxon = __commonJS(function(exports) {
     });
   }
   function diffRelative(start, end, opts) {
-    const round = isUndefined(opts.round) ? true : opts.round, rounding = isUndefined(opts.rounding) ? "trunc" : opts.rounding, format = (c, unit) => {
+    const round = isUndefined(opts.round) ? true : opts.round, rounding = isUndefined(opts.rounding) ? "trunc" : opts.rounding, format = (c, unit2) => {
       c = roundTo(c, round || opts.calendary ? 0 : 2, opts.calendary ? "round" : rounding);
       const formatter = end.loc.clone(opts).relFormatter(opts);
-      return formatter.format(c, unit);
-    }, differ = (unit) => {
+      return formatter.format(c, unit2);
+    }, differ = (unit2) => {
       if (opts.calendary) {
-        if (!end.hasSame(start, unit)) {
-          return end.startOf(unit).diff(start.startOf(unit), unit).get(unit);
+        if (!end.hasSame(start, unit2)) {
+          return end.startOf(unit2).diff(start.startOf(unit2), unit2).get(unit2);
         } else
           return 0;
       } else {
-        return end.diff(start, unit).get(unit);
+        return end.diff(start, unit2).get(unit2);
       }
     };
     if (opts.unit) {
       return format(differ(opts.unit), opts.unit);
     }
-    for (const unit of opts.units) {
-      const count = differ(unit);
+    for (const unit2 of opts.units) {
+      const count = differ(unit2);
       if (Math.abs(count) >= 1) {
-        return format(count, unit);
+        return format(count, unit2);
       }
     }
     return format(start > end ? -0 : 0, opts.units[opts.units.length - 1]);
@@ -4502,8 +4528,8 @@ var require_luxon = __commonJS(function(exports) {
       zoneOffsetTs = undefined;
       zoneOffsetGuessCache.clear();
     }
-    get(unit) {
-      return this[unit];
+    get(unit2) {
+      return this[unit2];
     }
     get isValid() {
       return this.invalid === null;
@@ -4789,12 +4815,12 @@ var require_luxon = __commonJS(function(exports) {
       const dur = Duration.fromDurationLike(duration).negate();
       return clone(this, adjustTime(this, dur));
     }
-    startOf(unit, {
+    startOf(unit2, {
       useLocaleWeeks = false
     } = {}) {
       if (!this.isValid)
         return this;
-      const o = {}, normalizedUnit = Duration.normalizeUnit(unit);
+      const o = {}, normalizedUnit = Duration.normalizeUnit(unit2);
       switch (normalizedUnit) {
         case "years":
           o.month = 1;
@@ -4832,10 +4858,10 @@ var require_luxon = __commonJS(function(exports) {
       }
       return this.set(o);
     }
-    endOf(unit, opts) {
+    endOf(unit2, opts) {
       return this.isValid ? this.plus({
-        [unit]: 1
-      }).startOf(unit, opts).minus(1) : this;
+        [unit2]: 1
+      }).startOf(unit2, opts).minus(1) : this;
     }
     toFormat(fmt, opts = {}) {
       return this.isValid ? Formatter.create(this.loc.redefaultToEN(opts)).formatDateTimeFromString(this, fmt) : INVALID;
@@ -4973,7 +4999,7 @@ var require_luxon = __commonJS(function(exports) {
     toJSDate() {
       return new Date(this.isValid ? this.ts : NaN);
     }
-    diff(otherDateTime, unit = "milliseconds", opts = {}) {
+    diff(otherDateTime, unit2 = "milliseconds", opts = {}) {
       if (!this.isValid || !otherDateTime.isValid) {
         return Duration.invalid("created by diffing an invalid DateTime");
       }
@@ -4982,23 +5008,23 @@ var require_luxon = __commonJS(function(exports) {
         numberingSystem: this.numberingSystem,
         ...opts
       };
-      const units = maybeArray(unit).map(Duration.normalizeUnit), otherIsLater = otherDateTime.valueOf() > this.valueOf(), earlier = otherIsLater ? this : otherDateTime, later = otherIsLater ? otherDateTime : this, diffed = diff(earlier, later, units, durOpts);
+      const units = maybeArray(unit2).map(Duration.normalizeUnit), otherIsLater = otherDateTime.valueOf() > this.valueOf(), earlier = otherIsLater ? this : otherDateTime, later = otherIsLater ? otherDateTime : this, diffed = diff(earlier, later, units, durOpts);
       return otherIsLater ? diffed.negate() : diffed;
     }
-    diffNow(unit = "milliseconds", opts = {}) {
-      return this.diff(DateTime.now(), unit, opts);
+    diffNow(unit2 = "milliseconds", opts = {}) {
+      return this.diff(DateTime.now(), unit2, opts);
     }
     until(otherDateTime) {
       return this.isValid ? Interval.fromDateTimes(this, otherDateTime) : this;
     }
-    hasSame(otherDateTime, unit, opts) {
+    hasSame(otherDateTime, unit2, opts) {
       if (!this.isValid)
         return false;
       const inputMs = otherDateTime.valueOf();
       const adjustedToZone = this.setZone(otherDateTime.zone, {
         keepLocalTime: true
       });
-      return adjustedToZone.startOf(unit, opts) <= inputMs && inputMs <= adjustedToZone.endOf(unit, opts);
+      return adjustedToZone.startOf(unit2, opts) <= inputMs && inputMs <= adjustedToZone.endOf(unit2, opts);
     }
     equals(other) {
       return this.isValid && other.isValid && this.valueOf() === other.valueOf() && this.zone.equals(other.zone) && this.loc.equals(other.loc);
@@ -5010,16 +5036,16 @@ var require_luxon = __commonJS(function(exports) {
         zone: this.zone
       }), padding = options.padding ? this < base ? -options.padding : options.padding : 0;
       let units = ["years", "months", "days", "hours", "minutes", "seconds"];
-      let unit = options.unit;
+      let unit2 = options.unit;
       if (Array.isArray(options.unit)) {
         units = options.unit;
-        unit = undefined;
+        unit2 = undefined;
       }
       return diffRelative(base, this.plus(padding), {
         ...options,
         numeric: "always",
         units,
-        unit
+        unit: unit2
       });
     }
     toRelativeCalendar(options = {}) {
@@ -5309,19 +5335,19 @@ var require_CronDate = __commonJS(function(exports) {
     subtractSecond() {
       this.#date = this.#date.minus({ seconds: 1 });
     }
-    addUnit(unit) {
-      this.#verbMap.add[unit]();
+    addUnit(unit2) {
+      this.#verbMap.add[unit2]();
     }
-    subtractUnit(unit) {
-      this.#verbMap.subtract[unit]();
+    subtractUnit(unit2) {
+      this.#verbMap.subtract[unit2]();
     }
-    invokeDateOperation(verb, unit) {
+    invokeDateOperation(verb, unit2) {
       if (verb === DateMathOp.Add) {
-        this.addUnit(unit);
+        this.addUnit(unit2);
         return;
       }
       if (verb === DateMathOp.Subtract) {
-        this.subtractUnit(unit);
+        this.subtractUnit(unit2);
         return;
       }
       throw new Error(`Invalid verb: ${verb}`);
@@ -5430,13 +5456,13 @@ var require_CronDate = __commonJS(function(exports) {
       }
       return day > lastDay - 7;
     }
-    applyDateOperation(op, unit, hoursLength) {
-      if (unit === TimeUnit.Month || unit === TimeUnit.Day) {
-        this.invokeDateOperation(op, unit);
+    applyDateOperation(op, unit2, hoursLength) {
+      if (unit2 === TimeUnit.Month || unit2 === TimeUnit.Day) {
+        this.invokeDateOperation(op, unit2);
         return;
       }
       const previousHour = this.getHours();
-      this.invokeDateOperation(op, unit);
+      this.invokeDateOperation(op, unit2);
       const currentHour = this.getHours();
       const diff = currentHour - previousHour;
       if (diff === 2) {
@@ -10312,17 +10338,17 @@ var require_typescript = __commonJS(function(exports, module) {
         }
         return true;
       }
-      function fail(message, stackCrawlMark) {
+      function fail2(message, stackCrawlMark) {
         debugger;
         const e = new Error(message ? `Debug Failure. ${message}` : "Debug Failure.");
         if (Error.captureStackTrace) {
-          Error.captureStackTrace(e, stackCrawlMark || fail);
+          Error.captureStackTrace(e, stackCrawlMark || fail2);
         }
         throw e;
       }
-      Debug2.fail = fail;
+      Debug2.fail = fail2;
       function failBadSyntaxKind(node, message, stackCrawlMark) {
-        return fail(`${message || "Unexpected node."}\r
+        return fail2(`${message || "Unexpected node."}\r
 Node ${formatSyntaxKind(node.kind)} was unexpected.`, stackCrawlMark || failBadSyntaxKind);
       }
       Debug2.failBadSyntaxKind = failBadSyntaxKind;
@@ -10333,38 +10359,38 @@ Node ${formatSyntaxKind(node.kind)} was unexpected.`, stackCrawlMark || failBadS
             message += `\r
 Verbose Debug Information: ` + (typeof verboseDebugInfo === "string" ? verboseDebugInfo : verboseDebugInfo());
           }
-          fail(message, stackCrawlMark || assert);
+          fail2(message, stackCrawlMark || assert);
         }
       }
       Debug2.assert = assert;
       function assertEqual(a, b, msg, msg2, stackCrawlMark) {
         if (a !== b) {
           const message = msg ? msg2 ? `${msg} ${msg2}` : msg : "";
-          fail(`Expected ${a} === ${b}. ${message}`, stackCrawlMark || assertEqual);
+          fail2(`Expected ${a} === ${b}. ${message}`, stackCrawlMark || assertEqual);
         }
       }
       Debug2.assertEqual = assertEqual;
       function assertLessThan(a, b, msg, stackCrawlMark) {
         if (a >= b) {
-          fail(`Expected ${a} < ${b}. ${msg || ""}`, stackCrawlMark || assertLessThan);
+          fail2(`Expected ${a} < ${b}. ${msg || ""}`, stackCrawlMark || assertLessThan);
         }
       }
       Debug2.assertLessThan = assertLessThan;
       function assertLessThanOrEqual(a, b, stackCrawlMark) {
         if (a > b) {
-          fail(`Expected ${a} <= ${b}`, stackCrawlMark || assertLessThanOrEqual);
+          fail2(`Expected ${a} <= ${b}`, stackCrawlMark || assertLessThanOrEqual);
         }
       }
       Debug2.assertLessThanOrEqual = assertLessThanOrEqual;
       function assertGreaterThanOrEqual(a, b, stackCrawlMark) {
         if (a < b) {
-          fail(`Expected ${a} >= ${b}`, stackCrawlMark || assertGreaterThanOrEqual);
+          fail2(`Expected ${a} >= ${b}`, stackCrawlMark || assertGreaterThanOrEqual);
         }
       }
       Debug2.assertGreaterThanOrEqual = assertGreaterThanOrEqual;
       function assertIsDefined(value, message, stackCrawlMark) {
         if (value === undefined || value === null) {
-          fail(message, stackCrawlMark || assertIsDefined);
+          fail2(message, stackCrawlMark || assertIsDefined);
         }
       }
       Debug2.assertIsDefined = assertIsDefined;
@@ -10386,7 +10412,7 @@ Verbose Debug Information: ` + (typeof verboseDebugInfo === "string" ? verboseDe
       Debug2.checkEachDefined = checkEachDefined;
       function assertNever(member, message = "Illegal value:", stackCrawlMark) {
         const detail = typeof member === "object" && hasProperty(member, "kind") && hasProperty(member, "pos") ? "SyntaxKind: " + formatSyntaxKind(member.kind) : JSON.stringify(member);
-        return fail(`${message} ${detail}`, stackCrawlMark || assertNever);
+        return fail2(`${message} ${detail}`, stackCrawlMark || assertNever);
       }
       Debug2.assertNever = assertNever;
       function assertEachNode(nodes, test, message, stackCrawlMark) {
@@ -115317,30 +115343,30 @@ ${lanes.join(`
       function getSourceFileFromReference(referencingFile, ref) {
         return getSourceFileFromReferenceWorker(resolveTripleslashReference(ref.fileName, referencingFile.fileName), getSourceFile);
       }
-      function getSourceFileFromReferenceWorker(fileName, getSourceFile2, fail, reason) {
+      function getSourceFileFromReferenceWorker(fileName, getSourceFile2, fail2, reason) {
         if (hasExtension(fileName)) {
           const canonicalFileName = host.getCanonicalFileName(fileName);
           if (!options.allowNonTsExtensions && !forEach(flatten(supportedExtensionsWithJsonIfResolveJsonModule), (extension) => fileExtensionIs(canonicalFileName, extension))) {
-            if (fail) {
+            if (fail2) {
               if (hasJSFileExtension(canonicalFileName)) {
-                fail(Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName);
+                fail2(Diagnostics.File_0_is_a_JavaScript_file_Did_you_mean_to_enable_the_allowJs_option, fileName);
               } else {
-                fail(Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
+                fail2(Diagnostics.File_0_has_an_unsupported_extension_The_only_supported_extensions_are_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
               }
             }
             return;
           }
           const sourceFile = getSourceFile2(fileName);
-          if (fail) {
+          if (fail2) {
             if (!sourceFile) {
               const redirect = getRedirectFromSourceFile(fileName);
               if (redirect == null ? undefined : redirect.outputDts) {
-                fail(Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect.outputDts, fileName);
+                fail2(Diagnostics.Output_file_0_has_not_been_built_from_source_file_1, redirect.outputDts, fileName);
               } else {
-                fail(Diagnostics.File_0_not_found, fileName);
+                fail2(Diagnostics.File_0_not_found, fileName);
               }
             } else if (isReferencedFile(reason) && canonicalFileName === host.getCanonicalFileName(getSourceFileByPath(reason.file).fileName)) {
-              fail(Diagnostics.A_file_cannot_have_a_reference_to_itself);
+              fail2(Diagnostics.A_file_cannot_have_a_reference_to_itself);
             }
           }
           return sourceFile;
@@ -115348,13 +115374,13 @@ ${lanes.join(`
           const sourceFileNoExtension = options.allowNonTsExtensions && getSourceFile2(fileName);
           if (sourceFileNoExtension)
             return sourceFileNoExtension;
-          if (fail && options.allowNonTsExtensions) {
-            fail(Diagnostics.File_0_not_found, fileName);
+          if (fail2 && options.allowNonTsExtensions) {
+            fail2(Diagnostics.File_0_not_found, fileName);
             return;
           }
           const sourceFileWithAddedExtension = forEach(supportedExtensions[0], (extension) => getSourceFile2(fileName + extension));
-          if (fail && !sourceFileWithAddedExtension)
-            fail(Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
+          if (fail2 && !sourceFileWithAddedExtension)
+            fail2(Diagnostics.Could_not_resolve_the_path_0_with_the_extensions_Colon_1, fileName, "'" + flatten(supportedExtensions).join("', '") + "'");
           return sourceFileWithAddedExtension;
         }
       }
@@ -175175,6 +175201,1468 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
   } });
 });
 
+// src/workflows/executors/system-one-decision.ts
+init_zod();
+init_secret_scrubber();
+
+// src/workflows/executors/base.ts
+class BaseExecutor {
+  deps;
+  retryPolicy;
+  constructor(deps) {
+    this.deps = deps;
+  }
+  async checkReadiness(_nodes) {
+    return [];
+  }
+  resolveApproval(_parkedOutput, _approval) {
+    return null;
+  }
+  async run(input) {
+    const configResult = this.configSchema.safeParse(input.config);
+    if (!configResult.success) {
+      return {
+        status: "failed",
+        error: `Input validation failed: ${configResult.error.message}`
+      };
+    }
+    let result;
+    try {
+      result = await this.execute(configResult.data, input.context, input.meta);
+    } catch (err) {
+      return {
+        status: "failed",
+        error: `Executor threw: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    if (result.status === "success" && result.output !== undefined) {
+      const outputResult = this.outputSchema.safeParse(result.output);
+      if (!outputResult.success) {
+        return {
+          status: "failed",
+          error: `Output validation failed: ${outputResult.error.message}`
+        };
+      }
+    }
+    return result;
+  }
+}
+
+// src/workflows/executors/human-in-the-loop.ts
+init_zod();
+init_constants();
+init_secret_scrubber();
+
+// src/workflows/approval-notifications.ts
+init_db();
+init_resolver();
+init_types();
+init_secret_scrubber();
+async function postApprovalCancellationUpdates(approvals, reason, client = getSlackApp()?.client) {
+  if (!client)
+    return;
+  const text = `This approval is no longer actionable: ${reason}`;
+  for (const approval of approvals) {
+    const channels = approval.notificationChannels;
+    const slackThreads = (channels ?? []).filter((notification) => notification.channel === "slack" && notification.messageTs);
+    if (slackThreads.length === 0)
+      continue;
+    for (const notification of slackThreads) {
+      if (notification.channel !== "slack" || !notification.messageTs)
+        continue;
+      const notificationKey = `${notification.target}:${notification.messageTs}`;
+      const claim = await claimApprovalCancellationNotification(approval.id, notificationKey);
+      if (!claim)
+        continue;
+      try {
+        await client.chat.postMessage({
+          channel: notification.target,
+          thread_ts: notification.messageTs,
+          text,
+          unfurl_links: false,
+          unfurl_media: false
+        });
+        await completeApprovalCancellationNotificationClaim(approval.id, notificationKey, claim.leaseToken);
+      } catch (error) {
+        await releaseApprovalCancellationNotificationClaim(approval.id, notificationKey, claim.leaseToken);
+        console.error(`[HITL] Failed to post cancellation update for approval ${approval.id}:`, scrubSecrets(error instanceof Error ? error.message : String(error)));
+      }
+    }
+  }
+}
+async function createApprovalFollowUpTask(request, templateEventType) {
+  if (request.workflowRunId || !request.sourceTaskId)
+    return false;
+  const sourceTask = await getTaskById(request.sourceTaskId);
+  if (!sourceTask)
+    return false;
+  if (templateEventType === "hitl.timeout" && TERMINAL_TASK_STATUSES.includes(sourceTask.status)) {
+    return false;
+  }
+  const { text: taskText } = templateEventType === "hitl.follow_up" ? resolveTemplate("hitl.follow_up", {
+    request_id: request.id,
+    title: request.title,
+    status: request.status,
+    responses: formatResponses(request.questions, request.responses ?? {})
+  }) : resolveTemplate("hitl.timeout", {
+    request_id: request.id,
+    title: request.title,
+    expires_at: request.expiresAt ?? "",
+    reason: request.resolutionReason ?? ""
+  });
+  await createTaskExtended(taskText, {
+    agentId: sourceTask.agentId,
+    routingReason: sourceTask.agentId ? "continuity" : undefined,
+    routingSource: sourceTask.agentId ? "engine_default" : undefined,
+    parentTaskId: request.sourceTaskId,
+    source: "system",
+    taskType: "hitl-follow-up",
+    tags: ["hitl", "follow-up"],
+    slackChannelId: sourceTask.slackChannelId ?? undefined,
+    slackThreadTs: sourceTask.slackThreadTs ?? undefined,
+    slackUserId: sourceTask.slackUserId ?? undefined
+  });
+  return true;
+}
+function formatResponses(questions, responses) {
+  return questions.map((q) => {
+    const answer = responses[q.id];
+    let answerText;
+    if (answer == null) {
+      answerText = "(no answer)";
+    } else if (q.type === "approval") {
+      const a = answer;
+      answerText = a.approved ? "Approved" : "Rejected";
+      if (a.comment)
+        answerText += ` — ${a.comment}`;
+    } else if (typeof answer === "object") {
+      answerText = JSON.stringify(answer);
+    } else {
+      answerText = String(answer);
+    }
+    return `- ${q.label}: ${answerText}`;
+  }).join(`
+`);
+}
+
+// src/workflows/executors/human-in-the-loop.ts
+var SelectOptionSchema = exports_external.object({
+  value: exports_external.string(),
+  label: exports_external.string(),
+  description: exports_external.string().optional()
+});
+var QuestionSchema = exports_external.discriminatedUnion("type", [
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("approval"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional()
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("text"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    placeholder: exports_external.string().optional(),
+    multiline: exports_external.boolean().optional()
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("single-select"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    options: exports_external.array(SelectOptionSchema)
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("multi-select"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    options: exports_external.array(SelectOptionSchema),
+    minSelections: exports_external.number().int().min(0).optional(),
+    maxSelections: exports_external.number().int().min(1).optional()
+  }),
+  exports_external.object({
+    id: exports_external.string(),
+    type: exports_external.literal("boolean"),
+    label: exports_external.string(),
+    required: exports_external.boolean().default(true),
+    description: exports_external.string().optional(),
+    defaultValue: exports_external.boolean().optional()
+  })
+]);
+var ApproverConfigSchema = exports_external.object({
+  users: exports_external.array(exports_external.string()).optional(),
+  roles: exports_external.array(exports_external.string()).optional(),
+  policy: exports_external.union([exports_external.literal("any"), exports_external.literal("all"), exports_external.object({ min: exports_external.number().int().min(1) })])
+});
+var NotificationConfigSchema = exports_external.object({
+  channel: exports_external.enum(["slack", "email"]),
+  target: exports_external.string()
+});
+var HITLTimeoutSchema = exports_external.object({
+  seconds: exports_external.number().int().min(1),
+  action: exports_external.literal("reject")
+});
+var DYNAMIC_QUESTIONS_TOKEN_RE = /^\{\{[^}]+\}\}$/;
+var MAX_HITL_QUESTIONS = 100;
+var SLACK_SECTION_TEXT_LIMIT = 3000;
+var MAX_REPORTED_ISSUES = 5;
+var HITLConfigSchema = exports_external.object({
+  title: exports_external.string(),
+  questions: exports_external.union([
+    exports_external.array(QuestionSchema).min(1),
+    exports_external.string().regex(DYNAMIC_QUESTIONS_TOKEN_RE, "questions must be an array or one exact {{interpolation}} token")
+  ]),
+  approvers: ApproverConfigSchema,
+  timeout: HITLTimeoutSchema.optional(),
+  notifications: exports_external.array(NotificationConfigSchema).optional()
+});
+var HITLOutputSchema = exports_external.object({
+  requestId: exports_external.string().uuid(),
+  status: exports_external.string(),
+  responses: exports_external.record(exports_external.string(), exports_external.unknown()).nullable()
+});
+function resolveHitlQuestions(value) {
+  const fail = (reason) => ({
+    ok: false,
+    error: `human-in-the-loop questions ${reason}`
+  });
+  if (typeof value === "string") {
+    return fail(value.trim() === "" ? "resolved to an empty value: the {{token}} did not resolve (check the node's inputs mapping and the upstream output)" : "resolved to a string; they must resolve to an array of question objects (use one exact {{token}} pointing at an array)");
+  }
+  if (!Array.isArray(value)) {
+    return fail(`must resolve to an array of question objects, got ${value === null ? "null" : typeof value}`);
+  }
+  if (value.length === 0) {
+    return fail("resolved to an empty array; refusing to create an approval card with no questions");
+  }
+  if (value.length > MAX_HITL_QUESTIONS) {
+    return fail(`resolved to ${value.length} questions, over the limit of ${MAX_HITL_QUESTIONS} per card; split or group them upstream`);
+  }
+  const issues = [];
+  const questions = [];
+  const seenIds = new Set;
+  value.forEach((raw, index) => {
+    const parsed = QuestionSchema.safeParse(raw);
+    if (!parsed.success) {
+      for (const issue of parsed.error.issues) {
+        const path = issue.path.length > 0 ? `.${issue.path.map(String).join(".")}` : "";
+        issues.push(`[${index}]${path}: ${issue.message}`);
+      }
+      return;
+    }
+    const question = parsed.data;
+    if (question.id.trim() === "") {
+      issues.push(`[${index}].id: must be a non-empty string`);
+    } else if (seenIds.has(question.id)) {
+      issues.push(`[${index}].id: duplicate id "${question.id}" (responses are keyed by id)`);
+    }
+    seenIds.add(question.id);
+    if ((question.type === "single-select" || question.type === "multi-select") && question.options.length === 0) {
+      issues.push(`[${index}].options: a ${question.type} question needs at least one option`);
+    }
+    questions.push(question);
+  });
+  if (issues.length > 0) {
+    const shown = issues.slice(0, MAX_REPORTED_ISSUES).join("; ");
+    const more = issues.length > MAX_REPORTED_ISSUES ? `; and ${issues.length - MAX_REPORTED_ISSUES} more issue(s)` : "";
+    return fail(`are invalid: ${shown}${more}`);
+  }
+  return { ok: true, questions };
+}
+function escapeSlackMrkdwn(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+function buildSlackQuestionsSummary(questions, timeoutText = "") {
+  const header = `*Questions:*
+`;
+  const lines = questions.map((q) => `• ${escapeSlackMrkdwn(q.label.replace(/\s+/g, " ").trim())}`);
+  const fits = (shown, omitted) => {
+    const tail = omitted > 0 ? `
+_…and ${omitted} more. Answer all of them on the dashboard._` : "";
+    const text = `${header}${shown.join(`
+`)}${tail}${timeoutText}`;
+    return text.length <= SLACK_SECTION_TEXT_LIMIT ? text : null;
+  };
+  const full = fits(lines, 0);
+  if (full)
+    return full;
+  for (let count = lines.length - 1;count >= 0; count--) {
+    const text = fits(lines.slice(0, count), lines.length - count);
+    if (text)
+      return text;
+  }
+  return `${header}_${questions.length} questions. Answer them on the dashboard._`;
+}
+
+class HumanInTheLoopExecutor extends BaseExecutor {
+  type = "human-in-the-loop";
+  mode = "async";
+  configSchema = HITLConfigSchema;
+  outputSchema = HITLOutputSchema;
+  async run(input) {
+    const resolved = resolveHitlQuestions(input.config?.questions);
+    if (!resolved.ok)
+      return { status: "failed", error: resolved.error };
+    return super.run({ ...input, config: { ...input.config, questions: resolved.questions } });
+  }
+  async execute(config, _context, meta) {
+    const { db } = this.deps;
+    const existing = await db.getApprovalRequestByStepId(meta.stepId);
+    if (existing) {
+      if (existing.status !== "pending") {
+        if (existing.status === "cancelled") {
+          return {
+            status: "failed",
+            error: `Approval request was cancelled: ${existing.resolutionReason ?? "workflow run cancelled"}`
+          };
+        }
+        const nextPort = existing.status === "timeout" ? "timeout" : existing.status === "rejected" ? "rejected" : "approved";
+        return {
+          status: "success",
+          output: {
+            requestId: existing.id,
+            status: existing.status,
+            responses: existing.responses
+          },
+          nextPort
+        };
+      }
+      return {
+        status: "success",
+        async: true,
+        waitFor: "approval.resolved",
+        correlationId: existing.id
+      };
+    }
+    if (!Array.isArray(config.questions)) {
+      return { status: "failed", error: "human-in-the-loop questions did not resolve to an array" };
+    }
+    const requestId = crypto.randomUUID();
+    const created = await db.createApprovalRequest({
+      id: requestId,
+      title: config.title,
+      questions: config.questions,
+      approvers: config.approvers,
+      workflowRunId: meta.runId,
+      workflowRunStepId: meta.stepId,
+      timeoutSeconds: config.timeout?.seconds,
+      notificationChannels: config.notifications,
+      createdBy: meta.requestedByUserId,
+      requireActionableWorkflow: true
+    });
+    if (created.status === "cancelled") {
+      return {
+        status: "success",
+        async: true,
+        waitFor: "approval.resolved",
+        correlationId: requestId
+      };
+    }
+    if (config.notifications?.length) {
+      this.dispatchNotifications(requestId, config, db).catch((err) => {
+        console.error("[HITL] Unexpected error dispatching notifications:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+      });
+    }
+    return {
+      status: "success",
+      async: true,
+      waitFor: "approval.resolved",
+      correlationId: requestId
+    };
+  }
+  async dispatchNotifications(requestId, config, db) {
+    if (!config.notifications?.length)
+      return;
+    const approvalUrl = `${getAppUrl()}/approval-requests/${requestId}`;
+    const updatedChannels = [...config.notifications];
+    let updated = false;
+    for (let i = 0;i < config.notifications.length; i++) {
+      const notification = config.notifications[i];
+      if (notification.channel === "email") {
+        console.warn(`[HITL] Email notifications not yet supported (target: ${notification.target})`);
+        continue;
+      }
+      if (notification.channel === "slack") {
+        try {
+          const { getSlackApp: getSlackApp2 } = await import("./app-mc7xfagn.js");
+          const slackApp = getSlackApp2();
+          if (!slackApp) {
+            console.warn("[HITL] Slack not initialized — cannot send notification");
+            continue;
+          }
+          const questions = Array.isArray(config.questions) ? config.questions : [];
+          const questionsText = buildSlackQuestionsSummary(questions);
+          const timeoutCaption = config.timeout ? [
+            {
+              type: "context",
+              elements: [
+                {
+                  type: "mrkdwn",
+                  text: `⏱ Timeout: ${formatTimeout(config.timeout.seconds)} — times out if not responded`
+                }
+              ]
+            }
+          ] : [];
+          const blocks = [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: `\uD83D\uDD14 *Approval Required: ${config.title}*`
+              }
+            },
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: questionsText
+              }
+            },
+            {
+              type: "actions",
+              elements: [
+                {
+                  type: "button",
+                  text: { type: "plain_text", text: "Review & Respond" },
+                  url: approvalUrl,
+                  style: "primary"
+                }
+              ]
+            },
+            ...timeoutCaption
+          ];
+          const result = await slackApp.client.chat.postMessage({
+            channel: notification.target,
+            text: `Approval Required: ${config.title} — ${approvalUrl}`,
+            unfurl_links: false,
+            unfurl_media: false,
+            blocks
+          });
+          if (result.ts) {
+            updatedChannels[i] = { ...notification, messageTs: result.ts };
+            updated = true;
+          }
+          console.log(`[HITL] Slack notification sent to ${notification.target} for request ${requestId}`);
+        } catch (err) {
+          console.error(`[HITL] Failed to send Slack notification to ${notification.target}:`, scrubSecrets(err instanceof Error ? err.message : String(err)));
+        }
+      }
+    }
+    if (updated) {
+      try {
+        await db.updateApprovalRequestNotifications(requestId, updatedChannels);
+        const latest = await db.getApprovalRequestById(requestId);
+        if (latest?.status === "cancelled") {
+          await postApprovalCancellationUpdates([latest], latest.resolutionReason ?? "Workflow run cancelled");
+        }
+      } catch (err) {
+        console.error("[HITL] Failed to update notification channels in DB:", scrubSecrets(err instanceof Error ? err.message : String(err)));
+      }
+    }
+  }
+}
+function formatTimeout(seconds) {
+  if (seconds < 60)
+    return `${seconds}s`;
+  if (seconds < 3600)
+    return `${Math.round(seconds / 60)}m`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.round(seconds % 3600 / 60);
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
+}
+
+// src/workflows/executors/workflow-llm.ts
+async function resolveWorkflowLlmConfig(requestedModel, env = process.env, options = {}) {
+  const credential = await resolveCredential({ env });
+  if (!credential) {
+    throw new Error("No workflow LLM credential found. Set OPENROUTER_API_KEY or OPENAI_API_KEY.");
+  }
+  if (options.requireKind && credential.kind !== options.requireKind) {
+    throw new Error(`No ${options.requireKind} credential found for this workflow LLM call.`);
+  }
+  if (credential.kind !== "openrouter" && credential.kind !== "openai") {
+    throw new Error(`Workflow LLM nodes do not support the resolved ${credential.kind} credential yet. Set OPENROUTER_API_KEY or OPENAI_API_KEY.`);
+  }
+  const providerPrefix = `${credential.kind}/`;
+  const model = requestedModel ?? DEFAULT_MODEL[credential.kind];
+  return {
+    apiKey: credential.apiKey,
+    baseURL: credential.kind === "openrouter" ? getOpenRouterBaseUrl(env) : undefined,
+    model: model.startsWith(providerPrefix) ? model.slice(providerPrefix.length) : model
+  };
+}
+
+// src/workflows/executors/system-one-providers.ts
+var TYPESAFE_KEY = "TYPESAFE_API_KEY";
+var OPENROUTER_KEY = "OPENROUTER_API_KEY";
+var LAYA_KEY = "LAYA_API_KEY";
+var LAYA_URL_KEY = "LAYA_URL";
+async function readGlobalConfig(db, key) {
+  const rows = await db.getSwarmConfigs({ scope: "global", key });
+  return rows.find((row) => row.scope === "global" && row.key === key)?.value;
+}
+var SYSTEM_ONE_PROVIDERS = {
+  typesafe: {
+    label: "TypeSafe",
+    keyName: TYPESAFE_KEY,
+    endpoint: "https://api.typesafe.ai/v1/systemone",
+    defaultModel: "jev-latest",
+    confidenceField: "confidence",
+    readKey: ({ db }) => readGlobalConfig(db, TYPESAFE_KEY)
+  },
+  openrouter: {
+    label: "OpenRouter",
+    keyName: OPENROUTER_KEY,
+    endpoint: "https://openrouter.ai/api/alpha/decisions",
+    defaultModel: "~typesafe/jev-latest",
+    confidenceField: "confidence",
+    deploymentProblem(env) {
+      return getOpenRouterBaseUrl(env) === DEFAULT_OPENROUTER_BASE_URL ? null : 'OPENROUTER_BASE_URL points at a gateway. SystemOne provider "openrouter" calls openrouter.ai directly and is not supported through a gateway; unset OPENROUTER_BASE_URL or use provider "typesafe".';
+    },
+    async readKey({ env }) {
+      try {
+        return (await resolveWorkflowLlmConfig(undefined, env, { requireKind: "openrouter" })).apiKey;
+      } catch {
+        return null;
+      }
+    }
+  },
+  laya: {
+    label: "laya",
+    keyName: LAYA_KEY,
+    endpoint: { configKey: LAYA_URL_KEY, path: "/v1/systemone" },
+    confidenceField: "answer_confidence",
+    readKey: ({ db }) => readGlobalConfig(db, LAYA_KEY)
+  }
+};
+var SYSTEM_ONE_PROVIDER_IDS = Object.keys(SYSTEM_ONE_PROVIDERS);
+var SYSTEM_ONE_DEFAULT_PROVIDER = "typesafe";
+function isSystemOneProviderId(value) {
+  return typeof value === "string" && Object.hasOwn(SYSTEM_ONE_PROVIDERS, value);
+}
+function systemOneProviderOf(config) {
+  if (config.provider === undefined)
+    return SYSTEM_ONE_DEFAULT_PROVIDER;
+  return isSystemOneProviderId(config.provider) ? config.provider : undefined;
+}
+var SET_IT = (keyName) => `Set ${keyName} as a global secret on the Secrets page (Settings > Secrets).`;
+var SET_URL = (configKey) => `Set ${configKey} as a global config value (set-config with scope global).`;
+function systemOneKeyMissingMessage(id) {
+  const { label, keyName } = SYSTEM_ONE_PROVIDERS[id];
+  return `${keyName} is not configured. SystemOne provider "${id}" needs a working ${label} API key. ${SET_IT(keyName)}`;
+}
+function systemOneKeyUnreadableMessage(id) {
+  return `Could not read ${SYSTEM_ONE_PROVIDERS[id].keyName} from swarm config`;
+}
+function systemOneKeyMalformedMessage(id) {
+  return `${SYSTEM_ONE_PROVIDERS[id].keyName} is not a valid bearer token value. ${SET_IT(SYSTEM_ONE_PROVIDERS[id].keyName)}`;
+}
+function systemOneKeyRejectedMessage(id, status, code) {
+  const { label, keyName } = SYSTEM_ONE_PROVIDERS[id];
+  const detail = code ? ` (${code})` : "";
+  return `${keyName} was rejected by ${label} (HTTP ${status}${detail}). ` + `The key is invalid, revoked, or lacks access to the model. Replace it on the Secrets page (Settings > Secrets). No decision was made.`;
+}
+function urlKeyOf(provider) {
+  return typeof provider.endpoint === "string" ? null : provider.endpoint.configKey;
+}
+function systemOneUrlMissingMessage(id) {
+  const provider = SYSTEM_ONE_PROVIDERS[id];
+  const configKey = urlKeyOf(provider) ?? "";
+  return `${configKey} is not configured. SystemOne provider "${id}" needs the URL of a ${provider.label} server. ${SET_URL(configKey)}`;
+}
+function systemOneUrlUnreadableMessage(id) {
+  return `Could not read ${urlKeyOf(SYSTEM_ONE_PROVIDERS[id]) ?? ""} from swarm config`;
+}
+function systemOneUrlInvalidMessage(id) {
+  const provider = SYSTEM_ONE_PROVIDERS[id];
+  const configKey = urlKeyOf(provider) ?? "";
+  return `${configKey} is not a usable ${provider.label} server URL. It must be an https URL (http only for localhost) with no credentials, query, or fragment. ${SET_URL(configKey)}`;
+}
+function hasWhitespaceOrControl(value) {
+  for (const char of value) {
+    const code = char.charCodeAt(0);
+    if (code <= 32 || code === 127)
+      return true;
+  }
+  return false;
+}
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]"]);
+function systemOneEndpointFromBase(base, path) {
+  let url;
+  try {
+    url = new URL(base.trim());
+  } catch {
+    return null;
+  }
+  const secure = url.protocol === "https:";
+  const loopback = url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname);
+  if (!secure && !loopback)
+    return null;
+  if (url.username || url.password || url.search || url.hash)
+    return null;
+  return `${url.origin}${url.pathname.replace(/\/+$/, "")}${path}`;
+}
+async function resolveSystemOneTarget(id, ctx, overrides = {}) {
+  const provider = SYSTEM_ONE_PROVIDERS[id];
+  const deploymentProblem = provider.deploymentProblem?.(ctx.env);
+  if (deploymentProblem)
+    return { ok: false, error: deploymentProblem };
+  const errors = [];
+  let endpoint;
+  if (typeof provider.endpoint === "string") {
+    endpoint = provider.endpoint;
+  } else {
+    const { configKey, path } = provider.endpoint;
+    let base;
+    let readable = true;
+    try {
+      base = await (overrides.serverUrl ? overrides.serverUrl(id) : readGlobalConfig(ctx.db, configKey));
+    } catch {
+      readable = false;
+      errors.push(systemOneUrlUnreadableMessage(id));
+    }
+    if (readable) {
+      if (!base || base.trim() === "") {
+        errors.push(systemOneUrlMissingMessage(id));
+      } else {
+        const resolved = systemOneEndpointFromBase(base, path);
+        if (resolved)
+          endpoint = resolved;
+        else
+          errors.push(systemOneUrlInvalidMessage(id));
+      }
+    }
+  }
+  let apiKey;
+  let keyProblem;
+  try {
+    apiKey = await (overrides.apiKey ? overrides.apiKey(id) : provider.readKey(ctx));
+  } catch {
+    keyProblem = systemOneKeyUnreadableMessage(id);
+  }
+  if (!keyProblem) {
+    if (!apiKey || apiKey.trim() === "")
+      keyProblem = systemOneKeyMissingMessage(id);
+    else if (hasWhitespaceOrControl(apiKey))
+      keyProblem = systemOneKeyMalformedMessage(id);
+  }
+  if (keyProblem)
+    errors.push(keyProblem);
+  if (errors.length > 0 || !endpoint || !apiKey)
+    return { ok: false, error: errors.join(" ") };
+  return { ok: true, apiKey, endpoint };
+}
+
+// src/workflows/executors/system-one-decision.ts
+var SYSTEM_ONE_DECISION_NODE_TYPE = "system-one-decision";
+var SYSTEM_ONE_ENDPOINT = SYSTEM_ONE_PROVIDERS.typesafe.endpoint;
+var SYSTEM_ONE_API_KEY_CONFIG_KEY = SYSTEM_ONE_PROVIDERS.typesafe.keyName;
+var SYSTEM_ONE_DEFAULT_TIMEOUT_MS = 30000;
+var SYSTEM_ONE_MIN_TIMEOUT_MS = 1000;
+var SYSTEM_ONE_MAX_TIMEOUT_MS = 300000;
+var SYSTEM_ONE_DEFAULT_MAX_RETRIES = 2;
+var SYSTEM_ONE_MAX_RETRIES_LIMIT = 3;
+var CHOICE_MIN_OPTIONS = 2;
+var CHOICE_MAX_OPTIONS = 255;
+var SCORE_MIN_LEVELS = 2;
+var SCORE_MAX_LEVELS = 10;
+var DEADLINE_MARGIN_MS = 250;
+var BACKOFF_BASE_MS = 500;
+var BACKOFF_CAP_MS = 8000;
+var DISTRIBUTION_TOLERANCE = 0.02;
+var MAX_RESPONSE_CHARS = 1048576;
+var MAX_ERROR_BODY_CHARS = 65536;
+var REVIEW_PORTS = ["approved", "rejected", "timeout"];
+var ENGINE_RETRY_DEFAULT = 3;
+var SystemOneEntrySchema = exports_external.union([
+  exports_external.string(),
+  exports_external.null(),
+  exports_external.array(exports_external.unknown()),
+  exports_external.record(exports_external.string(), exports_external.unknown())
+]);
+var SystemOneInstructionsSchema = SystemOneEntrySchema.refine((value) => value !== null && !(typeof value === "string" && value.trim() === ""), { message: "instructions must not be null or blank" });
+var SystemOneStateSchema = exports_external.union([
+  exports_external.string().min(1, "state must not be empty"),
+  exports_external.array(exports_external.string()).min(1, "state must not be an empty array"),
+  exports_external.record(exports_external.string(), exports_external.unknown())
+]);
+var NoulQuestionSchema = exports_external.strictObject({
+  type: exports_external.literal("noul"),
+  instructions: SystemOneInstructionsSchema,
+  criteria: exports_external.strictObject({ true: SystemOneEntrySchema.optional(), false: SystemOneEntrySchema.optional() }).refine((criteria) => criteria.true !== undefined || criteria.false !== undefined, {
+    message: "noul criteria must describe at least one of true / false"
+  }).optional()
+});
+var ChoiceQuestionSchema = exports_external.strictObject({
+  type: exports_external.literal("choice"),
+  instructions: SystemOneInstructionsSchema,
+  criteria: exports_external.record(exports_external.string().min(1), SystemOneEntrySchema).refine((criteria) => {
+    const count = Object.keys(criteria).length;
+    return count >= CHOICE_MIN_OPTIONS && count <= CHOICE_MAX_OPTIONS;
+  }, {
+    message: `choice criteria must define ${CHOICE_MIN_OPTIONS}-${CHOICE_MAX_OPTIONS} options`
+  })
+});
+var ScoreQuestionSchema = exports_external.strictObject({
+  type: exports_external.literal("score"),
+  instructions: SystemOneInstructionsSchema,
+  criteria: exports_external.array(SystemOneEntrySchema).min(SCORE_MIN_LEVELS).max(SCORE_MAX_LEVELS)
+});
+var SystemOneQuestionSchema = exports_external.discriminatedUnion("type", [
+  NoulQuestionSchema,
+  ChoiceQuestionSchema,
+  ScoreQuestionSchema
+]);
+var Unit = exports_external.number().min(0).max(1);
+var QUESTION_ID_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+var RESERVED_QUESTION_IDS = new Set([
+  ...Object.getOwnPropertyNames(Object.prototype),
+  "prototype"
+]);
+var SystemOnePrimitiveTypeSchema = exports_external.enum(["noul", "choice", "score"]);
+var HumanReviewSchema = exports_external.strictObject({
+  band: exports_external.strictObject({ min: Unit, max: Unit }).refine((band) => band.min <= band.max, { message: "band.min must not exceed band.max" }),
+  approvers: ApproverConfigSchema,
+  title: exports_external.string().min(1).optional(),
+  timeout: HITLTimeoutSchema.optional(),
+  notifications: exports_external.array(NotificationConfigSchema).optional()
+});
+var SystemOneDecisionConfigSchema = exports_external.strictObject({
+  provider: exports_external.enum(SYSTEM_ONE_PROVIDER_IDS).default(SYSTEM_ONE_DEFAULT_PROVIDER),
+  model: exports_external.string().min(1).optional(),
+  state: SystemOneStateSchema,
+  timeoutMs: exports_external.number().int().min(SYSTEM_ONE_MIN_TIMEOUT_MS).max(SYSTEM_ONE_MAX_TIMEOUT_MS).default(SYSTEM_ONE_DEFAULT_TIMEOUT_MS),
+  maxRetries: exports_external.number().int().min(0).max(SYSTEM_ONE_MAX_RETRIES_LIMIT).default(SYSTEM_ONE_DEFAULT_MAX_RETRIES),
+  questions: exports_external.record(exports_external.string().regex(QUESTION_ID_RE, "question ids must start with a letter or underscore and use only letters, digits, _ or -"), SystemOneQuestionSchema),
+  returns: exports_external.record(exports_external.string(), exports_external.strictObject({ type: SystemOnePrimitiveTypeSchema })),
+  humanReview: HumanReviewSchema.optional()
+}).superRefine((config, ctx) => {
+  const questionIds = Object.keys(config.questions);
+  if (questionIds.length === 0) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["questions"],
+      message: "system-one-decision needs at least one question"
+    });
+  }
+  for (const id of questionIds) {
+    if (RESERVED_QUESTION_IDS.has(id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["questions", id],
+        message: `"${id}" is reserved and cannot be a question id`
+      });
+    }
+    const declared = Object.hasOwn(config.returns, id) ? config.returns[id] : undefined;
+    if (!declared) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["returns"],
+        message: `returns must declare question "${id}"`
+      });
+    } else if (declared.type !== config.questions[id]?.type) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["returns", id, "type"],
+        message: `returns.${id}.type is "${declared.type}" but question "${id}" is "${config.questions[id]?.type}"`
+      });
+    }
+  }
+  for (const id of Object.keys(config.returns)) {
+    if (!Object.hasOwn(config.questions, id)) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["returns", id],
+        message: `returns declares "${id}" but no question has that id`
+      });
+    }
+  }
+});
+var NoulAnswerSchema = exports_external.strictObject({ type: exports_external.literal("noul"), noul: Unit });
+var ChoiceAnswerSchema = exports_external.strictObject({
+  type: exports_external.literal("choice"),
+  choice: exports_external.string(),
+  probabilities: exports_external.record(exports_external.string(), Unit),
+  confidence: Unit
+});
+var ScoreAnswerSchema = exports_external.strictObject({
+  type: exports_external.literal("score"),
+  score: exports_external.number(),
+  legend: exports_external.record(exports_external.string(), SystemOneEntrySchema),
+  probabilities: exports_external.record(exports_external.string(), Unit),
+  confidence: Unit
+});
+var SystemOneAnswerSchema = exports_external.discriminatedUnion("type", [
+  NoulAnswerSchema,
+  ChoiceAnswerSchema,
+  ScoreAnswerSchema
+]);
+var ReviewQuestionSchema = exports_external.strictObject({
+  confidence: Unit,
+  inBand: exports_external.boolean(),
+  decidedBy: exports_external.enum(["model", "human"]),
+  modelAnswer: exports_external.union([exports_external.string(), exports_external.number()]).optional()
+});
+var ReviewSchema = exports_external.strictObject({
+  status: exports_external.enum(["not_required", "pending", "approved", "rejected", "timeout"]),
+  approvalRequestId: exports_external.string().optional(),
+  reason: exports_external.string().optional(),
+  questions: exports_external.record(exports_external.string(), ReviewQuestionSchema)
+});
+var SystemOneDecisionOutputSchema = exports_external.object({
+  model: exports_external.string().min(1),
+  answers: exports_external.record(exports_external.string(), SystemOneAnswerSchema),
+  usage: exports_external.object({
+    input_tokens: exports_external.number().int().min(0),
+    output_tokens: exports_external.number().int().min(0)
+  }),
+  requestId: exports_external.string().optional(),
+  routing: exports_external.strictObject({ model: exports_external.string().min(1) }).optional(),
+  review: ReviewSchema.optional()
+});
+function systemOneRetryViolations(node) {
+  if (node.type !== SYSTEM_ONE_DECISION_NODE_TYPE)
+    return [];
+  const violations = [];
+  const attempts = (retry) => retry ? retry.maxRetries ?? ENGINE_RETRY_DEFAULT : 0;
+  if (attempts(node.retry) > 0) {
+    violations.push(`Node "${node.id}" (system-one-decision) must not set retry.maxRetries > 0: the system-one-decision executor retries transient transport errors itself (config.maxRetries), and engine retries would re-send rejected requests`);
+  }
+  if (attempts(node.validation?.retry) > 0) {
+    violations.push(`Node "${node.id}" (system-one-decision) must not set validation.retry.maxRetries > 0: a validation-driven retry would send another paid request`);
+  }
+  return violations;
+}
+function systemOneStaticShapeViolations(node) {
+  if (node.type !== SYSTEM_ONE_DECISION_NODE_TYPE)
+    return [];
+  const violations = [];
+  for (const field of ["questions", "returns"]) {
+    const value = node.config[field];
+    if (value !== undefined && (typeof value !== "object" || value === null || Array.isArray(value))) {
+      violations.push(`Node "${node.id}" (system-one-decision) config.${field} must be an object: question ids and return types are static, only state and descriptions may use {{tokens}}`);
+    }
+  }
+  const provider = node.config.provider;
+  if (typeof provider === "string" && provider.includes("{{")) {
+    violations.push(`Node "${node.id}" (system-one-decision) config.provider must be a literal (${SYSTEM_ONE_PROVIDER_IDS.join(", ")}), not a {{token}}: the provider decides which credential is checked before the run starts`);
+  }
+  if (isRecord(node.config.humanReview) && node.next != null) {
+    if (typeof node.next === "string" || Array.isArray(node.next)) {
+      violations.push(`Node "${node.id}" (system-one-decision) sets humanReview, so next must map output ports (${REVIEW_PORTS.join(", ")}): a single or list next would run the same successors after a rejection or a timeout`);
+    } else {
+      const ports = Object.keys(node.next);
+      const unknown2 = ports.filter((port) => !REVIEW_PORTS.includes(port));
+      if (unknown2.length > 0) {
+        violations.push(`Node "${node.id}" (system-one-decision) sets humanReview, so next ports must be ${REVIEW_PORTS.join(", ")}; got ${unknown2.map((port) => `"${port}"`).join(", ")}`);
+      }
+      if (!ports.includes("approved")) {
+        violations.push(`Node "${node.id}" (system-one-decision) sets humanReview, so next must define the "approved" port: it carries every answer that is accepted, by the model or by a person`);
+      }
+    }
+  }
+  return violations;
+}
+function systemOneUnresolvedError(nodeId, tokens) {
+  const rendered = [...new Set(tokens)].map((token) => `{{${token}}}`).join(", ");
+  return `SystemOne Decision node "${nodeId}" has unresolved interpolation token(s): ${rendered}. ` + "No request was sent. Declare the value in the node's inputs mapping or fix the path.";
+}
+
+class SystemOneContractError extends Error {
+}
+function fail(message) {
+  throw new SystemOneContractError(message);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function unit(value, what) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0 || value > 1) {
+    fail(`${what} must be a finite number between 0 and 1`);
+  }
+  return value;
+}
+function distribution(value, keys, what) {
+  if (!isRecord(value))
+    fail(`${what} must be an object`);
+  const actual = Object.keys(value);
+  const missing = keys.filter((key) => !Object.hasOwn(value, key));
+  const extra = actual.filter((key) => !keys.includes(key));
+  if (missing.length > 0 || extra.length > 0) {
+    fail(`${what} keys must be exactly the declared ${keys.length} option(s)` + (missing.length > 0 ? `; missing ${missing.length}` : "") + (extra.length > 0 ? `; ${extra.length} unexpected` : ""));
+  }
+  const out = {};
+  let sum = 0;
+  for (const key of keys) {
+    const p = unit(value[key], `${what}["${key}"]`);
+    out[key] = p;
+    sum += p;
+  }
+  if (Math.abs(sum - 1) > DISTRIBUTION_TOLERANCE) {
+    fail(`${what} must sum to 1 (within ${DISTRIBUTION_TOLERANCE})`);
+  }
+  return out;
+}
+function validateAnswer(id, question, raw, confidenceField) {
+  const at = `answer "${id}"`;
+  if (!isRecord(raw))
+    fail(`${at} must be an object`);
+  if (raw.type !== question.type) {
+    fail(`${at} has type ${JSON.stringify(raw.type)} but the question declares "${question.type}"`);
+  }
+  switch (question.type) {
+    case "noul":
+      return { type: "noul", noul: unit(raw.noul, `${at}.noul`) };
+    case "choice": {
+      const options = Object.keys(question.criteria);
+      if (typeof raw.choice !== "string" || !Object.hasOwn(question.criteria, raw.choice)) {
+        fail(`${at}.choice is not one of the declared options`);
+      }
+      return {
+        type: "choice",
+        choice: raw.choice,
+        probabilities: distribution(raw.probabilities, options, `${at}.probabilities`),
+        confidence: unit(raw[confidenceField], `${at}.${confidenceField}`)
+      };
+    }
+    case "score": {
+      const indices = question.criteria.map((_, index) => String(index));
+      const top = indices.length - 1;
+      if (typeof raw.score !== "number" || !Number.isFinite(raw.score) || raw.score < 0 || raw.score > top) {
+        fail(`${at}.score must be a finite number between 0 and ${top}`);
+      }
+      if (!isRecord(raw.legend))
+        fail(`${at}.legend must be an object`);
+      const legend = {};
+      for (const key of indices) {
+        if (!Object.hasOwn(raw.legend, key))
+          fail(`${at}.legend is missing level ${key}`);
+        const entry = SystemOneEntrySchema.safeParse(raw.legend[key]);
+        if (!entry.success)
+          fail(`${at}.legend["${key}"] must be a string, object, array, or null`);
+        legend[key] = entry.data;
+      }
+      return {
+        type: "score",
+        score: raw.score,
+        legend,
+        probabilities: distribution(raw.probabilities, indices, `${at}.probabilities`),
+        confidence: unit(raw[confidenceField], `${at}.${confidenceField}`)
+      };
+    }
+  }
+}
+var MAX_ROUTING_MODEL_CHARS = 128;
+function readRoutingModel(routing) {
+  if (!isRecord(routing))
+    return;
+  const { model } = routing;
+  return typeof model === "string" && model !== "" && model.length <= MAX_ROUTING_MODEL_CHARS ? model : undefined;
+}
+function validateSystemOneResponse(questions, body, requestId, confidenceField = "confidence") {
+  if (!isRecord(body))
+    fail("response body must be a JSON object");
+  if (typeof body.model !== "string" || body.model === "") {
+    fail("response is missing the model that produced the answers");
+  }
+  if (!isRecord(body.answers))
+    fail("response is missing the answers object");
+  const usage = exports_external.object({ input_tokens: exports_external.number().int().min(0), output_tokens: exports_external.number().int().min(0) }).safeParse(body.usage);
+  if (!usage.success)
+    fail("response usage must report non-negative integer input_tokens and output_tokens");
+  const declared = Object.keys(questions);
+  const unexpected = Object.keys(body.answers).filter((id) => !Object.hasOwn(questions, id));
+  if (unexpected.length > 0)
+    fail(`response contains ${unexpected.length} answer(s) for undeclared questions`);
+  const answers = {};
+  for (const id of declared) {
+    if (!Object.hasOwn(body.answers, id))
+      fail(`response is missing the answer for question "${id}"`);
+    const question = questions[id];
+    if (!question)
+      fail(`question "${id}" is not defined`);
+    answers[id] = validateAnswer(id, question, body.answers[id], confidenceField);
+  }
+  if (declared.length === 0)
+    fail("a system-one-decision call needs at least one question");
+  const routingModel = readRoutingModel(body.routing);
+  return {
+    model: body.model,
+    answers,
+    usage: usage.data,
+    ...requestId ? { requestId } : {},
+    ...routingModel ? { routing: { model: routingModel } } : {}
+  };
+}
+var REVIEW_CONFIRM_ID = "$confirm";
+var REVIEW_STATE_CHARS = 2000;
+var REVIEW_LABEL_CHARS = 160;
+var REVIEW_OPTION_CHARS = 200;
+var round6 = (value) => Math.round(value * 1e6) / 1e6;
+function answerConfidence(answer) {
+  return answer.type === "noul" ? round6(Math.max(answer.noul, 1 - answer.noul)) : answer.confidence;
+}
+function clip(text, max) {
+  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
+}
+function showEntry(entry, max) {
+  return clip(typeof entry === "string" ? entry : JSON.stringify(entry) ?? "", max);
+}
+function modelAnswerOf(answer) {
+  return answer.type === "choice" ? answer.choice : answer.type === "score" ? answer.score : answer.noul;
+}
+function buildReviewCard(nodeId, config, review, parked) {
+  const state = scrubSecrets(typeof config.state === "string" ? config.state : JSON.stringify(config.state) ?? "");
+  const questions = [
+    {
+      id: REVIEW_CONFIRM_ID,
+      type: "approval",
+      label: "Accept these answers and continue?",
+      required: true,
+      description: `Model ${parked.model}. Input: ${clip(state, REVIEW_STATE_CHARS)}`
+    }
+  ];
+  for (const [id, info] of Object.entries(parked.review?.questions ?? {})) {
+    if (!info.inBand)
+      continue;
+    const question = config.questions[id];
+    const answer = parked.answers[id];
+    if (!question || !answer)
+      continue;
+    const label = `${id}: ${showEntry(question.instructions, REVIEW_LABEL_CHARS)}`;
+    const said = `The model answered ${JSON.stringify(modelAnswerOf(answer))} at confidence ${info.confidence}.`;
+    if (question.type === "choice" && answer.type === "choice") {
+      questions.push({
+        id,
+        type: "single-select",
+        label,
+        required: false,
+        description: `${said} Leave empty to confirm it, or pick another option.`,
+        options: Object.entries(question.criteria).map(([value, entry]) => ({
+          value,
+          label: value,
+          ...typeof entry === "string" && entry ? { description: clip(entry, REVIEW_OPTION_CHARS) } : {}
+        }))
+      });
+    } else if (question.type === "score" && answer.type === "score") {
+      questions.push({
+        id,
+        type: "single-select",
+        label,
+        required: false,
+        description: `${said} Leave empty to confirm it, or pick a level.`,
+        options: question.criteria.map((entry, level) => ({
+          value: String(level),
+          label: `${level}: ${showEntry(entry, REVIEW_OPTION_CHARS)}`
+        }))
+      });
+    } else if (question.type === "noul" && answer.type === "noul") {
+      questions.push({
+        id,
+        type: "boolean",
+        label,
+        required: false,
+        defaultValue: answer.noul >= 0.5,
+        description: `${said} The switch starts on the side the model took.`
+      });
+    }
+  }
+  return {
+    title: review.title ?? `Review decision: ${nodeId}`,
+    questions,
+    approvers: review.approvers,
+    ...review.timeout ? { timeout: review.timeout } : {},
+    ...review.notifications ? { notifications: review.notifications } : {}
+  };
+}
+function readHumanAnswer(answer, response) {
+  if (response === undefined || response === null || response === "")
+    return { kind: "confirm" };
+  switch (answer.type) {
+    case "choice":
+      if (typeof response !== "string" || !Object.hasOwn(answer.probabilities, response)) {
+        return { kind: "invalid" };
+      }
+      return response === answer.choice ? { kind: "confirm" } : { kind: "override", answer: { ...answer, choice: response } };
+    case "score": {
+      if (typeof response !== "string" || !Object.hasOwn(answer.legend, response)) {
+        return { kind: "invalid" };
+      }
+      const level = Number(response);
+      return level === answer.score ? { kind: "confirm" } : { kind: "override", answer: { ...answer, score: level } };
+    }
+    case "noul":
+      if (typeof response !== "boolean")
+        return { kind: "invalid" };
+      return response === answer.noul >= 0.5 ? { kind: "confirm" } : { kind: "override", answer: { ...answer, noul: response ? 1 : 0 } };
+  }
+}
+function resolveReviewedDecision(parkedOutput, approval) {
+  const parked = SystemOneDecisionOutputSchema.safeParse(parkedOutput);
+  if (!parked.success || parked.data.review?.status !== "pending")
+    return null;
+  const decision = parked.data;
+  const parkedQuestions = decision.review?.questions ?? {};
+  const finish = (status, answers2, questions2, reason) => ({
+    output: {
+      ...decision,
+      answers: answers2,
+      review: {
+        status,
+        approvalRequestId: approval.requestId,
+        ...reason ? { reason } : {},
+        questions: questions2
+      }
+    },
+    nextPort: status
+  });
+  if (approval.status !== "approved") {
+    return finish(approval.status, decision.answers, parkedQuestions);
+  }
+  const answers = { ...decision.answers };
+  const questions = { ...parkedQuestions };
+  for (const [id, info] of Object.entries(parkedQuestions)) {
+    const modelAnswer = decision.answers[id];
+    if (!info.inBand || !modelAnswer)
+      continue;
+    const human = readHumanAnswer(modelAnswer, approval.responses?.[id]);
+    if (human.kind === "invalid") {
+      return finish("rejected", decision.answers, parkedQuestions, `The response for "${id}" is not one of its options`);
+    }
+    if (human.kind === "override")
+      answers[id] = human.answer;
+    questions[id] = { ...info, decidedBy: "human", modelAnswer: modelAnswerOf(modelAnswer) };
+  }
+  return finish("approved", answers, questions);
+}
+var REQUEST_ID_RE = /^[A-Za-z0-9._:-]{1,128}$/;
+var ERROR_CODE_RE = /^[A-Za-z0-9._:-]{1,64}$/;
+function readRequestId(headers) {
+  const value = headers.get("x-request-id") ?? headers.get("request-id");
+  return value && REQUEST_ID_RE.test(value) ? value : undefined;
+}
+function parseRetryAfter(value, now) {
+  if (!value)
+    return;
+  const trimmed = value.trim();
+  if (/^\d+(\.\d+)?$/.test(trimmed))
+    return Math.round(Number(trimmed) * 1000);
+  const at = Date.parse(trimmed);
+  return Number.isNaN(at) ? undefined : Math.max(0, at - now);
+}
+function readErrorCode(text) {
+  if (text.length === 0 || text.length > MAX_ERROR_BODY_CHARS)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    return;
+  }
+  if (!isRecord(parsed))
+    return;
+  const nested = isRecord(parsed.error) ? parsed.error : undefined;
+  const detail = isRecord(parsed.detail) ? parsed.detail : undefined;
+  for (const candidate of [
+    nested?.code,
+    nested?.type,
+    detail?.error_type,
+    parsed.code,
+    parsed.type
+  ]) {
+    if (typeof candidate === "string" && ERROR_CODE_RE.test(candidate))
+      return candidate;
+  }
+  return;
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted)
+      return resolve();
+    const timer = setTimeout(done, ms);
+    function done() {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", done);
+      resolve();
+    }
+    signal.addEventListener("abort", done, { once: true });
+  });
+}
+
+class SystemOneDecisionExecutor extends BaseExecutor {
+  options;
+  type = SYSTEM_ONE_DECISION_NODE_TYPE;
+  mode = "async";
+  configSchema = SystemOneDecisionConfigSchema;
+  outputSchema = SystemOneDecisionOutputSchema;
+  constructor(deps, options = {}) {
+    super(deps);
+    this.options = options;
+  }
+  providerContext() {
+    return { db: this.deps.db, env: this.options.env ?? process.env };
+  }
+  resolveTarget(id) {
+    return resolveSystemOneTarget(id, this.providerContext(), {
+      apiKey: this.options.getApiKey,
+      serverUrl: this.options.getServerUrl
+    });
+  }
+  async checkReadiness(nodes) {
+    const nodeIdsByProvider = new Map;
+    for (const node of nodes) {
+      const id = systemOneProviderOf(node.config);
+      if (id)
+        nodeIdsByProvider.set(id, [...nodeIdsByProvider.get(id) ?? [], node.id]);
+    }
+    const problems = [];
+    for (const [id, nodeIds] of nodeIdsByProvider) {
+      const target = await this.resolveTarget(id);
+      if (!target.ok)
+        problems.push({ nodeIds, message: target.error });
+    }
+    return problems;
+  }
+  async execute(config, context, meta) {
+    if (config.humanReview) {
+      const existing = await this.deps.db.getApprovalRequestByStepId(meta.stepId);
+      if (existing) {
+        return this.handOffToReviewer(config, await this.readParked(meta.stepId), context, meta);
+      }
+    }
+    const providerId = config.provider;
+    const provider = SYSTEM_ONE_PROVIDERS[providerId];
+    const target = await this.resolveTarget(providerId);
+    if (!target.ok)
+      return { status: "failed", error: target.error };
+    const { apiKey, endpoint } = target;
+    const model = config.model ?? provider.defaultModel;
+    const body = JSON.stringify({
+      state: config.state,
+      ...model === undefined ? {} : { model },
+      questions: config.questions
+    });
+    const scrub = (message) => message.split(apiKey).join("[REDACTED]");
+    const sent = await this.send(providerId, endpoint, apiKey, body, config.timeoutMs, config.maxRetries);
+    if (!sent.ok)
+      return { status: "failed", error: scrub(sent.error) };
+    let parsed;
+    try {
+      parsed = JSON.parse(sent.text);
+    } catch {
+      return { status: "failed", error: "SystemOne response was not valid JSON" };
+    }
+    let decision;
+    try {
+      decision = validateSystemOneResponse(config.questions, parsed, sent.requestId, provider.confidenceField);
+    } catch (err) {
+      if (err instanceof SystemOneContractError) {
+        return {
+          status: "failed",
+          error: scrub(`SystemOne response failed validation: ${err.message}`)
+        };
+      }
+      throw err;
+    }
+    if (!config.humanReview)
+      return { status: "success", output: decision };
+    return this.reviewDecision(config, config.humanReview, decision, context, meta);
+  }
+  async reviewDecision(config, review, decision, context, meta) {
+    const questions = {};
+    for (const [id, answer] of Object.entries(decision.answers)) {
+      const confidence = answerConfidence(answer);
+      questions[id] = {
+        confidence,
+        inBand: confidence >= review.band.min && confidence <= review.band.max,
+        decidedBy: "model"
+      };
+    }
+    if (!Object.values(questions).some((question) => question.inBand)) {
+      return {
+        status: "success",
+        output: { ...decision, review: { status: "not_required", questions } },
+        nextPort: "approved"
+      };
+    }
+    const parked = {
+      ...decision,
+      review: { status: "pending", questions }
+    };
+    await this.deps.db.updateWorkflowRunStep(meta.stepId, { output: parked });
+    return this.handOffToReviewer(config, parked, context, meta);
+  }
+  async readParked(stepId) {
+    const step = await this.deps.db.getWorkflowRunStep(stepId);
+    const parked = SystemOneDecisionOutputSchema.safeParse(step?.output);
+    return parked.success && parked.data.review?.status === "pending" ? parked.data : null;
+  }
+  async handOffToReviewer(config, parked, context, meta) {
+    if (!parked || !config.humanReview) {
+      return {
+        status: "failed",
+        error: "The decision this step parked with is missing, so its approval cannot be resumed. Run the node again."
+      };
+    }
+    const result = await new HumanInTheLoopExecutor(this.deps).run({
+      config: buildReviewCard(meta.nodeId, config, config.humanReview, parked),
+      context,
+      meta
+    });
+    if (result.status === "failed")
+      return { status: "failed", error: result.error };
+    if ("async" in result)
+      return result;
+    const answered = result.output;
+    const outcome = answered ? this.resolveApproval(parked, {
+      requestId: answered.requestId,
+      status: answered.status,
+      responses: answered.responses
+    }) : null;
+    if (!outcome) {
+      return {
+        status: "failed",
+        error: "The approval was answered but its result could not be applied"
+      };
+    }
+    return {
+      status: "success",
+      output: outcome.output,
+      nextPort: outcome.nextPort
+    };
+  }
+  resolveApproval(parkedOutput, approval) {
+    return resolveReviewedDecision(parkedOutput, approval);
+  }
+  async send(providerId, endpoint, apiKey, body, timeoutMs, maxRetries) {
+    const doFetch = this.options.fetch ?? fetch;
+    const sleep = this.options.sleep ?? defaultSleep;
+    const now = this.options.now ?? Date.now;
+    const random = this.options.random ?? Math.random;
+    const deadlineAt = now() + timeoutMs - DEADLINE_MARGIN_MS;
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), Math.max(0, deadlineAt - now()));
+    const timedOut = () => ({
+      ok: false,
+      error: `SystemOne request exceeded its ${timeoutMs}ms time budget`
+    });
+    try {
+      for (let attempt = 0;; attempt++) {
+        const result = await this.attemptOnce(doFetch, providerId, endpoint, apiKey, body, controller.signal, now);
+        if (result.kind === "ok") {
+          return { ok: true, text: result.text, requestId: result.requestId };
+        }
+        if (result.kind === "timeout" || controller.signal.aborted)
+          return timedOut();
+        const attempts = attempt + 1;
+        const suffix = attempts > 1 ? ` after ${attempts} attempts` : "";
+        if (!result.retryable || attempt >= maxRetries) {
+          return { ok: false, error: `${result.message}${suffix}` };
+        }
+        const backoff = Math.min(BACKOFF_CAP_MS, BACKOFF_BASE_MS * 2 ** attempt);
+        const delay = result.retryAfterMs ?? Math.round(backoff * (0.5 + random() * 0.5));
+        if (delay >= deadlineAt - now()) {
+          return {
+            ok: false,
+            error: `${result.message}${suffix}; the ${delay}ms retry delay does not fit the ${timeoutMs}ms time budget`
+          };
+        }
+        await sleep(delay, controller.signal);
+        if (controller.signal.aborted)
+          return timedOut();
+      }
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async attemptOnce(doFetch, providerId, endpoint, apiKey, body, signal, now) {
+    let res;
+    try {
+      res = await doFetch(endpoint, {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          accept: "application/json",
+          authorization: `Bearer ${apiKey}`
+        },
+        body,
+        redirect: "manual",
+        signal
+      });
+    } catch (err) {
+      if (signal.aborted)
+        return { kind: "timeout" };
+      const code2 = err?.code;
+      const detail2 = typeof code2 === "string" && /^[A-Z0-9_]{3,40}$/.test(code2) ? ` (${code2})` : "";
+      return {
+        kind: "fail",
+        message: `SystemOne request failed: network error${detail2}`,
+        retryable: true
+      };
+    }
+    const requestId = readRequestId(res.headers);
+    const withId = (message) => requestId ? `${message} [request ${requestId}]` : message;
+    if (res.status >= 200 && res.status < 300) {
+      let text;
+      try {
+        text = await res.text();
+      } catch {
+        if (signal.aborted)
+          return { kind: "timeout" };
+        return {
+          kind: "fail",
+          message: withId("SystemOne response body could not be read"),
+          retryable: true
+        };
+      }
+      if (text.length > MAX_RESPONSE_CHARS) {
+        return {
+          kind: "fail",
+          message: withId("SystemOne response exceeded the size limit"),
+          retryable: false
+        };
+      }
+      return { kind: "ok", text, requestId };
+    }
+    if (res.status >= 300 && res.status < 400) {
+      return {
+        kind: "fail",
+        message: withId(`SystemOne request was redirected (HTTP ${res.status}); redirects are refused`),
+        retryable: false
+      };
+    }
+    let errorText = "";
+    try {
+      errorText = await res.text();
+    } catch {
+      if (signal.aborted)
+        return { kind: "timeout" };
+    }
+    const code = readErrorCode(errorText);
+    if (res.status === 401 || res.status === 403) {
+      return {
+        kind: "fail",
+        message: withId(systemOneKeyRejectedMessage(providerId, res.status, code)),
+        retryable: false
+      };
+    }
+    const detail = code ? ` (${code})` : "";
+    const retryable = res.status === 408 || res.status === 429 || res.status >= 500;
+    return {
+      kind: "fail",
+      message: withId(`SystemOne API returned HTTP ${res.status}${detail}`),
+      retryable,
+      retryAfterMs: retryable ? parseRetryAfter(res.headers.get("retry-after"), now()) : undefined
+    };
+  }
+}
+
 // src/workflows/definition.ts
 function getNextTargets(next) {
   if (typeof next === "string")
@@ -175307,6 +176795,7 @@ function validateDefinition(def, registry, options = {}) {
     if (node.type === "human-in-the-loop" && typeof node.config.questions === "string" && !/^\{\{[^}]+\}\}$/.test(node.config.questions.trim())) {
       errors.push(`Node "${node.id}" human-in-the-loop config.questions must be an array or one exact {{interpolation}} token`);
     }
+    errors.push(...systemOneStaticShapeViolations(node), ...systemOneRetryViolations(node));
     if (node.type === "foreach") {
       validateForeachNode(node, errors);
       if (node.id.includes("#")) {
@@ -182044,25 +183533,25 @@ init_db();
 
 // src/apps/format-upgrades.ts
 var CURRENT_APP_SCHEMA_VERSION = 1;
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function upgradeFrom0(raw) {
   const upgraded = { ...raw };
-  if (isRecord(upgraded.page) && !Object.hasOwn(upgraded, "pages")) {
+  if (isRecord2(upgraded.page) && !Object.hasOwn(upgraded, "pages")) {
     upgraded.pages = { main: upgraded.page };
     upgraded.defaultPage = "main";
   }
   delete upgraded.page;
-  if (isRecord(upgraded.models)) {
+  if (isRecord2(upgraded.models)) {
     upgraded.models = Object.fromEntries(Object.entries(upgraded.models).map(([modelName, model]) => {
-      if (!isRecord(model))
+      if (!isRecord2(model))
         return [modelName, model];
       const upgradedModel = { ...model };
       delete upgradedModel.sources;
-      if (isRecord(upgradedModel.columns)) {
+      if (isRecord2(upgradedModel.columns)) {
         upgradedModel.columns = Object.fromEntries(Object.entries(upgradedModel.columns).map(([columnName, column]) => {
-          if (!isRecord(column))
+          if (!isRecord2(column))
             return [columnName, column];
           const upgradedColumn = { ...column };
           delete upgradedColumn.source;
@@ -182077,13 +183566,13 @@ function upgradeFrom0(raw) {
 }
 var APP_FORMAT_UPGRADES = [{ from: 0, to: 1, upgrade: upgradeFrom0 }];
 function schemaVersionOf(raw) {
-  if (!isRecord(raw) || typeof raw.schemaVersion !== "number" || !Number.isInteger(raw.schemaVersion)) {
+  if (!isRecord2(raw) || typeof raw.schemaVersion !== "number" || !Number.isInteger(raw.schemaVersion)) {
     return 0;
   }
   return raw.schemaVersion;
 }
 function upgradeAppDefinition(raw) {
-  if (!isRecord(raw))
+  if (!isRecord2(raw))
     return raw;
   let upgraded = raw;
   let version = schemaVersionOf(upgraded);
@@ -182667,6 +184156,21 @@ export interface SwarmSdk {
   config_set(args: { key: string; value: unknown; scope?: "global" | "agent" | "repo"; scopeId?: string; isSecret?: boolean }): Promise<unknown>;
   config_delete(args: { id: string }): Promise<unknown>;
 
+  // --- write: model catalog ---
+  modelCatalog_refresh(args?: { force?: boolean }): Promise<unknown>;
+  modelCatalog_overlayUpsert(args: {
+    provider: string;
+    modelId: string;
+    name?: string;
+    releaseDate?: string;
+    contextWindow?: number;
+    maxOutput?: number;
+    reasoningOptions?: Array<{ type: string; values?: string[] }>;
+    pricing?: { input?: number; output?: number; cache_read?: number; cache_write?: number };
+    reason: string;
+    verifiedBy?: string;
+  }): Promise<unknown>;
+
   // --- write: slack ---
   slack_post(args: { channelId: string; message: string; blocks?: unknown }): Promise<unknown>;
   slack_reply(args: { channelId?: string; threadTs?: string; message: string; taskId?: string; blocks?: unknown }): Promise<unknown>;
@@ -183405,4 +184909,4 @@ void _scriptMain;
   });
 }
 
-export { require_dist, isInvalidClientError, assertUrlSafe, publicEndpointSsrfOptions, discoverProtectedResourceMetadata, discoverAuthorizationServerMetadata, normalizeTokenEndpointAuthMethod, resolveAdvertisedTokenEndpointAuthMethod, authMethodForStoredClient, selectDcrTokenEndpointAuthMethod, registerClient, buildAuthorizeUrl, exchangeCodeForTokens, refreshMcpToken, revokeMcpToken, computeExpiresAt, getMcpOAuthToken, findReusableMcpOAuthClient, invalidateMcpOAuthClient, upsertMcpOAuthToken, applyMcpOAuthRefresh, markMcpOAuthTokenStatus, deleteMcpOAuthToken, insertMcpOAuthPending, consumeMcpOAuthPending, gcMcpOAuthPending, setMcpServerAuthMethod, ensureMcpToken, callMcpServerTool, listVendoredOpenapiEntries, ConnectionAuthInputSchema, connectionAuthSummary, listRelationalCredentialBindings, getCredentialBindingById, findCredentialBindingByIdentity, upsertCredentialBinding, disableCredentialBinding, listScriptConnections, listScriptConnectionsAsync, getScriptConnectionById, ScriptConnectionConflictError, connectionAuthInputFromFlat, upsertScriptConnection, refreshScriptConnection, setScriptConnectionEnabled, getScriptApiConnectionDescriptors, getScriptMcpConnectionDescriptors, getScriptApiTypes, getScriptMcpTypes, oauthAppToProviderConfig, getOAuthProviderConfig, getOAuthBindingTokenStatus, buildScriptCredentialBindingsWithFailures, buildScriptCredentialBindings, upsertScriptByName, getScript, getScriptById, getScriptVersion, listScripts, listScriptVersions, deleteScript, touchScratchScriptLastUsed, restoreScratchScriptLastUsedIfUnchanged, createScriptApi, listScriptApisForScript, getScriptApiById, getScriptApiSecret, updateScriptApi, rotateScriptApiSecret, deleteScriptApi, recordScriptApiUsage, buildSandboxedCommand, sandboxSpawnEnv, createCappedStreamState, snapshotCapped, readStreamCapped, writeBareImportShim, MIN_SCRIPT_WALL_CLOCK_MS, SCRIPT_LONG_TIMEOUT_HINT_MS, MAX_SCRIPT_WALL_CLOCK_MS, DEFAULT_SCRIPT_RESOURCES, require_typescript, checkImportAllowlist, validateScriptImports, runScript, getNextTargets, generateEdges, findEntryNodes, resolveValidationPort, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch, extractScriptSignature, extractArgsJsonSchema, getSavedScriptOwnerAgentId, runSavedScriptAsAgent, resolveSyncRunAs, AppNameSchema, ColumnKindSchema, isIso8601Date, SYSTEM_COLUMN_KINDS, SORTABLE_SYSTEM_DATE_COLUMNS, AppElementsSchema, AppDefinitionSchema, collectScriptReferences, parseAppDefinition, applyAppDefinitionPatch, upgradeAppDefinition, decodeAppDefinition, appDefinitionNeedsRepair, createApp, getApp, listApps, listAppRecords, updateApp, deleteApp, getScriptAppTypes, SCRIPT_SDK_TYPES, scriptSdkTypesWithGeneratedApis, SCRIPT_STDLIB_MODULE_TYPES, scriptStdlibTypesWithGeneratedApis, typecheckWithAmbient, typecheckScript };
+export { require_dist, isInvalidClientError, assertUrlSafe, publicEndpointSsrfOptions, discoverProtectedResourceMetadata, discoverAuthorizationServerMetadata, normalizeTokenEndpointAuthMethod, resolveAdvertisedTokenEndpointAuthMethod, authMethodForStoredClient, selectDcrTokenEndpointAuthMethod, registerClient, buildAuthorizeUrl, exchangeCodeForTokens, refreshMcpToken, revokeMcpToken, computeExpiresAt, getMcpOAuthToken, findReusableMcpOAuthClient, invalidateMcpOAuthClient, upsertMcpOAuthToken, applyMcpOAuthRefresh, markMcpOAuthTokenStatus, deleteMcpOAuthToken, insertMcpOAuthPending, consumeMcpOAuthPending, gcMcpOAuthPending, setMcpServerAuthMethod, ensureMcpToken, callMcpServerTool, listVendoredOpenapiEntries, ConnectionAuthInputSchema, connectionAuthSummary, listRelationalCredentialBindings, getCredentialBindingById, findCredentialBindingByIdentity, upsertCredentialBinding, disableCredentialBinding, listScriptConnections, listScriptConnectionsAsync, getScriptConnectionById, ScriptConnectionConflictError, connectionAuthInputFromFlat, upsertScriptConnection, refreshScriptConnection, setScriptConnectionEnabled, getScriptApiConnectionDescriptors, getScriptMcpConnectionDescriptors, getScriptApiTypes, getScriptMcpTypes, oauthAppToProviderConfig, getOAuthProviderConfig, getOAuthBindingTokenStatus, buildScriptCredentialBindingsWithFailures, buildScriptCredentialBindings, upsertScriptByName, getScript, getScriptById, getScriptVersion, listScripts, listScriptVersions, deleteScript, touchScratchScriptLastUsed, restoreScratchScriptLastUsedIfUnchanged, createScriptApi, listScriptApisForScript, getScriptApiById, getScriptApiSecret, updateScriptApi, rotateScriptApiSecret, deleteScriptApi, recordScriptApiUsage, buildSandboxedCommand, sandboxSpawnEnv, createCappedStreamState, snapshotCapped, readStreamCapped, writeBareImportShim, MIN_SCRIPT_WALL_CLOCK_MS, SCRIPT_LONG_TIMEOUT_HINT_MS, MAX_SCRIPT_WALL_CLOCK_MS, DEFAULT_SCRIPT_RESOURCES, require_typescript, checkImportAllowlist, validateScriptImports, runScript, BaseExecutor, postApprovalCancellationUpdates, createApprovalFollowUpTask, HumanInTheLoopExecutor, resolveWorkflowLlmConfig, SYSTEM_ONE_DECISION_NODE_TYPE, systemOneRetryViolations, systemOneUnresolvedError, SystemOneDecisionExecutor, getNextTargets, generateEdges, findEntryNodes, resolveValidationPort, getSuccessors, definitionNodeIds, validateDefinition, applyDefinitionPatch, extractScriptSignature, extractArgsJsonSchema, getSavedScriptOwnerAgentId, runSavedScriptAsAgent, resolveSyncRunAs, AppNameSchema, ColumnKindSchema, isIso8601Date, SYSTEM_COLUMN_KINDS, SORTABLE_SYSTEM_DATE_COLUMNS, AppElementsSchema, AppDefinitionSchema, collectScriptReferences, parseAppDefinition, applyAppDefinitionPatch, upgradeAppDefinition, decodeAppDefinition, appDefinitionNeedsRepair, createApp, getApp, listApps, listAppRecords, updateApp, deleteApp, getScriptAppTypes, SCRIPT_SDK_TYPES, scriptSdkTypesWithGeneratedApis, SCRIPT_STDLIB_MODULE_TYPES, scriptStdlibTypesWithGeneratedApis, typecheckWithAmbient, typecheckScript };