@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/presets/ai/index.cjs

@@ -0,0 +1,4377 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/base/resilience/_internal.ts
+function operatorOpts(opts) {
+  return { describeKind: "derived", ...opts };
+}
+function msgVal(m) {
+  return m[1];
+}
+function coerceDelayNs(raw) {
+  if (typeof raw !== "number" || !Number.isFinite(raw)) {
+    throw new TypeError("backoff strategy must return a finite number");
+  }
+  return raw < 0 ? 0 : raw;
+}
+function isNode(x) {
+  return x != null && typeof x === "object" && "cache" in x && typeof x.subscribe === "function";
+}
+var import_core4;
+var init_internal = __esm({
+  "src/base/resilience/_internal.ts"() {
+    "use strict";
+    import_core4 = require("@graphrefly/pure-ts/core");
+  }
+});
+
+// src/base/resilience/backoff.ts
+var backoff_exports = {};
+__export(backoff_exports, {
+  NS_PER_MS: () => NS_PER_MS,
+  NS_PER_SEC: () => NS_PER_SEC,
+  constant: () => constant,
+  decorrelatedJitter: () => decorrelatedJitter,
+  exponential: () => exponential,
+  fibonacci: () => fibonacci,
+  linear: () => linear,
+  resolveBackoffPreset: () => resolveBackoffPreset,
+  withMaxAttempts: () => withMaxAttempts
+});
+function clampNonNegative(value) {
+  return value < 0 ? 0 : value;
+}
+function applyJitter(delay, jitter) {
+  if (jitter === "none") return delay;
+  if (jitter === "full") return Math.random() * delay;
+  return delay / 2 + Math.random() * (delay / 2);
+}
+function randomBetween(min, max) {
+  return min + Math.random() * (max - min);
+}
+function constant(delayNs) {
+  const safe = clampNonNegative(delayNs);
+  return () => safe;
+}
+function linear(baseNs, stepNs) {
+  const safeBase = clampNonNegative(baseNs);
+  const safeStep = stepNs === void 0 ? safeBase : clampNonNegative(stepNs);
+  return (attempt) => safeBase + safeStep * Math.max(0, attempt);
+}
+function exponential(options) {
+  const baseNs = clampNonNegative(options?.baseNs ?? 100 * NS_PER_MS);
+  const factor = options?.factor !== void 0 && options.factor < 1 ? 1 : options?.factor ?? 2;
+  const maxDelayNs = clampNonNegative(options?.maxDelayNs ?? 30 * NS_PER_SEC);
+  const jitter = options?.jitter ?? "none";
+  return (attempt) => {
+    let delay;
+    if (baseNs === 0) {
+      delay = 0;
+    } else if (factor === 1) {
+      delay = baseNs;
+    } else {
+      const capRatio = maxDelayNs / baseNs;
+      let growth = 1;
+      for (let i = 0; i < Math.max(0, attempt); i++) {
+        if (growth >= capRatio) {
+          growth = capRatio;
+          break;
+        }
+        growth *= factor;
+      }
+      delay = baseNs * growth;
+      if (delay > maxDelayNs) delay = maxDelayNs;
+    }
+    return applyJitter(delay, jitter);
+  };
+}
+function fibonacci(baseNs = 100 * NS_PER_MS, maxDelayNs = 30 * NS_PER_SEC) {
+  const safeBase = clampNonNegative(baseNs);
+  const safeMax = clampNonNegative(maxDelayNs);
+  function fibUnit(attempt) {
+    if (attempt <= 0) return 1;
+    let prev = 1;
+    let cur = 2;
+    for (let i = 1; i < attempt; i++) {
+      const next = prev + cur;
+      prev = cur;
+      cur = next;
+    }
+    return cur;
+  }
+  return (attempt) => {
+    const raw = fibUnit(attempt) * safeBase;
+    return raw <= safeMax ? raw : safeMax;
+  };
+}
+function decorrelatedJitter(baseNs = 100 * NS_PER_MS, maxNs = 30 * NS_PER_SEC) {
+  return (_attempt, _error, prevDelayNs) => {
+    const last = prevDelayNs ?? baseNs;
+    const ceiling = Math.min(maxNs, last * 3);
+    return randomBetween(baseNs, ceiling);
+  };
+}
+function withMaxAttempts(strategy, maxAttempts) {
+  return (attempt, error, prevDelayNs) => {
+    if (attempt >= maxAttempts) return null;
+    return strategy(attempt, error, prevDelayNs);
+  };
+}
+function resolveBackoffPreset(name) {
+  if (name === "constant") return constant(1 * NS_PER_SEC);
+  if (name === "linear") return linear(1 * NS_PER_SEC);
+  if (name === "exponential") return exponential();
+  if (name === "fibonacci") return fibonacci();
+  if (name === "decorrelatedJitter") return decorrelatedJitter();
+  throw new Error(
+    `Unknown backoff preset: "${String(name)}". Use one of: constant, linear, exponential, fibonacci, decorrelatedJitter`
+  );
+}
+var NS_PER_MS, NS_PER_SEC;
+var init_backoff = __esm({
+  "src/base/resilience/backoff.ts"() {
+    "use strict";
+    NS_PER_MS = 1e6;
+    NS_PER_SEC = 1e9;
+  }
+});
+
+// src/base/resilience/timeout.ts
+var timeout_exports = {};
+__export(timeout_exports, {
+  TimeoutError: () => TimeoutError,
+  withTimeout: () => withTimeout
+});
+function withTimeout(source, opts, extraOpts) {
+  const isReactive = isNode(opts);
+  let latestOpts = null;
+  if (!isReactive) {
+    const staticOpts = opts;
+    if (staticOpts.ns === void 0 || typeof staticOpts.ns !== "number" || !Number.isFinite(staticOpts.ns) || staticOpts.ns <= 0) {
+      throw new RangeError("withTimeout: opts.ns must be a positive finite number");
+    }
+    latestOpts = {
+      ns: staticOpts.ns,
+      ...staticOpts.meta != null ? { meta: staticOpts.meta } : {}
+    };
+  } else {
+    const cached = opts.cache;
+    if (cached !== void 0) {
+      if (cached.ns === void 0 || typeof cached.ns !== "number" || !Number.isFinite(cached.ns) || cached.ns <= 0) {
+        throw new RangeError(
+          "withTimeout: opts.ns must be a positive finite number on first settle"
+        );
+      }
+      latestOpts = {
+        ns: cached.ns,
+        ...cached.meta != null ? { meta: cached.meta } : {}
+      };
+    }
+  }
+  const callerMeta = extraOpts?.meta;
+  const factoryArgs = isReactive ? { ns: "Node<Partial<TimeoutOptions>>" } : { ns: latestOpts.ns };
+  const timeoutState = (0, import_core5.node)([], {
+    name: "timeoutState",
+    describeKind: "state",
+    initial: { status: "pending" },
+    equals: (a, b) => a === b || a != null && b != null && typeof a === "object" && typeof b === "object" && a.status === b.status && JSON.stringify(a) === JSON.stringify(b)
+  });
+  const out = (0, import_core5.node)(
+    (_data, a) => {
+      let stopped = false;
+      let lastDeadlineNs = 0;
+      const timer = new import_core5.ResettableTimer();
+      let optsUnsub = null;
+      let srcUnsub = null;
+      function emitState(next) {
+        timeoutState.down([[import_core5.DIRTY], [import_core5.DATA, next]]);
+      }
+      function startTimer() {
+        if (stopped) return;
+        if (latestOpts == null || typeof latestOpts.ns !== "number" || !Number.isFinite(latestOpts.ns) || latestOpts.ns <= 0) {
+          return;
+        }
+        const ns = latestOpts.ns;
+        lastDeadlineNs = ns;
+        const startedAt = (0, import_core5.monotonicNs)();
+        const delayMs = ns / NS_PER_MS;
+        emitState({
+          status: "running",
+          startedAt_ns: startedAt,
+          deadline_ns: ns
+        });
+        timer.start(delayMs, () => {
+          if (stopped) return;
+          stopped = true;
+          srcUnsub?.();
+          emitState({
+            status: "errored",
+            firedAt_ns: (0, import_core5.monotonicNs)(),
+            deadline_ns: ns
+          });
+          a.down([[import_core5.ERROR, new TimeoutError(ns)]]);
+        });
+      }
+      function attachSource() {
+        if (srcUnsub != null || stopped) return;
+        srcUnsub = source.subscribe((msgs) => {
+          for (const m of msgs) {
+            if (stopped) return;
+            const t = m[0];
+            if (t === import_core5.DIRTY) a.down([[import_core5.DIRTY]]);
+            else if (t === import_core5.DATA) {
+              startTimer();
+              a.emit(m[1]);
+            } else if (t === import_core5.RESOLVED) a.down([[import_core5.RESOLVED]]);
+            else if (t === import_core5.COMPLETE) {
+              timer.cancel();
+              stopped = true;
+              emitState({
+                status: "completed",
+                settledAt_ns: (0, import_core5.monotonicNs)()
+              });
+              a.down([[import_core5.COMPLETE]]);
+              return;
+            } else if (t === import_core5.ERROR) {
+              timer.cancel();
+              stopped = true;
+              emitState({
+                status: "errored",
+                firedAt_ns: (0, import_core5.monotonicNs)(),
+                deadline_ns: lastDeadlineNs
+              });
+              a.down([m]);
+              return;
+            } else if (t === import_core5.TEARDOWN) {
+              timer.cancel();
+              stopped = true;
+              a.down([m]);
+              return;
+            } else a.down([m]);
+          }
+        });
+        if (latestOpts != null && latestOpts.ns > 0) {
+          startTimer();
+        }
+      }
+      if (isReactive) {
+        const optsNode = opts;
+        optsUnsub = optsNode.subscribe((msgs) => {
+          for (const m of msgs) {
+            if (m[0] !== import_core5.DATA) continue;
+            const next = m[1];
+            if (next == null || typeof next !== "object") continue;
+            const keys = Object.keys(next);
+            if (keys.length === 0) continue;
+            if ("ns" in next) {
+              if (typeof next.ns !== "number" || !Number.isFinite(next.ns) || next.ns <= 0) {
+                if (latestOpts == null) {
+                  stopped = true;
+                  a.down([
+                    [
+                      import_core5.ERROR,
+                      new RangeError(
+                        "withTimeout: opts.ns must be a positive finite number on first settle"
+                      )
+                    ]
+                  ]);
+                  return;
+                }
+                continue;
+              }
+            }
+            const wasNull = latestOpts == null;
+            latestOpts = {
+              ...latestOpts ?? { ns: 0 },
+              ...next
+            };
+            if (wasNull && latestOpts.ns > 0) {
+              attachSource();
+            }
+          }
+        });
+      }
+      if (latestOpts != null) {
+        attachSource();
+      }
+      return () => {
+        stopped = true;
+        timer.cancel();
+        if (srcUnsub) srcUnsub();
+        if (optsUnsub) optsUnsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.cache,
+      meta: { ...callerMeta ?? {}, ...(0, import_core5.factoryTag)("withTimeout", factoryArgs) }
+    }
+  );
+  return { node: out, timeoutState };
+}
+var import_core5, TimeoutError;
+var init_timeout = __esm({
+  "src/base/resilience/timeout.ts"() {
+    "use strict";
+    import_core5 = require("@graphrefly/pure-ts/core");
+    init_internal();
+    init_backoff();
+    TimeoutError = class extends Error {
+      name = "TimeoutError";
+      constructor(ns) {
+        super(`Timed out after ${ns / NS_PER_MS}ms`);
+      }
+    };
+  }
+});
+
+// src/presets/ai/index.ts
+var ai_exports = {};
+__export(ai_exports, {
+  AgentGraph: () => AgentGraph,
+  AgentLoopGraph: () => AgentLoopGraph,
+  AgentMemoryGraph: () => AgentMemoryGraph,
+  CompressionCache: () => CompressionCache,
+  DebateGraph: () => DebateGraph,
+  ZERO_COST: () => ZERO_COST,
+  addUsage: () => addUsage,
+  agent: () => agent,
+  agentLoop: () => agentLoop,
+  agentMemory: () => agentMemory,
+  heterogeneousDebate: () => heterogeneousDebate,
+  presetRegistry: () => presetRegistry,
+  renderContextView: () => renderContextView,
+  taggedContextPool: () => taggedContextPool,
+  tierCompress: () => tierCompress
+});
+module.exports = __toCommonJS(ai_exports);
+
+// src/presets/ai/agent.ts
+var import_core12 = require("@graphrefly/pure-ts/core");
+var import_extra8 = require("@graphrefly/pure-ts/extra");
+var import_graph6 = require("@graphrefly/pure-ts/graph");
+
+// src/utils/ai/_internal.ts
+var import_core = require("@graphrefly/pure-ts/core");
+var import_extra = require("@graphrefly/pure-ts/extra");
+
+// src/base/meta/domain-meta.ts
+function domainMeta(domain, kind, extra) {
+  return {
+    [domain]: true,
+    [`${domain}_type`]: kind,
+    ...extra ?? {}
+  };
+}
+
+// src/utils/ai/_internal.ts
+function aiMeta(kind, extra) {
+  return domainMeta("ai", kind, extra);
+}
+function isNodeLike(x) {
+  return typeof x === "object" && x !== null && "subscribe" in x && typeof x.subscribe === "function" && "cache" in x;
+}
+function stripFences(text) {
+  const match = text.match(/^```(?:json)?\s*([\s\S]*?)\s*```[\s\S]*$/);
+  return match ? match[1] : text;
+}
+
+// src/utils/messaging/index.ts
+var import_core3 = require("@graphrefly/pure-ts/core");
+var import_extra3 = require("@graphrefly/pure-ts/extra");
+var import_graph2 = require("@graphrefly/pure-ts/graph");
+
+// src/base/mutation/index.ts
+var import_core2 = require("@graphrefly/pure-ts/core");
+var import_extra2 = require("@graphrefly/pure-ts/extra");
+var import_graph = require("@graphrefly/pure-ts/graph");
+var DEFAULT_AUDIT_GUARD = (0, import_core2.policy)((allow, deny) => {
+  allow("observe");
+  allow("signal");
+  deny("write");
+});
+function createAuditLog(opts) {
+  const log = (0, import_extra2.reactiveLog)([], {
+    name: opts.name,
+    maxSize: opts.retainedLimit ?? 1024,
+    guard: opts.guard ?? DEFAULT_AUDIT_GUARD,
+    ...opts.versioning != null ? { versioning: opts.versioning } : {}
+  });
+  log.withLatest();
+  if (opts.graph) {
+    opts.graph.add(log.entries, { name: opts.name });
+  }
+  return log;
+}
+function deepFreeze(value) {
+  if (value === null || typeof value !== "object" || Object.isFrozen(value)) return value;
+  for (const k of Object.keys(value)) {
+    deepFreeze(value[k]);
+  }
+  return Object.freeze(value);
+}
+function mutate(act, opts) {
+  const { up, down } = typeof act === "function" ? { up: act, down: void 0 } : act;
+  const freeze = opts.freeze ?? true;
+  if (opts.frame === "inline") {
+    return function wrapped(...args) {
+      const sealed = freeze ? args.map(deepFreeze) : args;
+      const t_ns = (0, import_core2.wallClockNs)();
+      const seq = opts.seq ? bumpCursor(opts.seq) : void 0;
+      try {
+        const result = up(...sealed);
+        if (opts.log && opts.onSuccessRecord) {
+          appendAudit(
+            opts.log,
+            opts.onSuccessRecord,
+            sealed,
+            result,
+            { t_ns, seq },
+            opts.handlerVersion
+          );
+        }
+        return result;
+      } catch (err) {
+        if (opts.log && opts.onFailureRecord) {
+          const errorType = err instanceof Error ? err.name : typeof err;
+          appendAudit(
+            opts.log,
+            opts.onFailureRecord,
+            sealed,
+            err,
+            { t_ns, seq, errorType },
+            opts.handlerVersion
+          );
+        }
+        throw err;
+      }
+    };
+  }
+  return function wrapped(...args) {
+    const sealed = freeze ? args.map(deepFreeze) : args;
+    const t_ns = (0, import_core2.wallClockNs)();
+    let result;
+    let captured;
+    let captureSet = false;
+    let seq;
+    try {
+      (0, import_core2.batch)(() => {
+        if (opts.seq) seq = bumpCursor(opts.seq);
+        try {
+          result = up(...sealed);
+          if (opts.log && opts.onSuccessRecord) {
+            appendAudit(
+              opts.log,
+              opts.onSuccessRecord,
+              sealed,
+              result,
+              { t_ns, seq },
+              opts.handlerVersion
+            );
+          }
+        } catch (err) {
+          captured = err;
+          captureSet = true;
+          throw err;
+        }
+      });
+    } catch (outerErr) {
+      if (captureSet && down) {
+        try {
+          down(...sealed);
+        } catch (downErr) {
+          console.error(
+            `mutate: down hook threw \u2014 original action error preserved (${captured instanceof Error ? captured.name : typeof captured}). Down error:`,
+            downErr
+          );
+        }
+      }
+      if (captureSet && opts.log && opts.onFailureRecord) {
+        const errorType = captured instanceof Error ? captured.name : typeof captured;
+        appendAudit(
+          opts.log,
+          opts.onFailureRecord,
+          sealed,
+          captured,
+          { t_ns, seq, errorType },
+          opts.handlerVersion
+        );
+      }
+      throw captureSet ? captured : outerErr;
+    }
+    return result;
+  };
+}
+var _bumpCursorWarned = /* @__PURE__ */ new WeakSet();
+function bumpCursor(seq) {
+  const raw = seq.cache;
+  const valid = typeof raw === "number" && Number.isFinite(raw);
+  if (!valid && raw !== void 0 && !_bumpCursorWarned.has(seq)) {
+    _bumpCursorWarned.add(seq);
+    console.warn(
+      `bumpCursor: cursor cache held a non-numeric value (${String(raw)}); resetting to 0. Causes include: a snapshot codec round-tripping the cursor as a string / null / NaN, OR a malformed initial seed (e.g. state<number>(NaN)). Audit consumers may see colliding seq values after this point.`
+    );
+  }
+  const cur = valid ? raw : 0;
+  const next = cur + 1;
+  seq.down([[import_core2.DIRTY], [import_core2.DATA, next]]);
+  return next;
+}
+function appendAudit(audit, builder, args, value, meta, handlerVersion) {
+  const record = builder(args, value, meta);
+  if (record === void 0) return;
+  const stamped = handlerVersion != null ? { ...record, handlerVersion } : record;
+  audit.append(stamped);
+}
+function registerCursor(graph, name, initial = 0) {
+  const cursor = (0, import_core2.node)([], { initial, name, describeKind: "state" });
+  graph.add(cursor, { name });
+  return cursor;
+}
+
+// src/utils/messaging/index.ts
+function requireNonNegativeInt(value, label) {
+  if (!Number.isFinite(value) || !Number.isInteger(value) || value < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return value;
+}
+function messagingMeta(kind, extra) {
+  return domainMeta("messaging", kind, extra);
+}
+var DEFAULT_TOPIC_RETAINED_LIMIT = 1024;
+var TopicGraph = class extends import_graph2.Graph {
+  _log;
+  _publishImpl;
+  events;
+  /**
+   * Most recently published value. Stays in the protocol SENTINEL state
+   * (`cache === undefined`, no DATA emitted) until the first publish, then
+   * tracks the latest entry. Spec §5.12 reserves `undefined` as the
+   * "never sent DATA" sentinel — and `TopicGraph.publish(undefined)` is
+   * rejected — so `cache === undefined` unambiguously signals "empty topic"
+   * even when `T` itself includes `null` (i.e., `topic<number | null>`).
+   *
+   * **Within a reactive fn:** detect the empty-topic case via
+   * `ctx.prevData[i] === undefined` for the dep slot holding `topic.latest`,
+   * or check `latest.cache === undefined` outside reactive code. No
+   * separate `hasLatest` companion needed — the SENTINEL is the answer.
+   */
+  latest;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._log = (0, import_extra3.reactiveLog)([], {
+      name: "events",
+      maxSize: opts.retainedLimit ?? DEFAULT_TOPIC_RETAINED_LIMIT
+    });
+    this.events = this._log.entries;
+    this.add(this.events, { name: "events" });
+    this.latest = this.derived(
+      "latest",
+      ["events"],
+      (batchData, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const entries = data[0];
+        return entries.length === 0 ? [] : [entries[entries.length - 1]];
+      },
+      { meta: messagingMeta("topic_latest") }
+    );
+    this.addDisposer((0, import_extra3.keepalive)(this.latest));
+    this.addDisposer(() => {
+      this.events.down([[import_core3.COMPLETE]]);
+    });
+    this.addDisposer(() => this._log.disposeAllViews());
+    this._publishImpl = mutate(
+      (value) => {
+        this._log.append(value);
+      },
+      { frame: "inline", freeze: false }
+    );
+  }
+  publish(value) {
+    if (value === void 0) {
+      throw new TypeError(
+        `TopicGraph "${this.name}": publish(undefined) is not allowed (spec \xA75.12 SENTINEL).`
+      );
+    }
+    this._publishImpl(value);
+  }
+  /**
+   * Wire one or more append-log storage tiers (Audit 4). Each tier receives
+   * appended events per wave; rollback honors the wave-as-transaction model.
+   *
+   * Named `attachEventStorage` (not `attachStorage`) to avoid colliding with
+   * the inherited {@link Graph.attachSnapshotStorage} which takes the
+   * paired `AttachSnapshotTierPair[]` shape (Phase 14.6) — distinct
+   * concerns, distinct surfaces.
+   *
+   * @returns Disposer.
+   */
+  attachEventStorage(tiers) {
+    return this._log.attachStorage(tiers);
+  }
+  retained() {
+    return this.events.cache;
+  }
+  /** Internal log bundle — used by TopicBridgeGraph for `attach`. */
+  get _logBundle() {
+    return this._log;
+  }
+};
+var SubscriptionGraph = class extends import_graph2.Graph {
+  cursor;
+  available;
+  /**
+   * Reference to the upstream topic graph. Intentionally NOT mounted
+   * under this subscription: a subscription is a VIEW over an
+   * externally-owned topic. Double-mounting (e.g. hub-owned topic +
+   * sub-mount here) would make either-side teardown leave the other
+   * holding a dead reference. Node-level `derived([topicEvents], …)`
+   * still wires the data dependency across graph boundaries. D1(e).
+   */
+  topic;
+  _disposed = false;
+  _ackImpl;
+  _pullAndAckImpl;
+  constructor(name, topicGraph, opts = {}) {
+    super(name, opts.graph);
+    this.topic = topicGraph;
+    let initialCursor;
+    if (opts.from !== void 0) {
+      if (opts.from === "retained") {
+        initialCursor = 0;
+      } else if (opts.from === "now") {
+        initialCursor = topicGraph.events.cache.length;
+      } else {
+        initialCursor = requireNonNegativeInt(opts.from, "subscription from");
+      }
+    } else {
+      initialCursor = requireNonNegativeInt(opts.cursor ?? 0, "subscription cursor");
+    }
+    this.cursor = this.state("cursor", initialCursor, {
+      meta: messagingMeta("subscription_cursor")
+    });
+    this.available = topicGraph._logBundle.view({ kind: "fromCursor", cursor: this.cursor });
+    this.add(this.available, { name: "available" });
+    this.addDisposer((0, import_extra3.keepalive)(this.available));
+    if (opts.advanceOn !== void 0) {
+      const advanceOn = opts.advanceOn;
+      let advanceInitialized = false;
+      const advancePump = (0, import_core3.node)(
+        [advanceOn],
+        () => {
+          if (!advanceInitialized) {
+            advanceInitialized = true;
+            return;
+          }
+          if (this._disposed) return;
+          const avail = this.available.cache;
+          if (avail.length === 0) return;
+          const next = this.cursor.cache + avail.length;
+          this.cursor.emit(next);
+        },
+        {
+          name: "advancePump",
+          describeKind: "effect",
+          meta: messagingMeta("subscription_advance_pump")
+        }
+      );
+      this.add(advancePump, { name: "advancePump" });
+      this.addDisposer((0, import_extra3.keepalive)(advancePump));
+    }
+    this._ackImpl = mutate(
+      (count) => {
+        const available = this.available.cache;
+        const requested = count === void 0 ? available.length : requireNonNegativeInt(count, "subscription ack count");
+        const step = Math.min(requested, available.length);
+        if (step <= 0) return this.cursor.cache;
+        const next = this.cursor.cache + step;
+        this.cursor.emit(next);
+        return next;
+      },
+      { frame: "inline", freeze: false }
+    );
+    this._pullAndAckImpl = mutate(
+      (limit) => {
+        const available = this.available.cache;
+        const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pullAndAck limit");
+        const items = available.slice(0, max);
+        if (items.length === 0) return { items, cursor: this.cursor.cache };
+        const next = this.cursor.cache + items.length;
+        this.cursor.emit(next);
+        return { items, cursor: next };
+      },
+      { frame: "inline", freeze: false }
+    );
+  }
+  ack(count) {
+    if (this._disposed) return this.cursor.cache;
+    return this._ackImpl(count);
+  }
+  pull(limit) {
+    if (this._disposed) return [];
+    const available = this.available.cache;
+    const max = limit === void 0 ? available.length : requireNonNegativeInt(limit, "subscription pull limit");
+    return available.slice(0, max);
+  }
+  /**
+   * Atomic pull-and-acknowledge. Returns `{ items, cursor }` where `cursor`
+   * is the new cursor position after advancing. Under single-threaded JS the
+   * snapshot and advance are atomic; PY callers use a per-subscription Lock.
+   *
+   * Replaces `pull(limit, { ack: true })`.
+   */
+  pullAndAck(limit) {
+    if (this._disposed) return { items: [], cursor: this.cursor.cache };
+    return this._pullAndAckImpl(limit);
+  }
+  /**
+   * Release internal subscriptions and mark the subscription torn-down.
+   * Subsequent `pull`, `pullAndAck`, `ack` return empty / current cursor.
+   * Emits COMPLETE on `cursor` so derived consumers (e.g. `available`) see
+   * the termination signal. Also drains `addDisposer` callbacks (including
+   * the `keepalive(advancePump)` subscription) so no keepalive leak occurs.
+   */
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this.cursor.down([[import_core3.COMPLETE]]);
+    this.destroy();
+  }
+};
+function topic(name, opts) {
+  return new TopicGraph(name, opts);
+}
+function subscription(name, topicGraph, opts) {
+  return new SubscriptionGraph(name, topicGraph, opts);
+}
+
+// src/presets/ai/agent-loop.ts
+var import_core11 = require("@graphrefly/pure-ts/core");
+var import_extra7 = require("@graphrefly/pure-ts/extra");
+var import_graph5 = require("@graphrefly/pure-ts/graph");
+
+// src/base/sources/settled.ts
+var import_core6 = require("@graphrefly/pure-ts/core");
+function firstValueFrom(source) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    let shouldUnsub = false;
+    let unsub;
+    unsub = source.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (settled) return;
+        if (m[0] === import_core6.DATA) {
+          settled = true;
+          resolve(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core6.ERROR) {
+          settled = true;
+          reject(m[1]);
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+        if (m[0] === import_core6.COMPLETE) {
+          settled = true;
+          reject(new Error("completed without DATA"));
+          if (unsub) {
+            unsub();
+            unsub = void 0;
+          } else shouldUnsub = true;
+          return;
+        }
+      }
+    });
+    if (shouldUnsub) {
+      unsub?.();
+      unsub = void 0;
+    }
+  });
+}
+function firstWhere(source, predicate, opts) {
+  let pending;
+  let resolveFn;
+  let rejectFn;
+  let settled = false;
+  let shouldUnsub = false;
+  let unsub;
+  let inInitialSyncPhase = opts?.skipCurrent === true;
+  const settleData = (v) => {
+    if (settled) return;
+    settled = true;
+    if (resolveFn != null) resolveFn(v);
+    else pending = { kind: "data", value: v };
+  };
+  const settleError = (err) => {
+    if (settled) return;
+    settled = true;
+    if (rejectFn != null) rejectFn(err);
+    else pending = { kind: "error", err };
+  };
+  const settleComplete = () => {
+    if (settled) return;
+    settled = true;
+    const err = new Error("completed without matching value");
+    if (rejectFn != null) rejectFn(err);
+    else pending = { kind: "complete" };
+  };
+  const detach = () => {
+    if (unsub) {
+      unsub();
+      unsub = void 0;
+    } else shouldUnsub = true;
+  };
+  const sink = (msgs) => {
+    if (settled) return;
+    for (const m of msgs) {
+      if (settled) return;
+      if (inInitialSyncPhase && m[0] === import_core6.DATA) continue;
+      if (m[0] === import_core6.DATA) {
+        const v = m[1];
+        if (predicate(v)) {
+          settleData(v);
+          detach();
+          return;
+        }
+      }
+      if (m[0] === import_core6.ERROR) {
+        settleError(m[1]);
+        detach();
+        return;
+      }
+      if (m[0] === import_core6.COMPLETE) {
+        settleComplete();
+        detach();
+        return;
+      }
+    }
+  };
+  unsub = source.subscribe(sink);
+  inInitialSyncPhase = false;
+  if (opts?.kick != null && !settled) {
+    try {
+      opts.kick();
+    } catch (err) {
+      settleError(err);
+      detach();
+    }
+  }
+  if (shouldUnsub) {
+    unsub?.();
+    unsub = void 0;
+  }
+  return new Promise((resolve, reject) => {
+    if (pending != null) {
+      if (pending.kind === "data") resolve(pending.value);
+      else if (pending.kind === "error") reject(pending.err);
+      else reject(new Error("completed without matching value"));
+      return;
+    }
+    resolveFn = resolve;
+    rejectFn = reject;
+  });
+}
+var _timeoutOp;
+var _nsPerMs;
+async function awaitSettled(source, opts) {
+  const predicate = opts?.predicate ?? ((v) => v != null);
+  const skipCurrent = opts?.skipCurrent;
+  const kick = opts?.kick;
+  if (opts?.timeoutMs == null || opts.timeoutMs <= 0) {
+    return await firstWhere(source, predicate, { skipCurrent, kick });
+  }
+  if (_timeoutOp === void 0) {
+    const [timeoutMod, backoff] = await Promise.all([
+      Promise.resolve().then(() => (init_timeout(), timeout_exports)),
+      Promise.resolve().then(() => (init_backoff(), backoff_exports))
+    ]);
+    _timeoutOp = timeoutMod.withTimeout;
+    _nsPerMs = backoff.NS_PER_MS;
+  }
+  const guarded = _timeoutOp(source, { ns: opts.timeoutMs * _nsPerMs }).node;
+  return await firstWhere(guarded, predicate, { skipCurrent, kick });
+}
+function nodeSignal(source, opts) {
+  const ctrl = new AbortController();
+  const reason = opts?.reason ?? new Error("cancelled via nodeSignal");
+  let unsub;
+  let shouldUnsub = false;
+  const done = () => {
+    if (unsub) {
+      unsub();
+      unsub = void 0;
+    } else shouldUnsub = true;
+  };
+  unsub = source.subscribe((msgs) => {
+    if (ctrl.signal.aborted) return;
+    for (const m of msgs) {
+      if (m[0] === import_core6.DATA && m[1] === true) {
+        ctrl.abort(reason);
+        done();
+        return;
+      }
+      if (m[0] === import_core6.ERROR) {
+        ctrl.abort(m[1]);
+        done();
+        return;
+      }
+      if (m[0] === import_core6.COMPLETE) {
+        done();
+        return;
+      }
+    }
+  });
+  if (shouldUnsub) {
+    unsub?.();
+    unsub = void 0;
+  }
+  return {
+    signal: ctrl.signal,
+    dispose: () => {
+      if (unsub) {
+        unsub();
+        unsub = void 0;
+      }
+    }
+  };
+}
+
+// src/utils/ai/agents/chat-stream.ts
+var import_core7 = require("@graphrefly/pure-ts/core");
+var import_extra4 = require("@graphrefly/pure-ts/extra");
+var import_graph3 = require("@graphrefly/pure-ts/graph");
+var ChatStreamGraph = class extends import_graph3.Graph {
+  _log;
+  messages;
+  /**
+   * Most recently appended message. Stays in the protocol SENTINEL state
+   * (`cache === undefined`, no DATA emitted) until the first append, then
+   * tracks the latest entry. Per COMPOSITION-GUIDE §1a, the SENTINEL is
+   * the canonical "no value yet" signal — consumers detect empty via
+   * `data[i] === undefined` inside reactive fns or `latest.cache === undefined`
+   * outside. No `T | null` placeholder, no `hasLatest` companion.
+   */
+  latest;
+  messageCount;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._log = (0, import_extra4.reactiveLog)([], {
+      name: "messages",
+      maxSize: opts.maxMessages
+    });
+    this.messages = this._log.entries;
+    this.add(this.messages, { name: "messages" });
+    this.latest = (0, import_core7.node)(
+      [this.messages],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const entries = data[0];
+        if (entries.length === 0) {
+          actions.down([[import_core7.RESOLVED]]);
+          return;
+        }
+        actions.emit(entries[entries.length - 1]);
+      },
+      {
+        name: "latest",
+        describeKind: "derived",
+        meta: aiMeta("chat_latest")
+      }
+    );
+    this.add(this.latest, { name: "latest" });
+    this.addDisposer((0, import_extra4.keepalive)(this.latest));
+    this.messageCount = (0, import_core7.node)(
+      [this.messages],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(data[0].length);
+      },
+      {
+        name: "messageCount",
+        describeKind: "derived",
+        meta: aiMeta("chat_message_count"),
+        initial: 0
+      }
+    );
+    this.add(this.messageCount, { name: "messageCount" });
+    this.addDisposer((0, import_extra4.keepalive)(this.messageCount));
+  }
+  append(role, content, extra) {
+    this._log.append({ role, content, ...extra });
+  }
+  appendToolResult(callId, content) {
+    this._log.append({ role: "tool", content, toolCallId: callId });
+  }
+  clear() {
+    this._log.clear();
+  }
+  allMessages() {
+    return this.messages.cache;
+  }
+};
+function chatStream(name, opts) {
+  return new ChatStreamGraph(name, opts);
+}
+
+// src/utils/ai/agents/tool-execution.ts
+var import_core9 = require("@graphrefly/pure-ts/core");
+var import_extra5 = require("@graphrefly/pure-ts/extra");
+
+// src/base/resilience/retry.ts
+var import_core8 = require("@graphrefly/pure-ts/core");
+init_internal();
+init_backoff();
+function resolveRetryConfig(opts) {
+  const count = opts?.count;
+  const backoffOpt = opts?.backoff;
+  if (backoffOpt !== void 0 && count === void 0) {
+    throw new RangeError(
+      "retry({ backoff }) requires explicit count to prevent unbounded retries; pass { count: <n>, backoff: ... }"
+    );
+  }
+  const maxRetries = count !== void 0 ? count : 0;
+  if (maxRetries < 0) throw new RangeError("retry count must be >= 0");
+  const strategy = backoffOpt === void 0 ? null : typeof backoffOpt === "string" ? resolveBackoffPreset(backoffOpt) : backoffOpt;
+  return { maxRetries, strategy };
+}
+function retryFactoryArgs(opts) {
+  const args = {};
+  if (opts?.count !== void 0) args.count = opts.count;
+  if (typeof opts?.backoff === "string") args.backoff = opts.backoff;
+  return Object.keys(args).length > 0 ? args : void 0;
+}
+function _runRetryStateMachine(getCfg, acquireSource, a, emitState) {
+  let attempt = 0;
+  let stopped = false;
+  let prevDelay = null;
+  let unsub;
+  const timer = new import_core8.ResettableTimer();
+  const publish = (status) => {
+    emitState?.({ status, attempt, lastDelay_ns: prevDelay });
+  };
+  publish("pending");
+  function disconnectUpstream() {
+    unsub?.();
+    unsub = void 0;
+  }
+  function scheduleRetryOrFinish(err) {
+    if (stopped) return;
+    const cfg = getCfg();
+    if (attempt >= cfg.maxRetries) {
+      disconnectUpstream();
+      publish("errored");
+      a.down([[import_core8.ERROR, err]]);
+      return;
+    }
+    const raw = cfg.strategy === null ? 0 : cfg.strategy(attempt, err, prevDelay);
+    if (raw === null || raw === void 0) {
+      disconnectUpstream();
+      publish("errored");
+      a.down([[import_core8.ERROR, err]]);
+      return;
+    }
+    let delayNs;
+    try {
+      delayNs = coerceDelayNs(raw);
+    } catch {
+      disconnectUpstream();
+      publish("errored");
+      a.down([[import_core8.ERROR, err]]);
+      return;
+    }
+    prevDelay = delayNs;
+    attempt += 1;
+    disconnectUpstream();
+    publish("paused");
+    const delayMs = delayNs > 0 ? delayNs / NS_PER_MS : 1;
+    timer.start(delayMs, () => {
+      if (stopped) return;
+      connect();
+    });
+  }
+  function connect() {
+    timer.cancel();
+    disconnectUpstream();
+    let src;
+    try {
+      src = acquireSource();
+    } catch (err) {
+      scheduleRetryOrFinish(err);
+      return;
+    }
+    publish("running");
+    unsub = src.subscribe((msgs) => {
+      if (stopped) return;
+      for (const m of msgs) {
+        const t = m[0];
+        if (t === import_core8.DIRTY) a.down([[import_core8.DIRTY]]);
+        else if (t === import_core8.DATA) {
+          attempt = 0;
+          prevDelay = null;
+          a.emit(m[1]);
+          publish("running");
+        } else if (t === import_core8.RESOLVED) a.down([[import_core8.RESOLVED]]);
+        else if (t === import_core8.COMPLETE) {
+          stopped = true;
+          disconnectUpstream();
+          publish("completed");
+          a.down([[import_core8.COMPLETE]]);
+        } else if (t === import_core8.ERROR) {
+          scheduleRetryOrFinish(msgVal(m));
+          return;
+        } else a.down([m]);
+      }
+    });
+  }
+  connect();
+  return () => {
+    const wasStopped = stopped;
+    stopped = true;
+    timer.cancel();
+    disconnectUpstream();
+    if (!wasStopped) publish("cancelled");
+  };
+}
+function retry(input, opts) {
+  const retryState = (0, import_core8.node)([], {
+    name: "retryState",
+    describeKind: "state",
+    initial: { status: "pending", attempt: 0, lastDelay_ns: null },
+    equals: (a, b) => a === b || a != null && b != null && typeof a === "object" && typeof b === "object" && JSON.stringify(a) === JSON.stringify(b)
+  });
+  const emit = (s) => {
+    retryState.down([[import_core8.DIRTY], [import_core8.DATA, s]]);
+  };
+  if (typeof input === "function") {
+    return {
+      node: _retryFactory(input, opts, emit),
+      retryState
+    };
+  }
+  return {
+    node: _retrySource(input, opts, emit),
+    retryState
+  };
+}
+function makeMergedOptsMirror(arg) {
+  if (arg === void 0) {
+    return { current: () => void 0, unsub: () => void 0 };
+  }
+  if (!isNode(arg)) {
+    return { current: () => arg, unsub: () => void 0 };
+  }
+  const optsNode = arg;
+  let merged = optsNode.cache ?? void 0;
+  const unsub = optsNode.subscribe((msgs) => {
+    for (const m of msgs) {
+      if (m[0] !== import_core8.DATA) continue;
+      const next = m[1];
+      if (next == null || typeof next !== "object") continue;
+      if (Object.keys(next).length === 0) continue;
+      merged = { ...merged ?? {}, ...next };
+    }
+  });
+  return { current: () => merged, unsub };
+}
+var _retrySourceNonResubscribableWarned = /* @__PURE__ */ new WeakSet();
+function _retrySource(source, opts, emitState) {
+  const sourceWithFlag = source;
+  if (sourceWithFlag._resubscribable === false && !_retrySourceNonResubscribableWarned.has(source)) {
+    _retrySourceNonResubscribableWarned.add(source);
+    console.warn(
+      "retry(source, opts): source-mode requires `resubscribable: true` on the upstream node. Retries will be silent no-ops after the first ERROR. Either pass `resubscribable: true` to the source factory, OR use factory-mode retry `retry(() => buildSource(), opts)` so each attempt builds a fresh node."
+    );
+  }
+  const staticOpts = isNode(opts) ? void 0 : opts;
+  if (!isNode(opts)) resolveRetryConfig(staticOpts);
+  return (0, import_core8.node)(
+    (_data, a) => {
+      const merged = makeMergedOptsMirror(opts);
+      const getCfg = () => resolveRetryConfig(merged.current());
+      const inner = _runRetryStateMachine(getCfg, () => source, a, emitState);
+      return () => {
+        inner();
+        merged.unsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: source.cache,
+      meta: {
+        ...staticOpts?.meta ?? {},
+        ...(0, import_core8.factoryTag)(
+          "retry",
+          isNode(opts) ? { reactiveOpts: true } : retryFactoryArgs(staticOpts)
+        )
+      }
+    }
+  );
+}
+function _retryFactory(factory, opts, emitState) {
+  const staticOpts = isNode(opts) ? void 0 : opts;
+  if (!isNode(opts)) resolveRetryConfig(staticOpts);
+  return (0, import_core8.node)(
+    (_data, a) => {
+      const merged = makeMergedOptsMirror(opts);
+      const getCfg = () => resolveRetryConfig(merged.current());
+      const inner = _runRetryStateMachine(getCfg, factory, a, emitState);
+      return () => {
+        inner();
+        merged.unsub();
+      };
+    },
+    {
+      ...operatorOpts(),
+      initial: staticOpts?.initial,
+      meta: {
+        ...staticOpts?.meta ?? {},
+        ...(0, import_core8.factoryTag)(
+          "retry",
+          isNode(opts) ? { reactiveOpts: true } : retryFactoryArgs(staticOpts)
+        )
+      }
+    }
+  );
+}
+
+// src/utils/ai/agents/tool-execution.ts
+function toolExecution(opts) {
+  const { toolCalls, tools } = opts;
+  const retryCount = opts.retryCount ?? 1;
+  const onError = opts.onError ?? "rescue";
+  const batchEquals = (a, b) => {
+    if (a === b) return true;
+    if (a.length !== b.length) return false;
+    for (let i = 0; i < a.length; i++) {
+      const ai = a[i];
+      const bi = b[i];
+      if (ai?.id !== bi?.id) return false;
+      if (ai?.content !== bi?.content) return false;
+    }
+    return true;
+  };
+  return (0, import_extra5.switchMap)(toolCalls, (calls) => {
+    if (calls == null || calls.length === 0) {
+      throw new Error(
+        "toolExecution: received an empty tool-call batch as DATA \u2014 callers must upstream-filter empty batches (emit RESOLVED) so switchMap is only dispatched for non-empty batches."
+      );
+    }
+    const perCall = calls.map((call) => executeOne(call, tools, retryCount, onError));
+    return (0, import_core9.node)(
+      perCall,
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(data);
+      },
+      { describeKind: "derived", name: "toolExecution::batch", equals: batchEquals }
+    );
+  });
+}
+function executeOne(call, tools, retryCount, onError) {
+  const attempted = retry(() => tools.executeReactive(call.name, call.arguments), {
+    count: retryCount
+  }).node;
+  const onSuccess = (0, import_core9.node)(
+    [attempted],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const val = data[0];
+      actions.emit({
+        id: call.id,
+        content: typeof val === "string" ? val : JSON.stringify(val)
+      });
+    },
+    { describeKind: "derived" }
+  );
+  if (onError === "propagate") return onSuccess;
+  return (0, import_extra5.rescue)(onSuccess, (err) => ({
+    id: call.id,
+    content: JSON.stringify({ error: String(err) })
+  }));
+}
+
+// src/utils/ai/agents/tool-registry.ts
+var import_core10 = require("@graphrefly/pure-ts/core");
+var import_extra6 = require("@graphrefly/pure-ts/extra");
+var import_graph4 = require("@graphrefly/pure-ts/graph");
+var ToolRegistryGraph = class extends import_graph4.Graph {
+  definitions;
+  schemas;
+  _bundle;
+  constructor(name, opts = {}) {
+    super(name, opts.graph);
+    this._bundle = (0, import_extra6.reactiveMap)({
+      name: "definitions"
+    });
+    this.definitions = this._bundle.entries;
+    this.add(this.definitions, { name: "definitions" });
+    this.schemas = (0, import_core10.node)(
+      [this.definitions],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const defs = data[0];
+        actions.emit([...(defs ?? /* @__PURE__ */ new Map()).values()]);
+      },
+      {
+        name: "schemas",
+        describeKind: "derived",
+        meta: aiMeta("tool_schemas"),
+        initial: []
+      }
+    );
+    this.add(this.schemas, { name: "schemas" });
+    this.addDisposer((0, import_extra6.keepalive)(this.schemas));
+  }
+  register(tool) {
+    this._bundle.set(tool.name, tool);
+  }
+  unregister(name) {
+    this._bundle.delete(name);
+  }
+  /**
+   * Reactive execution — returns a `Node<unknown>` that emits the handler
+   * result. The returned node is a `producer` that:
+   *
+   * 1. Mints a per-call `AbortController` whose `signal` is threaded into
+   *    the handler call AND into `fromAny` (so a `fromPromise` /
+   *    `fromAsyncIter` inner abandons cleanly when the consumer
+   *    unsubscribes).
+   * 2. Runs `tool.handler(args, {signal})` inside a try/catch — a
+   *    synchronous throw surfaces as `[[ERROR, err]]` downstream instead
+   *    of escaping the producer.
+   * 3. Forwards every message from the inner `fromAny` chain to the
+   *    producer's outputs.
+   * 4. On teardown (subscriber count drops to zero, e.g. `switchMap`
+   *    supersede) calls `ac.abort()` and unsubscribes the inner.
+   *    Signal-aware handlers (e.g. `fetch(url, {signal})`) actually stop.
+   *
+   * Each call mints a fresh node tied to a fresh `handler(args, ...)`
+   * invocation — call `executeReactive` again for repeated invocations.
+   *
+   * @throws `Error` synchronously when `name` is not registered (no node is
+   *   constructed — the caller gets a pre-wiring failure rather than a
+   *   silent ERROR wave on an empty graph).
+   */
+  executeReactive(name, args) {
+    const tool = this._bundle.get(name);
+    if (!tool) throw new Error(`toolRegistry: unknown tool "${name}"`);
+    return (0, import_core10.node)(
+      [],
+      (_data, actions) => {
+        const ac = new AbortController();
+        let inner;
+        try {
+          const raw = tool.handler(args, { signal: ac.signal });
+          inner = handlerResultToNode(raw, ac.signal);
+        } catch (err) {
+          actions.down([[import_core10.ERROR, err]]);
+          return () => {
+            ac.abort();
+          };
+        }
+        const unsub = inner.subscribe((batch8) => {
+          actions.down(batch8);
+        });
+        return () => {
+          ac.abort();
+          unsub();
+        };
+      },
+      {
+        name: `executeReactive::${name}`,
+        describeKind: "producer",
+        meta: aiMeta("tool_execute_reactive")
+      }
+    );
+  }
+  getDefinition(name) {
+    return this._bundle.entries.cache?.get(name);
+  }
+};
+function toolRegistry(name, opts) {
+  return new ToolRegistryGraph(name, opts);
+}
+function handlerResultToNode(raw, signal) {
+  if (isNodeLike(raw)) {
+    return raw;
+  }
+  if (raw != null && typeof raw.then === "function") {
+    return (0, import_extra6.fromPromise)(raw, { signal });
+  }
+  if (raw != null && typeof raw === "object" && Symbol.asyncIterator in raw) {
+    return (0, import_extra6.fromAsyncIter)(raw, { signal });
+  }
+  return (0, import_extra6.fromPromise)(Promise.resolve(raw), { signal });
+}
+
+// src/presets/ai/agent-loop.ts
+var AgentLoopGraph = class extends import_graph5.Graph {
+  chat;
+  tools;
+  /** Current agent status. `initial: "idle"` — always has a real value. */
+  status;
+  /** Turn count (completed LLM invocations this run). `initial: 0`. */
+  turn;
+  /** Aborted flag; flipped by `abort()` or external `AbortSignal`. `initial: false`. */
+  aborted;
+  /**
+   * Most recent LLM response. State-backed mirror driven by the response
+   * effect. **Stays SENTINEL** (`cache === undefined`, no DATA emitted)
+   * until the first real response — bridge subscribers see no spurious
+   * push-on-subscribe DATA. After a real response, holds the latest
+   * `LLMResponse`. Reset between `run()` calls via `[[INVALIDATE]]` (clears
+   * cache back to SENTINEL) so a second run with a pre-aborted signal
+   * cannot leak the prior run's response. Bridge with
+   * `awaitSettled(lastResponse)` for the first DATA as a Promise; consumers
+   * inside reactive fns gate on `ctx.prevData[i] === undefined`.
+   */
+  lastResponse;
+  /** Tool-call batch emitted by the most recent LLM response. SENTINEL. */
+  toolCalls;
+  /** Tool-result batch (one entry per call) after reactive execution. SENTINEL. */
+  toolResults;
+  _terminalResult;
+  _disposeRunWiring;
+  /** Guards against overlapping `run()` calls. */
+  _running = false;
+  /**
+   * Abort controller for the currently-running `adapter.invoke`. Minted per
+   * switchMap project; aborted when the reactive `aborted` node flips true
+   * OR when the caller's external `AbortSignal` fires. Threaded into
+   * `adapter.invoke({ signal })` AND `fromAny(promise, { signal })`, so the
+   * reactive layer sees ERROR when the wire call is cancelled.
+   */
+  _currentAbortController = null;
+  constructor(name, opts) {
+    super(name, opts.graph);
+    this.chat = chatStream(`${name}-chat`, { maxMessages: opts.maxMessages });
+    this.mount("chat", this.chat);
+    this.tools = toolRegistry(`${name}-tools`);
+    this.mount("tools", this.tools);
+    if (opts.tools) {
+      for (const tool of opts.tools) {
+        this.tools.register(tool);
+      }
+    }
+    this.status = (0, import_core11.node)([], {
+      ...{
+        name: "status",
+        describeKind: "state",
+        meta: aiMeta("agent_status")
+      },
+      initial: "idle"
+    });
+    this.add(this.status, { name: "status" });
+    this.turn = (0, import_core11.node)([], {
+      ...{
+        name: "turn",
+        describeKind: "state",
+        meta: aiMeta("agent_turn_count")
+      },
+      initial: 0
+    });
+    this.add(this.turn, { name: "turn" });
+    this.aborted = (0, import_core11.node)([], {
+      ...{
+        name: "aborted",
+        describeKind: "state",
+        meta: aiMeta("agent_aborted")
+      },
+      initial: false
+    });
+    this.add(this.aborted, { name: "aborted" });
+    let latestTurn = 0;
+    const turnSub = this.turn.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === import_core11.DATA) latestTurn = m[1];
+    });
+    let latestAborted = false;
+    const abortedSub = this.aborted.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === import_core11.DATA) latestAborted = m[1];
+    });
+    const adapter = opts.adapter;
+    const systemPrompt = opts.systemPrompt;
+    const model = opts.model;
+    const temperature = opts.temperature;
+    const maxTokens = opts.maxTokens;
+    const maxTurns = opts.maxTurns ?? 10;
+    const stopWhen = opts.stopWhen;
+    const chat = this.chat;
+    const tools = this.tools;
+    const statusNode = this.status;
+    const turnNode = this.turn;
+    const abortedNode = this.aborted;
+    const promptInput = (0, import_core11.node)(
+      [statusNode],
+      (data, actions, ctx) => {
+        const stat = readLatest(data, ctx.prevData, 0, "idle");
+        if (stat !== "thinking" || latestAborted || latestTurn >= maxTurns) {
+          actions.down([[import_core11.RESOLVED]]);
+          return;
+        }
+        const messages = this.chat.messages.cache ?? [];
+        if (messages.length === 0) {
+          actions.down([[import_core11.RESOLVED]]);
+          return;
+        }
+        const schemas = this.tools.schemas.cache ?? [];
+        actions.emit({ messages, tools: schemas });
+      },
+      {
+        name: "promptInput",
+        describeKind: "derived",
+        meta: aiMeta("agent_prompt_input", {
+          // State this fn body samples beyond its declared `statusNode`
+          // dep. `aborted` / `turn` come from §28 closure mirrors
+          // (`latestAborted` / `latestTurn`); `chat.messages` /
+          // `tools.schemas` come from sole-owner `.cache` reads
+          // (Phase 12 D1 lock + F2 fix; see comment block above).
+          // Listed here so inspection tooling can surface fold-in
+          // state without grepping source.
+          closureReads: ["aborted", "turn", "chat.messages", "tools.schemas"]
+        })
+      }
+    );
+    const llmResponse = (0, import_extra7.switchMap)(
+      promptInput,
+      (input) => {
+        const controller = new AbortController();
+        this._currentAbortController = controller;
+        if (latestAborted) {
+          controller.abort(new Error("agentLoop: aborted"));
+        }
+        return (0, import_extra7.fromAny)(
+          adapter.invoke(input.messages, {
+            tools: input.tools.length > 0 ? input.tools : void 0,
+            systemPrompt,
+            model,
+            temperature,
+            maxTokens,
+            signal: controller.signal
+          }),
+          { signal: controller.signal }
+        );
+      },
+      { equals: () => false }
+    );
+    const lastResponseState = (0, import_core11.node)([], {
+      name: "lastResponse",
+      describeKind: "state",
+      meta: aiMeta("agent_last_response")
+    });
+    this.lastResponse = lastResponseState;
+    const toolCallsRaw = (0, import_core11.node)(
+      [lastResponseState, statusNode],
+      (data, actions, ctx) => {
+        const resp = readLatest(data, ctx.prevData, 0, void 0);
+        const stat = readLatest(data, ctx.prevData, 1, "idle");
+        if (stat !== "acting") {
+          actions.down([[import_core11.RESOLVED]]);
+          return;
+        }
+        const calls = resp?.toolCalls;
+        if (calls == null || calls.length === 0) {
+          actions.down([[import_core11.RESOLVED]]);
+          return;
+        }
+        actions.emit(calls);
+      },
+      {
+        name: "toolCallsRaw",
+        describeKind: "derived",
+        meta: aiMeta("agent_tool_calls_raw")
+      }
+    );
+    const gatedToolCallsNode = opts.interceptToolCalls ? opts.interceptToolCalls(toolCallsRaw) : toolCallsRaw;
+    this.toolCalls = gatedToolCallsNode;
+    const toolResultsNode = toolExecution({
+      toolCalls: gatedToolCallsNode,
+      tools,
+      retryCount: 1
+    });
+    this.toolResults = toolResultsNode;
+    const effResponse = (0, import_core11.node)(
+      [llmResponse],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        if (latestAborted) return;
+        const response = data[0];
+        const next = latestTurn + 1;
+        const hasToolCalls = response.toolCalls != null && response.toolCalls.length > 0;
+        const naturalStop = response.finishReason === "end_turn" && (!response.toolCalls || response.toolCalls.length === 0);
+        const customStop = stopWhen?.(response) === true;
+        const capReached = next >= maxTurns;
+        const nextStatus = customStop || naturalStop || !hasToolCalls || capReached ? "done" : "acting";
+        (0, import_core11.batch)(() => {
+          lastResponseState.emit(response);
+          statusNode.emit(nextStatus);
+          turnNode.emit(next);
+          chat.append("assistant", response.content, {
+            toolCalls: response.toolCalls
+          });
+        });
+      },
+      { describeKind: "effect" }
+    );
+    const effResults = (0, import_core11.node)(
+      [toolResultsNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        if (latestAborted) return;
+        const arr = data[0];
+        if (arr.length === 0) return;
+        const nextStatus = latestTurn >= maxTurns ? "done" : "thinking";
+        (0, import_core11.batch)(() => {
+          statusNode.emit(nextStatus);
+          for (const r of arr) chat.appendToolResult(r.id, r.content);
+        });
+      },
+      { describeKind: "effect" }
+    );
+    let latestStatus = statusNode.cache ?? "idle";
+    const statusSub = statusNode.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === import_core11.DATA) latestStatus = m[1];
+    });
+    const effAbort = (0, import_core11.node)(
+      [abortedNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        if (data[0] === true) {
+          this._currentAbortController?.abort(new Error("agentLoop: aborted"));
+          if (latestStatus !== "done") statusNode.emit("done");
+        }
+      },
+      { describeKind: "effect" }
+    );
+    const kaResponse = (0, import_extra7.keepalive)(effResponse);
+    const kaResults = (0, import_extra7.keepalive)(effResults);
+    const kaAbort = (0, import_extra7.keepalive)(effAbort);
+    this._terminalResult = (0, import_core11.node)(
+      [statusNode, lastResponseState],
+      (data, actions, ctx) => {
+        const stat = readLatest(data, ctx.prevData, 0, "idle");
+        const resp = readLatest(data, ctx.prevData, 1, void 0);
+        if (stat === "done") {
+          if (resp !== void 0) {
+            actions.emit(resp);
+            return;
+          }
+          const err = new Error("agentLoop: aborted");
+          err.name = "AbortError";
+          actions.down([[import_core11.ERROR, err]]);
+          return;
+        }
+        if (stat === "error") {
+          actions.down([[import_core11.ERROR, new Error("agentLoop: errored")]]);
+          return;
+        }
+        actions.down([[import_core11.RESOLVED]]);
+      },
+      {
+        name: "terminalResult",
+        describeKind: "derived",
+        meta: aiMeta("agent_terminal_result"),
+        // `lastResponseState` is SENTINEL until the first real response
+        // arrives — without `partial: true`, the spec §2.7 first-run
+        // gate would block this fn from ever firing on the abort-
+        // before-response path (`status → "done"` while `lastResponse`
+        // has never delivered DATA). The fn explicitly handles the
+        // SENTINEL case (`resp === undefined → ERROR(AbortError)`),
+        // so partial-fire is safe by design.
+        partial: true
+      }
+    );
+    this.add(promptInput, { name: "promptInput" });
+    this.add(llmResponse, { name: "llmResponse" });
+    this.add(this.lastResponse, { name: "lastResponse" });
+    if (this.toolCalls === toolCallsRaw) {
+      this.add(this.toolCalls, { name: "toolCalls" });
+    } else {
+      this.add(toolCallsRaw, { name: "toolCallsRaw" });
+      this.add(this.toolCalls, { name: "toolCalls" });
+    }
+    this.add(toolResultsNode, { name: "toolResults" });
+    this.add(this._terminalResult, { name: "terminalResult" });
+    this.addDisposer(turnSub);
+    this.addDisposer(abortedSub);
+    this.addDisposer(statusSub);
+    this.addDisposer(kaResponse);
+    this.addDisposer(kaResults);
+    this.addDisposer(kaAbort);
+    this._disposeRunWiring = () => {
+    };
+  }
+  /**
+   * Bridge to `Promise<LLMResponse>` over the reactive pipeline.
+   *
+   * - If `userMessage` is provided, appends it as a user message and
+   *   transitions status to `"thinking"` to kick the loop.
+   * - If `signal` is provided, binds it to the reactive `aborted` node
+   *   AND threads into `adapter.invoke({ signal })` so the wire call can
+   *   cancel mid-flight. The reactive `aborted` state + effect 3 guarantee
+   *   that even an adapter that ignores `signal` will stop emitting into
+   *   the agent graph.
+   * - Resolves when `status === "done"` with the final LLM response.
+   *   Rejects with `AbortError` when the abort signal fires pre-response.
+   *   Rejects with the stage error when `status === "error"`.
+   *
+   * **Concurrency:** `run()` refuses to overlap with a pending call on the
+   * same agent. Attempting to call `run()` while a previous `run()` is
+   * still in-flight throws a `RangeError` immediately. Stale-resolution
+   * safety is provided by `awaitSettled({skipCurrent: true})`, which
+   * ignores the cached initial DATA from any previous run and resolves
+   * only on a fresh post-subscribe emission of `_terminalResult`.
+   */
+  async run(userMessage, signal) {
+    if (this._running) {
+      throw new RangeError(
+        `agentLoop "${this.name}": run() called while a previous run() is still pending \u2014 await the previous run before starting another, or call abort() first`
+      );
+    }
+    this._running = true;
+    let offAbort;
+    try {
+      (0, import_core11.batch)(() => {
+        this.lastResponse.down([[import_core11.INVALIDATE]]);
+        this.turn.emit(0);
+        this.aborted.emit(false);
+        this.status.emit("idle");
+      });
+      if (userMessage != null) this.chat.append("user", userMessage);
+      const resultPromise = awaitSettled(this._terminalResult, { skipCurrent: true });
+      if (signal != null) {
+        if (signal.aborted) {
+          this.aborted.emit(true);
+        } else {
+          const listener = () => this.aborted.emit(true);
+          signal.addEventListener("abort", listener, { once: true });
+          offAbort = () => signal.removeEventListener("abort", listener);
+        }
+      }
+      if (signal?.aborted !== true) {
+        this.status.emit("thinking");
+      }
+      return await resultPromise;
+    } finally {
+      offAbort?.();
+      this._running = false;
+      this._currentAbortController = null;
+    }
+  }
+  /**
+   * Flip the reactive `aborted` state. Equivalent to setting an external
+   * `AbortSignal` — the pipeline observes and transitions to `"done"`.
+   */
+  abort() {
+    this.aborted.emit(true);
+  }
+  destroy() {
+    try {
+      this._disposeRunWiring();
+    } catch {
+    }
+    super.destroy();
+  }
+};
+function readLatest(batchData, prevData, index, fallback) {
+  const batch8 = batchData[index];
+  if (batch8 != null && batch8.length > 0) return batch8[batch8.length - 1];
+  const prev = prevData[index];
+  return prev !== void 0 ? prev : fallback;
+}
+function agentLoop(name, opts) {
+  const g = new AgentLoopGraph(name, opts);
+  g.tagFactory("agentLoop", (0, import_core11.placeholderArgs)(opts));
+  return g;
+}
+
+// src/presets/ai/agent.ts
+var EMPTY_INPUT = Object.freeze({ regular: 0 });
+var EMPTY_OUTPUT = Object.freeze({ regular: 0 });
+var EMPTY_USAGE = Object.freeze({ input: EMPTY_INPUT, output: EMPTY_OUTPUT });
+var ZERO_COST = Object.freeze({ usage: EMPTY_USAGE, turns: 0 });
+function addOptional(a, b) {
+  if (a == null && b == null) return void 0;
+  return (a ?? 0) + (b ?? 0);
+}
+function addExtensions(a, b) {
+  if (a == null && b == null) return void 0;
+  const out = { ...a ?? {} };
+  for (const [k, v] of Object.entries(b ?? {})) {
+    out[k] = (out[k] ?? 0) + v;
+  }
+  return out;
+}
+function addUsage(a, b) {
+  const out = {
+    input: {
+      regular: a.input.regular + b.input.regular,
+      ...addOptional(a.input.cacheRead, b.input.cacheRead) !== void 0 && {
+        cacheRead: addOptional(a.input.cacheRead, b.input.cacheRead)
+      },
+      ...addOptional(a.input.cacheWrite5m, b.input.cacheWrite5m) !== void 0 && {
+        cacheWrite5m: addOptional(a.input.cacheWrite5m, b.input.cacheWrite5m)
+      },
+      ...addOptional(a.input.cacheWrite1h, b.input.cacheWrite1h) !== void 0 && {
+        cacheWrite1h: addOptional(a.input.cacheWrite1h, b.input.cacheWrite1h)
+      },
+      ...addOptional(a.input.cacheWriteOther, b.input.cacheWriteOther) !== void 0 && {
+        cacheWriteOther: addOptional(a.input.cacheWriteOther, b.input.cacheWriteOther)
+      },
+      ...addOptional(a.input.audio, b.input.audio) !== void 0 && {
+        audio: addOptional(a.input.audio, b.input.audio)
+      },
+      ...addOptional(a.input.image, b.input.image) !== void 0 && {
+        image: addOptional(a.input.image, b.input.image)
+      },
+      ...addOptional(a.input.video, b.input.video) !== void 0 && {
+        video: addOptional(a.input.video, b.input.video)
+      },
+      ...addOptional(a.input.toolUse, b.input.toolUse) !== void 0 && {
+        toolUse: addOptional(a.input.toolUse, b.input.toolUse)
+      },
+      ...addExtensions(a.input.extensions, b.input.extensions) !== void 0 && {
+        extensions: addExtensions(a.input.extensions, b.input.extensions)
+      }
+    },
+    output: {
+      regular: a.output.regular + b.output.regular,
+      ...addOptional(a.output.reasoning, b.output.reasoning) !== void 0 && {
+        reasoning: addOptional(a.output.reasoning, b.output.reasoning)
+      },
+      ...addOptional(a.output.audio, b.output.audio) !== void 0 && {
+        audio: addOptional(a.output.audio, b.output.audio)
+      },
+      ...addOptional(a.output.predictionAccepted, b.output.predictionAccepted) !== void 0 && {
+        predictionAccepted: addOptional(
+          a.output.predictionAccepted,
+          b.output.predictionAccepted
+        )
+      },
+      ...addOptional(a.output.predictionRejected, b.output.predictionRejected) !== void 0 && {
+        predictionRejected: addOptional(
+          a.output.predictionRejected,
+          b.output.predictionRejected
+        )
+      },
+      ...addExtensions(a.output.extensions, b.output.extensions) !== void 0 && {
+        extensions: addExtensions(a.output.extensions, b.output.extensions)
+      }
+    },
+    ...addExtensions(a.auxiliary, b.auxiliary) !== void 0 && {
+      auxiliary: addExtensions(a.auxiliary, b.auxiliary)
+    }
+  };
+  return out;
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["done", "error"]);
+var AgentGraph = class extends import_graph6.Graph {
+  /** The agent's typed inbox. Writable; `in.emit(value)` kicks the loop. */
+  in;
+  /** The agent's typed outbox. SENTINEL until first response. */
+  out;
+  /** Lifecycle status (translated from the underlying loop's substates). */
+  status;
+  /** Cumulative cost for the current / most-recent input. */
+  cost;
+  /** The underlying agentLoop — exposed for inspection / advanced wiring. */
+  loop;
+  /** Optional shared memory subgraph (mounted at `memory/` if provided). */
+  memory;
+  constructor(spec, opts) {
+    super(spec.name, opts);
+    const initialTools = Array.isArray(spec.tools) ? spec.tools : void 0;
+    this.loop = agentLoop(`${spec.name}-loop`, {
+      adapter: spec.adapter,
+      ...spec.systemPrompt != null ? { systemPrompt: spec.systemPrompt } : {},
+      ...initialTools != null ? { tools: initialTools } : {},
+      ...spec.maxIterations != null ? { maxTurns: spec.maxIterations } : {}
+    });
+    this.mount("loop", this.loop);
+    if (spec.tools != null && !Array.isArray(spec.tools)) {
+      const toolsNode = spec.tools;
+      const registered = /* @__PURE__ */ new Set();
+      const unsubTools = toolsNode.subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] !== import_core12.DATA) continue;
+          const next = m[1];
+          const nextNames = new Set(next.map((t) => t.name));
+          for (const name of registered) {
+            if (!nextNames.has(name)) {
+              this.loop.tools.unregister(name);
+              registered.delete(name);
+            }
+          }
+          for (const tool of next) {
+            if (!registered.has(tool.name)) {
+              this.loop.tools.register(tool);
+              registered.add(tool.name);
+            }
+          }
+        }
+      });
+      this.addDisposer(unsubTools);
+    }
+    this.memory = spec.memory ?? null;
+    if (this.memory != null) {
+      this.mount("memory", this.memory);
+    }
+    this.in = (0, import_core12.node)([], {
+      name: "in",
+      describeKind: "state",
+      meta: aiMeta("agent_in"),
+      equals: () => false
+    });
+    this.add(this.in, { name: "in" });
+    const costNode = (0, import_core12.node)([], {
+      name: "cost",
+      describeKind: "state",
+      meta: aiMeta("agent_cost"),
+      initial: ZERO_COST
+    });
+    this.add(costNode, { name: "cost" });
+    this.cost = costNode;
+    const outMapper = spec.outMapper ?? defaultOutMapper();
+    const outNode = (0, import_core12.node)(
+      [this.loop.lastResponse],
+      (data, a, ctx) => {
+        const batch0 = data[0];
+        const resp = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+        if (resp === void 0) {
+          a.down([[import_core12.RESOLVED]]);
+          return;
+        }
+        a.emit(outMapper(resp));
+      },
+      {
+        name: "out",
+        describeKind: "derived",
+        meta: aiMeta("agent_out"),
+        // Each in.emit may produce a structurally-equal response (e.g.
+        // from a deterministic adapter) — disable framework dedup so
+        // repeat emits propagate and `awaitSettled({skipCurrent:true})`
+        // sees them. Callers can wrap with `distinctUntilChanged` if
+        // they want change-only semantics.
+        equals: () => false
+      }
+    );
+    this.add(outNode, { name: "out" });
+    this.out = outNode;
+    const statusNode = (0, import_core12.node)([], {
+      name: "status",
+      describeKind: "state",
+      meta: aiMeta("agent_status"),
+      initial: "idle"
+    });
+    this.add(statusNode, { name: "status" });
+    this.status = statusNode;
+    const statusMirrorEff = (0, import_core12.node)(
+      [this.loop.status],
+      (data, _a, ctx) => {
+        const batch0 = data[0];
+        const loopStatus = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0] ?? "idle";
+        const next = loopStatus === "idle" ? "idle" : loopStatus === "thinking" || loopStatus === "acting" ? "running" : loopStatus === "done" ? "done" : loopStatus === "error" ? "error" : "idle";
+        if (statusNode.cache !== next) statusNode.emit(next);
+      },
+      { describeKind: "effect", meta: aiMeta("agent_status_mirror") }
+    );
+    this.addDisposer((0, import_extra8.keepalive)(statusMirrorEff));
+    const costEff = (0, import_core12.node)(
+      [this.loop.lastResponse],
+      (data, _a, ctx) => {
+        const batch0 = data[0];
+        const resp = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+        if (resp === void 0) return;
+        const prev = costNode.cache ?? ZERO_COST;
+        const turns = this.loop.turn.cache ?? prev.turns;
+        const next = {
+          usage: resp.usage != null ? addUsage(prev.usage, resp.usage) : prev.usage,
+          turns
+        };
+        costNode.emit(next);
+      },
+      { describeKind: "effect", meta: aiMeta("agent_cost_rollup") }
+    );
+    this.addDisposer((0, import_extra8.keepalive)(costEff));
+    const inMapper = spec.inMapper ?? defaultInMapper();
+    const inputTopic = topic("input-topic");
+    this.mount("input-topic", inputTopic);
+    const inputSub = subscription("input-sub", inputTopic, {
+      from: "now"
+    });
+    this.mount("input-sub", inputSub);
+    const inputBridge = this.in.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] !== import_core12.DATA) continue;
+        const input = m[1];
+        inMapper(input);
+        inputTopic.publish(input);
+      }
+    });
+    this.addDisposer(inputBridge);
+    const drainEffect = (0, import_core12.node)(
+      [inputSub.available, this.loop.status],
+      (data, _a, ctx) => {
+        const availBatch = data[0];
+        const statusBatch = data[1];
+        const avail = (availBatch != null && availBatch.length > 0 ? availBatch.at(-1) : ctx.prevData[0] ?? []) ?? [];
+        const stat = (statusBatch != null && statusBatch.length > 0 ? statusBatch.at(-1) : ctx.prevData[1] ?? "idle") ?? "idle";
+        if (avail.length === 0) return;
+        if (stat === "thinking" || stat === "acting") return;
+        const result = inputSub.pullAndAck(1);
+        if (result.items.length === 0) return;
+        const input = result.items[0];
+        const userMsg = inMapper(input);
+        (0, import_core12.batch)(() => {
+          this.loop.lastResponse.down([[import_core12.INVALIDATE]]);
+          this.loop.turn.emit(0);
+          this.loop.aborted.emit(false);
+          costNode.emit(ZERO_COST);
+          this.loop.chat.append("user", userMsg);
+          this.loop.status.emit("thinking");
+        });
+      },
+      { describeKind: "effect", meta: aiMeta("agent_input_drain") }
+    );
+    this.addDisposer((0, import_extra8.keepalive)(drainEffect));
+    this.addDisposer((0, import_extra8.keepalive)(this.out));
+    void TERMINAL_STATUSES;
+  }
+};
+function defaultInMapper() {
+  return (input) => {
+    if (typeof input !== "string") {
+      throw new TypeError(
+        `agent: inMapper is required when TIn is not a string (got ${typeof input}). Pass spec.inMapper.`
+      );
+    }
+    return input;
+  };
+}
+function defaultOutMapper() {
+  return (response) => response;
+}
+
+// src/presets/ai/agent-memory.ts
+var import_core19 = require("@graphrefly/pure-ts/core");
+var import_extra15 = require("@graphrefly/pure-ts/extra");
+var import_graph9 = require("@graphrefly/pure-ts/graph");
+
+// src/base/composition/distill.ts
+var import_core14 = require("@graphrefly/pure-ts/core");
+var import_extra11 = require("@graphrefly/pure-ts/extra");
+
+// src/base/sources/async.ts
+var import_core13 = require("@graphrefly/pure-ts/core");
+var import_extra9 = require("@graphrefly/pure-ts/extra");
+var import_extra10 = require("@graphrefly/pure-ts/extra");
+function forEach(source, fn, opts) {
+  const inner = (0, import_core13.node)(
+    [source],
+    (data, _actions) => {
+      const batch0 = data[0];
+      if (batch0 != null && batch0.length > 0) {
+        for (const v of batch0) fn(v);
+      }
+    },
+    { describeKind: "effect", ...opts }
+  );
+  return inner.subscribe(() => {
+  });
+}
+
+// src/base/composition/distill.ts
+function isNodeLike2(value) {
+  return typeof value === "object" && value !== null && "cache" in value && typeof value.subscribe === "function";
+}
+function keepalive6(node20) {
+  node20.subscribe(() => void 0);
+}
+function mapFromSnapshot(snapshot) {
+  if (snapshot instanceof Map) return snapshot;
+  return /* @__PURE__ */ new Map();
+}
+function applyExtraction(store, extraction) {
+  if (!Array.isArray(extraction.upsert)) {
+    throw new TypeError("distill extraction requires upsert: Array<{ key, value }>");
+  }
+  (0, import_core14.batch)(() => {
+    for (const { key, value } of extraction.upsert) {
+      store.set(key, value);
+    }
+    for (const key of extraction.remove ?? []) {
+      store.delete(key);
+    }
+  });
+}
+function distill(source, extractFn, opts) {
+  const sourceNode = (0, import_extra11.fromAny)(source);
+  const store = (0, import_extra11.reactiveMap)(opts.mapOptions ?? {});
+  const budget = opts.budget ?? 2e3;
+  const hasContext = opts.context !== void 0 && opts.context !== null;
+  const contextNode = hasContext ? (0, import_extra11.fromAny)(opts.context) : (0, import_core14.node)([], { initial: null });
+  const extractionStream = (0, import_extra11.fromAny)(
+    extractFn(sourceNode, store.entries)
+  );
+  forEach(extractionStream, (extraction) => {
+    applyExtraction(store, extraction);
+  });
+  if (opts.evict) {
+    const verdictUnsubs = /* @__PURE__ */ new Map();
+    const evictionKeys = (0, import_core14.node)(
+      [store.entries],
+      (batchData, actions, ctx) => {
+        const batch0 = batchData[0];
+        const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+        const out = [];
+        const entries = mapFromSnapshot(snapshot);
+        for (const key of verdictUnsubs.keys()) {
+          if (!entries.has(key)) {
+            verdictUnsubs.get(key)();
+            verdictUnsubs.delete(key);
+          }
+        }
+        for (const [key, mem] of entries) {
+          const verdict = opts.evict(key, mem);
+          if (isNodeLike2(verdict)) {
+            if (!verdictUnsubs.has(key)) {
+              const unsub = forEach(verdict, (val) => {
+                if (val === true && store.has(key)) {
+                  store.delete(key);
+                }
+              });
+              verdictUnsubs.set(key, unsub);
+            }
+            continue;
+          }
+          if (typeof verdict === "boolean") {
+            if (verdict) out.push(key);
+            continue;
+          }
+          throw new TypeError("distill evict() must return boolean or Node<boolean>");
+        }
+        actions.emit(out);
+      },
+      { describeKind: "derived" }
+    );
+    forEach(evictionKeys, (keys) => {
+      for (const key of keys) store.delete(key);
+    });
+  }
+  const hasConsolidateTrigger = opts.consolidateTrigger !== void 0 && opts.consolidateTrigger !== null;
+  if (opts.consolidate && hasConsolidateTrigger) {
+    const consolidateTriggerNode = (0, import_extra11.fromAny)(opts.consolidateTrigger);
+    const consolidatePaired = (0, import_extra11.withLatestFrom)(
+      consolidateTriggerNode,
+      store.entries
+    );
+    const consolidationStream = (0, import_extra11.switchMap)(
+      consolidatePaired,
+      ([, entries]) => opts.consolidate(mapFromSnapshot(entries))
+    );
+    forEach(consolidationStream, (extraction) => {
+      applyExtraction(store, extraction);
+    });
+  }
+  const compact = (0, import_core14.node)(
+    [store.entries, contextNode],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      const context = data[1];
+      const map = mapFromSnapshot(snapshot);
+      const entries = [...map.entries()].map(([key, value]) => ({
+        key,
+        value,
+        score: opts.score(value, context),
+        cost: opts.cost(value)
+      }));
+      entries.sort((a, b) => b.score - a.score);
+      const packed = [];
+      let remaining = budget;
+      for (const item of entries) {
+        if (item.cost <= remaining) {
+          packed.push({ key: item.key, value: item.value, score: item.score });
+          remaining -= item.cost;
+        }
+      }
+      actions.emit(packed);
+    },
+    { describeKind: "derived", meta: { ...(0, import_core14.factoryTag)("distill", { budget }) } }
+  );
+  const size = (0, import_core14.node)(
+    [store.entries],
+    (batchData, actions, ctx) => {
+      const batch0 = batchData[0];
+      const snapshot = batch0 != null && batch0.length > 0 ? batch0.at(-1) : ctx.prevData[0];
+      actions.emit(mapFromSnapshot(snapshot).size);
+    },
+    { describeKind: "derived" }
+  );
+  keepalive6(compact);
+  keepalive6(size);
+  return { store, compact, size };
+}
+
+// src/utils/ai/memory/memory-composers.ts
+var import_core16 = require("@graphrefly/pure-ts/core");
+var import_extra13 = require("@graphrefly/pure-ts/extra");
+var import_graph8 = require("@graphrefly/pure-ts/graph");
+
+// src/base/utils/decay.ts
+var DEFAULT_DECAY_RATE = Math.LN2 / (7 * 86400);
+function decay(baseScore, ageSeconds2, ratePerSecond, minScore = 0) {
+  if (!Number.isFinite(baseScore)) return minScore;
+  if (!Number.isFinite(ageSeconds2) || ageSeconds2 <= 0) return Math.max(minScore, baseScore);
+  if (!Number.isFinite(ratePerSecond) || ratePerSecond <= 0) return Math.max(minScore, baseScore);
+  const decayed = baseScore * Math.exp(-ratePerSecond * ageSeconds2);
+  return Math.max(minScore, decayed);
+}
+
+// src/utils/memory/index.ts
+var import_core15 = require("@graphrefly/pure-ts/core");
+var import_extra12 = require("@graphrefly/pure-ts/extra");
+var import_graph7 = require("@graphrefly/pure-ts/graph");
+var NS_PER_SEC2 = 1e9;
+function memoryMeta(kind, extra) {
+  return domainMeta("memory", kind, extra);
+}
+function toNode(v, name) {
+  if (v instanceof import_core15.NodeImpl) return v;
+  return (0, import_core15.node)([], { initial: v, ...name ? { name } : void 0 });
+}
+function ageSeconds(now, lastNs) {
+  return (now - lastNs) / NS_PER_SEC2;
+}
+function cosineSimilarity(a, b) {
+  const n = Math.max(a.length, b.length);
+  let dot = 0;
+  let na = 0;
+  let nb = 0;
+  for (let i = 0; i < n; i += 1) {
+    const av = a[i] ?? 0;
+    const bv = b[i] ?? 0;
+    dot += av * bv;
+    na += av * av;
+    nb += bv * bv;
+  }
+  if (na === 0 || nb === 0) return 0;
+  const score = dot / Math.sqrt(na * nb);
+  return Number.isFinite(score) ? score : 0;
+}
+function searchResultsEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = a[i];
+    const y = b[i];
+    if (x.id !== y.id || x.score !== y.score || x.meta !== y.meta) return false;
+  }
+  return true;
+}
+function rankedEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i += 1) {
+    const x = a[i];
+    const y = b[i];
+    if (x.id !== y.id || x.score !== y.score || x.lastAccessNs !== y.lastAccessNs || x.value !== y.value)
+      return false;
+  }
+  return true;
+}
+function collection(name, opts = {}) {
+  const maxSize = opts.maxSize;
+  const ranked = opts.ranked ?? true;
+  const decayRate = ranked ? opts.decayRate ?? 0 : 0;
+  const minScore = opts.minScore ?? 0;
+  if (maxSize !== void 0 && maxSize < 1) {
+    throw new RangeError("collection: maxSize must be >= 1");
+  }
+  const scoreFnDefault = () => ranked ? 1 : 0;
+  const scoreInput = opts.score ?? scoreFnDefault;
+  const scoreNode = ranked && scoreInput instanceof import_core15.NodeImpl ? scoreInput : void 0;
+  const readScoreFn = () => {
+    if (scoreNode) return scoreNode.cache ?? scoreFnDefault;
+    return scoreInput;
+  };
+  const graph = new import_graph7.Graph(name);
+  const retentionScore = (_k, v) => ranked ? decay(v.baseScore, ageSeconds((0, import_core15.monotonicNs)(), v.lastAccessNs), decayRate, minScore) : v.lastAccessNs;
+  const items = (0, import_extra12.reactiveMap)({
+    name: "items",
+    ...maxSize !== void 0 ? { retention: { score: retentionScore, maxSize } } : {}
+  });
+  graph.add(items.entries, { name: "items" });
+  let refreshTick;
+  if (ranked && decayRate > 0) {
+    const intervalMs = opts.refreshIntervalMs ?? Math.max(1, 1e3 * Math.LN2 / (10 * decayRate));
+    const tickCounter = (0, import_extra12.fromTimer)(intervalMs, { period: intervalMs });
+    refreshTick = (0, import_core15.node)(
+      [tickCounter],
+      (_batchData, actions) => {
+        actions.emit((0, import_core15.monotonicNs)());
+      },
+      {
+        name: "refresh_tick_ns",
+        describeKind: "derived",
+        initial: (0, import_core15.monotonicNs)(),
+        meta: memoryMeta("clock")
+      }
+    );
+    graph.add(refreshTick, { name: "refresh_tick_ns" });
+  }
+  let rankedNode;
+  if (ranked) {
+    const rankedDeps = [items.entries];
+    if (refreshTick) rankedDeps.push(refreshTick);
+    if (scoreNode) rankedDeps.push(scoreNode);
+    rankedNode = (0, import_core15.node)(
+      rankedDeps,
+      (batchData, actions, ctx) => {
+        const values = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const snapshot = values[0];
+        let now;
+        if (refreshTick) {
+          const tickValue = values[1];
+          now = typeof tickValue === "number" ? tickValue : (0, import_core15.monotonicNs)();
+        } else {
+          now = (0, import_core15.monotonicNs)();
+        }
+        if (!snapshot || snapshot.size === 0) {
+          actions.emit([]);
+          return;
+        }
+        const out2 = [];
+        for (const entry of snapshot.values()) {
+          out2.push({
+            ...entry,
+            score: decay(entry.baseScore, ageSeconds(now, entry.lastAccessNs), decayRate, minScore)
+          });
+        }
+        out2.sort((a, b) => b.score - a.score || b.lastAccessNs - a.lastAccessNs);
+        actions.emit(out2);
+      },
+      {
+        name: "ranked",
+        describeKind: "derived",
+        equals: rankedEqual,
+        meta: memoryMeta("ranked")
+      }
+    );
+    graph.add(rankedNode, { name: "ranked" });
+  } else {
+    rankedNode = (0, import_core15.node)([], {
+      initial: [],
+      name: "ranked",
+      describeKind: "state",
+      meta: memoryMeta("ranked_disabled")
+    });
+    graph.add(rankedNode, { name: "ranked" });
+  }
+  const size = (0, import_core15.node)(
+    [items.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit((snapshot ?? /* @__PURE__ */ new Map()).size);
+    },
+    {
+      name: "size",
+      describeKind: "derived",
+      initial: 0,
+      meta: memoryMeta("size")
+    }
+  );
+  graph.add(size, { name: "size" });
+  graph.addDisposer((0, import_extra12.keepalive)(size));
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  const upsertImpl = (id, value, _opts) => {
+    const now = (0, import_core15.monotonicNs)();
+    const prev = items.get(id);
+    const baseScore = _opts?.score ?? readScoreFn()(value);
+    items.set(id, {
+      id,
+      value,
+      baseScore,
+      createdAtNs: prev?.createdAtNs ?? now,
+      lastAccessNs: now
+    });
+  };
+  const removeImpl = (id) => {
+    if (!items.has(id)) return;
+    items.delete(id);
+  };
+  const clearImpl = () => {
+    if (items.size === 0) return;
+    items.clear();
+  };
+  const rescoreImpl = () => {
+    if (!ranked) return;
+    const fn = readScoreFn();
+    const snapshot = items.entries.cache;
+    if (!snapshot || snapshot.size === 0) return;
+    const updates = [];
+    for (const entry of snapshot.values()) {
+      updates.push([entry.id, { ...entry, baseScore: fn(entry.value) }]);
+    }
+    items.setMany(updates);
+  };
+  const upsert = mutate(upsertImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "upsert", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const remove = mutate(removeImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "remove", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const clear = mutate(clearImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "clear", t_ns: m.t_ns, seq: m.seq })
+  });
+  const rescore = mutate(rescoreImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "rescore", t_ns: m.t_ns, seq: m.seq })
+  });
+  function itemNode(id) {
+    const idN = toNode(id, "id");
+    return (0, import_core15.node)(
+      [items.entries, idN],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const map = data[0];
+        const key = data[1];
+        actions.emit(map?.get(key));
+      },
+      {
+        describeKind: "derived",
+        meta: memoryMeta("collection_item")
+      }
+    );
+  }
+  function hasNode(id) {
+    const idN = toNode(id, "id");
+    return (0, import_core15.node)(
+      [items.entries, idN],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const map = data[0];
+        const key = data[1];
+        actions.emit(map?.has(key) ?? false);
+      },
+      {
+        describeKind: "derived",
+        meta: memoryMeta("collection_has")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    events,
+    items: items.entries,
+    ranked: rankedNode,
+    size,
+    upsert,
+    remove,
+    clear,
+    rescore,
+    itemNode,
+    hasNode
+  });
+  return out;
+}
+function vectorIndex(opts = {}) {
+  const backend = opts.backend ?? "flat";
+  const dimension = opts.dimension;
+  const strictDimension = opts.strictDimension ?? true;
+  const maxSize = opts.maxSize;
+  const userRetentionScore = opts.retentionScore;
+  let hnsw;
+  if (backend === "hnsw") {
+    hnsw = opts.hnswFactory?.();
+    if (!hnsw) {
+      throw new Error(
+        'vectorIndex backend "hnsw" requires an optional dependency adapter; install your HNSW package and provide `hnswFactory`.'
+      );
+    }
+  }
+  const graph = new import_graph7.Graph(opts.name ?? "vector_index");
+  let inferredDimension;
+  function assertDimension(vector) {
+    if (dimension !== void 0) {
+      if (vector.length !== dimension) {
+        throw new RangeError(
+          `vector dimension mismatch: expected ${dimension}, got ${vector.length}`
+        );
+      }
+      return;
+    }
+    if (!strictDimension) return;
+    if (inferredDimension === void 0) {
+      inferredDimension = vector.length;
+      return;
+    }
+    if (vector.length !== inferredDimension) {
+      throw new RangeError(
+        `vector dimension mismatch: inferred ${inferredDimension} from first upsert, got ${vector.length}. Pass \`strictDimension: false\` to opt into zero-pad behavior, or set an explicit \`dimension\`.`
+      );
+    }
+  }
+  const baseRetentionScore = userRetentionScore ?? ((r) => r.upsertedAtNs);
+  let clearInProgress = false;
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  const entries = (0, import_extra12.reactiveMap)({
+    name: "entries",
+    ...maxSize !== void 0 ? {
+      retention: {
+        score: (_k, v) => baseRetentionScore(v),
+        maxSize,
+        onArchive: (key) => {
+          if (clearInProgress) return;
+          if (backend === "hnsw") hnsw.remove(key);
+          events.append({
+            action: "evict",
+            id: key,
+            t_ns: (0, import_core15.wallClockNs)(),
+            seq: bumpCursor(seqCursor)
+          });
+        }
+      }
+    } : {}
+  });
+  graph.add(entries.entries, { name: "entries" });
+  graph.addDisposer((0, import_extra12.keepalive)(entries.entries));
+  if (hnsw?.dispose) {
+    const disposeAdapter = hnsw.dispose.bind(hnsw);
+    graph.addDisposer(() => disposeAdapter());
+  }
+  const upsertImpl = (id, vector, meta) => {
+    assertDimension(vector);
+    if (backend === "hnsw") hnsw.upsert(id, vector, meta);
+    const copiedMeta = (() => {
+      if (meta === void 0) return void 0;
+      if (meta === null || typeof meta !== "object") return meta;
+      return Array.isArray(meta) ? [...meta] : { ...meta };
+    })();
+    const record = {
+      id,
+      vector: [...vector],
+      ...copiedMeta !== void 0 ? { meta: copiedMeta } : {},
+      upsertedAtNs: (0, import_core15.monotonicNs)()
+    };
+    entries.set(id, record);
+  };
+  const removeImpl = (id) => {
+    if (!entries.has(id)) return;
+    if (backend === "hnsw") hnsw.remove(id);
+    entries.delete(id);
+  };
+  const clearImpl = () => {
+    if (entries.size === 0) return;
+    clearInProgress = true;
+    try {
+      entries.clear();
+      if (backend === "hnsw") hnsw.clear();
+    } finally {
+      clearInProgress = false;
+    }
+    inferredDimension = void 0;
+  };
+  const reindexImpl = () => {
+    if (backend !== "hnsw") return;
+    const snapshot = entries.entries.cache;
+    if (!snapshot) return;
+    hnsw.clear();
+    for (const r of snapshot.values()) {
+      hnsw.upsert(r.id, r.vector, r.meta);
+    }
+  };
+  const upsert = mutate(upsertImpl, {
+    frame: "inline",
+    log: events,
+    freeze: false,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "upsert", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const remove = mutate(removeImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({ action: "remove", id, t_ns: m.t_ns, seq: m.seq })
+  });
+  const clear = mutate(clearImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "clear", t_ns: m.t_ns, seq: m.seq })
+  });
+  const reindex = mutate(reindexImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: (_args, _r, m) => ({ action: "reindex", t_ns: m.t_ns, seq: m.seq })
+  });
+  function searchNode(query, k = 5) {
+    const kN = toNode(k, "k");
+    return (0, import_core15.node)(
+      [entries.entries, query, kN],
+      (batchData, actions, ctx) => {
+        const values = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const snapshot = values[0];
+        const q = values[1];
+        const kRaw = values[2];
+        const kVal = Number.isFinite(kRaw) ? Math.max(0, Math.floor(kRaw)) : 0;
+        if (!snapshot || snapshot.size === 0 || kVal <= 0) {
+          actions.emit([]);
+          return;
+        }
+        if (q == null || q.length === 0) {
+          actions.emit([]);
+          return;
+        }
+        const expectedDim = dimension ?? (strictDimension ? inferredDimension : void 0);
+        if (expectedDim !== void 0 && q.length !== expectedDim) {
+          actions.emit([]);
+          return;
+        }
+        if (backend === "hnsw") {
+          const adapterResults = hnsw.search(q, kVal);
+          actions.emit([...adapterResults]);
+          return;
+        }
+        const ranked = [...snapshot.values()].map((row) => {
+          const result = {
+            id: row.id,
+            score: cosineSimilarity(q, row.vector),
+            ...row.meta !== void 0 ? { meta: row.meta } : {}
+          };
+          return result;
+        }).sort((a, b) => b.score - a.score).slice(0, kVal);
+        actions.emit(ranked);
+      },
+      {
+        describeKind: "derived",
+        // A1: include `score` in equality. The previous id-only
+        // comparator suppressed re-emissions when the same set of
+        // IDs/order had different scores (re-upsert with new
+        // vector; query change preserving ranking order).
+        equals: (a, b) => searchResultsEqual(a, b),
+        meta: memoryMeta("vector_search")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    backend,
+    events,
+    entries: entries.entries,
+    upsert,
+    remove,
+    clear,
+    reindex,
+    searchNode
+  });
+  return out;
+}
+var TRIPLE_SEP = "\0";
+function tripleKey(from, to, relation) {
+  return `${from}${TRIPLE_SEP}${to}${TRIPLE_SEP}${relation}`;
+}
+function buildAdjacency(edges, side) {
+  if (!edges || edges.size === 0) return /* @__PURE__ */ new Map();
+  const buckets = /* @__PURE__ */ new Map();
+  for (const edge of edges.values()) {
+    const key = side === "from" ? edge.from : edge.to;
+    let bucket = buckets.get(key);
+    if (!bucket) {
+      bucket = [];
+      buckets.set(key, bucket);
+    }
+    bucket.push(edge);
+  }
+  const out = /* @__PURE__ */ new Map();
+  for (const [key, bucket] of buckets) out.set(key, Object.freeze(bucket));
+  return out;
+}
+function adjacencyEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (a.size !== b.size) return false;
+  for (const [k, av] of a) {
+    const bv = b.get(k);
+    if (!bv || av.length !== bv.length) return false;
+    for (let i = 0; i < av.length; i += 1) {
+      const ae = av[i];
+      const be = bv[i];
+      if (ae.from !== be.from || ae.to !== be.to || ae.relation !== be.relation || ae.weight !== be.weight)
+        return false;
+    }
+  }
+  return true;
+}
+function knowledgeGraph(name, opts = {}) {
+  const orphanGC = opts.orphanGC ?? "keep";
+  if (opts.entitiesMaxSize !== void 0 && opts.entitiesMaxSize < 1) {
+    throw new RangeError("knowledgeGraph: entitiesMaxSize must be >= 1");
+  }
+  if (opts.edgesMaxSize !== void 0 && opts.edgesMaxSize < 1) {
+    throw new RangeError("knowledgeGraph: edgesMaxSize must be >= 1");
+  }
+  const graph = new import_graph7.Graph(name);
+  const entitiesMap = (0, import_extra12.reactiveMap)({
+    name: "entities",
+    ...opts.entitiesMaxSize !== void 0 ? { maxSize: opts.entitiesMaxSize } : {}
+  });
+  const edgesMap = (0, import_extra12.reactiveMap)({
+    name: "edges",
+    ...opts.edgesMaxSize !== void 0 ? { maxSize: opts.edgesMaxSize } : {}
+  });
+  graph.add(entitiesMap.entries, { name: "entities" });
+  graph.add(edgesMap.entries, { name: "edges" });
+  const adjacencyOut = (0, import_core15.node)(
+    [edgesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit(buildAdjacency(snapshot, "from"));
+    },
+    {
+      name: "adjacencyOut",
+      describeKind: "derived",
+      initial: /* @__PURE__ */ new Map(),
+      equals: adjacencyEqual,
+      meta: memoryMeta("adjacency_out")
+    }
+  );
+  const adjacencyIn = (0, import_core15.node)(
+    [edgesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const snapshot = data[0];
+      actions.emit(buildAdjacency(snapshot, "to"));
+    },
+    {
+      name: "adjacencyIn",
+      describeKind: "derived",
+      initial: /* @__PURE__ */ new Map(),
+      equals: adjacencyEqual,
+      meta: memoryMeta("adjacency_in")
+    }
+  );
+  graph.add(adjacencyOut, { name: "adjacencyOut" });
+  graph.add(adjacencyIn, { name: "adjacencyIn" });
+  graph.addDisposer((0, import_extra12.keepalive)(adjacencyOut));
+  graph.addDisposer((0, import_extra12.keepalive)(adjacencyIn));
+  const entityCount = (0, import_core15.node)(
+    [entitiesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const m = data[0];
+      actions.emit((m ?? /* @__PURE__ */ new Map()).size);
+    },
+    { name: "entityCount", describeKind: "derived", initial: 0, meta: memoryMeta("entity_count") }
+  );
+  const edgeCount = (0, import_core15.node)(
+    [edgesMap.entries],
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const m = data[0];
+      actions.emit((m ?? /* @__PURE__ */ new Map()).size);
+    },
+    { name: "edgeCount", describeKind: "derived", initial: 0, meta: memoryMeta("edge_count") }
+  );
+  graph.add(entityCount, { name: "entityCount" });
+  graph.add(edgeCount, { name: "edgeCount" });
+  graph.addDisposer((0, import_extra12.keepalive)(entityCount));
+  graph.addDisposer((0, import_extra12.keepalive)(edgeCount));
+  const events = createAuditLog({
+    name: "events",
+    retainedLimit: 1024,
+    graph
+  });
+  const seqCursor = registerCursor(graph, "seq", 0);
+  function entityHasReferences(id) {
+    const out2 = adjacencyOut.cache;
+    const inb = adjacencyIn.cache;
+    if ((out2?.get(id)?.length ?? 0) > 0) return true;
+    if ((inb?.get(id)?.length ?? 0) > 0) return true;
+    return false;
+  }
+  function applyOrphanGC(candidates) {
+    if (orphanGC !== "remove") return;
+    for (const candidate of candidates) {
+      if (!entitiesMap.has(candidate)) continue;
+      if (entityHasReferences(candidate)) continue;
+      entitiesMap.delete(candidate);
+      events.append({
+        action: "orphanRemove",
+        id: candidate,
+        t_ns: (0, import_core15.wallClockNs)(),
+        seq: bumpCursor(seqCursor)
+      });
+    }
+  }
+  const upsertEntityImpl = (id, value) => {
+    entitiesMap.set(id, value);
+  };
+  const removeEntityImpl = (id) => {
+    const snapshot = edgesMap.entries.cache;
+    const cascadedNeighbors = /* @__PURE__ */ new Set();
+    if (snapshot) {
+      const toDrop = [];
+      for (const [key, edge] of snapshot) {
+        if (edge.from === id || edge.to === id) {
+          toDrop.push(key);
+          if (edge.from !== id) cascadedNeighbors.add(edge.from);
+          if (edge.to !== id) cascadedNeighbors.add(edge.to);
+        }
+      }
+      if (toDrop.length > 0) edgesMap.deleteMany(toDrop);
+    }
+    if (entitiesMap.has(id)) entitiesMap.delete(id);
+    applyOrphanGC([...cascadedNeighbors]);
+  };
+  const linkImpl = (from, to, relation, weight = 1) => {
+    edgesMap.set(tripleKey(from, to, relation), { from, to, relation, weight });
+  };
+  const unlinkImpl = (from, to, relation) => {
+    if (relation !== void 0) {
+      edgesMap.delete(tripleKey(from, to, relation));
+    } else {
+      const snapshot = edgesMap.entries.cache;
+      if (!snapshot) return;
+      const toDrop = [];
+      for (const [key, edge] of snapshot) {
+        if (edge.from === from && edge.to === to) toDrop.push(key);
+      }
+      if (toDrop.length > 0) edgesMap.deleteMany(toDrop);
+    }
+    applyOrphanGC([from, to]);
+  };
+  const upsertEntity = mutate(upsertEntityImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({
+      action: "upsertEntity",
+      id,
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  const removeEntity = mutate(removeEntityImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([id], _r, m) => ({
+      action: "removeEntity",
+      id,
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  const link = mutate(linkImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([from, to, relation, weight], _r, m) => ({
+      action: "link",
+      from,
+      to,
+      relation,
+      weight: weight ?? 1,
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  const unlink = mutate(unlinkImpl, {
+    frame: "inline",
+    log: events,
+    seq: seqCursor,
+    onSuccessRecord: ([from, to, relation], _r, m) => ({
+      action: "unlink",
+      from,
+      to,
+      ...relation !== void 0 ? { relation } : {},
+      t_ns: m.t_ns,
+      seq: m.seq
+    })
+  });
+  function relatedNode(id, relation) {
+    const idN = toNode(id, "id");
+    const relN = relation !== void 0 ? toNode(relation, "relation") : void 0;
+    const deps = relN ? [adjacencyOut, adjacencyIn, idN, relN] : [adjacencyOut, adjacencyIn, idN];
+    return (0, import_core15.node)(
+      deps,
+      (batchData, actions, ctx) => {
+        const values = batchData.map(
+          (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+        );
+        const out2 = values[0];
+        const inb = values[1];
+        const key = values[2];
+        const rel = relN ? values[3] : void 0;
+        const outE = out2?.get(key) ?? [];
+        const inE = inb?.get(key) ?? [];
+        const seen = /* @__PURE__ */ new Set();
+        const acc = [];
+        for (const edge of outE) {
+          const k = tripleKey(edge.from, edge.to, edge.relation);
+          if (seen.has(k)) continue;
+          if (rel !== void 0 && edge.relation !== rel) continue;
+          seen.add(k);
+          acc.push(edge);
+        }
+        for (const edge of inE) {
+          const k = tripleKey(edge.from, edge.to, edge.relation);
+          if (seen.has(k)) continue;
+          if (rel !== void 0 && edge.relation !== rel) continue;
+          seen.add(k);
+          acc.push(edge);
+        }
+        actions.emit(acc);
+      },
+      {
+        describeKind: "derived",
+        equals: (a, b) => {
+          const av = a;
+          const bv = b;
+          if (av === bv) return true;
+          if (av == null || bv == null) return false;
+          if (av.length !== bv.length) return false;
+          for (let i = 0; i < av.length; i += 1) {
+            const x = av[i];
+            const y = bv[i];
+            if (x.from !== y.from || x.to !== y.to || x.relation !== y.relation || x.weight !== y.weight)
+              return false;
+          }
+          return true;
+        },
+        meta: memoryMeta("related")
+      }
+    );
+  }
+  const out = Object.assign(graph, {
+    events,
+    entities: entitiesMap.entries,
+    edges: edgesMap.entries,
+    adjacencyOut,
+    adjacencyIn,
+    entityCount,
+    edgeCount,
+    upsertEntity,
+    removeEntity,
+    link,
+    unlink,
+    relatedNode
+  });
+  return out;
+}
+
+// src/utils/ai/memory/memory-composers.ts
+var MemoryWithVectorsGraph = class extends import_graph8.Graph {
+  vectors;
+  constructor(opts) {
+    super(opts.name ?? "memory-vectors", opts.graph);
+    this.vectors = vectorIndex({ dimension: opts.dimension });
+    this.mount("vectorIndex", this.vectors);
+    const embedFn = opts.embedFn;
+    const vectorsRef = this.vectors;
+    const indexer = (0, import_core16.node)(
+      [opts.store.store.entries],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        const storeMap = data[0] ?? /* @__PURE__ */ new Map();
+        for (const [key, mem] of storeMap) {
+          const vec = embedFn(mem);
+          if (vec) vectorsRef.upsert(key, vec, mem);
+        }
+      },
+      { name: "indexer", describeKind: "effect" }
+    );
+    this.add(indexer, { name: "indexer" });
+    this.addDisposer((0, import_extra13.keepalive)(indexer));
+  }
+};
+function memoryWithVectors(opts) {
+  return new MemoryWithVectorsGraph(opts);
+}
+var MemoryWithKGGraph = class extends import_graph8.Graph {
+  kg;
+  constructor(opts) {
+    const name = opts.name ?? "memory-kg";
+    super(name, opts.graph);
+    const kgName = opts.kgName ?? `${name}-kg`;
+    const mountPath = opts.mountPath ?? "knowledge-kg";
+    this.kg = knowledgeGraph(kgName);
+    this.mount(mountPath, this.kg);
+    if (!opts.entityFn) return;
+    const entityFn = opts.entityFn;
+    const kgRef = this.kg;
+    const indexer = (0, import_core16.node)(
+      [opts.store.store.entries],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        const storeMap = data[0] ?? /* @__PURE__ */ new Map();
+        for (const [key, mem] of storeMap) {
+          const extracted = entityFn(key, mem);
+          if (!extracted) continue;
+          for (const ent of extracted.entities ?? []) {
+            kgRef.upsertEntity(ent.id, ent.value);
+          }
+          for (const rel of extracted.relations ?? []) {
+            kgRef.link(rel.from, rel.to, rel.relation, rel.weight);
+          }
+        }
+      },
+      { name: "indexer", describeKind: "effect" }
+    );
+    this.add(indexer, { name: "indexer" });
+    this.addDisposer((0, import_extra13.keepalive)(indexer));
+  }
+};
+function memoryWithKG(opts) {
+  return new MemoryWithKGGraph(opts);
+}
+var MemoryWithTiersGraph = class extends import_graph8.Graph {
+  store;
+  tiers;
+  compact;
+  size;
+  permanent;
+  permanentKeys;
+  entryCreatedAtNs;
+  constructor(opts) {
+    super(opts.name ?? "memory-tiers", opts.graph);
+    const decayRate = opts.decayRate ?? DEFAULT_DECAY_RATE;
+    const maxActive = opts.maxActive ?? 1e3;
+    const archiveThreshold = opts.archiveThreshold ?? 0.1;
+    const permanentFilter = opts.permanentFilter ?? (() => false);
+    this.permanent = collection("permanent", { ranked: false });
+    this.mount("permanent", this.permanent);
+    this.permanentKeys = (0, import_extra13.reactiveMap)({ name: "permanentKeys" });
+    this.add(this.permanentKeys.entries, { name: "permanentKeys" });
+    this.entryCreatedAtNs = (0, import_extra13.reactiveMap)({ name: "entryCreatedAtNs" });
+    this.add(this.entryCreatedAtNs.entries, { name: "entryCreatedAtNs" });
+    let contextNode;
+    if (opts.context) {
+      contextNode = (0, import_extra13.fromAny)(opts.context);
+    } else {
+      contextNode = (0, import_core16.node)([], { initial: null });
+      this.add(contextNode, { name: "context" });
+    }
+    let latestCtx = contextNode.cache;
+    const ctxUnsub = contextNode.subscribe((msgs) => {
+      for (const m of msgs) if (m[0] === import_core16.DATA) latestCtx = m[1];
+    });
+    this.addDisposer(ctxUnsub);
+    const permanentKeysRef = this.permanentKeys;
+    const entryCreatedAtNsRef = this.entryCreatedAtNs;
+    const score = opts.score;
+    const retention = {
+      score: (key, value) => {
+        if (permanentFilter(key, value)) return Number.POSITIVE_INFINITY;
+        if (permanentKeysRef.has(key)) return Number.POSITIVE_INFINITY;
+        const nowNs = (0, import_core16.monotonicNs)();
+        const createdNs = entryCreatedAtNsRef.get(key) ?? nowNs;
+        const ageSeconds2 = Number(nowNs - createdNs) / 1e9;
+        return decay(score(value, latestCtx), ageSeconds2, decayRate);
+      },
+      archiveThreshold,
+      maxSize: maxActive
+    };
+    this.store = distill(opts.source, opts.extractFn, {
+      score: opts.score,
+      cost: opts.cost,
+      ...opts.budget !== void 0 ? { budget: opts.budget } : {},
+      ...opts.evict !== void 0 ? { evict: opts.evict } : {},
+      ...opts.consolidate !== void 0 ? { consolidate: opts.consolidate } : {},
+      ...opts.consolidateTrigger !== void 0 ? { consolidateTrigger: opts.consolidateTrigger } : {},
+      ...opts.context !== void 0 ? { context: opts.context } : {},
+      mapOptions: { retention }
+    });
+    this.add(this.store.store.entries, { name: "store" });
+    this.compact = this.store.compact;
+    this.add(this.compact, { name: "compact" });
+    this.size = this.store.size;
+    this.add(this.size, { name: "size" });
+    const storeRef = this.store;
+    const tierOf = (key) => {
+      if (permanentKeysRef.has(key)) return "permanent";
+      const m = storeRef.store.entries.cache ?? /* @__PURE__ */ new Map();
+      if (m.has(key)) return "active";
+      return "archived";
+    };
+    const permanentRef = this.permanent;
+    const markPermanent = (key, value) => {
+      permanentKeysRef.set(key, true);
+      permanentRef.upsert(key, value);
+    };
+    const syncCreatedAt = (0, import_core16.node)(
+      [this.store.store.entries],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        const map = data[0] ?? /* @__PURE__ */ new Map();
+        const nowNs = (0, import_core16.monotonicNs)();
+        const toAdd = [];
+        for (const key of map.keys()) {
+          if (!entryCreatedAtNsRef.has(key)) toAdd.push(key);
+        }
+        if (toAdd.length > 0) {
+          (0, import_core16.batch)(() => {
+            for (const key of toAdd) entryCreatedAtNsRef.set(key, nowNs);
+          });
+        }
+      },
+      { name: "entryCreatedAtNs/sync", describeKind: "effect" }
+    );
+    this.add(syncCreatedAt, { name: "entryCreatedAtNs/sync" });
+    this.addDisposer((0, import_extra13.keepalive)(syncCreatedAt));
+    const entriesUnsub = this.store.store.entries.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] !== import_core16.DATA) continue;
+        const map = m[1];
+        const created = entryCreatedAtNsRef.entries.cache;
+        if (created == null) continue;
+        const toDelete = [];
+        for (const key of created.keys()) {
+          if (!map.has(key)) toDelete.push(key);
+        }
+        if (toDelete.length > 0) {
+          (0, import_core16.batch)(() => {
+            for (const key of toDelete) entryCreatedAtNsRef.delete(key);
+          });
+        }
+      }
+    });
+    this.addDisposer(entriesUnsub);
+    const promoter = (0, import_core16.node)(
+      [this.store.store.entries],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        const map = data[0] ?? /* @__PURE__ */ new Map();
+        for (const [key, mem] of map) {
+          if (permanentKeysRef.has(key)) continue;
+          if (permanentFilter(key, mem)) {
+            (0, import_core16.batch)(() => {
+              markPermanent(key, mem);
+            });
+          }
+        }
+      },
+      { name: "promoter", describeKind: "effect" }
+    );
+    this.add(promoter, { name: "promoter" });
+    this.addDisposer((0, import_extra13.keepalive)(promoter));
+    let archiveHandle = null;
+    if (opts.archiveTier) {
+      archiveHandle = this.attachSnapshotStorage(
+        [{ snapshot: opts.archiveTier }],
+        opts.archiveStorageOptions ?? {}
+      );
+      this.addDisposer(() => archiveHandle?.dispose());
+    }
+    this.tiers = {
+      permanent: this.permanent,
+      activeEntries: this.store.store.entries,
+      archiveHandle,
+      tierOf,
+      markPermanent
+    };
+  }
+};
+function memoryWithTiers(opts) {
+  return new MemoryWithTiersGraph(opts);
+}
+function sharedPrefixDepth(q, e) {
+  if (!q || !e) return 0;
+  const n = Math.min(q.length, e.length);
+  let i = 0;
+  while (i < n && q[i] === e[i]) i++;
+  return i;
+}
+var packedEquals = (a, b) => {
+  if (a === b) return true;
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+  return true;
+};
+var MemoryRetrievalGraph = class extends import_graph8.Graph {
+  _store;
+  _vectors;
+  _kg;
+  _opts;
+  _contextNode;
+  _topK;
+  _graphDepth;
+  _budget;
+  _contextWeight;
+  _retrieveSeq = 0;
+  constructor(opts) {
+    super(opts.name ?? "memory-retrieval", opts.graph);
+    this._store = opts.store;
+    this._vectors = opts.vectors ?? null;
+    this._kg = opts.kg ?? null;
+    this._opts = opts;
+    this._topK = opts.topK ?? 20;
+    this._graphDepth = opts.graphDepth ?? 1;
+    this._budget = opts.budget ?? 2e3;
+    this._contextWeight = opts.contextWeight ?? 0;
+    if (opts.context) {
+      this._contextNode = (0, import_extra13.fromAny)(opts.context);
+    } else {
+      this._contextNode = this.state("_context", null);
+    }
+  }
+  _runRetrieval(storeMap, ctx, query) {
+    const opts = this._opts;
+    const candidateMap = /* @__PURE__ */ new Map();
+    let vectorCandidates = [];
+    if (this._vectors && query.vector) {
+      const q = query.vector;
+      const snapshot = this._vectors.entries.cache;
+      if (snapshot && snapshot.size > 0 && this._topK > 0) {
+        const scored = [...snapshot.values()].map(
+          (row) => ({
+            id: row.id,
+            score: cosineSimilarity(q, row.vector),
+            ...row.meta !== void 0 ? { meta: row.meta } : {}
+          })
+        ).sort((a, b) => b.score - a.score).slice(0, this._topK);
+        vectorCandidates = scored;
+        for (const vc of vectorCandidates) {
+          const mem = storeMap.get(vc.id);
+          if (mem) candidateMap.set(vc.id, { value: mem, sources: /* @__PURE__ */ new Set(["vector"]) });
+        }
+      }
+    }
+    const graphExpanded = [];
+    if (this._kg) {
+      const adjOut = this._kg.adjacencyOut.cache;
+      const adjIn = this._kg.adjacencyIn.cache;
+      const seedIds = [...query.entityIds ?? [], ...[...candidateMap.keys()]];
+      const visited = /* @__PURE__ */ new Set();
+      let frontier = seedIds;
+      for (let depth = 0; depth < this._graphDepth; depth++) {
+        const nextFrontier = [];
+        for (const id of frontier) {
+          if (visited.has(id)) continue;
+          visited.add(id);
+          const outEdges = adjOut?.get(id) ?? [];
+          const inEdges = adjIn?.get(id) ?? [];
+          for (const edge of outEdges) {
+            const targetId = edge.to;
+            if (!visited.has(targetId)) {
+              nextFrontier.push(targetId);
+              const mem = storeMap.get(targetId);
+              if (mem) {
+                const existing = candidateMap.get(targetId);
+                if (existing) existing.sources.add("graph");
+                else candidateMap.set(targetId, { value: mem, sources: /* @__PURE__ */ new Set(["graph"]) });
+                graphExpanded.push(targetId);
+              }
+            }
+          }
+          for (const edge of inEdges) {
+            const targetId = edge.from;
+            if (!visited.has(targetId)) {
+              nextFrontier.push(targetId);
+              const mem = storeMap.get(targetId);
+              if (mem) {
+                const existing = candidateMap.get(targetId);
+                if (existing) existing.sources.add("graph");
+                else candidateMap.set(targetId, { value: mem, sources: /* @__PURE__ */ new Set(["graph"]) });
+                graphExpanded.push(targetId);
+              }
+            }
+          }
+        }
+        frontier = nextFrontier;
+      }
+    }
+    for (const [key, mem] of storeMap) {
+      if (!candidateMap.has(key)) {
+        candidateMap.set(key, { value: mem, sources: /* @__PURE__ */ new Set(["store"]) });
+      }
+    }
+    const qDepth = query.context?.length ?? 0;
+    const ranked = [];
+    for (const [key, { value, sources }] of candidateMap) {
+      const entryContext = opts.contextOf ? opts.contextOf(value) : void 0;
+      let score = opts.score(value, ctx);
+      if (this._contextWeight > 0 && qDepth > 0) {
+        const shared = sharedPrefixDepth(query.context, entryContext);
+        if (shared > 0) score = score * (1 + this._contextWeight * shared / qDepth);
+      }
+      const entry = entryContext ? { key, value, score, sources: [...sources], context: entryContext } : { key, value, score, sources: [...sources] };
+      ranked.push(entry);
+    }
+    ranked.sort((a, b) => b.score - a.score);
+    const packed = [];
+    let usedBudget = 0;
+    for (const entry of ranked) {
+      const c = opts.cost(entry.value);
+      if (usedBudget + c > this._budget && packed.length > 0) break;
+      packed.push(entry);
+      usedBudget += c;
+    }
+    return { packed, trace: { vectorCandidates, graphExpanded, ranked, packed } };
+  }
+  /**
+   * Reactive consumer API — chain into the graph.
+   *
+   * Each call constructs its own per-input subgraph mounted at
+   * `retrieve_${id}` (auto-incrementing within this MemoryRetrievalGraph
+   * instance) with named nodes:
+   *
+   * - `context` — `fromAny(queryInput)` projection (so the input node is
+   *   visible to `describe()` even when callers pass a raw value).
+   * - `result` — pure derived `{ packed, trace }`.
+   * - `projection` — the packed-array node returned to the caller.
+   *
+   * `result` declares the substrate's `store.entries`, the optional
+   * `context` Node, the local `context` projection, and (when configured)
+   * `vectors.entries` / `kg.adjacencyOut` / `kg.adjacencyIn` as deps —
+   * so vector upserts and KG mutations re-trigger retrieval even when
+   * the input is unchanged.
+   *
+   * **Lifecycle contract (DS-13.5.C, 2026-05-01).** The per-call subgraph
+   * stays mounted while the returned `projection` has at least one
+   * subscriber. When the last subscriber unsubscribes, projection's
+   * `deactivate` cleanup hook fires (canonical "last unsubscribe" signal
+   * via the existing `NodeFnCleanup.onDeactivation` protocol), which calls
+   * `parent.remove(retrieve_${id})` and tears the per-call topology
+   * down via TEARDOWN cascade (post-DS-13.5.A Q16, COMPLETE auto-precedes).
+   *
+   * **Single-shot lifecycle.** This auto-unmount is keyed to the FIRST
+   * last-unsubscribe event — projection is non-resubscribable from the
+   * caller's perspective. Callers who need to subscribe / unsubscribe /
+   * re-subscribe should hold a long-lived subscription externally (e.g.
+   * `keepalive(projection)`) or call `retrieveReactive(...)` again to
+   * mount a fresh per-call subgraph.
+   *
+   * **Caller obligation.** Either subscribe to `projection` (and
+   * eventually unsubscribe to trigger cleanup) OR drop the returned
+   * reference without subscribing — in the no-subscribe case the
+   * subgraph is dormant (no compute fires) and a parent `destroy()`
+   * cascade reclaims it. Holding `projection` without subscribing AND
+   * without ever destroying the parent is the leak case the JSDoc above
+   * the C1 rework covers.
+   *
+   * One-shot callers use `awaitSettled(retrieveReactive(input))`.
+   */
+  retrieveReactive(queryInput) {
+    const id = ++this._retrieveSeq;
+    const segment = `retrieve_${id}`;
+    const sub = new import_graph8.Graph(segment);
+    const inputNode = (0, import_extra13.fromAny)(queryInput);
+    const localContext = sub.derived(
+      "context",
+      [inputNode],
+      (batchData, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        return [data[0] ?? null];
+      },
+      {
+        meta: aiMeta("retrieval_query_input"),
+        initial: null
+      }
+    );
+    const resultDeps = [
+      this._store.store.entries,
+      this._contextNode,
+      localContext
+    ];
+    if (this._vectors) resultDeps.push(this._vectors.entries);
+    if (this._kg) {
+      resultDeps.push(this._kg.adjacencyOut);
+      resultDeps.push(this._kg.adjacencyIn);
+    }
+    const result = sub.derived(
+      "result",
+      resultDeps,
+      (batchData, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        const query = data[2];
+        if (query == null) {
+          return [{ packed: [], trace: null }];
+        }
+        const storeMap = data[0] ?? /* @__PURE__ */ new Map();
+        const { packed, trace } = this._runRetrieval(storeMap, data[1], query);
+        return [{ packed, trace }];
+      },
+      {
+        meta: aiMeta("retrieval_reactive_result"),
+        initial: { packed: [], trace: null }
+      }
+    );
+    const projection = (0, import_core16.node)(
+      [result],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (b, i) => b != null && b.length > 0 ? b.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(data[0].packed);
+        return {
+          onDeactivation: () => {
+            try {
+              this.remove(segment);
+            } catch {
+            }
+          }
+        };
+      },
+      {
+        name: "projection",
+        describeKind: "derived",
+        meta: aiMeta("retrieval_reactive"),
+        initial: [],
+        equals: packedEquals
+      }
+    );
+    sub.add(projection, { name: "projection" });
+    this.mount(segment, sub);
+    return projection;
+  }
+};
+function memoryRetrieval(opts) {
+  return new MemoryRetrievalGraph(opts);
+}
+
+// src/utils/ai/prompts/prompt-call.ts
+var import_core18 = require("@graphrefly/pure-ts/core");
+
+// src/utils/ai/prompts/prompt-node.ts
+var import_core17 = require("@graphrefly/pure-ts/core");
+var import_extra14 = require("@graphrefly/pure-ts/extra");
+function extractContent(resp) {
+  if (resp != null && typeof resp === "object" && "content" in resp) {
+    return String(resp.content);
+  }
+  if (typeof resp === "string") return resp;
+  return String(resp);
+}
+function previewContent(text, max = 200) {
+  if (text.length <= max) return text;
+  return `${text.slice(0, max)}\u2026`;
+}
+function promptNode(adapter, deps, prompt, opts) {
+  const format = opts?.format ?? "text";
+  const baseName = opts?.name ?? "prompt_node";
+  if (opts?.tools !== void 0 && format !== "raw") {
+    console.warn(
+      "promptNode: `tools` is set but `format !== 'raw'`. Tool calls in the response will be silently dropped \u2014 set `format: 'raw'` to receive the full LLMResponse with `toolCalls`."
+    );
+  }
+  const userDepsLength = deps.length;
+  const allDeps = opts?.tools !== void 0 ? [...deps, opts.tools] : deps;
+  const messagesNode = (0, import_core17.node)(
+    allDeps,
+    (batchData, actions, ctx) => {
+      const data = batchData.map(
+        (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+      );
+      const userValues = data.slice(0, userDepsLength);
+      const toolsValue = opts?.tools !== void 0 ? data[userDepsLength] : void 0;
+      if (userValues.some((v) => v == null)) {
+        actions.emit({ messages: [], tools: toolsValue });
+        return;
+      }
+      const text = typeof prompt === "string" ? prompt : prompt(...userValues);
+      if (!text) {
+        actions.emit({ messages: [], tools: toolsValue });
+        return;
+      }
+      actions.emit({
+        messages: [{ role: "user", content: text }],
+        tools: toolsValue
+      });
+    },
+    {
+      name: `${baseName}::messages`,
+      meta: aiMeta("prompt_node::messages")
+    }
+  );
+  const result = (0, import_extra14.switchMap)(
+    messagesNode,
+    (envelope) => {
+      const { messages: msgs, tools } = envelope;
+      if (!msgs || msgs.length === 0) {
+        return (0, import_core17.node)([], { initial: null });
+      }
+      return (0, import_core17.node)(
+        (_data, actions) => {
+          let done = false;
+          let cancelled = false;
+          let abortDispose;
+          const invokeOpts = {
+            model: opts?.model,
+            temperature: opts?.temperature,
+            maxTokens: opts?.maxTokens,
+            systemPrompt: opts?.systemPrompt,
+            ...tools !== void 0 ? { tools } : {}
+          };
+          if (opts?.abort) {
+            const sig = nodeSignal(opts.abort);
+            invokeOpts.signal = sig.signal;
+            abortDispose = sig.dispose;
+          }
+          let invokeResult;
+          try {
+            invokeResult = adapter.invoke(msgs, invokeOpts);
+          } catch (err) {
+            done = true;
+            actions.down([[import_core17.ERROR, err]]);
+            return () => {
+              abortDispose?.();
+            };
+          }
+          const callNode = (0, import_extra14.fromAny)(invokeResult);
+          const sub = callNode.subscribe((batch8) => {
+            if (cancelled || done) return;
+            for (const msg of batch8) {
+              if (cancelled || done) return;
+              if (msg[0] === import_core17.DATA) {
+                const resp = msg[1];
+                if (format === "raw") {
+                  actions.emit(resp);
+                } else {
+                  let content;
+                  try {
+                    content = extractContent(resp);
+                  } catch (err) {
+                    const wrapped = new Error(
+                      `promptNode: failed to extract content from LLM response: ${err.message}`
+                    );
+                    abortDispose?.();
+                    abortDispose = void 0;
+                    done = true;
+                    actions.down([[import_core17.ERROR, wrapped]]);
+                    return;
+                  }
+                  try {
+                    const parsed = format === "json" ? JSON.parse(stripFences(content)) : content;
+                    actions.emit(parsed);
+                  } catch (err) {
+                    const wrapped = new Error(
+                      `promptNode: failed to parse LLM response as JSON: ${err.message}
+  Raw content (first 200 chars): ${previewContent(content)}`
+                    );
+                    abortDispose?.();
+                    abortDispose = void 0;
+                    done = true;
+                    actions.down([[import_core17.ERROR, wrapped]]);
+                    return;
+                  }
+                }
+              } else if (msg[0] === import_core17.ERROR) {
+                abortDispose?.();
+                abortDispose = void 0;
+                done = true;
+                actions.down([[import_core17.ERROR, msg[1]]]);
+                return;
+              } else if (msg[0] === import_core17.COMPLETE) {
+                abortDispose?.();
+                abortDispose = void 0;
+                done = true;
+                actions.down([[import_core17.COMPLETE]]);
+                return;
+              } else {
+                actions.down([msg]);
+              }
+            }
+          });
+          return () => {
+            cancelled = true;
+            sub();
+            abortDispose?.();
+            abortDispose = void 0;
+          };
+        },
+        {
+          describeKind: "producer",
+          name: `${baseName}::response`,
+          meta: aiMeta("prompt_node::response")
+        }
+      );
+    },
+    {
+      name: `${baseName}::output`,
+      meta: opts?.meta ? { ...aiMeta("prompt_node::output"), ...opts.meta } : aiMeta("prompt_node::output")
+    }
+  );
+  return result;
+}
+
+// src/utils/ai/prompts/prompt-call.ts
+function promptCall(systemPrompt, buildUserContent, opts, defaultName) {
+  const name = opts.name ?? defaultName;
+  return (input) => {
+    const inputState = (0, import_core18.node)([], { initial: input });
+    return promptNode(
+      opts.adapter,
+      [inputState],
+      (value) => buildUserContent(value),
+      {
+        name,
+        format: "json",
+        systemPrompt,
+        model: opts.model,
+        temperature: opts.temperature ?? 0,
+        maxTokens: opts.maxTokens
+      }
+    );
+  };
+}
+function llmExtractor(systemPrompt, opts) {
+  const cap = opts.maxExistingKeys ?? 100;
+  const call = promptCall(
+    systemPrompt,
+    (input) => JSON.stringify({ input: input.raw, existingKeys: input.existingKeys }),
+    opts,
+    "llmExtractor"
+  );
+  return (raw, existing) => {
+    const existingKeys = cap === Number.POSITIVE_INFINITY ? [...existing.keys()] : [...existing.keys()].slice(0, cap);
+    return call({ raw, existingKeys });
+  };
+}
+function llmConsolidator(systemPrompt, opts) {
+  const call = promptCall(
+    systemPrompt,
+    (memories) => JSON.stringify({ memories }),
+    opts,
+    "llmConsolidator"
+  );
+  return (entries) => {
+    const memories = [...entries.entries()].map(([key, value]) => ({ key, value }));
+    return call(memories);
+  };
+}
+
+// src/presets/ai/agent-memory.ts
+var AgentMemoryGraph = class extends import_graph9.Graph {
+  distillBundle;
+  compact;
+  size;
+  /** Vector index bundle (null if not enabled). */
+  vectors;
+  /** Knowledge graph (null if not enabled). */
+  kg;
+  /** Memory tiers bundle (null if not configured). */
+  memoryTiers;
+  /**
+   * The mounted `MemoryWithTiersGraph` subgraph (null when `opts.tiers` was
+   * omitted). Surfaces the inner graph for `describe()` / `explain()` walks
+   * and for callers that need direct access to the tiers subgraph (e.g.
+   * to register additional disposers or attach storage). Companion to
+   * `memoryTiers`, which carries only the bundle's reactive surface (B5e).
+   */
+  tiers;
+  /**
+   * Reactive consumer API. Given a reactive `RetrievalQuery | null` source,
+   * returns a `Node` emitting the packed retrieval results. Composable with
+   * graph topology — subscribe it, chain it into `promptNode`, or switchMap
+   * over a user-input node.
+   *
+   * Each call mounts its own per-input subgraph at
+   * `retrieval::retrieve_${id}` (via `MemoryRetrievalGraph`); concurrent
+   * calls don't share state mirrors. One-shot consumers wrap with
+   * `awaitSettled(retrieveReactive(query))`.
+   *
+   * Null when no retrieval pipeline is configured.
+   *
+   * **QA F-9 (2026-04-30):** the prior `retrieval` / `retrievalTrace`
+   * shared state-node mirrors have been dropped. Use `retrieveReactive`
+   * for per-call reactive results; one-shot trace consumers should
+   * subscribe to the projection's upstream `result` derived directly
+   * via `view.target.resolve("retrieval::retrieve_${id}::result")`.
+   */
+  retrieveReactive;
+  constructor(name, source, opts) {
+    super(name, opts.graph);
+    let rawExtractFn;
+    if (opts.extractFn) {
+      rawExtractFn = opts.extractFn;
+    } else if (opts.adapter && opts.extractPrompt) {
+      rawExtractFn = llmExtractor(opts.extractPrompt, { adapter: opts.adapter });
+    } else {
+      throw new Error("agentMemory: provide either extractFn or adapter + extractPrompt");
+    }
+    this.tagFactory("agentMemory", (0, import_core19.placeholderArgs)(opts));
+    const extractFn = (rawNode, existingNode) => {
+      let latestExisting = existingNode.cache ?? /* @__PURE__ */ new Map();
+      const unsubExisting = existingNode.subscribe((msgs) => {
+        for (const m of msgs) {
+          if (m[0] === import_core19.DATA) latestExisting = m[1];
+        }
+      });
+      this.addDisposer(unsubExisting);
+      return (0, import_extra15.switchMap)(rawNode, (raw) => {
+        if (raw == null) return { upsert: [] };
+        return rawExtractFn(raw, latestExisting);
+      });
+    };
+    let filteredSource = source;
+    if (opts.admissionFilter) {
+      const srcNode = (0, import_extra15.fromAny)(source);
+      const filter = opts.admissionFilter;
+      filteredSource = (0, import_core19.node)(
+        [srcNode],
+        (batchData, actions, ctx) => {
+          const data = batchData.map(
+            (batch8, i) => batch8 != null && batch8.length > 0 ? batch8.at(-1) : ctx.prevData[i]
+          );
+          const raw = data[0];
+          if (filter(raw)) {
+            actions.emit(raw);
+          } else {
+            actions.down([[import_core19.RESOLVED]]);
+          }
+        },
+        { name: "admissionFilter", describeKind: "derived" }
+      );
+    }
+    let consolidateFn;
+    if (opts.consolidateFn) {
+      consolidateFn = opts.consolidateFn;
+    } else if (opts.adapter && opts.consolidatePrompt) {
+      consolidateFn = llmConsolidator(opts.consolidatePrompt, { adapter: opts.adapter });
+    }
+    let consolidateTrigger = opts.consolidateTrigger;
+    if (!consolidateTrigger && consolidateFn && opts.reflection?.enabled !== false) {
+      const interval = opts.reflection?.interval ?? 3e5;
+      consolidateTrigger = (0, import_extra15.fromTimer)(interval, { period: interval });
+    }
+    const distillOpts = {
+      score: opts.score,
+      cost: opts.cost,
+      budget: opts.budget ?? 2e3,
+      context: opts.context,
+      consolidate: consolidateFn,
+      consolidateTrigger
+    };
+    let distillBundle;
+    let memoryTiersBundle = null;
+    let tiersSubgraph = null;
+    if (opts.tiers) {
+      const tiersGraph = memoryWithTiers({
+        // User customization first; canonical agent-memory-level overrides
+        // last so they always win even if `MemoryTiersOptions` later adds
+        // any of the same keys.
+        ...opts.tiers,
+        name: "tiers",
+        source: filteredSource,
+        extractFn,
+        score: opts.score,
+        cost: opts.cost,
+        ...opts.budget !== void 0 ? { budget: opts.budget } : { budget: 2e3 },
+        ...opts.context !== void 0 ? { context: opts.context } : {},
+        ...consolidateFn !== void 0 ? { consolidate: consolidateFn } : {},
+        ...consolidateTrigger !== void 0 ? { consolidateTrigger } : {}
+      });
+      this.mount("tiers", tiersGraph);
+      distillBundle = tiersGraph.store;
+      memoryTiersBundle = tiersGraph.tiers;
+      tiersSubgraph = tiersGraph;
+    } else {
+      distillBundle = distill(filteredSource, extractFn, distillOpts);
+      this.add(distillBundle.store.entries, { name: "store" });
+      this.add(distillBundle.compact, { name: "compact" });
+      this.add(distillBundle.size, { name: "size" });
+    }
+    let vectors = null;
+    if (opts.vectorDimensions && opts.vectorDimensions > 0 && opts.embedFn) {
+      const vectorsGraph = memoryWithVectors({
+        name: "vectors",
+        store: distillBundle,
+        dimension: opts.vectorDimensions,
+        embedFn: opts.embedFn
+      });
+      this.mount("vectors", vectorsGraph);
+      vectors = vectorsGraph.vectors;
+    }
+    let kg = null;
+    if (opts.enableKnowledgeGraph) {
+      const kgGraph = memoryWithKG({
+        name: "knowledge",
+        store: distillBundle,
+        kgName: `${name}-kg`,
+        mountPath: "knowledge-kg",
+        ...opts.entityFn !== void 0 ? { entityFn: opts.entityFn } : {}
+      });
+      this.mount("knowledge", kgGraph);
+      kg = kgGraph.kg;
+    }
+    let retrieveReactive = null;
+    if (vectors || kg) {
+      const retrievalGraph = memoryRetrieval({
+        name: "retrieval",
+        store: distillBundle,
+        vectors,
+        kg,
+        score: opts.score,
+        cost: opts.cost,
+        ...opts.budget !== void 0 ? { budget: opts.budget } : {},
+        ...opts.retrieval?.topK !== void 0 ? { topK: opts.retrieval.topK } : {},
+        ...opts.retrieval?.graphDepth !== void 0 ? { graphDepth: opts.retrieval.graphDepth } : {},
+        ...opts.contextOf !== void 0 ? { contextOf: opts.contextOf } : {},
+        ...opts.contextWeight !== void 0 ? { contextWeight: opts.contextWeight } : {},
+        ...opts.context !== void 0 ? { context: opts.context } : {}
+      });
+      this.mount("retrieval", retrievalGraph);
+      retrieveReactive = retrievalGraph.retrieveReactive.bind(retrievalGraph);
+    }
+    this.distillBundle = distillBundle;
+    this.compact = distillBundle.compact;
+    this.size = distillBundle.size;
+    this.vectors = vectors;
+    this.kg = kg;
+    this.memoryTiers = memoryTiersBundle;
+    this.tiers = tiersSubgraph;
+    this.retrieveReactive = retrieveReactive;
+  }
+};
+function agentMemory(name, source, opts) {
+  return new AgentMemoryGraph(name, source, opts);
+}
+
+// src/presets/ai/agents.ts
+var import_extra16 = require("@graphrefly/pure-ts/extra");
+function agent(parent, spec) {
+  const graph = new AgentGraph(spec);
+  parent.mount(spec.name, graph);
+  return {
+    in: graph.in,
+    out: graph.out,
+    status: graph.status,
+    cost: graph.cost,
+    graph
+  };
+}
+function presetRegistry(initial) {
+  const registry = (0, import_extra16.reactiveMap)({ name: "presetRegistry" });
+  if (initial != null) {
+    for (const [id, preset] of initial) {
+      registry.set(id, preset);
+    }
+  }
+  return {
+    registry,
+    put(id, preset) {
+      registry.set(id, preset);
+    },
+    remove(id) {
+      if (!registry.has(id)) return false;
+      registry.delete(id);
+      return true;
+    }
+  };
+}
+
+// src/presets/ai/context/index.ts
+var import_core20 = require("@graphrefly/pure-ts/core");
+var import_extra17 = require("@graphrefly/pure-ts/extra");
+var import_graph10 = require("@graphrefly/pure-ts/graph");
+var CompressionCache = class {
+  constructor(_max) {
+    this._max = _max;
+  }
+  _m = /* @__PURE__ */ new Map();
+  /** Insertion-order list of `id` keys for LRU eviction at the id granularity. */
+  _order = [];
+  get(id, tier) {
+    const inner = this._m.get(id);
+    const v = inner?.get(tier);
+    if (v !== void 0) {
+      const i = this._order.indexOf(id);
+      if (i >= 0) this._order.splice(i, 1);
+      this._order.push(id);
+    }
+    return v;
+  }
+  set(id, tier, value) {
+    let inner = this._m.get(id);
+    if (inner === void 0) {
+      inner = /* @__PURE__ */ new Map();
+      this._m.set(id, inner);
+    }
+    inner.set(tier, value);
+    const i = this._order.indexOf(id);
+    if (i >= 0) this._order.splice(i, 1);
+    this._order.push(id);
+    while (this._m.size > this._max) {
+      const evict = this._order.shift();
+      if (evict === void 0) break;
+      this._m.delete(evict);
+    }
+  }
+};
+var _poolSeq = 0;
+function taggedContextPool(parent, opts) {
+  const mountName = opts.name ?? `ctxpool-${opts.topic}-${++_poolSeq}`;
+  const graph = new import_graph10.Graph(mountName);
+  parent.mount(mountName, graph);
+  const log = (0, import_extra17.reactiveLog)(void 0, {
+    name: `${mountName}.log`,
+    maxSize: opts.maxEntries
+  });
+  const cache = new CompressionCache(opts.cacheMax ?? 512);
+  let autoId = 0;
+  const entries = log.entries;
+  function add(e) {
+    const id = e.id ?? `ctx-${++autoId}`;
+    log.append({
+      id,
+      payload: e.payload,
+      tags: e.tags,
+      importance: e.importance,
+      compressible: e.compressible,
+      topic: e.topic,
+      t_ns: (0, import_core20.wallClockNs)()
+      // QA P2 — clock.ts invariant (was Date.now()*1e6)
+    });
+    return id;
+  }
+  function byTag(tag) {
+    return (0, import_core20.node)(
+      [entries],
+      (data, actions, ctx) => {
+        const cur = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
+        actions.emit((cur ?? []).filter((x) => x.tags.includes(tag)));
+      },
+      { describeKind: "derived", meta: aiMeta("contextPool.byTag", { tag }) }
+    );
+  }
+  function poolGC(policy2) {
+    const all = log.entries.cache ?? [];
+    const nowNs = (0, import_core20.wallClockNs)();
+    let survivors = all.filter((e) => {
+      if (policy2.topic != null && e.topic !== policy2.topic) return true;
+      if (policy2.olderThanNs != null && nowNs - e.t_ns >= policy2.olderThanNs) return false;
+      if (policy2.importanceBelow != null && e.importance < policy2.importanceBelow) return false;
+      return true;
+    });
+    if (policy2.max != null && survivors.length > policy2.max) {
+      survivors = survivors.slice(survivors.length - policy2.max);
+    }
+    const removed = all.length - survivors.length;
+    if (removed > 0) {
+      log.clear();
+      log.appendMany(survivors);
+    }
+    return removed;
+  }
+  return {
+    add,
+    entries,
+    byTag,
+    poolGC,
+    graph,
+    _cache: cache,
+    _opts: opts,
+    dispose() {
+      log.dispose();
+    }
+  };
+}
+var DEFAULT_TOKENIZER = (s) => Math.ceil(s.length / 4);
+function matches(e, m) {
+  if (m.topic != null) {
+    if (typeof m.topic === "string" ? e.topic !== m.topic : !m.topic.test(e.topic)) return false;
+  }
+  if (m.tagsAny != null && !m.tagsAny.some((t) => e.tags.includes(t))) return false;
+  if (m.importanceMin != null && e.importance < m.importanceMin) return false;
+  if (m.importanceMax != null && e.importance > m.importanceMax) return false;
+  if (m.compressible != null && e.compressible !== m.compressible) return false;
+  return true;
+}
+function tierCompress(e, rules, pressure, cache, llmCompress) {
+  const base = {
+    id: e.id,
+    topic: e.topic,
+    tags: e.tags,
+    tier: 0,
+    payload: e.payload,
+    compressed: false
+  };
+  if (pressure <= 0) return base;
+  for (const rule of rules) {
+    if (!matches(e, rule.match)) continue;
+    switch (rule.action) {
+      case "evict":
+        return void 0;
+      case "reference":
+        return { ...base, tier: 1, payload: `[ref:${e.id}]`, compressed: true };
+      case "truncate": {
+        const s = typeof e.payload === "string" ? e.payload : JSON.stringify(e.payload);
+        return {
+          ...base,
+          tier: 1,
+          payload: s.length > rule.maxChars ? s.slice(0, rule.maxChars) : s,
+          compressed: s.length > rule.maxChars
+        };
+      }
+      case "llm-summary": {
+        if (!llmCompress) {
+          throw new Error("tierCompress: 'llm-summary' rule requires `llmCompress`");
+        }
+        const cached = cache.get(e.id, rule.toTier);
+        const text = cached ?? llmCompress(e, rule.toTier);
+        if (cached === void 0) cache.set(e.id, rule.toTier, text);
+        return { ...base, tier: rule.toTier, payload: text, compressed: true };
+      }
+    }
+  }
+  return base;
+}
+function renderContextView(pool, view) {
+  const usesLlm = view.rules.some((r) => r.action === "llm-summary");
+  if (usesLlm && !pool._opts.llmCompress) {
+    throw new Error(
+      "renderContextView: view has an 'llm-summary' rule but the pool was created without `llmCompress` (DS-14.6.A D-A3)."
+    );
+  }
+  const tokenize = view.tokenizer ?? DEFAULT_TOKENIZER;
+  const llmCompress = pool._opts.llmCompress;
+  return (0, import_core20.node)(
+    [pool.entries, view.pressure],
+    (data, actions, ctx) => {
+      const entries = data[0] != null && data[0].length > 0 ? data[0].at(-1) : ctx.prevData[0];
+      const pressure = data[1] != null && data[1].length > 0 ? data[1].at(-1) : ctx.prevData[1];
+      if (entries === void 0) {
+        actions.emit([]);
+        return;
+      }
+      const p = pressure ?? 0;
+      const rendered = [];
+      for (const e of entries) {
+        if (!view.filter(e)) continue;
+        const r = tierCompress(e, view.rules, p, pool._cache, llmCompress);
+        if (r !== void 0) rendered.push(r);
+      }
+      const cost = (r) => tokenize(typeof r.payload === "string" ? r.payload : JSON.stringify(r.payload));
+      let total = 0;
+      for (const r of rendered) total += cost(r);
+      if (total > view.budgetTokens) {
+        const byImp = entries.reduce(
+          (acc, e) => acc.set(e.id, e.importance),
+          /* @__PURE__ */ new Map()
+        );
+        rendered.sort((a, b) => (byImp.get(a.id) ?? 0) - (byImp.get(b.id) ?? 0));
+        while (total > view.budgetTokens && rendered.length > 0) {
+          total -= cost(rendered.shift());
+        }
+      }
+      actions.emit(rendered);
+    },
+    { describeKind: "derived", meta: aiMeta("contextView", { topic: pool._opts.topic }) }
+  );
+}
+
+// src/presets/ai/debate/index.ts
+var import_core21 = require("@graphrefly/pure-ts/core");
+var import_extra18 = require("@graphrefly/pure-ts/extra");
+var import_graph11 = require("@graphrefly/pure-ts/graph");
+var DebateGraph = class extends import_graph11.Graph {
+};
+var SYNTH_RE = /synth/i;
+function defaultConverge(transcript) {
+  const rounds = transcript.reduce((m, t) => Math.max(m, t.round), 0);
+  if (rounds < 2) return false;
+  const at = (r) => {
+    const m = /* @__PURE__ */ new Map();
+    for (const t of transcript) if (t.round === r) m.set(t.role, t.content);
+    return m;
+  };
+  const prev = at(rounds - 1);
+  const cur = at(rounds);
+  if (prev.size === 0 || prev.size !== cur.size) return false;
+  for (const [role, content] of cur) if (prev.get(role) !== content) return false;
+  return true;
+}
+var _debateSeq = 0;
+function heterogeneousDebate(parent, opts) {
+  const output = opts.output ?? "transcript";
+  if (output === "synthesizer-final" && !opts.participants.some((p) => SYNTH_RE.test(p.role))) {
+    throw new Error(
+      "heterogeneousDebate: output 'synthesizer-final' requires a participant whose role matches /synth/i (DS-14.6.A D-C2)."
+    );
+  }
+  if (opts.participants.length === 0) {
+    throw new Error("heterogeneousDebate: at least one participant is required");
+  }
+  const name = opts.name ?? `debate-${++_debateSeq}`;
+  const graph = new DebateGraph(name);
+  parent.mount(name, graph);
+  const term = opts.rounds ?? 3;
+  const maxRounds = opts.maxRounds ?? 12;
+  const converge = opts.converge ?? defaultConverge;
+  const untilNode = typeof term === "object" ? term.until : (0, import_core21.node)([], { initial: false });
+  const roundTrigger = (0, import_core21.node)([], { name: `${name}.round`, initial: 0 });
+  const statusState = (0, import_core21.node)([], { name: `${name}.status`, initial: "running" });
+  const resultState = (0, import_core21.node)([], { name: `${name}.result`, initial: void 0 });
+  let history = [];
+  function buildMessages(p) {
+    const msgs = [
+      { role: "system", content: p.systemPrompt },
+      { role: "user", content: opts.question }
+    ];
+    for (const t of history) {
+      msgs.push({ role: "assistant", content: `[${t.role} r${t.round}] ${t.content}` });
+    }
+    return msgs;
+  }
+  const roundWork = (0, import_extra18.switchMap)(
+    roundTrigger,
+    (r) => (0, import_core21.node)(
+      [],
+      (_data, actions) => {
+        if (r < 1) {
+          actions.down([[import_core21.RESOLVED]]);
+          return void 0;
+        }
+        const ac = new AbortController();
+        let cancelled = false;
+        (async () => {
+          const turns = [];
+          try {
+            for (const p of opts.participants) {
+              const res = await firstValueFrom(
+                (0, import_extra18.fromAny)(
+                  p.adapter.invoke(buildMessages(p), {
+                    signal: ac.signal
+                  })
+                )
+              );
+              if (cancelled) return;
+              turns.push({ round: r, role: p.role, content: res.content });
+            }
+            if (!cancelled) actions.emit({ round: r, turns });
+          } catch (err) {
+            if (!cancelled) actions.down([[import_core21.ERROR, err]]);
+          }
+        })();
+        return () => {
+          cancelled = true;
+          ac.abort();
+        };
+      },
+      { describeKind: "producer", name: `${name}.round-work` }
+    ),
+    { name: `${name}.rounds` }
+  );
+  graph.add(roundWork, { name: "rounds" });
+  const transcript = (0, import_core21.node)(
+    [roundWork],
+    (batchData, actions, ctx) => {
+      const env = batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : ctx.prevData[0];
+      if (env === void 0) {
+        actions.down([[import_core21.RESOLVED]]);
+        return;
+      }
+      actions.emit(history.slice());
+    },
+    { name: `${name}.transcript`, describeKind: "derived" }
+  );
+  graph.add(transcript, { name: "transcript" });
+  const converged = (0, import_core21.node)(
+    [transcript, untilNode],
+    (batchData, actions, ctx) => {
+      const tr = batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : ctx.prevData[0];
+      const untilV = batchData[1] != null && batchData[1].length > 0 ? batchData[1].at(-1) : ctx.prevData[1];
+      const rounds = (tr ?? []).reduce((m, t) => Math.max(m, t.round), 0);
+      if (typeof term === "number") {
+        actions.emit({ done: rounds >= term, reason: "max-rounds" });
+        return;
+      }
+      if (term === "until-converge") {
+        if (converge(tr ?? [])) actions.emit({ done: true, reason: "converged" });
+        else actions.emit({ done: rounds >= maxRounds, reason: "max-rounds" });
+        return;
+      }
+      actions.emit({ done: untilV === true || rounds >= maxRounds, reason: "max-rounds" });
+    },
+    { name: `${name}.converged`, describeKind: "derived" }
+  );
+  graph.add(converged, { name: "converged" });
+  const decideEffect = (0, import_core21.node)(
+    [roundWork, untilNode],
+    (batchData, _actions, ctx) => {
+      const env = batchData[0] != null && batchData[0].length > 0 ? batchData[0].at(-1) : void 0;
+      const untilV = batchData[1] != null && batchData[1].length > 0 ? batchData[1].at(-1) : ctx.prevData[1];
+      if (env === void 0) {
+        if (typeof term === "object" && untilV === true && statusState.cache === "running") {
+          finalize("max-rounds");
+        }
+        return;
+      }
+      history = [...history, ...env.turns];
+      const r = env.round;
+      let done = false;
+      let reason = "max-rounds";
+      if (typeof term === "number") done = r >= term;
+      else if (term === "until-converge") {
+        if (converge(history)) {
+          done = true;
+          reason = "converged";
+        } else done = r >= maxRounds;
+      } else done = untilV === true || r >= maxRounds;
+      if (done) finalize(reason);
+      else roundTrigger.emit(r + 1);
+    },
+    { name: `${name}.decide`, describeKind: "effect", errorWhenDepsError: false }
+  );
+  graph.add(decideEffect, { name: "decide" });
+  function finalize(reason) {
+    let out;
+    if (output === "transcript") out = history.slice();
+    else if (output === "synthesizer-final") {
+      const synth = [...history].reverse().find((t) => SYNTH_RE.test(t.role));
+      out = synth?.content ?? null;
+    } else out = output.project(history.slice());
+    (0, import_core21.batch)(() => {
+      statusState.emit(reason);
+      resultState.emit(out);
+    });
+  }
+  const errorWatcher = (0, import_core21.node)(
+    [roundWork],
+    (_b, _a, ec) => {
+      const t = ec.terminalDeps[0];
+      if (t !== void 0 && t !== true && statusState.cache === "running") {
+        (0, import_core21.batch)(() => {
+          statusState.emit("error");
+          resultState.emit(new Error("heterogeneousDebate: a participant adapter errored"));
+        });
+      }
+    },
+    { name: `${name}.error-watcher`, describeKind: "effect", errorWhenDepsError: false }
+  );
+  graph.add(errorWatcher, { name: "error-watcher" });
+  decideEffect.subscribe(() => void 0);
+  errorWatcher.subscribe(() => void 0);
+  transcript.subscribe(() => void 0);
+  converged.subscribe(() => void 0);
+  let running = false;
+  return {
+    transcript,
+    result: resultState,
+    status: statusState,
+    graph,
+    async run() {
+      if (running) {
+        throw new RangeError(
+          `heterogeneousDebate "${name}": run() called while a previous run() is still pending`
+        );
+      }
+      running = true;
+      try {
+        history = [];
+        (0, import_core21.batch)(() => {
+          statusState.emit("running");
+          resultState.down([[import_core21.INVALIDATE]]);
+        });
+        const settled = awaitSettled(resultState, { skipCurrent: true });
+        roundTrigger.emit(1);
+        return await settled;
+      } finally {
+        running = false;
+      }
+    }
+  };
+}
+//# sourceMappingURL=index.cjs.map