@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/chunk-GBCENOLN.js

@@ -0,0 +1,1575 @@
+import {
+  agent
+} from "./chunk-5THCXDWY.js";
+import {
+  DEFAULT_EXECUTE_PROMPT,
+  DEFAULT_PRESET_ID,
+  DEFAULT_QUEUE_CONFIGS,
+  DEFAULT_SEVERITY_WEIGHTS,
+  DEFAULT_TRIAGE_PROMPT,
+  DEFAULT_VERIFY_PROMPT,
+  QUEUE_NAMES,
+  defaultErrorClassifier,
+  resolvePromptFn,
+  strategyKey,
+  strategyModel
+} from "./chunk-OIWU3NYV.js";
+import {
+  jobFlow,
+  jobQueue
+} from "./chunk-PKPO3JTZ.js";
+import {
+  pipelineGraph
+} from "./chunk-CGHORL6G.js";
+import {
+  _oneShotLlmCall,
+  aiMeta,
+  promptNode,
+  stripFences
+} from "./chunk-OO5BM6CJ.js";
+import {
+  SPAWNS_TOPIC,
+  messagingHub,
+  subscription,
+  topic,
+  topicBridge
+} from "./chunk-Q3EYOCZB.js";
+import {
+  DEFAULT_DECAY_RATE
+} from "./chunk-QMBYUVRL.js";
+import {
+  tryIncrementBounded
+} from "./chunk-BXGZFGZ4.js";
+
+// src/presets/harness/refine-loop.ts
+import {
+  batch,
+  node as createNode,
+  DATA,
+  ERROR,
+  monotonicNs,
+  placeholderArgs,
+  RESOLVED
+} from "@graphrefly/pure-ts/core";
+import { switchMap } from "@graphrefly/pure-ts/extra";
+import { Graph } from "@graphrefly/pure-ts/graph";
+var RefineLoopGraph = class extends Graph {
+  best;
+  /**
+   * Best score so far. Pseudo-private (`_score`) to avoid colliding with any
+   * future `Graph.prototype.score` method (B5d forward-compat hazard
+   * prevention). Typed-public — read via `loop._score.cache` /
+   * `loop._score.subscribe(...)` from external code.
+   */
+  _score;
+  status;
+  history;
+  strategy;
+  /**
+   * Monotonic iteration counter. Pseudo-private (`_iteration`) to avoid
+   * colliding with any future `Graph.prototype.iteration` method (B5d
+   * forward-compat hazard prevention). Typed-public — read via
+   * `loop._iteration.cache` / `loop._iteration.subscribe(...)`.
+   */
+  _iteration;
+  /** Stage topic — subscribe for per-stage streaming / cursor consumers. */
+  generate;
+  /** Stage topic — subscribe for per-stage streaming / cursor consumers. */
+  evaluate;
+  /** Stage topic — subscribe for per-stage streaming / cursor consumers. */
+  analyze;
+  /** Stage topic — subscribe for per-stage streaming / cursor consumers. */
+  decide;
+  /** Internal: paused-flag node. Mounted as "paused" in describe(). */
+  _pauseState;
+  constructor(seed, evaluator, initialStrategy, opts) {
+    const name = opts.name ?? "refine-loop";
+    super(name, opts.graph);
+    this.tagFactory(
+      "refineLoop",
+      placeholderArgs({ seed, evaluator, initialStrategy, ...opts })
+    );
+    const datasetNode = isNode(opts.dataset) ? opts.dataset : createNode([], {
+      name: "dataset",
+      initial: opts.dataset
+    });
+    this.add(datasetNode, { name: "dataset" });
+    const iterationTrigger = createNode([], { name: "iteration", initial: 0 });
+    this.add(iterationTrigger, { name: "iteration" });
+    const strategyNode = createNode([], {
+      name: "strategy",
+      initial: initialStrategy,
+      equals: () => false
+      // always propagate strategy swaps
+    });
+    this.add(strategyNode, { name: "strategy" });
+    const lastFeedbackState = createNode([], {
+      name: "lastFeedback",
+      initial: null
+    });
+    this.add(lastFeedbackState, { name: "lastFeedback" });
+    const prevCandidatesState = createNode([], {
+      name: "prevCandidates",
+      initial: []
+    });
+    this.add(prevCandidatesState, { name: "prevCandidates" });
+    const pauseState = createNode([], { name: "paused", initial: false });
+    this.add(pauseState, { name: "paused" });
+    const statusState = createNode([], { name: "status", initial: "running" });
+    this.add(statusState, { name: "status" });
+    const historyState = createNode([], {
+      name: "history",
+      initial: [],
+      equals: () => false
+      // append-style; reactive consumers want every push
+    });
+    this.add(historyState, { name: "history" });
+    const bestState = createNode([], { name: "best", initial: null });
+    this.add(bestState, { name: "best" });
+    const scoreState = createNode([], { name: "score", initial: Number.NEGATIVE_INFINITY });
+    this.add(scoreState, { name: "score" });
+    const budgetState = createNode([], { name: "budget-used", initial: 0 });
+    this.add(budgetState, { name: "budget-used" });
+    const hub = messagingHub("stages");
+    this.mount("stages", hub);
+    const hubGenerateTopic = hub.topic("generate");
+    const hubEvaluateTopic = hub.topic("evaluate");
+    const hubAnalyzeTopic = hub.topic("analyze");
+    const hubDecideTopic = hub.topic("decide");
+    this.best = bestState;
+    this._score = scoreState;
+    this.status = statusState;
+    this.history = historyState;
+    this.strategy = strategyNode;
+    this._iteration = iterationTrigger;
+    this.generate = hubGenerateTopic;
+    this.evaluate = hubEvaluateTopic;
+    this.analyze = hubAnalyzeTopic;
+    this.decide = hubDecideTopic;
+    this._pauseState = pauseState;
+    let latestStrategy = initialStrategy;
+    let latestFeedback = null;
+    let latestPrevCandidates = [];
+    this.addDisposer(
+      strategyNode.subscribe((msgs) => {
+        for (const m of msgs) if (m[0] === DATA) latestStrategy = m[1];
+      })
+    );
+    this.addDisposer(
+      lastFeedbackState.subscribe((msgs) => {
+        for (const m of msgs) if (m[0] === DATA) latestFeedback = m[1];
+      })
+    );
+    this.addDisposer(
+      prevCandidatesState.subscribe((msgs) => {
+        for (const m of msgs) if (m[0] === DATA) latestPrevCandidates = m[1];
+      })
+    );
+    const candidatesNode = switchMap(
+      iterationTrigger,
+      (iter) => {
+        const strat = latestStrategy;
+        const isSeed = iter === 0 || latestFeedback == null;
+        return createNode(
+          [],
+          (_data, actions) => {
+            let cancelled = false;
+            try {
+              const result = isSeed ? strat.seed(seed) : strat.generate(latestFeedback, latestPrevCandidates);
+              if (result instanceof Promise) {
+                result.then(
+                  (v) => {
+                    if (!cancelled) actions.emit({ iter, items: v });
+                  },
+                  (err) => {
+                    if (!cancelled) actions.down([[ERROR, err]]);
+                  }
+                );
+                return () => {
+                  cancelled = true;
+                };
+              }
+              actions.emit({ iter, items: result });
+            } catch (err) {
+              cancelled = true;
+              actions.down([[ERROR, err]]);
+            }
+            return void 0;
+          },
+          { describeKind: "producer" }
+        );
+      },
+      { name: "candidates" }
+    );
+    this.add(candidatesNode, { name: "candidates" });
+    const candidatesItemsNode = createNode(
+      [candidatesNode],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const env = data[0];
+        if (env === void 0) {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        actions.emit(env.items);
+      },
+      { name: "candidates-items", describeKind: "derived" }
+    );
+    this.add(candidatesItemsNode, { name: "candidates-items" });
+    const errorWatcher = createNode(
+      [candidatesNode],
+      (_batchData, _actions, ctx) => {
+        const terminal = ctx.terminalDeps[0];
+        if (terminal !== void 0 && terminal !== true) {
+          statusState.emit("errored");
+        }
+      },
+      { name: "error-watcher", describeKind: "effect", errorWhenDepsError: false }
+    );
+    this.add(errorWatcher, { name: "error-watcher" });
+    this.addDisposer(errorWatcher.subscribe(() => void 0));
+    const generateEventNode = createNode(
+      [candidatesNode],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const env = data[0];
+        actions.emit({
+          iteration: env.iter,
+          candidates: env.items,
+          timestamp_ns: monotonicNs()
+        });
+      },
+      { name: "generate-event", describeKind: "derived" }
+    );
+    this.add(generateEventNode, { name: "generate-event" });
+    this.addDisposer(generateEventNode.subscribe(() => void 0));
+    const generatePublishEffect = createNode(
+      [generateEventNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        hubGenerateTopic.publish(data[0]);
+      },
+      { name: "generate-publish", describeKind: "effect" }
+    );
+    this.add(generatePublishEffect, { name: "generate-publish" });
+    this.addDisposer(generatePublishEffect.subscribe(() => void 0));
+    const generateMirrorEffect = createNode(
+      [candidatesNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const env = data[0];
+        prevCandidatesState.emit(env.items);
+      },
+      { name: "generate-mirror", describeKind: "effect" }
+    );
+    this.add(generateMirrorEffect, { name: "generate-mirror" });
+    this.addDisposer(generateMirrorEffect.subscribe(() => void 0));
+    const scoresNode = evaluator(candidatesItemsNode, datasetNode);
+    this.add(scoresNode, { name: "scores" });
+    const evaluateEventNode = createNode(
+      [scoresNode, candidatesNode],
+      (batchData, actions, ctx) => {
+        const scoresFired = batchData[0] != null && batchData[0].length > 0;
+        if (!scoresFired) {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const scores = data[0];
+        const env = data[1];
+        actions.emit({
+          iteration: env.iter,
+          candidates: env.items,
+          scores,
+          timestamp_ns: monotonicNs()
+        });
+      },
+      { name: "evaluate-event", describeKind: "derived" }
+    );
+    this.add(evaluateEventNode, { name: "evaluate-event" });
+    this.addDisposer(evaluateEventNode.subscribe(() => void 0));
+    const evaluatePublishEffect = createNode(
+      [evaluateEventNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        hubEvaluateTopic.publish(data[0]);
+      },
+      { name: "evaluate-publish", describeKind: "effect" }
+    );
+    this.add(evaluatePublishEffect, { name: "evaluate-publish" });
+    this.addDisposer(evaluatePublishEffect.subscribe(() => void 0));
+    const feedbackEnvelopeNode = createNode(
+      [scoresNode, candidatesNode],
+      (batchData, actions, ctx) => {
+        const scoresFired = batchData[0] != null && batchData[0].length > 0;
+        if (!scoresFired) {
+          actions.down([[RESOLVED]]);
+          return;
+        }
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const scores = data[0];
+        const env = data[1];
+        actions.emit({
+          iter: env.iter,
+          items: env.items,
+          scores,
+          feedback: latestStrategy.analyze(scores, env.items)
+        });
+      },
+      { name: "feedback-envelope", describeKind: "derived" }
+    );
+    this.add(feedbackEnvelopeNode, { name: "feedback-envelope" });
+    const feedbackNode = createNode(
+      [feedbackEnvelopeNode],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const fbEnv = data[0];
+        actions.emit(fbEnv.feedback);
+      },
+      { name: "feedback", describeKind: "derived" }
+    );
+    this.add(feedbackNode, { name: "feedback" });
+    const analyzeEventNode = createNode(
+      [feedbackEnvelopeNode],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const fbEnv = data[0];
+        actions.emit({
+          iteration: fbEnv.iter,
+          candidates: fbEnv.items,
+          feedback: fbEnv.feedback,
+          timestamp_ns: monotonicNs()
+        });
+      },
+      { name: "analyze-event", describeKind: "derived" }
+    );
+    this.add(analyzeEventNode, { name: "analyze-event" });
+    this.addDisposer(analyzeEventNode.subscribe(() => void 0));
+    const analyzePublishEffect = createNode(
+      [analyzeEventNode],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        hubAnalyzeTopic.publish(data[0]);
+      },
+      { name: "analyze-publish", describeKind: "effect" }
+    );
+    this.add(analyzePublishEffect, { name: "analyze-publish" });
+    this.addDisposer(analyzePublishEffect.subscribe(() => void 0));
+    const patienceNode = createNode(
+      [historyState],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const h = data[0];
+        if (opts.patience == null || h.length <= opts.patience) {
+          actions.emit(false);
+          return;
+        }
+        const lookback = h.slice(-(opts.patience + 1));
+        const baseline = lookback[0].bestScore;
+        actions.emit(lookback.slice(1).every((i) => i.bestScore <= baseline));
+      },
+      { name: "patience-check", describeKind: "derived" }
+    );
+    this.add(patienceNode, { name: "patience-check" });
+    const minScoreNode = createNode(
+      [scoreState],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(opts.minScore != null && data[0] >= opts.minScore);
+      },
+      { name: "min-score-check", describeKind: "derived" }
+    );
+    this.add(minScoreNode, { name: "min-score-check" });
+    const minDeltaNode = createNode(
+      [historyState],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const h = data[0];
+        if (opts.minDelta == null || h.length < 2) {
+          actions.emit(false);
+          return;
+        }
+        const prev = h[h.length - 2].bestScore;
+        const curr = h[h.length - 1].bestScore;
+        actions.emit(Math.abs(curr - prev) < opts.minDelta);
+      },
+      { name: "min-delta-check", describeKind: "derived" }
+    );
+    this.add(minDeltaNode, { name: "min-delta-check" });
+    const maxEvalsNode = createNode(
+      [budgetState],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(opts.maxEvaluations != null && data[0] >= opts.maxEvaluations);
+      },
+      { name: "max-evaluations-check", describeKind: "derived" }
+    );
+    this.add(maxEvalsNode, { name: "max-evaluations-check" });
+    const maxIterNode = createNode(
+      [iterationTrigger],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(opts.maxIterations != null && data[0] >= opts.maxIterations);
+      },
+      { name: "max-iterations-check", describeKind: "derived" }
+    );
+    this.add(maxIterNode, { name: "max-iterations-check" });
+    const budgetExhaustedNode = createNode(
+      [budgetState],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        actions.emit(opts.budget != null && data[0] >= opts.budget);
+      },
+      { name: "budget-exhausted-check", describeKind: "derived" }
+    );
+    this.add(budgetExhaustedNode, { name: "budget-exhausted-check" });
+    this.addDisposer(patienceNode.subscribe(() => void 0));
+    this.addDisposer(minScoreNode.subscribe(() => void 0));
+    this.addDisposer(minDeltaNode.subscribe(() => void 0));
+    this.addDisposer(maxEvalsNode.subscribe(() => void 0));
+    this.addDisposer(maxIterNode.subscribe(() => void 0));
+    this.addDisposer(budgetExhaustedNode.subscribe(() => void 0));
+    const convergedNode = createNode(
+      [patienceNode, minScoreNode, minDeltaNode, maxEvalsNode, maxIterNode],
+      (batchData, actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const [p, ms, md, me, mi] = data;
+        if (p) {
+          actions.emit({ converged: true, reason: "patience" });
+          return;
+        }
+        if (ms) {
+          actions.emit({ converged: true, reason: "min-score" });
+          return;
+        }
+        if (md) {
+          actions.emit({ converged: true, reason: "min-delta" });
+          return;
+        }
+        if (me) {
+          actions.emit({ converged: true, reason: "max-evaluations" });
+          return;
+        }
+        if (mi) {
+          actions.emit({ converged: true, reason: "max-iterations" });
+          return;
+        }
+        actions.emit({ converged: false });
+      },
+      { name: "converged", describeKind: "derived" }
+    );
+    this.add(convergedNode, { name: "converged" });
+    this.addDisposer(convergedNode.subscribe(() => void 0));
+    let lastDecidedIteration = -1;
+    const decideEffect = createNode(
+      [feedbackEnvelopeNode, pauseState],
+      (batchData, _actions, ctx) => {
+        const feedbackFired = batchData[0] != null && batchData[0].length > 0;
+        if (!feedbackFired) return;
+        const data = batchData.map(
+          (batch3, i2) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i2]
+        );
+        const fbEnv = data[0];
+        const paused = data[1];
+        const i = fbEnv.iter;
+        const fb = fbEnv.feedback;
+        const cs = fbEnv.items;
+        const scores = fbEnv.scores;
+        if (i <= lastDecidedIteration) return;
+        lastDecidedIteration = i;
+        const currentHistory = historyState.cache;
+        const currentBudget = budgetState.cache;
+        const { best, bestScore } = pickBest(cs, scores);
+        const iteration = {
+          n: i,
+          candidates: cs,
+          scores,
+          feedback: fb,
+          best,
+          bestScore,
+          timestamp_ns: monotonicNs()
+        };
+        const nextHistory = [...currentHistory, iteration];
+        const nextBudget = currentBudget + cs.length;
+        let decision = "continue";
+        let reason;
+        const budgetOut = opts.budget != null && nextBudget >= opts.budget;
+        if (budgetOut) {
+          decision = "budget";
+          reason = "budget";
+        } else if (opts.minScore != null && fb.score >= opts.minScore) {
+          decision = "converged";
+          reason = "min-score";
+        } else if (opts.maxIterations != null && i >= opts.maxIterations) {
+          decision = "converged";
+          reason = "max-iterations";
+        } else if (opts.maxEvaluations != null && nextBudget >= opts.maxEvaluations) {
+          decision = "converged";
+          reason = "max-evaluations";
+        } else if (opts.minDelta != null && nextHistory.length >= 2) {
+          const prev = nextHistory[nextHistory.length - 2].bestScore;
+          const curr = nextHistory[nextHistory.length - 1].bestScore;
+          if (Math.abs(curr - prev) < opts.minDelta) {
+            decision = "converged";
+            reason = "min-delta";
+          }
+        } else if (opts.patience != null && nextHistory.length > opts.patience) {
+          const lookback = nextHistory.slice(-(opts.patience + 1));
+          const baseline = lookback[0].bestScore;
+          if (lookback.slice(1).every((it) => it.bestScore <= baseline)) {
+            decision = "converged";
+            reason = "patience";
+          }
+        }
+        if (decision === "continue" && paused) {
+          decision = "paused";
+        }
+        batch(() => {
+          bestState.emit(best);
+          scoreState.emit(fb.score);
+          historyState.emit(nextHistory);
+          budgetState.emit(nextBudget);
+          lastFeedbackState.emit(fb);
+          hubDecideTopic.publish({
+            iteration: i,
+            decision,
+            reason,
+            timestamp_ns: monotonicNs()
+          });
+          if (decision === "continue") {
+            iterationTrigger.emit(i + 1);
+          } else {
+            statusState.emit(
+              decision === "converged" ? "converged" : decision === "budget" ? "budget" : "paused"
+            );
+          }
+        });
+      },
+      { name: "decide-bridge", describeKind: "effect" }
+    );
+    this.add(decideEffect, { name: "decide-bridge" });
+    this.addDisposer(decideEffect.subscribe(() => void 0));
+  }
+  /** Swap the active strategy mid-run (human-in-the-loop handoff). */
+  setStrategy(next) {
+    this.strategy.emit(next);
+  }
+  /** Pause after the current iteration completes. */
+  pause() {
+    this._pauseState.emit(true);
+  }
+  /**
+   * Resume a paused loop. Idempotent: only un-pauses from the "paused"
+   * terminal state. Converged / budget / errored are permanent — a user
+   * wanting to start over should construct a fresh refineLoop.
+   */
+  resume() {
+    if (this.status.cache !== "paused") return;
+    batch(() => {
+      this._pauseState.emit(false);
+      this.status.emit("running");
+      this._iteration.emit(this._iteration.cache + 1);
+    });
+  }
+};
+function isNode(x) {
+  if (typeof x !== "object" || x === null) return false;
+  const obj = x;
+  return typeof obj.subscribe === "function" && typeof obj.down === "function" && typeof obj.emit === "function";
+}
+function pickBest(candidates, scores) {
+  if (candidates.length === 0) {
+    return { best: null, bestScore: Number.NEGATIVE_INFINITY };
+  }
+  if (candidates.length === 1) {
+    const mean = meanScore(scores);
+    return { best: candidates[0], bestScore: mean };
+  }
+  const hasFanOut = scores.some((s) => typeof s.candidateIndex === "number");
+  if (hasFanOut) {
+    const sums = new Array(candidates.length);
+    for (let i = 0; i < candidates.length; i++) sums[i] = { sum: 0, count: 0 };
+    for (const s of scores) {
+      const idx = s.candidateIndex;
+      if (typeof idx === "number" && idx >= 0 && idx < candidates.length) {
+        sums[idx].sum += s.score;
+        sums[idx].count += 1;
+      }
+    }
+    let best2 = candidates[0];
+    let bestScore2 = sums[0].count > 0 ? sums[0].sum / sums[0].count : Number.NEGATIVE_INFINITY;
+    for (let i = 1; i < candidates.length; i++) {
+      const avg = sums[i].count > 0 ? sums[i].sum / sums[i].count : Number.NEGATIVE_INFINITY;
+      if (avg > bestScore2) {
+        bestScore2 = avg;
+        best2 = candidates[i];
+      }
+    }
+    return { best: best2, bestScore: bestScore2 };
+  }
+  let best = candidates[0];
+  let bestScore = scores[0]?.score ?? Number.NEGATIVE_INFINITY;
+  for (let i = 1; i < candidates.length; i++) {
+    const s = scores[i]?.score ?? Number.NEGATIVE_INFINITY;
+    if (s > bestScore) {
+      bestScore = s;
+      best = candidates[i];
+    }
+  }
+  return { best, bestScore };
+}
+function meanScore(scores) {
+  if (scores.length === 0) return Number.NEGATIVE_INFINITY;
+  let sum = 0;
+  for (const s of scores) sum += s.score;
+  return sum / scores.length;
+}
+function refineLoop(seed, evaluator, initialStrategy, opts) {
+  return new RefineLoopGraph(seed, evaluator, initialStrategy, opts);
+}
+function blindVariation(opts) {
+  const width = opts.width ?? 4;
+  const name = opts.name ?? "blindVariation";
+  return {
+    name,
+    seed(seed) {
+      return [seed];
+    },
+    analyze(scores, _candidates) {
+      const score = meanScore(scores);
+      let worst = null;
+      for (const s of scores) {
+        if (!worst || s.score < worst.score) worst = s;
+      }
+      return {
+        summary: `blindVariation iteration: mean=${score.toFixed(3)}, n=${scores.length}`,
+        score,
+        weakTasks: worst ? [worst.taskId] : []
+      };
+    },
+    async generate(_feedback, candidates) {
+      if (candidates.length === 0) {
+        throw new Error(
+          "blindVariation.generate: empty candidate batch \u2014 cannot derive prior for teacher"
+        );
+      }
+      const prior = candidates[candidates.length - 1];
+      let iterCost = 0;
+      const reportCost = (n) => {
+        iterCost += n;
+      };
+      const ctx = { prior, reportCost };
+      try {
+        if (opts.parallel !== false) {
+          return await Promise.all(Array.from({ length: width }, () => opts.teacher(ctx)));
+        }
+        const out = [];
+        for (let i = 0; i < width; i++) {
+          out.push(await opts.teacher(ctx));
+        }
+        return out;
+      } finally {
+        if (opts.tokens != null && iterCost > 0) {
+          tryIncrementBounded(opts.tokens, Number.MAX_SAFE_INTEGER, iterCost);
+        }
+      }
+    }
+  };
+}
+function isErrorCritiquePrivate(v) {
+  return typeof v === "object" && v !== null && v.kind === "errorCritique";
+}
+function defaultFormatCritique(failures, feedback) {
+  if (failures.length === 0) {
+    return `No task scored below the batch mean (${feedback.score.toFixed(3)}). Reinforce the current direction.`;
+  }
+  const lines = failures.map((f) => {
+    const err = f.error != null ? ` | error: ${f.error}` : "";
+    return `- ${f.taskId} (score=${f.score.toFixed(3)})${err}`;
+  });
+  return `Failures below threshold:
+${lines.join("\n")}`;
+}
+function errorCritique(opts) {
+  const width = opts.width ?? 4;
+  const name = opts.name ?? "errorCritique";
+  const maxFailureSamples = opts.maxFailureSamples ?? 5;
+  const format = opts.formatCritique ?? defaultFormatCritique;
+  return {
+    name,
+    seed(seed) {
+      return [seed];
+    },
+    analyze(scores, candidates) {
+      const score = meanScore(scores);
+      const userThreshold = typeof opts.failureThreshold === "function" ? opts.failureThreshold(scores) : opts.failureThreshold;
+      const thresholdUnresolvable = userThreshold === void 0 && !Number.isFinite(score);
+      const threshold = userThreshold ?? score;
+      const allFailures = thresholdUnresolvable ? [...scores].sort((a, b) => a.score - b.score) : scores.filter((s) => s.score < threshold).slice().sort((a, b) => a.score - b.score);
+      const failures = allFailures.slice(0, maxFailureSamples);
+      const { best, bestScore } = pickBest(candidates, scores);
+      const feedbackShell = {
+        summary: "",
+        score,
+        weakTasks: failures.map((f) => f.taskId)
+      };
+      const critiqueText = format(failures, feedbackShell);
+      const priv = {
+        kind: "errorCritique",
+        best,
+        failures,
+        critiqueText
+      };
+      const retainedSuffix = allFailures.length > failures.length ? ` (top ${failures.length} retained)` : "";
+      return {
+        summary: `errorCritique iteration: mean=${score.toFixed(3)}, failures=${allFailures.length}${retainedSuffix}/${scores.length}, bestScore=${bestScore.toFixed(3)}`,
+        critique: priv,
+        weakTasks: failures.map((f) => f.taskId),
+        score
+      };
+    },
+    async generate(feedback, candidates) {
+      if (candidates.length === 0) {
+        throw new Error(
+          "errorCritique.generate: empty candidate batch \u2014 cannot derive prior for teacher"
+        );
+      }
+      const priv = isErrorCritiquePrivate(feedback.critique) ? feedback.critique : void 0;
+      const prior = priv !== void 0 ? priv.best : candidates[candidates.length - 1];
+      const critique = priv?.critiqueText ?? feedback.summary;
+      const failures = priv?.failures ?? [];
+      let iterCost = 0;
+      const reportCost = (n) => {
+        iterCost += n;
+      };
+      const ctx = { prior, critique, failures, reportCost };
+      try {
+        if (opts.parallel !== false) {
+          return await Promise.all(Array.from({ length: width }, () => opts.teacher(ctx)));
+        }
+        const out = [];
+        for (let i = 0; i < width; i++) {
+          out.push(await opts.teacher(ctx));
+        }
+        return out;
+      } finally {
+        if (opts.tokens != null && iterCost > 0) {
+          tryIncrementBounded(opts.tokens, Number.MAX_SAFE_INTEGER, iterCost);
+        }
+      }
+    }
+  };
+}
+
+// src/presets/harness/harness-loop.ts
+import { monotonicNs as monotonicNs2, node, placeholderArgs as placeholderArgs2 } from "@graphrefly/pure-ts/core";
+import { merge, withLatestFrom } from "@graphrefly/pure-ts/extra";
+import { Graph as Graph2 } from "@graphrefly/pure-ts/graph";
+
+// src/utils/harness/_internal.ts
+function trackingKey(item) {
+  return item.relatedTo?.[0] ?? item.summary;
+}
+
+// src/presets/harness/harness-loop.ts
+var TOPIC_INTAKE = "intake";
+var TOPIC_TRIAGE_OUTPUT = "triage-output";
+var TOPIC_RETRY = "retry";
+var TOPIC_VERIFY_RESULTS = "verify-results";
+var TOPIC_UNROUTED = "__unrouted";
+function defaultLlmExecutor(adapter, prompt) {
+  const promptFn = resolvePromptFn(
+    prompt,
+    DEFAULT_EXECUTE_PROMPT,
+    (tpl, item) => tpl.replace("{{item}}", JSON.stringify(item))
+  );
+  return (job, opts) => {
+    const item = job.payload.item;
+    const messages = [{ role: "user", content: promptFn(item) }];
+    const failurePayload = (detail) => ({
+      ...job.payload,
+      execution: { item, outcome: "failure", detail }
+    });
+    const formatErr = (err) => err instanceof Error ? err.message : String(err);
+    return _oneShotLlmCall(adapter, messages, {
+      parentSignal: opts?.signal,
+      onSuccess: (resp) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(stripFences(String(resp.content)));
+        } catch (err) {
+          return failurePayload(`execute parse error: ${formatErr(err)}`);
+        }
+        if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return failurePayload(
+            `execute parse error: non-object response: ${JSON.stringify(parsed)}`
+          );
+        }
+        const obj = parsed;
+        return {
+          ...job.payload,
+          execution: {
+            item,
+            outcome: obj.outcome ?? "failure",
+            detail: obj.detail ?? "unknown",
+            artifact: obj.artifact
+          }
+        };
+      },
+      onFailure: (kind, err) => {
+        if (kind === "complete") {
+          return failurePayload("adapter completed without emitting DATA");
+        }
+        return failurePayload(`executor failed: ${formatErr(err)}`);
+      }
+    });
+  };
+}
+function defaultLlmVerifier(adapter, prompt) {
+  const promptFn = resolvePromptFn(
+    prompt,
+    DEFAULT_VERIFY_PROMPT,
+    (tpl, pair) => {
+      const [execution, item] = pair;
+      return tpl.replace("{{execution}}", JSON.stringify(execution)).replace("{{item}}", JSON.stringify(item));
+    }
+  );
+  return (job, opts) => {
+    const { item, execution } = job.payload;
+    if (execution == null) {
+      return {
+        ...job.payload,
+        verify: {
+          verified: false,
+          findings: ["verifier: prior execute stage produced no execution"],
+          errorClass: "structural"
+        }
+      };
+    }
+    const messages = [
+      { role: "user", content: promptFn([execution, item]) }
+    ];
+    const failurePayload = (finding) => ({
+      ...job.payload,
+      verify: {
+        verified: false,
+        findings: [finding],
+        errorClass: "self-correctable"
+      }
+    });
+    const formatErr = (err) => err instanceof Error ? err.message : String(err);
+    return _oneShotLlmCall(adapter, messages, {
+      parentSignal: opts?.signal,
+      onSuccess: (resp) => {
+        let parsed;
+        try {
+          parsed = JSON.parse(stripFences(String(resp.content)));
+        } catch (err) {
+          return failurePayload(`verify parse error: ${formatErr(err)}`);
+        }
+        if (parsed == null || typeof parsed !== "object" || Array.isArray(parsed)) {
+          return failurePayload(
+            `verify parse error: non-object response: ${JSON.stringify(parsed)}`
+          );
+        }
+        const obj = parsed;
+        return {
+          ...job.payload,
+          verify: {
+            verified: obj.verified === true,
+            findings: obj.findings ?? [],
+            errorClass: obj.errorClass
+          }
+        };
+      },
+      onFailure: (kind, err) => {
+        if (kind === "complete") {
+          return failurePayload("verifier completed without emitting DATA");
+        }
+        return failurePayload(`verifier failed: ${formatErr(err)}`);
+      }
+    });
+  };
+}
+var HarnessGraph = class extends Graph2 {
+  /** Messaging hub — the routing-data plane. Queue topics live here. */
+  queues;
+  /**
+   * EXECUTE → VERIFY JobFlow (Tier 6.5 C2). Pumps own claim/ack/nack
+   * lifecycle for each stage. Inspect via:
+   * - `harness.executeFlow.queue("execute").pending` — pending depth.
+   * - `harness.executeFlow.queue("verify").pending` — items mid-execute.
+   * - `harness.executeFlow.completed` — verified items waiting for the
+   *   dispatch effect's 3-way routing.
+   * - `harness.executeFlow.completedCount` — total terminal completions.
+   */
+  executeFlow;
+  /**
+   * Per-route JobQueueGraph audit mirrors. Each triaged item that reaches
+   * a queue is also enqueued here, giving reactive `depth` + `pending` +
+   * `jobs` observables per route. The dispatch effect ack/removeBy-id's
+   * the matching job on terminal verdict. The executeFlow JobFlow handles
+   * the EXECUTE → VERIFY data flow; this is a parallel audit-side ledger
+   * for per-route depth metrics. Inspect via
+   * `harness.jobs.get(route).depth.cache` for backpressure metrics.
+   */
+  jobs;
+  /** Per-route gate controllers (only for gated queues). */
+  gates;
+  /**
+   * Per-route queue topics — typed accessor for the four
+   * {@link QUEUE_NAMES} entries (`auto-fix`, `needs-decision`,
+   * `investigation`, `backlog`). Mirrors the `gates` / `jobs` map
+   * shape so callers can iterate `[route, topic]` pairs without
+   * hand-rolling `harness.queues.topicNames()` + meta-topic exclusion.
+   *
+   * Excludes the meta topics that share the hub:
+   * `intake` (use {@link intake}), `verify-results` (use
+   * {@link verifyResults}), `retry` (use {@link retry}), `__unrouted`
+   * (use {@link unrouted}), and the internal `triage-output` fan-in.
+   */
+  queueTopics;
+  /** Strategy model — `auditedSuccessTracker` keyed by `StrategyKey`. */
+  strategy;
+  /** Global retry count across all items (circuit breaker). Reactive — subscribable. */
+  totalRetries;
+  /** Global reingestion count across all items (circuit breaker). Reactive — subscribable. */
+  totalReingestions;
+  /**
+   * Per-route priority score nodes, populated only when `opts.priority` is
+   * set on {@link harnessLoop}. Each node emits a score combining severity,
+   * attention decay, and strategy-model effectiveness for the route's
+   * current head-of-queue item. `undefined` means the caller did not opt
+   * in to priority scoring.
+   */
+  priorityScores;
+  /**
+   * REFLECT-stage tick marker — emits one DATA per terminal verdict observed
+   * on `executeFlow.completed`. `equals: () => false` so each completion
+   * produces an observable tick (no Object.is collapse on identical
+   * `null` payloads). Inspection tools (`harnessTrace`, dashboards) can
+   * subscribe directly here instead of resolving by string path
+   * (`harness.node("reflect")`) — the field is the lock against rename
+   * drift.
+   */
+  reflect;
+  constructor(name, queues, executeFlow, queueTopics, jobs, gates, strategy, totalRetries, totalReingestions, reflect, priorityScores) {
+    super(name);
+    this.queues = queues;
+    this.executeFlow = executeFlow;
+    this.queueTopics = queueTopics;
+    this.jobs = jobs;
+    this.gates = gates;
+    this.strategy = strategy;
+    this.totalRetries = totalRetries;
+    this.totalReingestions = totalReingestions;
+    this.reflect = reflect;
+    this.priorityScores = priorityScores;
+  }
+  /** Intake topic — publish items here to enter the loop. */
+  get intake() {
+    return this.queues.topic(TOPIC_INTAKE);
+  }
+  /** Verify results topic — subscribe to see verification outcomes. */
+  get verifyResults() {
+    return this.queues.topic(TOPIC_VERIFY_RESULTS);
+  }
+  /** Retry feedback topic — fast-retry re-entry point. */
+  get retry() {
+    return this.queues.topic(TOPIC_RETRY);
+  }
+  /** Dead-letter topic for items whose LLM-chosen route is unknown. */
+  get unrouted() {
+    return this.queues.topic(TOPIC_UNROUTED);
+  }
+  /**
+   * Stage-label → observe-path map for the 7 pipeline stages.
+   *
+   * Decouples inspection tools (`harnessTrace`, `harnessProfile`, custom
+   * dashboards) from mount-structure churn: hub migration, future stage
+   * splits, gate remounting, or the Tier 6.5 C2 JobFlow rewire shouldn't
+   * require edits to `trace.ts` as long as this method stays accurate.
+   *
+   * Each stage yields `{ label, paths }`; consumers iterate paths per
+   * stage and attach observers. Tier 6.5: EXECUTE / VERIFY paths now
+   * resolve to the `executeFlow` stage queues + the `verify-dispatch`
+   * effect node.
+   */
+  stageNodes() {
+    const hub = this.queues;
+    const resolveHubPath = (name) => hub.has(name) ? `queues::${name}::latest` : null;
+    const includeIf = (value) => value == null ? [] : [value];
+    const queuePaths = QUEUE_NAMES.flatMap((r) => includeIf(resolveHubPath(r)));
+    const gatePaths = [];
+    for (const [route] of this.gates) {
+      gatePaths.push(`gates::${route}/gate`);
+    }
+    return [
+      { label: "INTAKE", paths: includeIf(resolveHubPath("intake")) },
+      { label: "TRIAGE", paths: ["triage"] },
+      { label: "QUEUE", paths: queuePaths },
+      { label: "GATE", paths: gatePaths },
+      { label: "EXECUTE", paths: ["executeFlow::execute::events"] },
+      { label: "VERIFY", paths: ["executeFlow::verify::events"] },
+      { label: "REFLECT", paths: ["reflect"] },
+      { label: "STRATEGY", paths: ["strategy::entries"] }
+    ];
+  }
+};
+function harnessLoop(name, opts) {
+  const adapter = opts.adapter;
+  const maxRetries = opts.maxRetries ?? 2;
+  const retainedLimit = opts.retainedLimit ?? 1e3;
+  const errorClassifier = opts.errorClassifier ?? defaultErrorClassifier;
+  const queueConfigs = /* @__PURE__ */ new Map();
+  for (const route of QUEUE_NAMES) {
+    queueConfigs.set(route, {
+      ...DEFAULT_QUEUE_CONFIGS[route],
+      ...opts.queues?.[route]
+    });
+  }
+  const queuesHub = messagingHub(`${name}/queues`, {
+    defaultTopicOptions: { retainedLimit }
+  });
+  const intake = queuesHub.topic(TOPIC_INTAKE);
+  const triageOutput = queuesHub.topic(TOPIC_TRIAGE_OUTPUT);
+  const retryTopic = queuesHub.topic(TOPIC_RETRY);
+  const verifyResults = queuesHub.topic(TOPIC_VERIFY_RESULTS);
+  const queueTopics = /* @__PURE__ */ new Map();
+  for (const route of QUEUE_NAMES) {
+    queueTopics.set(route, queuesHub.topic(route));
+  }
+  const unroutedTopic = queuesHub.topic(TOPIC_UNROUTED);
+  const strategy = strategyModel();
+  const triageInput = withLatestFrom(
+    intake.latest,
+    strategy.entries
+  );
+  const triagePromptFn = resolvePromptFn(
+    opts.triagePrompt,
+    DEFAULT_TRIAGE_PROMPT,
+    (tpl, pair) => {
+      const [item, strat] = pair;
+      return tpl.replace("{{strategy}}", JSON.stringify(Array.from(strat.entries()))).replace("{{item}}", JSON.stringify(item));
+    }
+  );
+  const triageNode = promptNode(
+    adapter,
+    [triageInput],
+    (pair) => {
+      const asPair = pair;
+      if (asPair === void 0) return "";
+      return triagePromptFn(asPair);
+    },
+    {
+      name: "triage",
+      format: "json"
+    }
+  );
+  const routerInput = withLatestFrom(triageNode, triageInput);
+  const router = node(
+    [routerInput],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+      );
+      const pair = data[0];
+      if (pair == null) return;
+      const [classification, triagePair] = pair;
+      if (!classification?.route) return;
+      const intakeItem = triagePair?.[0];
+      const merged = { ...classification, ...intakeItem };
+      triageOutput.publish(merged);
+    },
+    { describeKind: "effect" }
+  );
+  const routerUnsub = router.subscribe(() => {
+  });
+  const knownRoutes = new Set(QUEUE_NAMES);
+  for (const route of QUEUE_NAMES) {
+    topicBridge(`bridge/${route}`, triageOutput, queueTopics.get(route), {
+      map: (item) => item.route === route ? item : void 0
+    });
+  }
+  topicBridge("bridge/__unrouted", triageOutput, unroutedTopic, {
+    map: (item) => knownRoutes.has(item.route) ? void 0 : item
+  });
+  const jobQueues = /* @__PURE__ */ new Map();
+  const routeJobIds = /* @__PURE__ */ new Map();
+  for (const route of QUEUE_NAMES) {
+    jobQueues.set(route, jobQueue(`jobs/${route}`));
+  }
+  const jobMirrorUnsubs = [];
+  for (const route of QUEUE_NAMES) {
+    const topic2 = queueTopics.get(route);
+    const jq = jobQueues.get(route);
+    const seen = /* @__PURE__ */ new WeakSet();
+    const mirror = node(
+      [topic2.events],
+      (batchData, _actions, ctx) => {
+        const data = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const events = data[0];
+        const arr = events ?? [];
+        for (const item of arr) {
+          if (seen.has(item)) continue;
+          seen.add(item);
+          const id = jq.enqueue(item);
+          routeJobIds.set(trackingKey(item), { route, id });
+        }
+      },
+      { name: `jobs/${route}-mirror`, describeKind: "effect" }
+    );
+    jobMirrorUnsubs.push(mirror.subscribe(() => {
+    }));
+  }
+  function ackJob(item) {
+    const key = trackingKey(item);
+    const entry = routeJobIds.get(key);
+    if (!entry) return;
+    jobQueues.get(entry.route)?.removeById(entry.id);
+    routeJobIds.delete(key);
+  }
+  const gateGraph = pipelineGraph("gates");
+  const gateControllers = /* @__PURE__ */ new Map();
+  for (const route of QUEUE_NAMES) {
+    const config = queueConfigs.get(route);
+    if (!config.gated) continue;
+    const topic2 = queueTopics.get(route);
+    const ctrl = gateGraph.approvalGate(
+      `${route}/gate`,
+      topic2.latest,
+      {
+        maxPending: config.maxPending,
+        startOpen: config.startOpen
+      }
+    );
+    gateControllers.set(route, ctrl);
+  }
+  const queueOutputs = [];
+  for (const route of QUEUE_NAMES) {
+    const config = queueConfigs.get(route);
+    if (config.gated && gateControllers.has(route)) {
+      queueOutputs.push(gateControllers.get(route).output);
+    } else {
+      queueOutputs.push(queueTopics.get(route).latest);
+    }
+  }
+  queueOutputs.push(retryTopic.latest);
+  const executeInput = merge(...queueOutputs);
+  const executor = opts.executor ?? defaultLlmExecutor(adapter, opts.executePrompt);
+  const verifier = opts.verifier ?? defaultLlmVerifier(adapter, opts.verifyPrompt);
+  const executeMaxPerPump = opts.executeMaxPerPump ?? Number.MAX_SAFE_INTEGER;
+  const verifyMaxPerPump = opts.verifyMaxPerPump ?? Number.MAX_SAFE_INTEGER;
+  const executeFlow = jobFlow(`${name}/executeFlow`, {
+    stages: [
+      { name: "execute", work: (job) => executor(job), maxPerPump: executeMaxPerPump },
+      { name: "verify", work: (job) => verifier(job), maxPerPump: verifyMaxPerPump }
+    ]
+  });
+  const enqueueEffect = node(
+    [executeInput],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+      );
+      const item = data[0];
+      if (item === void 0) return;
+      executeFlow.enqueue({ item });
+    },
+    { name: "execute-enqueue", describeKind: "effect" }
+  );
+  const enqueueUnsub = enqueueEffect.subscribe(() => {
+  });
+  const maxReingestions = opts.maxReingestions ?? 1;
+  const maxTotalRetries = Math.min(opts.maxTotalRetries ?? maxRetries * 10, 100);
+  const maxTotalReingestions = Math.min(opts.maxTotalReingestions ?? maxReingestions * 10, 100);
+  const totalRetries = node([], { initial: 0 });
+  const totalReingestions = node([], { initial: 0 });
+  function assembleResult(execution, verify, item) {
+    return {
+      item,
+      execution,
+      verified: verify.verified,
+      findings: verify.findings ?? [],
+      errorClass: verify.errorClass
+    };
+  }
+  function handleVerified(vr, item) {
+    strategy.record(strategyKey(DEFAULT_PRESET_ID, item.rootCause, item.intervention), true, {
+      presetId: DEFAULT_PRESET_ID,
+      rootCause: item.rootCause,
+      intervention: item.intervention
+    });
+    verifyResults.publish(vr);
+    ackJob(item);
+  }
+  function handleRetry(vr, item) {
+    const key = trackingKey(item);
+    const itemRetries = item.$retries ?? 0;
+    const retryItem = {
+      ...item,
+      $retries: itemRetries + 1,
+      summary: `[RETRY ${itemRetries + 1}/${maxRetries}] ${key} \u2014 Previous attempt failed: ${vr.findings.join("; ")}`,
+      relatedTo: [key]
+    };
+    retryTopic.publish(retryItem);
+  }
+  function handleStructural(vr, item) {
+    strategy.record(strategyKey(DEFAULT_PRESET_ID, item.rootCause, item.intervention), false, {
+      presetId: DEFAULT_PRESET_ID,
+      rootCause: item.rootCause,
+      intervention: item.intervention
+    });
+    verifyResults.publish(vr);
+    ackJob(item);
+    const key = trackingKey(item);
+    const itemReingestions = item.$reingestions ?? 0;
+    if (itemReingestions < maxReingestions && tryIncrementBounded(totalReingestions, maxTotalReingestions)) {
+      intake.publish({
+        source: item.source,
+        summary: `Verification failed for: ${key}`,
+        evidence: vr.findings.join("\n"),
+        affectsAreas: item.affectsAreas,
+        affectsEvalTasks: item.affectsEvalTasks,
+        severity: item.severity ?? "high",
+        relatedTo: [key],
+        $reingestions: itemReingestions + 1
+      });
+    }
+  }
+  let dispatchCursor = 0;
+  const dispatchEffect = node(
+    [executeFlow.completed],
+    (batchData, _actions, ctx) => {
+      const data = batchData.map(
+        (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+      );
+      const log = data[0];
+      const arr = log ?? [];
+      if (dispatchCursor > arr.length) dispatchCursor = arr.length;
+      const start = dispatchCursor;
+      dispatchCursor = arr.length;
+      for (let i = start; i < arr.length; i++) {
+        const job = arr[i];
+        const { item, execution, verify } = job.payload;
+        if (execution == null || verify == null) {
+          ackJob(item);
+          continue;
+        }
+        const vr = assembleResult(execution, verify, item);
+        if (vr.verified) {
+          handleVerified(vr, item);
+          continue;
+        }
+        const errClass = vr.errorClass ?? errorClassifier({
+          item,
+          outcome: execution.outcome,
+          detail: vr.findings.join("; ")
+        });
+        const itemRetries = item.$retries ?? 0;
+        if (errClass === "self-correctable" && itemRetries < maxRetries && tryIncrementBounded(totalRetries, maxTotalRetries)) {
+          handleRetry(vr, item);
+        } else {
+          handleStructural(vr, item);
+        }
+      }
+    },
+    { name: "verify-dispatch", describeKind: "effect" }
+  );
+  const dispatchUnsub = dispatchEffect.subscribe(() => {
+  });
+  const reflectNode = node(
+    [executeFlow.completed],
+    (_batchData, actions) => {
+      actions.emit(null);
+    },
+    {
+      name: "reflect",
+      equals: () => false
+    }
+  );
+  let priorityScores;
+  if (opts.priority) {
+    priorityScores = buildPriorityScores(queueTopics, strategy, opts);
+  }
+  const harness = new HarnessGraph(
+    name,
+    queuesHub,
+    executeFlow,
+    queueTopics,
+    jobQueues,
+    gateControllers,
+    strategy,
+    totalRetries,
+    totalReingestions,
+    reflectNode,
+    priorityScores
+  );
+  harness.addDisposer(routerUnsub);
+  harness.addDisposer(enqueueUnsub);
+  harness.addDisposer(dispatchUnsub);
+  for (const unsub of jobMirrorUnsubs) harness.addDisposer(unsub);
+  harness.add(triageInput, { name: "triage-input" });
+  harness.add(triageNode, { name: "triage" });
+  harness.add(routerInput, { name: "router-input" });
+  harness.add(executeInput, { name: "execute-input" });
+  harness.add(enqueueEffect, { name: "execute-enqueue" });
+  harness.add(dispatchEffect, { name: "verify-dispatch" });
+  harness.add(reflectNode, { name: "reflect" });
+  harness.addDisposer(reflectNode.subscribe(() => void 0));
+  if (priorityScores) {
+    for (const [route, score] of priorityScores) {
+      harness.add(score, { name: `priority/${route}` });
+      harness.addDisposer(score.subscribe(() => {
+      }));
+    }
+  }
+  harness.mount("queues", queuesHub);
+  harness.mount("gates", gateGraph);
+  harness.mount("executeFlow", executeFlow);
+  harness.mount("strategy", strategy);
+  for (const [route, jq] of jobQueues) {
+    harness.mount(`jobs/${route}`, jq);
+  }
+  harness.tagFactory("harnessLoop", placeholderArgs2(opts));
+  return harness;
+}
+function buildPriorityScores(queueTopics, strategy, opts) {
+  if (!opts.lastInteractionNs) {
+    throw new Error(
+      "harnessLoop: `opts.priority` requires `opts.lastInteractionNs` \u2014 pass a Node<number> (e.g. `fromTimer(60_000)` or a `state(monotonicNs())` you bump on human interaction). Priority scores only decay when this node settles; an internal default would freeze age at construction time."
+    );
+  }
+  const lastInteractionNs = opts.lastInteractionNs;
+  const signals = opts.priority ?? {};
+  const severityWeights = {
+    ...DEFAULT_SEVERITY_WEIGHTS,
+    ...signals.severityWeights
+  };
+  const decayRate = signals.decayRate ?? DEFAULT_DECAY_RATE;
+  const effectivenessThreshold = signals.effectivenessThreshold ?? 0.7;
+  const effectivenessBoost = signals.effectivenessBoost ?? 15;
+  const scores = /* @__PURE__ */ new Map();
+  for (const [route, topic2] of queueTopics) {
+    const score = node(
+      [
+        topic2.latest,
+        strategy.entries,
+        lastInteractionNs
+      ],
+      (batchData, actions, ctx) => {
+        const vals = batchData.map(
+          (batch3, i) => batch3 != null && batch3.length > 0 ? batch3.at(-1) : ctx.prevData[i]
+        );
+        const item = vals[0];
+        if (item === void 0) {
+          actions.emit(0);
+          return;
+        }
+        const baseWeight = severityWeights[item.severity ?? "medium"] ?? 40;
+        const ageSeconds = (monotonicNs2() - vals[2]) / 1e9;
+        let s = baseWeight * Math.exp(-decayRate * Math.max(0, ageSeconds));
+        const key = strategyKey(DEFAULT_PRESET_ID, item.rootCause, item.intervention);
+        const strat = vals[1];
+        const entry = strat?.get(key);
+        if (entry && entry.successRate >= effectivenessThreshold) {
+          s += effectivenessBoost;
+        }
+        actions.emit(s);
+      },
+      { name: `priority/${route}`, describeKind: "derived" }
+    );
+    scores.set(route, score);
+  }
+  return scores;
+}
+
+// src/presets/harness/spawnable.ts
+import { batch as batch2, DATA as DATA2, node as node2, wallClockNs } from "@graphrefly/pure-ts/core";
+import { keepalive } from "@graphrefly/pure-ts/extra";
+import { Graph as Graph3 } from "@graphrefly/pure-ts/graph";
+var SpawnableGraph = class extends Graph3 {
+  spawnTopic;
+  rejected;
+  activeSlot;
+  _spawnSub;
+  _registry;
+  _depthCap;
+  _validate;
+  _disposed = false;
+  constructor(opts) {
+    const name = opts.name ?? "spawnable";
+    super(name);
+    this._registry = opts.registry;
+    this._depthCap = opts.depthCap;
+    this._validate = opts.validate;
+    this.spawnTopic = opts.hub.topic(SPAWNS_TOPIC);
+    this.rejected = topic("rejected");
+    this.mount("rejected", this.rejected);
+    const activeSlotNode = node2([], {
+      name: "active-slot",
+      describeKind: "state",
+      meta: aiMeta("spawnable_active_slot"),
+      initial: /* @__PURE__ */ new Map(),
+      equals: () => false
+    });
+    this.add(activeSlotNode, { name: "active-slot" });
+    this.activeSlot = activeSlotNode;
+    this._spawnSub = subscription("spawn-sub", this.spawnTopic, {
+      from: opts.from ?? "now"
+    });
+    this.mount("spawn-sub", this._spawnSub);
+    const subRef = this._spawnSub;
+    const unsub = subRef.available.subscribe((msgs) => {
+      if (this._disposed) return;
+      for (const m of msgs) {
+        if (m[0] !== DATA2) continue;
+        const items = m[1];
+        if (items.length === 0) continue;
+        for (const req of items) {
+          if (this._disposed) return;
+          this._processRequest(req);
+        }
+        subRef.ack(items.length);
+      }
+    });
+    this.addDisposer(unsub);
+    this.addDisposer(() => {
+      this._disposed = true;
+    });
+    this.addDisposer(keepalive(activeSlotNode));
+  }
+  _processRequest(req) {
+    if (this._disposed) return;
+    if (this._validate && !this._validate(req)) {
+      this.rejected.publish({ request: req, reason: "schema validation failed" });
+      return;
+    }
+    if (req.expiresAt != null) {
+      const expiry = Date.parse(req.expiresAt);
+      if (!Number.isFinite(expiry)) {
+        this.rejected.publish({ request: req, reason: "invalid expiresAt" });
+        return;
+      }
+      const nowMs = wallClockNs() / 1e6;
+      if (nowMs >= expiry) {
+        this.rejected.publish({ request: req, reason: "expired" });
+        return;
+      }
+    }
+    const currentMap = this.activeSlot.cache ?? /* @__PURE__ */ new Map();
+    if (this._depthCap != null && currentMap.size >= this._depthCap) {
+      this.rejected.publish({
+        request: req,
+        reason: `depth-cap exceeded (${currentMap.size}/${this._depthCap})`
+      });
+      return;
+    }
+    const spec = this._registry.registry.get(req.payload.presetId);
+    if (!spec) {
+      this.rejected.publish({
+        request: req,
+        reason: `unknown presetId: ${req.payload.presetId}`
+      });
+      return;
+    }
+    const slotName = `spawn-${req.id}`;
+    let bundle;
+    try {
+      bundle = agent(this, { ...spec, name: slotName });
+    } catch (e) {
+      this.rejected.publish({
+        request: req,
+        reason: `agent mint failed: ${e.message ?? "unknown"}`
+      });
+      return;
+    }
+    const updated = new Map(currentMap);
+    updated.set(req.id, bundle);
+    this.activeSlot.emit(updated);
+    let statusUnsub;
+    const onTerminal = (stat) => {
+      if (stat !== "done" && stat !== "error") return;
+      const live = this.activeSlot.cache ?? /* @__PURE__ */ new Map();
+      if (!live.has(req.id)) return;
+      batch2(() => {
+        try {
+          this.remove(slotName);
+        } catch {
+        }
+        const next = new Map(live);
+        next.delete(req.id);
+        this.activeSlot.emit(next);
+      });
+      statusUnsub?.();
+      statusUnsub = void 0;
+    };
+    statusUnsub = bundle.status.subscribe((msgs) => {
+      for (const m of msgs) {
+        if (m[0] === DATA2) onTerminal(m[1]);
+      }
+    });
+    this.addDisposer(() => statusUnsub?.());
+    bundle.in.emit(req.payload.taskInput);
+  }
+};
+function spawnable(opts) {
+  const graph = new SpawnableGraph(opts);
+  opts.hub.mount(opts.name ?? "spawnable", graph);
+  return {
+    spawnTopic: graph.spawnTopic,
+    activeSlot: graph.activeSlot,
+    rejected: graph.rejected,
+    graph
+  };
+}
+
+export {
+  RefineLoopGraph,
+  refineLoop,
+  blindVariation,
+  errorCritique,
+  defaultLlmExecutor,
+  defaultLlmVerifier,
+  HarnessGraph,
+  harnessLoop,
+  SpawnableGraph,
+  spawnable
+};
+//# sourceMappingURL=chunk-GBCENOLN.js.map