@graphrefly/graphrefly 0.13.0 → 0.15.0

package/dist/graph/index.js

@@ -4,14 +4,14 @@ import {
   createDagCborZstdCodec,
   negotiateCodec,
   replayWAL
-} from "../chunk-QOGWU5K7.js";
+} from "../chunk-ZHTHUX5D.js";
 import {
   GRAPH_META_SEGMENT,
   Graph,
   reachable
-} from "../chunk-UQI4GAHD.js";
-import "../chunk-PFMXKG4Y.js";
-import "../chunk-6B2ZCCNN.js";
+} from "../chunk-CRACCCJY.js";
+import "../chunk-XQ4UMAU7.js";
+import "../chunk-H243FWYP.js";
 export {
   GRAPH_META_SEGMENT,
   Graph,

package/dist/index.cjs

@@ -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) {
@@ -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);
@@ -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,
@@ -13522,7 +13523,9 @@ function promptNode(adapter, deps, prompt, opts) {
   const messagesNode = derived(
     deps,
     (values) => {
+      if (values.some((v) => v == null)) return [];
       const text = typeof prompt === "string" ? prompt : prompt(...values);
+      if (!text) return [];
       const msgs = [];
       if (opts?.systemPrompt) msgs.push({ role: "system", content: opts.systemPrompt });
       msgs.push({ role: "user", content: text });
@@ -17383,6 +17386,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 +18332,362 @@ 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
+function baseSummary(summary) {
+  return summary.replace(/^\[RETRY \d+\/\d+\]\s*/, "");
+}
+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;
+  /** Per-item fast-retry counts (keyed by base summary). */
+  retryTracker;
+  /** Per-item reingestion counts (keyed by base summary). */
+  reingestionTracker;
+  constructor(name, intake, queues, gates, strategy, verifyResults, retryTracker, reingestionTracker) {
+    super(name);
+    this.intake = intake;
+    this.queues = queues;
+    this.gates = gates;
+    this.strategy = strategy;
+    this.verifyResults = verifyResults;
+    this.retryTracker = retryTracker;
+    this.reingestionTracker = reingestionTracker;
+  }
+};
+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 triageInput = withLatestFrom(
+    intake.latest,
+    strategy.node
+  );
+  const triageNode = promptNode(
+    adapter,
+    [triageInput],
+    opts.triagePrompt ?? ((pair) => {
+      const [item, strat] = pair;
+      if (!item) return "";
+      return DEFAULT_TRIAGE_PROMPT.replace(
+        "{{strategy}}",
+        JSON.stringify(Array.from(strat.entries()))
+      ).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);
+  });
+  router.subscribe(() => {
+  });
+  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) => 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) => DEFAULT_VERIFY_PROMPT.replace("{{execution}}", JSON.stringify(execution)).replace(
+      "{{item}}",
+      JSON.stringify(item)
+    )),
+    {
+      name: "verify",
+      format: "json",
+      retries: 1
+    }
+  );
+  const verifyWithExec = withLatestFrom(verifyNode, executeNode);
+  const verifyContext = withLatestFrom(
+    verifyWithExec,
+    executeInput
+  );
+  const maxReingestions = opts.maxReingestions ?? 1;
+  const retryTracker = /* @__PURE__ */ new Map();
+  const reingestionTracker = /* @__PURE__ */ new Map();
+  const fastRetry = effect([verifyContext], ([ctx]) => {
+    const [[vo, execRaw], item] = ctx;
+    if (!vo || !item) return;
+    const exec = {
+      item,
+      outcome: execRaw?.outcome ?? "failure",
+      detail: execRaw?.detail ?? "unknown"
+    };
+    const vr = {
+      item,
+      execution: exec,
+      verified: vo.verified,
+      findings: vo.findings ?? [],
+      errorClass: vo.errorClass
+    };
+    if (vr.verified) {
+      strategy.record(item.rootCause, item.intervention, true);
+      verifyResults.publish(vr);
+      return;
+    }
+    const errClass = vr.errorClass ?? errorClassifier({
+      item,
+      outcome: "failure",
+      detail: vr.findings.join("; ")
+    });
+    const key = baseSummary(item.summary);
+    const retryCount = retryTracker.get(key) ?? 0;
+    if (errClass === "self-correctable" && retryCount < maxRetries) {
+      retryTracker.set(key, retryCount + 1);
+      const retryItem = {
+        ...item,
+        summary: `[RETRY ${retryCount + 1}/${maxRetries}] ${baseSummary(item.summary)} \u2014 Previous attempt failed: ${vr.findings.join("; ")}`
+      };
+      retryTopic.publish(retryItem);
+    } else {
+      strategy.record(item.rootCause, item.intervention, false);
+      verifyResults.publish(vr);
+      const itemReingestions = reingestionTracker.get(key) ?? 0;
+      if (itemReingestions < maxReingestions) {
+        reingestionTracker.set(key, itemReingestions + 1);
+        intake.publish({
+          source: "eval",
+          summary: `Verification failed for: ${baseSummary(item.summary)}`,
+          evidence: vr.findings.join("\n"),
+          affectsAreas: item.affectsAreas,
+          affectsEvalTasks: item.affectsEvalTasks,
+          severity: "high",
+          relatedTo: [baseSummary(item.summary)]
+        });
+      }
+    }
+  });
+  fastRetry.subscribe(() => {
+  });
+  const harness = new HarnessGraph(
+    name,
+    intake,
+    queueTopics,
+    gateControllers,
+    strategy,
+    verifyResults,
+    retryTracker,
+    reingestionTracker
+  );
+  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, {
@@ -18890,6 +19302,7 @@ var version = "0.0.0";
   globToRegExp,
   graph,
   graphspec,
+  harness,
   interval,
   isBatching,
   isKnownMessageType,