@graphrefly/graphrefly 0.12.0 → 0.14.0

package/dist/index.cjs

@@ -134,10 +134,10 @@ __export(index_exports, {
   distill: () => distill,
   distinctUntilChanged: () => distinctUntilChanged,
   domainTemplates: () => domain_templates_exports,
+  downWithBatch: () => downWithBatch,
   dynamicNode: () => dynamicNode,
   effect: () => effect,
   elementAt: () => elementAt,
-  emitWithBatch: () => emitWithBatch,
   empty: () => empty,
   escapeRegexChar: () => escapeRegexChar,
   exhaustMap: () => exhaustMap,
@@ -185,6 +185,7 @@ __export(index_exports, {
   globToRegExp: () => globToRegExp,
   graph: () => graph_exports,
   graphspec: () => graphspec_exports,
+  harness: () => harness_exports,
   interval: () => interval,
   isBatching: () => isBatching,
   isKnownMessageType: () => isKnownMessageType,
@@ -427,8 +428,7 @@ function drainPending() {
   if (ownsFlush) {
     flushInProgress = true;
   }
-  let firstError;
-  let hasError = false;
+  const errors = [];
   try {
     let iterations = 0;
     while (pendingPhase2.length > 0 || pendingPhase3.length > 0) {
@@ -446,10 +446,7 @@ function drainPending() {
           try {
             run();
           } catch (e) {
-            if (!hasError) {
-              firstError = e;
-              hasError = true;
-            }
+            errors.push(e);
           }
         }
       }
@@ -467,10 +464,7 @@ function drainPending() {
           try {
             run();
           } catch (e) {
-            if (!hasError) {
-              firstError = e;
-              hasError = true;
-            }
+            errors.push(e);
           }
         }
       }
@@ -480,8 +474,11 @@ function drainPending() {
       flushInProgress = false;
     }
   }
-  if (hasError) {
-    throw firstError;
+  if (errors.length === 1) {
+    throw errors[0];
+  }
+  if (errors.length > 1) {
+    throw new AggregateError(errors, "batch drain: multiple callbacks threw");
   }
 }
 function partitionForBatch(messages) {
@@ -499,12 +496,12 @@ function partitionForBatch(messages) {
   }
   return { immediate, deferred, terminal };
 }
-function emitWithBatch(emit, messages, phase = 2, options) {
+function downWithBatch(sink, messages, phase = 2, options) {
   if (messages.length === 0) {
     return;
   }
   if (options?.strategy === "sequential") {
-    _emitSequential(emit, messages, phase);
+    _downSequential(sink, messages, phase);
     return;
   }
   const queue = phase === 3 ? pendingPhase3 : pendingPhase2;
@@ -512,61 +509,61 @@ function emitWithBatch(emit, messages, phase = 2, options) {
     const t = messages[0][0];
     if (t === DATA || t === RESOLVED) {
       if (isBatching()) {
-        queue.push(() => emit(messages));
+        queue.push(() => sink(messages));
       } else {
-        emit(messages);
+        sink(messages);
       }
     } else if (isTerminalMessage(t)) {
       if (isBatching()) {
-        queue.push(() => emit(messages));
+        queue.push(() => sink(messages));
       } else {
-        emit(messages);
+        sink(messages);
       }
     } else {
-      emit(messages);
+      sink(messages);
     }
     return;
   }
   const { immediate, deferred, terminal } = partitionForBatch(messages);
   if (immediate.length > 0) {
-    emit(immediate);
+    sink(immediate);
   }
   if (isBatching()) {
     if (deferred.length > 0) {
-      queue.push(() => emit(deferred));
+      queue.push(() => sink(deferred));
     }
     if (terminal.length > 0) {
-      queue.push(() => emit(terminal));
+      queue.push(() => sink(terminal));
     }
   } else {
     if (deferred.length > 0) {
-      emit(deferred);
+      sink(deferred);
     }
     if (terminal.length > 0) {
-      emit(terminal);
+      sink(terminal);
     }
   }
 }
-function _emitSequential(emit, messages, phase = 2) {
+function _downSequential(sink, messages, phase = 2) {
   const dataQueue = phase === 3 ? pendingPhase3 : pendingPhase2;
   for (const msg of messages) {
     const tier = messageTier(msg[0]);
     if (tier === 2) {
       if (isBatching()) {
         const m = msg;
-        dataQueue.push(() => emit([m]));
+        dataQueue.push(() => sink([m]));
       } else {
-        emit([msg]);
+        sink([msg]);
       }
     } else if (tier >= 3) {
       if (isBatching()) {
         const m = msg;
-        pendingPhase3.push(() => emit([m]));
+        pendingPhase3.push(() => sink([m]));
       } else {
-        emit([msg]);
+        sink([msg]);
       }
     } else {
-      emit([msg]);
+      sink([msg]);
     }
   }
 }
@@ -854,7 +851,7 @@ var NodeImpl = class {
   _singleDepSinks = /* @__PURE__ */ new WeakSet();
   _upstreamUnsubs = [];
   _actions;
-  _boundEmitToSinks;
+  _boundDownToSinks;
   _inspectorHook;
   _versioning;
   _hashFn;
@@ -901,7 +898,7 @@ var NodeImpl = class {
       },
       emit(value) {
         self._manualEmitUsed = true;
-        self._emitAutoValue(value);
+        self._downAutoValue(value);
       },
       up(messages) {
         self._upInternal(messages);
@@ -909,7 +906,7 @@ var NodeImpl = class {
     };
     this.down = this.down.bind(this);
     this.up = this.up.bind(this);
-    this._boundEmitToSinks = this._emitToSinks.bind(this);
+    this._boundDownToSinks = this._downToSinks.bind(this);
   }
   get name() {
     return this._registryName ?? this._optsName;
@@ -1015,12 +1012,12 @@ var NodeImpl = class {
           if (sinkMessages[i][0] !== DIRTY) filtered.push(sinkMessages[i]);
         }
         if (filtered.length > 0) {
-          emitWithBatch(this._boundEmitToSinks, filtered);
+          downWithBatch(this._boundDownToSinks, filtered);
         }
         return;
       }
     }
-    emitWithBatch(this._boundEmitToSinks, sinkMessages);
+    downWithBatch(this._boundDownToSinks, sinkMessages);
   }
   subscribe(sink, hints) {
     if (hints?.actor != null && this._guard != null) {
@@ -1107,7 +1104,7 @@ var NodeImpl = class {
     this._disconnectUpstream();
   }
   // --- Private methods (prototype, _ prefix) ---
-  _emitToSinks(messages) {
+  _downToSinks(messages) {
     if (this._sinks == null) return;
     if (typeof this._sinks === "function") {
       this._sinks(messages);
@@ -1122,6 +1119,9 @@ var NodeImpl = class {
     for (const m of messages) {
       const t = m[0];
       if (t === DATA) {
+        if (m.length < 2) {
+          continue;
+        }
         this._cached = m[1];
         if (this._versioning != null) {
           advanceVersion(this._versioning, m[1], this._hashFn);
@@ -1169,7 +1169,7 @@ var NodeImpl = class {
   _canSkipDirty() {
     return this._sinkCount === 1 && this._singleDepSinkCount === 1;
   }
-  _emitAutoValue(value) {
+  _downAutoValue(value) {
     const wasDirty = this._status === "dirty";
     let unchanged;
     try {
@@ -1222,7 +1222,7 @@ var NodeImpl = class {
         this._cleanup = out.cleanup;
         if (this._manualEmitUsed) return;
         if ("value" in out) {
-          this._emitAutoValue(out.value);
+          this._downAutoValue(out.value);
         }
         return;
       }
@@ -1232,7 +1232,7 @@ var NodeImpl = class {
       }
       if (this._manualEmitUsed) return;
       if (out === void 0) return;
-      this._emitAutoValue(out);
+      this._downAutoValue(out);
     } catch (err) {
       const errMsg = err instanceof Error ? err.message : String(err);
       const wrapped = new Error(`Node "${this.name}": fn threw: ${errMsg}`, { cause: err });
@@ -1409,7 +1409,7 @@ var DynamicNodeImpl = class {
   _singleDepSinks = /* @__PURE__ */ new WeakSet();
   // Actions object (for onMessage handler)
   _actions;
-  _boundEmitToSinks;
+  _boundDownToSinks;
   // Mutable state
   _cached = NO_VALUE;
   _status = "disconnected";
@@ -1456,7 +1456,7 @@ var DynamicNodeImpl = class {
         self._downInternal(messages);
       },
       emit(value) {
-        self._emitAutoValue(value);
+        self._downAutoValue(value);
       },
       up(messages) {
         for (const dep of self._deps) {
@@ -1464,7 +1464,7 @@ var DynamicNodeImpl = class {
         }
       }
     };
-    this._boundEmitToSinks = this._emitToSinks.bind(this);
+    this._boundDownToSinks = this._downToSinks.bind(this);
   }
   get name() {
     return this._registryName ?? this._optsName;
@@ -1544,12 +1544,12 @@ var DynamicNodeImpl = class {
           if (sinkMessages[i][0] !== DIRTY) filtered.push(sinkMessages[i]);
         }
         if (filtered.length > 0) {
-          emitWithBatch(this._boundEmitToSinks, filtered);
+          downWithBatch(this._boundDownToSinks, filtered);
         }
         return;
       }
     }
-    emitWithBatch(this._boundEmitToSinks, sinkMessages);
+    downWithBatch(this._boundDownToSinks, sinkMessages);
   }
   _canSkipDirty() {
     return this._sinkCount === 1 && this._singleDepSinkCount === 1;
@@ -1625,7 +1625,7 @@ var DynamicNodeImpl = class {
     this._disconnect();
   }
   // --- Private methods ---
-  _emitToSinks(messages) {
+  _downToSinks(messages) {
     if (this._sinks == null) return;
     if (typeof this._sinks === "function") {
       this._sinks(messages);
@@ -1679,7 +1679,7 @@ var DynamicNodeImpl = class {
       }
     }
   }
-  _emitAutoValue(value) {
+  _downAutoValue(value) {
     const wasDirty = this._status === "dirty";
     let unchanged;
     try {
@@ -1739,7 +1739,7 @@ var DynamicNodeImpl = class {
       const result = this._fn(get);
       this._rewire(trackedDeps);
       if (result === void 0) return;
-      this._emitAutoValue(result);
+      this._downAutoValue(result);
     } catch (err) {
       this._downInternal([[ERROR, err]]);
     }
@@ -1803,14 +1803,14 @@ var DynamicNodeImpl = class {
         this._dirtyBits.add(index);
         this._settledBits.delete(index);
         if (this._dirtyBits.size === 1) {
-          emitWithBatch(this._boundEmitToSinks, [[DIRTY]]);
+          downWithBatch(this._boundDownToSinks, [[DIRTY]]);
         }
         continue;
       }
       if (t === DATA || t === RESOLVED) {
         if (!this._dirtyBits.has(index)) {
           this._dirtyBits.add(index);
-          emitWithBatch(this._boundEmitToSinks, [[DIRTY]]);
+          downWithBatch(this._boundDownToSinks, [[DIRTY]]);
         }
         this._settledBits.add(index);
         if (this._allDirtySettled()) {
@@ -4645,7 +4645,7 @@ var Graph = class _Graph {
   _createObserveResult(path, target, options) {
     const timeline = options.timeline === true;
     const causal = options.causal === true;
-    const derived2 = options.derived === true;
+    const derived3 = options.derived === true;
     const minimal = options.detail === "minimal";
     const result = {
       values: {},
@@ -4658,14 +4658,14 @@ var Graph = class _Graph {
     let lastTriggerDepIndex;
     let lastRunDepValues;
     let detachInspectorHook;
-    if ((causal || derived2) && target instanceof NodeImpl) {
+    if ((causal || derived3) && target instanceof NodeImpl) {
       detachInspectorHook = target._setInspectorHook((event) => {
         if (event.kind === "dep_message") {
           lastTriggerDepIndex = event.depIndex;
           return;
         }
         lastRunDepValues = [...event.depValues];
-        if (derived2) {
+        if (derived3) {
           result.events.push({
             type: "derived",
             path,
@@ -5562,9 +5562,9 @@ __export(core_exports, {
   defaultHash: () => defaultHash,
   derived: () => derived,
   describeNode: () => describeNode,
+  downWithBatch: () => downWithBatch,
   dynamicNode: () => dynamicNode,
   effect: () => effect,
-  emitWithBatch: () => emitWithBatch,
   isBatching: () => isBatching,
   isKnownMessageType: () => isKnownMessageType,
   isPhase2Message: () => isPhase2Message,
@@ -12967,6 +12967,7 @@ __export(patterns_exports, {
   demoShell: () => demo_shell_exports,
   domainTemplates: () => domain_templates_exports,
   graphspec: () => graphspec_exports,
+  harness: () => harness_exports,
   layout: () => reactive_layout_exports,
   memory: () => memory_exports,
   messaging: () => messaging_exports,
@@ -14917,7 +14918,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache2) {
     hyphenWidth = adapter.measureSegment("-", font).width;
     fontCache.set("-", hyphenWidth);
   }
-  function emitLine(endSeg = lineEndSeg, endGrapheme = lineEndGrapheme, width = lineW) {
+  function flushLine(endSeg = lineEndSeg, endGrapheme = lineEndGrapheme, width = lineW) {
     let text = "";
     for (let i = lineStartSeg; i < endSeg; i++) {
       const seg = segments[i];
@@ -14980,7 +14981,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache2) {
     const seg = segments[i];
     if (seg.kind === "hard-break") {
       if (hasContent) {
-        emitLine();
+        flushLine();
       } else {
         lines.push({
           text: "",
@@ -15014,20 +15015,20 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache2) {
         lineW += w;
         lineEndSeg = i + 1;
         lineEndGrapheme = 0;
-        emitLine(i + 1, 0, seg.kind === "space" ? lineW - w : lineW);
+        flushLine(i + 1, 0, seg.kind === "space" ? lineW - w : lineW);
         continue;
       }
       if (pendingBreakSeg >= 0) {
-        emitLine(pendingBreakSeg, 0, pendingBreakWidth);
+        flushLine(pendingBreakSeg, 0, pendingBreakWidth);
         i--;
         continue;
       }
       if (w > maxWidth && seg.graphemeWidths) {
-        emitLine();
+        flushLine();
         appendBreakableSegment(i, 0, seg.graphemeWidths);
         continue;
       }
-      emitLine();
+      flushLine();
       i--;
       continue;
     }
@@ -15040,7 +15041,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache2) {
     }
   }
   if (hasContent) {
-    emitLine();
+    flushLine();
   }
   return { lines, lineCount: lines.length };
   function appendBreakableSegment(segIdx, startG, gWidths) {
@@ -15051,7 +15052,7 @@ function computeLineBreaks(segments, maxWidth, adapter, font, cache2) {
         continue;
       }
       if (lineW + gw > maxWidth + 5e-3) {
-        emitLine();
+        flushLine();
         startLineAtGrapheme(segIdx, g, gw);
       } else {
         lineW += gw;
@@ -15142,9 +15143,9 @@ function reactiveLayout(opts) {
         const hr = hitRate;
         const len = result.length;
         const el = elapsed;
-        emitWithBatch((msgs) => meta["cache-hit-rate"]?.down(msgs), [[DATA, hr]], 3);
-        emitWithBatch((msgs) => meta["segment-count"]?.down(msgs), [[DATA, len]], 3);
-        emitWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, el]], 3);
+        downWithBatch((msgs) => meta["cache-hit-rate"]?.down(msgs), [[DATA, hr]], 3);
+        downWithBatch((msgs) => meta["segment-count"]?.down(msgs), [[DATA, len]], 3);
+        downWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, el]], 3);
       }
       return result;
     },
@@ -17383,6 +17384,59 @@ ${validation.errors.join("\n")}`);
   return parsed;
 }
 
+// src/patterns/harness/index.ts
+var harness_exports = {};
+__export(harness_exports, {
+  DEFAULT_DECAY_RATE: () => DEFAULT_DECAY_RATE2,
+  DEFAULT_QUEUE_CONFIGS: () => DEFAULT_QUEUE_CONFIGS,
+  DEFAULT_SEVERITY_WEIGHTS: () => DEFAULT_SEVERITY_WEIGHTS,
+  HarnessGraph: () => HarnessGraph,
+  defaultErrorClassifier: () => defaultErrorClassifier,
+  evalIntakeBridge: () => evalIntakeBridge,
+  harnessLoop: () => harnessLoop,
+  priorityScore: () => priorityScore,
+  strategyKey: () => strategyKey,
+  strategyModel: () => strategyModel
+});
+
+// src/patterns/harness/bridge.ts
+function evalIntakeBridge(evalSource, intakeTopic, opts) {
+  const defaultSeverity = opts?.defaultSeverity ?? "medium";
+  return effect([evalSource], ([results]) => {
+    if (results == null) return;
+    const runs = Array.isArray(results) ? results : [results];
+    for (const run of runs) {
+      for (const task2 of run.tasks) {
+        if (task2.valid && task2.judge_scores?.every((s) => s.pass)) continue;
+        if (!task2.valid && (!task2.judge_scores || task2.judge_scores.length === 0)) {
+          intakeTopic.publish({
+            source: "eval",
+            summary: `Task ${task2.task_id} invalid (model: ${run.model})`,
+            evidence: `Run ${run.run_id}: task produced invalid output`,
+            affectsAreas: ["graphspec"],
+            affectsEvalTasks: [task2.task_id],
+            severity: defaultSeverity
+          });
+          continue;
+        }
+        if (task2.judge_scores) {
+          for (const score of task2.judge_scores) {
+            if (score.pass) continue;
+            intakeTopic.publish({
+              source: "eval",
+              summary: `${task2.task_id}: ${score.claim} (model: ${run.model})`,
+              evidence: score.reasoning,
+              affectsAreas: ["graphspec"],
+              affectsEvalTasks: [task2.task_id],
+              severity: defaultSeverity
+            });
+          }
+        }
+      }
+    }
+  });
+}
+
 // src/patterns/messaging.ts
 var messaging_exports = {};
 __export(messaging_exports, {
@@ -18276,6 +18330,326 @@ function onFailure(graph, name, source, recover, opts) {
   return step;
 }
 
+// src/patterns/harness/types.ts
+function strategyKey(rootCause, intervention) {
+  return `${rootCause}\u2192${intervention}`;
+}
+function defaultErrorClassifier(result) {
+  const d = result.detail.toLowerCase();
+  if (d.includes("parse") || d.includes("json") || d.includes("config") || d.includes("validation") || d.includes("syntax")) {
+    return "self-correctable";
+  }
+  return "structural";
+}
+var DEFAULT_SEVERITY_WEIGHTS = {
+  critical: 100,
+  high: 70,
+  medium: 40,
+  low: 10
+};
+var DEFAULT_DECAY_RATE2 = Math.LN2 / (7 * 24 * 3600);
+var DEFAULT_QUEUE_CONFIGS = {
+  "auto-fix": { gated: false },
+  "needs-decision": { gated: true },
+  investigation: { gated: true },
+  backlog: { gated: false, startOpen: false }
+};
+
+// src/patterns/harness/strategy.ts
+function strategyModel() {
+  const _map = reactiveMap({ name: "strategy-entries" });
+  const snapshot = derived(
+    [_map.node],
+    ([mapSnap]) => {
+      const raw = mapSnap.value.map;
+      return new Map(raw);
+    },
+    {
+      name: "strategy-model",
+      equals: (a, b) => {
+        const am = a;
+        const bm = b;
+        if (am.size !== bm.size) return false;
+        for (const [k, v] of am) {
+          const bv = bm.get(k);
+          if (!bv || v.attempts !== bv.attempts || v.successes !== bv.successes) return false;
+        }
+        return true;
+      }
+    }
+  );
+  function record(rootCause, intervention, success) {
+    const key = strategyKey(rootCause, intervention);
+    const existing = _map.get(key);
+    const attempts = (existing?.attempts ?? 0) + 1;
+    const successes = (existing?.successes ?? 0) + (success ? 1 : 0);
+    _map.set(key, {
+      rootCause,
+      intervention,
+      attempts,
+      successes,
+      successRate: successes / attempts
+    });
+  }
+  function lookup(rootCause, intervention) {
+    return _map.get(strategyKey(rootCause, intervention));
+  }
+  const _unsub = snapshot.subscribe(() => {
+  });
+  return { node: snapshot, record, lookup };
+}
+function priorityScore(item, strategy, lastInteractionNs, urgency, signals) {
+  const severityWeights = { ...DEFAULT_SEVERITY_WEIGHTS, ...signals?.severityWeights };
+  const decayRate = signals?.decayRate ?? DEFAULT_DECAY_RATE2;
+  const effectivenessThreshold = signals?.effectivenessThreshold ?? 0.7;
+  const effectivenessBoost = signals?.effectivenessBoost ?? 15;
+  const deps = [item, strategy, lastInteractionNs];
+  if (urgency) deps.push(urgency);
+  return derived(
+    deps,
+    (values) => {
+      const itm = values[0];
+      const strat = values[1];
+      const lastNs = values[2];
+      const urg = urgency ? values[3] : 0;
+      const baseWeight = severityWeights[itm.severity ?? "medium"];
+      const ageSeconds = (monotonicNs() - lastNs) / 1e9;
+      let score = decay(baseWeight, ageSeconds, decayRate, 0);
+      const key = strategyKey(itm.rootCause, itm.intervention);
+      const entry = strat.get(key);
+      if (entry && entry.successRate >= effectivenessThreshold) {
+        score += effectivenessBoost;
+      }
+      score += urg * 20;
+      return score;
+    },
+    { name: "priority-score" }
+  );
+}
+
+// src/patterns/harness/loop.ts
+var DEFAULT_TRIAGE_PROMPT = `You are a triage classifier for a reactive collaboration harness.
+
+Given an intake item, classify it and output JSON:
+{
+  "rootCause": "composition" | "missing-fn" | "bad-docs" | "schema-gap" | "regression" | "unknown",
+  "intervention": "template" | "catalog-fn" | "docs" | "wrapper" | "schema-change" | "investigate",
+  "route": "auto-fix" | "needs-decision" | "investigation" | "backlog",
+  "priority": <number 0-100>,
+  "triageReasoning": "<one sentence>"
+}
+
+Strategy model (past effectiveness):
+{{strategy}}
+
+Intake item:
+{{item}}`;
+var DEFAULT_EXECUTE_PROMPT = `You are an implementation agent.
+
+Given a triaged issue with root cause and intervention type, produce a fix.
+
+Issue:
+{{item}}
+
+Output JSON:
+{
+  "outcome": "success" | "failure" | "partial",
+  "detail": "<description of what was done or what failed>"
+}`;
+var DEFAULT_VERIFY_PROMPT = `You are a QA reviewer.
+
+Given an execution result, verify whether the fix is correct.
+
+Execution:
+{{execution}}
+
+Original issue:
+{{item}}
+
+Output JSON:
+{
+  "verified": true/false,
+  "findings": ["<finding1>", ...],
+  "errorClass": "self-correctable" | "structural"  // only if verified=false
+}`;
+var QUEUE_NAMES = [
+  "auto-fix",
+  "needs-decision",
+  "investigation",
+  "backlog"
+];
+var HarnessGraph = class extends Graph {
+  /** Intake topic — publish items here to enter the loop. */
+  intake;
+  /** Per-route queue topics. */
+  queues;
+  /** Per-route gate controllers (only for gated queues). */
+  gates;
+  /** Strategy model bundle — record outcomes, lookup effectiveness. */
+  strategy;
+  /** Verify results topic — subscribe to see verification outcomes. */
+  verifyResults;
+  constructor(name, intake, queues, gates, strategy, verifyResults) {
+    super(name);
+    this.intake = intake;
+    this.queues = queues;
+    this.gates = gates;
+    this.strategy = strategy;
+    this.verifyResults = verifyResults;
+  }
+};
+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 intake = new TopicGraph("intake", { retainedLimit });
+  const strategy = strategyModel();
+  const triageNode = promptNode(
+    adapter,
+    [intake.latest, strategy.node],
+    opts.triagePrompt ?? ((item, strat) => {
+      return DEFAULT_TRIAGE_PROMPT.replace("{{strategy}}", JSON.stringify(strat)).replace(
+        "{{item}}",
+        JSON.stringify(item)
+      );
+    }),
+    {
+      name: "triage",
+      format: "json",
+      retries: 1
+    }
+  );
+  const queueTopics = /* @__PURE__ */ new Map();
+  for (const route of QUEUE_NAMES) {
+    queueTopics.set(route, new TopicGraph(`queue/${route}`, { retainedLimit }));
+  }
+  const _router = effect([triageNode], ([triaged]) => {
+    const item = triaged;
+    if (!item || !item.route) return;
+    const topic2 = queueTopics.get(item.route);
+    if (topic2) topic2.publish(item);
+  });
+  const gateGraph = new Graph("gates");
+  const gateControllers = /* @__PURE__ */ new Map();
+  for (const route of QUEUE_NAMES) {
+    const config = queueConfigs.get(route);
+    const topic2 = queueTopics.get(route);
+    if (config.gated) {
+      gateGraph.add(`${route}/source`, topic2.latest);
+      const ctrl = gate(gateGraph, `${route}/gate`, `${route}/source`, {
+        maxPending: config.maxPending,
+        startOpen: config.startOpen
+      });
+      gateControllers.set(route, ctrl);
+    }
+  }
+  const retryTopic = new TopicGraph("retry-input", { retainedLimit });
+  const queueOutputs = [];
+  for (const route of QUEUE_NAMES) {
+    const config = queueConfigs.get(route);
+    if (config.gated && gateControllers.has(route)) {
+      queueOutputs.push(gateControllers.get(route).node);
+    } else {
+      queueOutputs.push(queueTopics.get(route).latest);
+    }
+  }
+  queueOutputs.push(retryTopic.latest);
+  const executeInput = merge(...queueOutputs);
+  const executeNode = promptNode(
+    adapter,
+    [executeInput],
+    opts.executePrompt ?? ((item) => {
+      return DEFAULT_EXECUTE_PROMPT.replace("{{item}}", JSON.stringify(item));
+    }),
+    {
+      name: "execute",
+      format: "json",
+      retries: 1
+    }
+  );
+  const verifyResults = new TopicGraph("verify-results", { retainedLimit });
+  const verifyNode = promptNode(
+    adapter,
+    [executeNode, executeInput],
+    opts.verifyPrompt ?? ((execution, item) => {
+      return DEFAULT_VERIFY_PROMPT.replace("{{execution}}", JSON.stringify(execution)).replace(
+        "{{item}}",
+        JSON.stringify(item)
+      );
+    }),
+    {
+      name: "verify",
+      format: "json",
+      retries: 1
+    }
+  );
+  const maxReingestions = opts.maxReingestions ?? 1;
+  let reingestionCount = 0;
+  const _fastRetry = effect([verifyNode], ([result]) => {
+    const vr = result;
+    if (!vr) return;
+    if (vr.verified) {
+      strategy.record(vr.item.rootCause, vr.item.intervention, true);
+      verifyResults.publish(vr);
+      return;
+    }
+    const errClass = vr.errorClass ?? errorClassifier({
+      item: vr.item,
+      outcome: "failure",
+      detail: vr.findings.join("; "),
+      retryCount: 0
+    });
+    const exec = vr.execution;
+    const retryCount = exec?.retryCount ?? 0;
+    if (errClass === "self-correctable" && retryCount < maxRetries) {
+      const retryItem = {
+        ...vr.item,
+        summary: `[RETRY ${retryCount + 1}/${maxRetries}] ${vr.item.summary} \u2014 Previous attempt failed: ${vr.findings.join("; ")}`
+      };
+      retryTopic.publish(retryItem);
+    } else {
+      strategy.record(vr.item.rootCause, vr.item.intervention, false);
+      verifyResults.publish(vr);
+      if (reingestionCount < maxReingestions) {
+        reingestionCount++;
+        intake.publish({
+          source: "eval",
+          summary: `Verification failed for: ${vr.item.summary}`,
+          evidence: vr.findings.join("\n"),
+          affectsAreas: vr.item.affectsAreas,
+          affectsEvalTasks: vr.item.affectsEvalTasks,
+          severity: "high",
+          relatedTo: [vr.item.summary]
+        });
+      }
+    }
+  });
+  const harness = new HarnessGraph(
+    name,
+    intake,
+    queueTopics,
+    gateControllers,
+    strategy,
+    verifyResults
+  );
+  harness.mount("intake", intake);
+  for (const [route, topic2] of queueTopics) {
+    harness.mount(`queue/${route}`, topic2);
+  }
+  harness.mount("gates", gateGraph);
+  harness.mount("retry-input", retryTopic);
+  harness.mount("verify-results", verifyResults);
+  return harness;
+}
+
 // src/patterns/reactive-layout/index.ts
 var reactive_layout_exports = {};
 __export(reactive_layout_exports, {
@@ -18687,8 +19061,8 @@ function reactiveBlockLayout(opts) {
       const elapsed = monotonicNs() - t0;
       const meta = measuredBlocksNode.meta;
       if (meta) {
-        emitWithBatch((msgs) => meta["block-count"]?.down(msgs), [[DATA, result.length]], 3);
-        emitWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, elapsed]], 3);
+        downWithBatch((msgs) => meta["block-count"]?.down(msgs), [[DATA, result.length]], 3);
+        downWithBatch((msgs) => meta["layout-time-ns"]?.down(msgs), [[DATA, elapsed]], 3);
       }
       return result;
     },
@@ -18839,10 +19213,10 @@ var version = "0.0.0";
   distill,
   distinctUntilChanged,
   domainTemplates,
+  downWithBatch,
   dynamicNode,
   effect,
   elementAt,
-  emitWithBatch,
   empty,
   escapeRegexChar,
   exhaustMap,
@@ -18890,6 +19264,7 @@ var version = "0.0.0";
   globToRegExp,
   graph,
   graphspec,
+  harness,
   interval,
   isBatching,
   isKnownMessageType,