@desplega.ai/agent-swarm 1.172.0 → 2.0.0

package/dist/cli-jta2eyzc.js

@@ -0,0 +1,619 @@
+import {
+  __commonJS
+} from "./cli-bc05qbss.js";
+
+// node_modules/lru-cache/dist/commonjs/index.min.js
+var require_index_min = __commonJS(function(exports) {
+  Object.defineProperty(exports, "__esModule", { value: true });
+  exports.LRUCache = undefined;
+  var x = typeof performance == "object" && performance && typeof performance.now == "function" ? performance : Date;
+  var U = new Set;
+  var R = typeof process == "object" && process ? process : {};
+  var I = (a, t, e, i) => {
+    typeof R.emitWarning == "function" ? R.emitWarning(a, t, e, i) : console.error(`[${e}] ${t}: ${a}`);
+  };
+  var C = globalThis.AbortController;
+  var L = globalThis.AbortSignal;
+  if (typeof C > "u") {
+    L = class {
+      onabort;
+      _onabort = [];
+      reason;
+      aborted = false;
+      addEventListener(i, s) {
+        this._onabort.push(s);
+      }
+    }, C = class {
+      constructor() {
+        t();
+      }
+      signal = new L;
+      abort(i) {
+        if (!this.signal.aborted) {
+          this.signal.reason = i, this.signal.aborted = true;
+          for (let s of this.signal._onabort)
+            s(i);
+          this.signal.onabort?.(i);
+        }
+      }
+    };
+    let a = R.env?.LRU_CACHE_IGNORE_AC_WARNING !== "1", t = () => {
+      a && (a = false, I("AbortController is not defined. If using lru-cache in node 14, load an AbortController polyfill from the `node-abort-controller` package. A minimal polyfill is provided for use by LRUCache.fetch(), but it should not be relied upon in other contexts (eg, passing it to other APIs that use AbortController/AbortSignal might have undesirable effects). You may disable this with LRU_CACHE_IGNORE_AC_WARNING=1 in the env.", "NO_ABORT_CONTROLLER", "ENOTSUP", t));
+    };
+  }
+  var G = (a) => !U.has(a);
+  var H = Symbol("type");
+  var y = (a) => a && a === Math.floor(a) && a > 0 && isFinite(a);
+  var M = (a) => y(a) ? a <= Math.pow(2, 8) ? Uint8Array : a <= Math.pow(2, 16) ? Uint16Array : a <= Math.pow(2, 32) ? Uint32Array : a <= Number.MAX_SAFE_INTEGER ? z : null : null;
+  var z = class extends Array {
+    constructor(t) {
+      super(t), this.fill(0);
+    }
+  };
+  var W = class a {
+    heap;
+    length;
+    static #o = false;
+    static create(t) {
+      let e = M(t);
+      if (!e)
+        return [];
+      a.#o = true;
+      let i = new a(t, e);
+      return a.#o = false, i;
+    }
+    constructor(t, e) {
+      if (!a.#o)
+        throw new TypeError("instantiate Stack using Stack.create(n)");
+      this.heap = new e(t), this.length = 0;
+    }
+    push(t) {
+      this.heap[this.length++] = t;
+    }
+    pop() {
+      return this.heap[--this.length];
+    }
+  };
+  var D = class a {
+    #o;
+    #c;
+    #w;
+    #C;
+    #S;
+    #L;
+    #U;
+    #m;
+    get perf() {
+      return this.#m;
+    }
+    ttl;
+    ttlResolution;
+    ttlAutopurge;
+    updateAgeOnGet;
+    updateAgeOnHas;
+    allowStale;
+    noDisposeOnSet;
+    noUpdateTTL;
+    maxEntrySize;
+    sizeCalculation;
+    noDeleteOnFetchRejection;
+    noDeleteOnStaleGet;
+    allowStaleOnFetchAbort;
+    allowStaleOnFetchRejection;
+    ignoreFetchAbort;
+    #n;
+    #_;
+    #s;
+    #i;
+    #t;
+    #a;
+    #u;
+    #l;
+    #h;
+    #b;
+    #r;
+    #y;
+    #A;
+    #d;
+    #g;
+    #T;
+    #v;
+    #f;
+    #I;
+    static unsafeExposeInternals(t) {
+      return { starts: t.#A, ttls: t.#d, autopurgeTimers: t.#g, sizes: t.#y, keyMap: t.#s, keyList: t.#i, valList: t.#t, next: t.#a, prev: t.#u, get head() {
+        return t.#l;
+      }, get tail() {
+        return t.#h;
+      }, free: t.#b, isBackgroundFetch: (e) => t.#e(e), backgroundFetch: (e, i, s, h) => t.#G(e, i, s, h), moveToTail: (e) => t.#D(e), indexes: (e) => t.#F(e), rindexes: (e) => t.#O(e), isStale: (e) => t.#p(e) };
+    }
+    get max() {
+      return this.#o;
+    }
+    get maxSize() {
+      return this.#c;
+    }
+    get calculatedSize() {
+      return this.#_;
+    }
+    get size() {
+      return this.#n;
+    }
+    get fetchMethod() {
+      return this.#L;
+    }
+    get memoMethod() {
+      return this.#U;
+    }
+    get dispose() {
+      return this.#w;
+    }
+    get onInsert() {
+      return this.#C;
+    }
+    get disposeAfter() {
+      return this.#S;
+    }
+    constructor(t) {
+      let { max: e = 0, ttl: i, ttlResolution: s = 1, ttlAutopurge: h, updateAgeOnGet: n, updateAgeOnHas: o, allowStale: r, dispose: f, onInsert: m, disposeAfter: c, noDisposeOnSet: d, noUpdateTTL: g, maxSize: A = 0, maxEntrySize: p = 0, sizeCalculation: _, fetchMethod: l, memoMethod: w, noDeleteOnFetchRejection: b, noDeleteOnStaleGet: S, allowStaleOnFetchRejection: u, allowStaleOnFetchAbort: T, ignoreFetchAbort: F, perf: v } = t;
+      if (v !== undefined && typeof v?.now != "function")
+        throw new TypeError("perf option must have a now() method if specified");
+      if (this.#m = v ?? x, e !== 0 && !y(e))
+        throw new TypeError("max option must be a nonnegative integer");
+      let O = e ? M(e) : Array;
+      if (!O)
+        throw new Error("invalid max value: " + e);
+      if (this.#o = e, this.#c = A, this.maxEntrySize = p || this.#c, this.sizeCalculation = _, this.sizeCalculation) {
+        if (!this.#c && !this.maxEntrySize)
+          throw new TypeError("cannot set sizeCalculation without setting maxSize or maxEntrySize");
+        if (typeof this.sizeCalculation != "function")
+          throw new TypeError("sizeCalculation set to non-function");
+      }
+      if (w !== undefined && typeof w != "function")
+        throw new TypeError("memoMethod must be a function if defined");
+      if (this.#U = w, l !== undefined && typeof l != "function")
+        throw new TypeError("fetchMethod must be a function if specified");
+      if (this.#L = l, this.#v = !!l, this.#s = new Map, this.#i = new Array(e).fill(undefined), this.#t = new Array(e).fill(undefined), this.#a = new O(e), this.#u = new O(e), this.#l = 0, this.#h = 0, this.#b = W.create(e), this.#n = 0, this.#_ = 0, typeof f == "function" && (this.#w = f), typeof m == "function" && (this.#C = m), typeof c == "function" ? (this.#S = c, this.#r = []) : (this.#S = undefined, this.#r = undefined), this.#T = !!this.#w, this.#I = !!this.#C, this.#f = !!this.#S, this.noDisposeOnSet = !!d, this.noUpdateTTL = !!g, this.noDeleteOnFetchRejection = !!b, this.allowStaleOnFetchRejection = !!u, this.allowStaleOnFetchAbort = !!T, this.ignoreFetchAbort = !!F, this.maxEntrySize !== 0) {
+        if (this.#c !== 0 && !y(this.#c))
+          throw new TypeError("maxSize must be a positive integer if specified");
+        if (!y(this.maxEntrySize))
+          throw new TypeError("maxEntrySize must be a positive integer if specified");
+        this.#B();
+      }
+      if (this.allowStale = !!r, this.noDeleteOnStaleGet = !!S, this.updateAgeOnGet = !!n, this.updateAgeOnHas = !!o, this.ttlResolution = y(s) || s === 0 ? s : 1, this.ttlAutopurge = !!h, this.ttl = i || 0, this.ttl) {
+        if (!y(this.ttl))
+          throw new TypeError("ttl must be a positive integer if specified");
+        this.#j();
+      }
+      if (this.#o === 0 && this.ttl === 0 && this.#c === 0)
+        throw new TypeError("At least one of max, maxSize, or ttl is required");
+      if (!this.ttlAutopurge && !this.#o && !this.#c) {
+        let E = "LRU_CACHE_UNBOUNDED";
+        G(E) && (U.add(E), I("TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.", "UnboundedCacheWarning", E, a));
+      }
+    }
+    getRemainingTTL(t) {
+      return this.#s.has(t) ? 1 / 0 : 0;
+    }
+    #j() {
+      let t = new z(this.#o), e = new z(this.#o);
+      this.#d = t, this.#A = e;
+      let i = this.ttlAutopurge ? new Array(this.#o) : undefined;
+      this.#g = i, this.#N = (n, o, r = this.#m.now()) => {
+        if (e[n] = o !== 0 ? r : 0, t[n] = o, i?.[n] && (clearTimeout(i[n]), i[n] = undefined), o !== 0 && i) {
+          let f = setTimeout(() => {
+            this.#p(n) && this.#E(this.#i[n], "expire");
+          }, o + 1);
+          f.unref && f.unref(), i[n] = f;
+        }
+      }, this.#R = (n) => {
+        e[n] = t[n] !== 0 ? this.#m.now() : 0;
+      }, this.#z = (n, o) => {
+        if (t[o]) {
+          let r = t[o], f = e[o];
+          if (!r || !f)
+            return;
+          n.ttl = r, n.start = f, n.now = s || h();
+          let m = n.now - f;
+          n.remainingTTL = r - m;
+        }
+      };
+      let s = 0, h = () => {
+        let n = this.#m.now();
+        if (this.ttlResolution > 0) {
+          s = n;
+          let o = setTimeout(() => s = 0, this.ttlResolution);
+          o.unref && o.unref();
+        }
+        return n;
+      };
+      this.getRemainingTTL = (n) => {
+        let o = this.#s.get(n);
+        if (o === undefined)
+          return 0;
+        let r = t[o], f = e[o];
+        if (!r || !f)
+          return 1 / 0;
+        let m = (s || h()) - f;
+        return r - m;
+      }, this.#p = (n) => {
+        let o = e[n], r = t[n];
+        return !!r && !!o && (s || h()) - o > r;
+      };
+    }
+    #R = () => {};
+    #z = () => {};
+    #N = () => {};
+    #p = () => false;
+    #B() {
+      let t = new z(this.#o);
+      this.#_ = 0, this.#y = t, this.#W = (e) => {
+        this.#_ -= t[e], t[e] = 0;
+      }, this.#P = (e, i, s, h) => {
+        if (this.#e(i))
+          return 0;
+        if (!y(s))
+          if (h) {
+            if (typeof h != "function")
+              throw new TypeError("sizeCalculation must be a function");
+            if (s = h(i, e), !y(s))
+              throw new TypeError("sizeCalculation return invalid (expect positive integer)");
+          } else
+            throw new TypeError("invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set.");
+        return s;
+      }, this.#M = (e, i, s) => {
+        if (t[e] = i, this.#c) {
+          let h = this.#c - t[e];
+          for (;this.#_ > h; )
+            this.#x(true);
+        }
+        this.#_ += t[e], s && (s.entrySize = i, s.totalCalculatedSize = this.#_);
+      };
+    }
+    #W = (t) => {};
+    #M = (t, e, i) => {};
+    #P = (t, e, i, s) => {
+      if (i || s)
+        throw new TypeError("cannot set size without setting maxSize or maxEntrySize on cache");
+      return 0;
+    };
+    *#F({ allowStale: t = this.allowStale } = {}) {
+      if (this.#n)
+        for (let e = this.#h;!(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#l)); )
+          e = this.#u[e];
+    }
+    *#O({ allowStale: t = this.allowStale } = {}) {
+      if (this.#n)
+        for (let e = this.#l;!(!this.#H(e) || ((t || !this.#p(e)) && (yield e), e === this.#h)); )
+          e = this.#a[e];
+    }
+    #H(t) {
+      return t !== undefined && this.#s.get(this.#i[t]) === t;
+    }
+    *entries() {
+      for (let t of this.#F())
+        this.#t[t] !== undefined && this.#i[t] !== undefined && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+    }
+    *rentries() {
+      for (let t of this.#O())
+        this.#t[t] !== undefined && this.#i[t] !== undefined && !this.#e(this.#t[t]) && (yield [this.#i[t], this.#t[t]]);
+    }
+    *keys() {
+      for (let t of this.#F()) {
+        let e = this.#i[t];
+        e !== undefined && !this.#e(this.#t[t]) && (yield e);
+      }
+    }
+    *rkeys() {
+      for (let t of this.#O()) {
+        let e = this.#i[t];
+        e !== undefined && !this.#e(this.#t[t]) && (yield e);
+      }
+    }
+    *values() {
+      for (let t of this.#F())
+        this.#t[t] !== undefined && !this.#e(this.#t[t]) && (yield this.#t[t]);
+    }
+    *rvalues() {
+      for (let t of this.#O())
+        this.#t[t] !== undefined && !this.#e(this.#t[t]) && (yield this.#t[t]);
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+    [Symbol.toStringTag] = "LRUCache";
+    find(t, e = {}) {
+      for (let i of this.#F()) {
+        let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+        if (h !== undefined && t(h, this.#i[i], this))
+          return this.get(this.#i[i], e);
+      }
+    }
+    forEach(t, e = this) {
+      for (let i of this.#F()) {
+        let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+        h !== undefined && t.call(e, h, this.#i[i], this);
+      }
+    }
+    rforEach(t, e = this) {
+      for (let i of this.#O()) {
+        let s = this.#t[i], h = this.#e(s) ? s.__staleWhileFetching : s;
+        h !== undefined && t.call(e, h, this.#i[i], this);
+      }
+    }
+    purgeStale() {
+      let t = false;
+      for (let e of this.#O({ allowStale: true }))
+        this.#p(e) && (this.#E(this.#i[e], "expire"), t = true);
+      return t;
+    }
+    info(t) {
+      let e = this.#s.get(t);
+      if (e === undefined)
+        return;
+      let i = this.#t[e], s = this.#e(i) ? i.__staleWhileFetching : i;
+      if (s === undefined)
+        return;
+      let h = { value: s };
+      if (this.#d && this.#A) {
+        let n = this.#d[e], o = this.#A[e];
+        if (n && o) {
+          let r = n - (this.#m.now() - o);
+          h.ttl = r, h.start = Date.now();
+        }
+      }
+      return this.#y && (h.size = this.#y[e]), h;
+    }
+    dump() {
+      let t = [];
+      for (let e of this.#F({ allowStale: true })) {
+        let i = this.#i[e], s = this.#t[e], h = this.#e(s) ? s.__staleWhileFetching : s;
+        if (h === undefined || i === undefined)
+          continue;
+        let n = { value: h };
+        if (this.#d && this.#A) {
+          n.ttl = this.#d[e];
+          let o = this.#m.now() - this.#A[e];
+          n.start = Math.floor(Date.now() - o);
+        }
+        this.#y && (n.size = this.#y[e]), t.unshift([i, n]);
+      }
+      return t;
+    }
+    load(t) {
+      this.clear();
+      for (let [e, i] of t) {
+        if (i.start) {
+          let s = Date.now() - i.start;
+          i.start = this.#m.now() - s;
+        }
+        this.set(e, i.value, i);
+      }
+    }
+    set(t, e, i = {}) {
+      if (e === undefined)
+        return this.delete(t), this;
+      let { ttl: s = this.ttl, start: h, noDisposeOnSet: n = this.noDisposeOnSet, sizeCalculation: o = this.sizeCalculation, status: r } = i, { noUpdateTTL: f = this.noUpdateTTL } = i, m = this.#P(t, e, i.size || 0, o);
+      if (this.maxEntrySize && m > this.maxEntrySize)
+        return r && (r.set = "miss", r.maxEntrySizeExceeded = true), this.#E(t, "set"), this;
+      let c = this.#n === 0 ? undefined : this.#s.get(t);
+      if (c === undefined)
+        c = this.#n === 0 ? this.#h : this.#b.length !== 0 ? this.#b.pop() : this.#n === this.#o ? this.#x(false) : this.#n, this.#i[c] = t, this.#t[c] = e, this.#s.set(t, c), this.#a[this.#h] = c, this.#u[c] = this.#h, this.#h = c, this.#n++, this.#M(c, m, r), r && (r.set = "add"), f = false, this.#I && this.#C?.(e, t, "add");
+      else {
+        this.#D(c);
+        let d = this.#t[c];
+        if (e !== d) {
+          if (this.#v && this.#e(d)) {
+            d.__abortController.abort(new Error("replaced"));
+            let { __staleWhileFetching: g } = d;
+            g !== undefined && !n && (this.#T && this.#w?.(g, t, "set"), this.#f && this.#r?.push([g, t, "set"]));
+          } else
+            n || (this.#T && this.#w?.(d, t, "set"), this.#f && this.#r?.push([d, t, "set"]));
+          if (this.#W(c), this.#M(c, m, r), this.#t[c] = e, r) {
+            r.set = "replace";
+            let g = d && this.#e(d) ? d.__staleWhileFetching : d;
+            g !== undefined && (r.oldValue = g);
+          }
+        } else
+          r && (r.set = "update");
+        this.#I && this.onInsert?.(e, t, e === d ? "update" : "replace");
+      }
+      if (s !== 0 && !this.#d && this.#j(), this.#d && (f || this.#N(c, s, h), r && this.#z(r, c)), !n && this.#f && this.#r) {
+        let d = this.#r, g;
+        for (;g = d?.shift(); )
+          this.#S?.(...g);
+      }
+      return this;
+    }
+    pop() {
+      try {
+        for (;this.#n; ) {
+          let t = this.#t[this.#l];
+          if (this.#x(true), this.#e(t)) {
+            if (t.__staleWhileFetching)
+              return t.__staleWhileFetching;
+          } else if (t !== undefined)
+            return t;
+        }
+      } finally {
+        if (this.#f && this.#r) {
+          let t = this.#r, e;
+          for (;e = t?.shift(); )
+            this.#S?.(...e);
+        }
+      }
+    }
+    #x(t) {
+      let e = this.#l, i = this.#i[e], s = this.#t[e];
+      return this.#v && this.#e(s) ? s.__abortController.abort(new Error("evicted")) : (this.#T || this.#f) && (this.#T && this.#w?.(s, i, "evict"), this.#f && this.#r?.push([s, i, "evict"])), this.#W(e), this.#g?.[e] && (clearTimeout(this.#g[e]), this.#g[e] = undefined), t && (this.#i[e] = undefined, this.#t[e] = undefined, this.#b.push(e)), this.#n === 1 ? (this.#l = this.#h = 0, this.#b.length = 0) : this.#l = this.#a[e], this.#s.delete(i), this.#n--, e;
+    }
+    has(t, e = {}) {
+      let { updateAgeOnHas: i = this.updateAgeOnHas, status: s } = e, h = this.#s.get(t);
+      if (h !== undefined) {
+        let n = this.#t[h];
+        if (this.#e(n) && n.__staleWhileFetching === undefined)
+          return false;
+        if (this.#p(h))
+          s && (s.has = "stale", this.#z(s, h));
+        else
+          return i && this.#R(h), s && (s.has = "hit", this.#z(s, h)), true;
+      } else
+        s && (s.has = "miss");
+      return false;
+    }
+    peek(t, e = {}) {
+      let { allowStale: i = this.allowStale } = e, s = this.#s.get(t);
+      if (s === undefined || !i && this.#p(s))
+        return;
+      let h = this.#t[s];
+      return this.#e(h) ? h.__staleWhileFetching : h;
+    }
+    #G(t, e, i, s) {
+      let h = e === undefined ? undefined : this.#t[e];
+      if (this.#e(h))
+        return h;
+      let n = new C, { signal: o } = i;
+      o?.addEventListener("abort", () => n.abort(o.reason), { signal: n.signal });
+      let r = { signal: n.signal, options: i, context: s }, f = (p, _ = false) => {
+        let { aborted: l } = n.signal, w = i.ignoreFetchAbort && p !== undefined, b = i.ignoreFetchAbort || !!(i.allowStaleOnFetchAbort && p !== undefined);
+        if (i.status && (l && !_ ? (i.status.fetchAborted = true, i.status.fetchError = n.signal.reason, w && (i.status.fetchAbortIgnored = true)) : i.status.fetchResolved = true), l && !w && !_)
+          return c(n.signal.reason, b);
+        let S = g, u = this.#t[e];
+        return (u === g || w && _ && u === undefined) && (p === undefined ? S.__staleWhileFetching !== undefined ? this.#t[e] = S.__staleWhileFetching : this.#E(t, "fetch") : (i.status && (i.status.fetchUpdated = true), this.set(t, p, r.options))), p;
+      }, m = (p) => (i.status && (i.status.fetchRejected = true, i.status.fetchError = p), c(p, false)), c = (p, _) => {
+        let { aborted: l } = n.signal, w = l && i.allowStaleOnFetchAbort, b = w || i.allowStaleOnFetchRejection, S = b || i.noDeleteOnFetchRejection, u = g;
+        if (this.#t[e] === g && (!S || !_ && u.__staleWhileFetching === undefined ? this.#E(t, "fetch") : w || (this.#t[e] = u.__staleWhileFetching)), b)
+          return i.status && u.__staleWhileFetching !== undefined && (i.status.returnedStale = true), u.__staleWhileFetching;
+        if (u.__returned === u)
+          throw p;
+      }, d = (p, _) => {
+        let l = this.#L?.(t, h, r);
+        l && l instanceof Promise && l.then((w) => p(w === undefined ? undefined : w), _), n.signal.addEventListener("abort", () => {
+          (!i.ignoreFetchAbort || i.allowStaleOnFetchAbort) && (p(undefined), i.allowStaleOnFetchAbort && (p = (w) => f(w, true)));
+        });
+      };
+      i.status && (i.status.fetchDispatched = true);
+      let g = new Promise(d).then(f, m), A = Object.assign(g, { __abortController: n, __staleWhileFetching: h, __returned: undefined });
+      return e === undefined ? (this.set(t, A, { ...r.options, status: undefined }), e = this.#s.get(t)) : this.#t[e] = A, A;
+    }
+    #e(t) {
+      if (!this.#v)
+        return false;
+      let e = t;
+      return !!e && e instanceof Promise && e.hasOwnProperty("__staleWhileFetching") && e.__abortController instanceof C;
+    }
+    async fetch(t, e = {}) {
+      let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: h = this.noDeleteOnStaleGet, ttl: n = this.ttl, noDisposeOnSet: o = this.noDisposeOnSet, size: r = 0, sizeCalculation: f = this.sizeCalculation, noUpdateTTL: m = this.noUpdateTTL, noDeleteOnFetchRejection: c = this.noDeleteOnFetchRejection, allowStaleOnFetchRejection: d = this.allowStaleOnFetchRejection, ignoreFetchAbort: g = this.ignoreFetchAbort, allowStaleOnFetchAbort: A = this.allowStaleOnFetchAbort, context: p, forceRefresh: _ = false, status: l, signal: w } = e;
+      if (!this.#v)
+        return l && (l.fetch = "get"), this.get(t, { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: h, status: l });
+      let b = { allowStale: i, updateAgeOnGet: s, noDeleteOnStaleGet: h, ttl: n, noDisposeOnSet: o, size: r, sizeCalculation: f, noUpdateTTL: m, noDeleteOnFetchRejection: c, allowStaleOnFetchRejection: d, allowStaleOnFetchAbort: A, ignoreFetchAbort: g, status: l, signal: w }, S = this.#s.get(t);
+      if (S === undefined) {
+        l && (l.fetch = "miss");
+        let u = this.#G(t, S, b, p);
+        return u.__returned = u;
+      } else {
+        let u = this.#t[S];
+        if (this.#e(u)) {
+          let E = i && u.__staleWhileFetching !== undefined;
+          return l && (l.fetch = "inflight", E && (l.returnedStale = true)), E ? u.__staleWhileFetching : u.__returned = u;
+        }
+        let T = this.#p(S);
+        if (!_ && !T)
+          return l && (l.fetch = "hit"), this.#D(S), s && this.#R(S), l && this.#z(l, S), u;
+        let F = this.#G(t, S, b, p), O = F.__staleWhileFetching !== undefined && i;
+        return l && (l.fetch = T ? "stale" : "refresh", O && T && (l.returnedStale = true)), O ? F.__staleWhileFetching : F.__returned = F;
+      }
+    }
+    async forceFetch(t, e = {}) {
+      let i = await this.fetch(t, e);
+      if (i === undefined)
+        throw new Error("fetch() returned undefined");
+      return i;
+    }
+    memo(t, e = {}) {
+      let i = this.#U;
+      if (!i)
+        throw new Error("no memoMethod provided to constructor");
+      let { context: s, forceRefresh: h, ...n } = e, o = this.get(t, n);
+      if (!h && o !== undefined)
+        return o;
+      let r = i(t, o, { options: n, context: s });
+      return this.set(t, r, n), r;
+    }
+    get(t, e = {}) {
+      let { allowStale: i = this.allowStale, updateAgeOnGet: s = this.updateAgeOnGet, noDeleteOnStaleGet: h = this.noDeleteOnStaleGet, status: n } = e, o = this.#s.get(t);
+      if (o !== undefined) {
+        let r = this.#t[o], f = this.#e(r);
+        return n && this.#z(n, o), this.#p(o) ? (n && (n.get = "stale"), f ? (n && i && r.__staleWhileFetching !== undefined && (n.returnedStale = true), i ? r.__staleWhileFetching : undefined) : (h || this.#E(t, "expire"), n && i && (n.returnedStale = true), i ? r : undefined)) : (n && (n.get = "hit"), f ? r.__staleWhileFetching : (this.#D(o), s && this.#R(o), r));
+      } else
+        n && (n.get = "miss");
+    }
+    #k(t, e) {
+      this.#u[e] = t, this.#a[t] = e;
+    }
+    #D(t) {
+      t !== this.#h && (t === this.#l ? this.#l = this.#a[t] : this.#k(this.#u[t], this.#a[t]), this.#k(this.#h, t), this.#h = t);
+    }
+    delete(t) {
+      return this.#E(t, "delete");
+    }
+    #E(t, e) {
+      let i = false;
+      if (this.#n !== 0) {
+        let s = this.#s.get(t);
+        if (s !== undefined)
+          if (this.#g?.[s] && (clearTimeout(this.#g?.[s]), this.#g[s] = undefined), i = true, this.#n === 1)
+            this.#V(e);
+          else {
+            this.#W(s);
+            let h = this.#t[s];
+            if (this.#e(h) ? h.__abortController.abort(new Error("deleted")) : (this.#T || this.#f) && (this.#T && this.#w?.(h, t, e), this.#f && this.#r?.push([h, t, e])), this.#s.delete(t), this.#i[s] = undefined, this.#t[s] = undefined, s === this.#h)
+              this.#h = this.#u[s];
+            else if (s === this.#l)
+              this.#l = this.#a[s];
+            else {
+              let n = this.#u[s];
+              this.#a[n] = this.#a[s];
+              let o = this.#a[s];
+              this.#u[o] = this.#u[s];
+            }
+            this.#n--, this.#b.push(s);
+          }
+      }
+      if (this.#f && this.#r?.length) {
+        let s = this.#r, h;
+        for (;h = s?.shift(); )
+          this.#S?.(...h);
+      }
+      return i;
+    }
+    clear() {
+      return this.#V("delete");
+    }
+    #V(t) {
+      for (let e of this.#O({ allowStale: true })) {
+        let i = this.#t[e];
+        if (this.#e(i))
+          i.__abortController.abort(new Error("deleted"));
+        else {
+          let s = this.#i[e];
+          this.#T && this.#w?.(i, s, t), this.#f && this.#r?.push([i, s, t]);
+        }
+      }
+      if (this.#s.clear(), this.#t.fill(undefined), this.#i.fill(undefined), this.#d && this.#A) {
+        this.#d.fill(0), this.#A.fill(0);
+        for (let e of this.#g ?? [])
+          e !== undefined && clearTimeout(e);
+        this.#g?.fill(undefined);
+      }
+      if (this.#y && this.#y.fill(0), this.#l = 0, this.#h = 0, this.#b.length = 0, this.#_ = 0, this.#n = 0, this.#f && this.#r) {
+        let e = this.#r, i;
+        for (;i = e?.shift(); )
+          this.#S?.(...i);
+      }
+    }
+  };
+  exports.LRUCache = D;
+});
+
+export { require_index_min };

package/dist/{cli-esnpehf5.js → cli-k382tshb.js}

@@ -7,7 +7,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@desplega.ai/agent-swarm",
-    version: "1.172.0",
+    version: "2.0.0",
     description: "agent-swarm.dev — an open-source operating system for AI work: a lead agent breaks goals into tasks, routes them to specialized workers such as Claude Code or Codex, runs each worker in an isolated container, and preserves shared memory, tools, schedules, and review gates so delegated work compounds across sessions.",
     keywords: [
       "agent-swarm.dev",
@@ -175,11 +175,6 @@ var init_package = __esm(() => {
       "docs:mcp": "bun scripts/generate-mcp-docs.ts",
       "docs:openapi": "bun scripts/generate-openapi.ts",
       "docs:business-use": "bun scripts/generate-business-use-docs.ts",
-      "pm2-start": "pm2 start ecosystem.config.cjs",
-      "pm2-stop": "pm2 stop ecosystem.config.cjs",
-      "pm2-restart": "pm2 restart ecosystem.config.cjs",
-      "pm2-logs": "pm2 logs swarm-api swarm-ui swarm-lead swarm-worker",
-      "pm2-status": "pm2 status swarm-api swarm-ui swarm-lead swarm-worker",
       seed: "bun scripts/seed.ts",
       "seed:clean": "bun scripts/seed.ts --clean",
       "seed:people": "bun scripts/seed-people.ts",
@@ -187,12 +182,12 @@ var init_package = __esm(() => {
     },
     devDependencies: {
       "@biomejs/biome": "^2.3.10",
-      "@desplega.ai/slack-mock": "^0.4.0",
+      "@desplega.ai/slack-mock": "^0.4.1",
       "@desplega/model-catalog": "workspace:*",
       "@desplega/model-routing": "workspace:*",
       "@faker-js/faker": "^10.4.0",
-      "@opencode/plugin": "2.0.28",
-      "@opencode/sdk": "2.0.28",
+      "@opencode/plugin": "2.0.29",
+      "@opencode/sdk": "2.0.29",
       "@oxlint/plugins": "1.78.0",
       "@types/bun": "latest",
       "@typescript/native-preview": "7.0.0-dev.20260707.2",
@@ -212,13 +207,16 @@ var init_package = __esm(() => {
     dependencies: {
       "@agentclientprotocol/sdk": "1.8.0",
       "@ai-sdk/openai": "^3.0.41",
-      "@anthropic-ai/claude-agent-sdk": "0.3.296",
-      "@anthropic-ai/sdk": "^0.133.0",
+      "@anthropic-ai/claude-agent-sdk": "0.3.300",
+      "@anthropic-ai/sdk": "^0.134.0",
       "@asteasolutions/zod-to-openapi": "^8.0.0",
       "@aws-sdk/client-bedrock": "3.1048.0",
+      "@chat-adapter/discord": "4.41.1",
+      "@chat-adapter/slack": "4.41.1",
+      "@chat-adapter/teams": "4.41.1",
+      "@chat-adapter/telegram": "4.41.1",
       "@cursor/sdk": "1.0.37",
       "@desplega.ai/business-use": "^0.4.2",
-      "@desplega.ai/localtunnel": "^2.2.0",
       "@earendil-works/pi-agent-core": "^1.2.0",
       "@earendil-works/pi-ai": "^1.2.0",
       "@earendil-works/pi-coding-agent": "^1.2.0",
@@ -237,15 +235,16 @@ var init_package = __esm(() => {
       "@opentelemetry/sdk-node": "^0.218.0",
       "@opentelemetry/semantic-conventions": "^1.41.1",
       "@slack/bolt": "^4.6.0",
+      "@slack/web-api": "7.13.0",
       "@types/react": "^19.2.7",
       "@x402/core": "^2.5.0",
       "@x402/evm": "^2.5.0",
       "@x402/fetch": "^2.5.0",
       ai: "^6.0.116",
+      chat: "4.41.1",
       "cron-parser": "^5.4.0",
       "date-fns": "^4.1.0",
       e2b: "2.26.0",
-      hono: "^4.12.3",
       ink: "^6.5.1",
       oauth4webapi: "^3.8.5",
       openai: "^6.22.0",