@graphrefly/graphrefly 0.13.0 → 0.15.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { N as Node, A as Actor, a as NodeOptions, b as NodeActions, c as NodeFn } from './meta-CrZUQAJ6.js';
 export { C as CLEANUP_RESULT, d as COMPLETE, e as CleanupResult, D as DATA, f as DEFAULT_ACTOR, g as DIRTY, h as DescribeDetail, i as DescribeField, j as DescribeNodeOutput, E as ERROR, G as GuardAction, k as GuardDenied, l as GuardDeniedDetails, H as HashFn, I as INVALIDATE, M as Message, m as Messages, n as NodeDescribeKind, o as NodeGuard, p as NodeSink, q as NodeStatus, r as NodeTransportOptions, s as NodeVersionInfo, O as OnMessageHandler, P as PAUSE, t as PolicyAllow, u as PolicyDeny, v as PolicyRuleData, R as RESOLVED, w as RESUME, S as SubscribeHints, T as TEARDOWN, V as V0, x as V1, y as VersioningLevel, z as VersioningOptions, B as accessHintForGuard, F as advanceVersion, J as cleanupResult, K as createVersioning, L as defaultHash, Q as describeNode, U as isKnownMessageType, W as isPhase2Message, X as isTerminalMessage, Y as isV1, Z as knownMessageTypes, _ as messageTier, $ as metaSnapshot, a0 as node, a1 as normalizeActor, a2 as policy, a3 as policyFromRules, a4 as propagatesToMeta, a5 as resolveDescribeFields } from './meta-CrZUQAJ6.js';
-import { i as index$a, c as cqrs } from './index-DSp5R3Xq.js';
+import { i as index$b, c as cqrs } from './index-DSp5R3Xq.js';
 import { Ref, WatchSource } from 'vue';
 import { G as Graph, a as GraphOptions, b as GraphAutoCheckpointHandle, A as AutoCheckpointAdapter, c as GraphAutoCheckpointOptions } from './graph-BXIK5Dq5.js';
 export { D as DescribeFilter, d as GRAPH_META_SEGMENT, e as GraphActorOptions, f as GraphCheckpointRecord, g as GraphDescribeOptions, h as GraphDescribeOutput, i as GraphDiagramDirection, j as GraphDiagramOptions, k as GraphDiffChange, l as GraphDiffResult, m as GraphDumpOptions, n as GraphFactoryContext, o as GraphNodeFactory, p as GraphObserveAll, q as GraphObserveOne, r as GraphPersistSnapshot, s as GraphSpyHandle, t as GraphSpyOptions, u as GraphSpyTheme, v as GraphSpyThemeName, O as ObserveDetail, w as ObserveEvent, x as ObserveOptions, y as ObserveResult, R as ReachableDirection, z as ReachableOptions, T as TraceEntry, B as reachable } from './graph-BXIK5Dq5.js';
@@ -10,7 +10,7 @@ export { A as AdapterHandlers, b as AsyncSourceOpts, B as BackoffPreset, c as Ba
 export { D as DeltaCheckpoint, E as EvictedSubgraphInfo, a as EvictionPolicy, G as GraphCodec, J as JsonCodec, L as LazyGraphCodec, W as WALEntry, c as createDagCborCodec, b as createDagCborZstdCodec, i as graph, n as negotiateCodec, r as replayWAL } from './index-BkToATim.js';
 import { R as ReactiveLogSnapshot } from './reactive-log-DV--7BWd.js';
 export { a as ReactiveLogBundle, b as ReactiveLogOptions, l as logSlice, o as observeGraph$, c as observeNode$, r as reactiveLog, t as toMessages$, d as toObservable } from './reactive-log-DV--7BWd.js';
-import { M as MeasurementAdapter, i as index$b } from './index-fYObbpUw.js';
+import { M as MeasurementAdapter, i as index$c } from './index-fYObbpUw.js';
 import '@nestjs/common';
 import '@nestjs/core';
 import 'rxjs';
@@ -86,15 +86,15 @@ declare function atom$1<T>(initial: T, options?: AtomOptions): WritableAtom<T>;
 declare function atom$1<T>(read: ReadFn<T>, options?: AtomOptions): ReadableAtom<T>;
 declare function atom$1<T>(read: ReadFn<T>, write: WriteFn<T>, options?: AtomOptions): WritableAtom<T>;
 
-type index$9_AtomOptions = AtomOptions;
-type index$9_GetFn = GetFn;
-type index$9_ReadFn<T> = ReadFn<T>;
-type index$9_ReadableAtom<T> = ReadableAtom<T>;
-type index$9_SetFn = SetFn;
-type index$9_WritableAtom<T> = WritableAtom<T>;
-type index$9_WriteFn<T> = WriteFn<T>;
-declare namespace index$9 {
-  export { type index$9_AtomOptions as AtomOptions, type index$9_GetFn as GetFn, type index$9_ReadFn as ReadFn, type index$9_ReadableAtom as ReadableAtom, type index$9_SetFn as SetFn, type index$9_WritableAtom as WritableAtom, type index$9_WriteFn as WriteFn, atom$1 as atom };
+type index$a_AtomOptions = AtomOptions;
+type index$a_GetFn = GetFn;
+type index$a_ReadFn<T> = ReadFn<T>;
+type index$a_ReadableAtom<T> = ReadableAtom<T>;
+type index$a_SetFn = SetFn;
+type index$a_WritableAtom<T> = WritableAtom<T>;
+type index$a_WriteFn<T> = WriteFn<T>;
+declare namespace index$a {
+  export { type index$a_AtomOptions as AtomOptions, type index$a_GetFn as GetFn, type index$a_ReadFn as ReadFn, type index$a_ReadableAtom as ReadableAtom, type index$a_SetFn as SetFn, type index$a_WritableAtom as WritableAtom, type index$a_WriteFn as WriteFn, atom$1 as atom };
 }
 
 /**
@@ -206,19 +206,19 @@ declare function onMount(store: NanoAtom<any> | NanoComputed<any>, cb: () => (()
  */
 declare function action<Args extends any[], Return>(_store: NanoAtom<any> | NanoComputed<any>, _name: string, fn: (...args: Args) => Return): (...args: Args) => Return;
 
-type index$8_NanoAtom<T> = NanoAtom<T>;
-type index$8_NanoComputed<T> = NanoComputed<T>;
-type index$8_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
-declare const index$8_action: typeof action;
-declare const index$8_atom: typeof atom;
-declare const index$8_computed: typeof computed;
-declare const index$8_getValue: typeof getValue;
-declare const index$8_map: typeof map;
-declare const index$8_onMount: typeof onMount;
-declare const index$8_onStart: typeof onStart;
-declare const index$8_onStop: typeof onStop;
-declare namespace index$8 {
-  export { type index$8_NanoAtom as NanoAtom, type index$8_NanoComputed as NanoComputed, type index$8_NanoMap as NanoMap, index$8_action as action, index$8_atom as atom, index$8_computed as computed, index$8_getValue as getValue, index$8_map as map, index$8_onMount as onMount, index$8_onStart as onStart, index$8_onStop as onStop };
+type index$9_NanoAtom<T> = NanoAtom<T>;
+type index$9_NanoComputed<T> = NanoComputed<T>;
+type index$9_NanoMap<T extends Record<string, unknown>> = NanoMap<T>;
+declare const index$9_action: typeof action;
+declare const index$9_atom: typeof atom;
+declare const index$9_computed: typeof computed;
+declare const index$9_getValue: typeof getValue;
+declare const index$9_map: typeof map;
+declare const index$9_onMount: typeof onMount;
+declare const index$9_onStart: typeof onStart;
+declare const index$9_onStop: typeof onStop;
+declare namespace index$9 {
+  export { type index$9_NanoAtom as NanoAtom, type index$9_NanoComputed as NanoComputed, type index$9_NanoMap as NanoMap, index$9_action as action, index$9_atom as atom, index$9_computed as computed, index$9_getValue as getValue, index$9_map as map, index$9_onMount as onMount, index$9_onStart as onStart, index$9_onStop as onStop };
 }
 
 /**
@@ -254,7 +254,7 @@ type NodeFactory$3<K, R extends Record<string, any>> = (key: K) => {
  */
 declare function useSubscribeRecord$3<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$3<K, R>): Record<K, R>;
 
-declare namespace index$7 {
+declare namespace index$8 {
   export { type NodeFactory$3 as NodeFactory, useStore$3 as useStore, useSubscribe$3 as useSubscribe, useSubscribeRecord$3 as useSubscribeRecord };
 }
 
@@ -343,15 +343,15 @@ declare const Signal: {
     }) => (() => void);
 };
 
-type index$6_AnySignal<T> = AnySignal<T>;
-declare const index$6_Signal: typeof Signal;
-type index$6_SignalComputed<T> = SignalComputed<T>;
-declare const index$6_SignalComputed: typeof SignalComputed;
-type index$6_SignalOptions = SignalOptions;
-type index$6_SignalState<T> = SignalState<T>;
-declare const index$6_SignalState: typeof SignalState;
-declare namespace index$6 {
-  export { type index$6_AnySignal as AnySignal, index$6_Signal as Signal, index$6_SignalComputed as SignalComputed, type index$6_SignalOptions as SignalOptions, index$6_SignalState as SignalState };
+type index$7_AnySignal<T> = AnySignal<T>;
+declare const index$7_Signal: typeof Signal;
+type index$7_SignalComputed<T> = SignalComputed<T>;
+declare const index$7_SignalComputed: typeof SignalComputed;
+type index$7_SignalOptions = SignalOptions;
+type index$7_SignalState<T> = SignalState<T>;
+declare const index$7_SignalState: typeof SignalState;
+declare namespace index$7 {
+  export { type index$7_AnySignal as AnySignal, index$7_Signal as Signal, index$7_SignalComputed as SignalComputed, type index$7_SignalOptions as SignalOptions, index$7_SignalState as SignalState };
 }
 
 /** Solid accessor function — returns current value when called. */
@@ -378,9 +378,9 @@ type NodeFactory$2<K, R extends Record<string, any>> = (key: K) => {
  */
 declare function useSubscribeRecord$2<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$2<K, R>): Accessor<Record<K, R>>;
 
-type index$5_Accessor<T> = Accessor<T>;
-declare namespace index$5 {
-  export { type index$5_Accessor as Accessor, type NodeFactory$2 as NodeFactory, useStore$2 as useStore, useSubscribe$2 as useSubscribe, useSubscribeRecord$2 as useSubscribeRecord };
+type index$6_Accessor<T> = Accessor<T>;
+declare namespace index$6 {
+  export { type index$6_Accessor as Accessor, type NodeFactory$2 as NodeFactory, useStore$2 as useStore, useSubscribe$2 as useSubscribe, useSubscribeRecord$2 as useSubscribeRecord };
 }
 
 /** Svelte store contract — implements the minimal `subscribe` method. */
@@ -415,10 +415,10 @@ type NodeFactory$1<K, R extends Record<string, any>> = (key: K) => {
  */
 declare function useSubscribeRecord$1<K extends string, R extends Record<string, any>>(keysNode: Node<K[]>, factory: NodeFactory$1<K, R>): SvelteReadable<Record<K, R>>;
 
-type index$4_SvelteReadable<T> = SvelteReadable<T>;
-type index$4_SvelteWritable<T> = SvelteWritable<T>;
-declare namespace index$4 {
-  export { type NodeFactory$1 as NodeFactory, type index$4_SvelteReadable as SvelteReadable, type index$4_SvelteWritable as SvelteWritable, useStore$1 as useStore, useSubscribe$1 as useSubscribe, useSubscribeRecord$1 as useSubscribeRecord };
+type index$5_SvelteReadable<T> = SvelteReadable<T>;
+type index$5_SvelteWritable<T> = SvelteWritable<T>;
+declare namespace index$5 {
+  export { type NodeFactory$1 as NodeFactory, type index$5_SvelteReadable as SvelteReadable, type index$5_SvelteWritable as SvelteWritable, useStore$1 as useStore, useSubscribe$1 as useSubscribe, useSubscribeRecord$1 as useSubscribeRecord };
 }
 
 /**
@@ -443,12 +443,12 @@ type NodeFactory<K, R extends Record<string, any>> = (key: K) => {
  */
 declare function useSubscribeRecord<K extends string, R extends Record<string, any>>(keys: WatchSource<K[] | undefined>, factory: NodeFactory<K, R>): Readonly<Ref<Record<K, R>>>;
 
-type index$3_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
-declare const index$3_useStore: typeof useStore;
-declare const index$3_useSubscribe: typeof useSubscribe;
-declare const index$3_useSubscribeRecord: typeof useSubscribeRecord;
-declare namespace index$3 {
-  export { type index$3_NodeFactory as NodeFactory, index$3_useStore as useStore, index$3_useSubscribe as useSubscribe, index$3_useSubscribeRecord as useSubscribeRecord };
+type index$4_NodeFactory<K, R extends Record<string, any>> = NodeFactory<K, R>;
+declare const index$4_useStore: typeof useStore;
+declare const index$4_useSubscribe: typeof useSubscribe;
+declare const index$4_useSubscribeRecord: typeof useSubscribeRecord;
+declare namespace index$4 {
+  export { type index$4_NodeFactory as NodeFactory, index$4_useStore as useStore, index$4_useSubscribe as useSubscribe, index$4_useSubscribeRecord as useSubscribeRecord };
 }
 
 /** Zustand-compatible Store API. */
@@ -478,11 +478,11 @@ type StateCreator<T> = (set: StoreApi<T>["setState"], get: StoreApi<T>["getState
  */
 declare function create<T extends object>(initializer: StateCreator<T>): Graph & StoreApi<T>;
 
-type index$2_StateCreator<T> = StateCreator<T>;
-type index$2_StoreApi<T> = StoreApi<T>;
-declare const index$2_create: typeof create;
-declare namespace index$2 {
-  export { type index$2_StateCreator as StateCreator, type index$2_StoreApi as StoreApi, index$2_create as create };
+type index$3_StateCreator<T> = StateCreator<T>;
+type index$3_StoreApi<T> = StoreApi<T>;
+declare const index$3_create: typeof create;
+declare namespace index$3 {
+  export { type index$3_StateCreator as StateCreator, type index$3_StoreApi as StoreApi, index$3_create as create };
 }
 
 /**
@@ -495,8 +495,8 @@ declare namespace index$2 {
  * - `@graphrefly/graphrefly-ts/compat/solid` -> `solid-js`
  */
 
-declare namespace index$1 {
-  export { index$9 as jotai, index$8 as nanostores, index$a as nestjs, index$7 as react, index$6 as signals, index$5 as solid, index$4 as svelte, index$3 as vue, index$2 as zustand };
+declare namespace index$2 {
+  export { index$a as jotai, index$9 as nanostores, index$b as nestjs, index$8 as react, index$7 as signals, index$6 as solid, index$5 as svelte, index$4 as vue, index$3 as zustand };
 }
 
 /**
@@ -2052,6 +2052,184 @@ declare namespace messaging {
   export { type messaging_JobEnvelope as JobEnvelope, messaging_JobFlowGraph as JobFlowGraph, type messaging_JobFlowOptions as JobFlowOptions, messaging_JobQueueGraph as JobQueueGraph, type messaging_JobQueueOptions as JobQueueOptions, type messaging_JobState as JobState, messaging_SubscriptionGraph as SubscriptionGraph, type messaging_SubscriptionOptions as SubscriptionOptions, messaging_TopicBridgeGraph as TopicBridgeGraph, type messaging_TopicBridgeOptions as TopicBridgeOptions, messaging_TopicGraph as TopicGraph, type messaging_TopicOptions as TopicOptions, messaging_jobFlow as jobFlow, messaging_jobQueue as jobQueue, messaging_subscription as subscription, messaging_topic as topic, messaging_topicBridge as topicBridge };
 }
 
+/**
+ * Harness wiring types (roadmap §9.0).
+ *
+ * Shared types for the reactive collaboration loop: intake, triage, queue,
+ * gate, execute, verify, reflect. These types are intentionally domain-agnostic
+ * — the harness loop is not specific to eval workflows.
+ *
+ * @module
+ */
+/** Sources that can produce intake items. */
+type IntakeSource = "eval" | "test" | "human" | "code-change" | "hypothesis" | "parity";
+/** Severity levels for intake items. */
+type Severity = "critical" | "high" | "medium" | "low";
+/** Root cause categories for triage classification. */
+type RootCause = "composition" | "missing-fn" | "bad-docs" | "schema-gap" | "regression" | "unknown";
+/** Intervention types that address root causes. */
+type Intervention = "template" | "catalog-fn" | "docs" | "wrapper" | "schema-change" | "investigate";
+/** Routing destinations after triage. */
+type QueueRoute = "auto-fix" | "needs-decision" | "investigation" | "backlog";
+/**
+ * An item entering the harness loop via the INTAKE stage.
+ *
+ * All intake sources produce this uniform shape — the intake topic
+ * doesn't care where items came from.
+ */
+interface IntakeItem {
+    source: IntakeSource;
+    summary: string;
+    evidence: string;
+    affectsAreas: string[];
+    affectsEvalTasks?: string[];
+    severity?: Severity;
+    relatedTo?: string[];
+}
+/** Output of the TRIAGE stage — enriched intake item with classification. */
+interface TriagedItem extends IntakeItem {
+    rootCause: RootCause;
+    intervention: Intervention;
+    route: QueueRoute;
+    priority: number;
+    triageReasoning?: string;
+}
+/** Effectiveness record for a rootCause→intervention pair. */
+interface StrategyEntry {
+    rootCause: RootCause;
+    intervention: Intervention;
+    attempts: number;
+    successes: number;
+    successRate: number;
+}
+/** Key format: `${rootCause}→${intervention}`. */
+type StrategyKey = `${RootCause}→${Intervention}`;
+declare function strategyKey(rootCause: RootCause, intervention: Intervention): StrategyKey;
+/** LLM output shape from the EXECUTE stage (partial — lacks `item`). */
+type ExecuteOutput = {
+    outcome: "success" | "failure" | "partial";
+    detail: string;
+};
+/** Full execution result assembled downstream (LLM output + context). */
+interface ExecutionResult {
+    item: TriagedItem;
+    outcome: "success" | "failure" | "partial";
+    detail: string;
+}
+/** Whether an error is self-correctable (fast-retry) or structural (full loop). */
+type ErrorClass = "self-correctable" | "structural";
+/** Classifier for fast-retry path. */
+type ErrorClassifier = (result: ExecutionResult) => ErrorClass;
+/** Default error classifier: parse/config errors are self-correctable. */
+declare function defaultErrorClassifier(result: ExecutionResult): ErrorClass;
+/** Result of the VERIFY stage. */
+interface VerifyResult {
+    item: TriagedItem;
+    execution: ExecutionResult;
+    verified: boolean;
+    findings: string[];
+    errorClass?: ErrorClass;
+}
+/** Configurable signals for priority scoring. */
+interface PrioritySignals {
+    /** Per-severity base weight (default: critical=100, high=70, medium=40, low=10). */
+    severityWeights?: Partial<Record<Severity, number>>;
+    /** Decay rate per second for attention decay (default ~1.15e-6 ≈ 7-day half-life). */
+    decayRate?: number;
+    /** Strategy model effectiveness boost threshold (default 0.7). */
+    effectivenessThreshold?: number;
+    /** Strategy model effectiveness boost amount (default 15). */
+    effectivenessBoost?: number;
+}
+/** Default severity weights. */
+declare const DEFAULT_SEVERITY_WEIGHTS: Record<Severity, number>;
+/** Default decay rate: ~7-day half-life. */
+declare const DEFAULT_DECAY_RATE: number;
+/** Per-queue configuration in the harness loop. */
+interface QueueConfig {
+    /** Whether this queue is gated (requires human approval). */
+    gated: boolean;
+    /** Maximum pending items in the gate (default Infinity). */
+    maxPending?: number;
+    /** Start the gate in open (auto-approve) mode? */
+    startOpen?: boolean;
+}
+/** Default queue configurations. */
+declare const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig>;
+/** Options for {@link harnessLoop}. */
+interface HarnessLoopOptions {
+    /** LLM adapter for promptNode-based stages (triage, execute, verify, reflect). */
+    adapter: unknown;
+    /** Custom triage prompt (receives IntakeItem + strategy model as context). */
+    triagePrompt?: string | ((...args: unknown[]) => string);
+    /** Custom execute prompt. */
+    executePrompt?: string | ((...args: unknown[]) => string);
+    /** Custom verify prompt. */
+    verifyPrompt?: string | ((...args: unknown[]) => string);
+    /** Per-queue configuration overrides. */
+    queues?: Partial<Record<QueueRoute, QueueConfig>>;
+    /** Priority scoring signals. */
+    priority?: PrioritySignals;
+    /** Error classifier for fast-retry path. */
+    errorClassifier?: ErrorClassifier;
+    /** Max fast-retries per item before routing to full intake (default 2). */
+    maxRetries?: number;
+    /** Max re-ingestions from verify→intake before giving up (default 1). */
+    maxReingestions?: number;
+    /** Retained limit for topic logs (default 1000). */
+    retainedLimit?: number;
+}
+
+/**
+ * Eval→intake bridge (roadmap §9.0).
+ *
+ * Effect node that parses eval results into IntakeItem[] and publishes
+ * to an intake TopicGraph. Produces per-criterion findings, not per-task scores.
+ *
+ * @module
+ */
+
+/**
+ * Minimal eval result shape accepted by the bridge.
+ *
+ * TS eval runner uses `EvalRun` from `evals/lib/types.ts` which is a superset
+ * of this shape. The bridge only reads what it needs.
+ */
+interface EvalResult {
+    run_id: string;
+    model: string;
+    tasks: EvalTaskResult[];
+}
+interface EvalTaskResult {
+    task_id: string;
+    valid: boolean;
+    judge_scores?: EvalJudgeScore[];
+}
+interface EvalJudgeScore {
+    claim: string;
+    pass: boolean;
+    reasoning: string;
+}
+interface EvalIntakeBridgeOptions {
+    /** Name for the effect node (default "eval-intake-bridge"). */
+    name?: string;
+    /** Minimum severity for eval-sourced items (default "medium"). */
+    defaultSeverity?: Severity;
+}
+/**
+ * Create an effect node that watches an eval results source and publishes
+ * per-criterion findings to an intake topic.
+ *
+ * Each failing judge criterion produces a separate IntakeItem — not one
+ * item per task. This gives the triage stage granular findings to classify.
+ *
+ * @param evalSource - Node emitting EvalResult (or EvalResult[]).
+ * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
+ * @param opts - Optional configuration.
+ * @returns The effect node (for lifecycle management).
+ */
+declare function evalIntakeBridge(evalSource: Node<EvalResult | EvalResult[]>, intakeTopic: TopicGraph<IntakeItem>, opts?: EvalIntakeBridgeOptions): Node<unknown>;
+
 /**
  * Orchestration patterns (roadmap §4.1).
  *
@@ -2206,6 +2384,140 @@ declare namespace orchestration {
   export { type orchestration_ApprovalOptions as ApprovalOptions, type orchestration_BranchResult as BranchResult, type orchestration_GateController as GateController, type orchestration_GateOptions as GateOptions, type orchestration_LoopOptions as LoopOptions, type orchestration_OrchestrationStepOptions as OrchestrationStepOptions, type orchestration_SensorControls as SensorControls, type StepRef$1 as StepRef, type orchestration_SubPipelineBuilder as SubPipelineBuilder, type orchestration_WaitOptions as WaitOptions, orchestration_approval as approval, orchestration_branch as branch, orchestration_forEach as forEach, orchestration_gate as gate, orchestration_join as join, orchestration_loop as loop, orchestration_onFailure as onFailure, orchestration_pipeline as pipeline, orchestration_sensor as sensor, orchestration_subPipeline as subPipeline, orchestration_task as task, orchestration_valve as valve, orchestration_wait as wait };
 }
 
+/**
+ * Strategy model and priority scoring (roadmap §9.0).
+ *
+ * Pure-computation derived nodes — no LLM, no async.
+ *
+ * @module
+ */
+
+/** Snapshot shape for the strategy model node. */
+type StrategySnapshot = ReadonlyMap<StrategyKey, StrategyEntry>;
+/** Bundle returned by {@link strategyModel}. */
+interface StrategyModelBundle {
+    /** Reactive node — current strategy map. */
+    readonly node: Node<StrategySnapshot>;
+    /** Record a completed issue (success or failure). */
+    record(rootCause: RootCause, intervention: Intervention, success: boolean): void;
+    /** Look up effectiveness for a specific pair. */
+    lookup(rootCause: RootCause, intervention: Intervention): StrategyEntry | undefined;
+}
+/**
+ * Create a strategy model that tracks `rootCause × intervention → successRate`
+ * over completed issues. Pure derived computation — no LLM.
+ *
+ * The model feeds back into TRIAGE for routing hints.
+ */
+declare function strategyModel(): StrategyModelBundle;
+/**
+ * Create a priority scoring derived node for a single triaged item.
+ *
+ * Combines severity weight, attention decay, strategy model effectiveness,
+ * and an optional external urgency signal.
+ *
+ * @param item - Node holding the triaged item.
+ * @param strategy - Strategy model node.
+ * @param lastInteractionNs - Node holding the monotonic timestamp (ns) of last human interaction.
+ * @param urgency - Optional external urgency signal node (0–1 scale).
+ * @param signals - Configurable scoring parameters.
+ */
+declare function priorityScore(item: Node<TriagedItem>, strategy: Node<StrategySnapshot>, lastInteractionNs: Node<number>, urgency?: Node<number>, signals?: PrioritySignals): Node<number>;
+
+/**
+ * harnessLoop() factory (roadmap §9.0).
+ *
+ * Wires the static 7-stage topology: INTAKE → TRIAGE → QUEUE → GATE →
+ * EXECUTE → VERIFY → REFLECT. Static topology, flowing data — the Kafka
+ * insight applied to human+LLM collaboration.
+ *
+ * @module
+ */
+
+/** The graph returned by {@link harnessLoop}. */
+declare class HarnessGraph extends Graph {
+    /** Intake topic — publish items here to enter the loop. */
+    readonly intake: TopicGraph<IntakeItem>;
+    /** Per-route queue topics. */
+    readonly queues: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
+    /** Per-route gate controllers (only for gated queues). */
+    readonly gates: ReadonlyMap<QueueRoute, GateController<TriagedItem>>;
+    /** Strategy model bundle — record outcomes, lookup effectiveness. */
+    readonly strategy: StrategyModelBundle;
+    /** Verify results topic — subscribe to see verification outcomes. */
+    readonly verifyResults: TopicGraph<VerifyResult>;
+    /** Per-item fast-retry counts (keyed by base summary). */
+    readonly retryTracker: ReadonlyMap<string, number>;
+    /** Per-item reingestion counts (keyed by base summary). */
+    readonly reingestionTracker: ReadonlyMap<string, number>;
+    constructor(name: string, intake: TopicGraph<IntakeItem>, queues: Map<QueueRoute, TopicGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, verifyResults: TopicGraph<VerifyResult>, retryTracker: Map<string, number>, reingestionTracker: Map<string, number>);
+}
+/**
+ * Wire the reactive collaboration loop as a static-topology graph.
+ *
+ * The loop has 7 stages:
+ * 1. **INTAKE** — items arrive from multiple sources via `intake.publish()`
+ * 2. **TRIAGE** — promptNode classifies, routes, and prioritizes
+ * 3. **QUEUE** — 4 priority-ordered TopicGraphs (auto-fix, needs-decision, investigation, backlog)
+ * 4. **GATE** — human approval on configurable queues
+ * 5. **EXECUTE** — promptNode or human implements the fix
+ * 6. **VERIFY** — promptNode reviews + optional fast-retry
+ * 7. **REFLECT** — strategy model records outcomes
+ *
+ * @param name - Graph name.
+ * @param opts - Configuration.
+ * @returns HarnessGraph with controller accessors.
+ */
+declare function harnessLoop(name: string, opts: HarnessLoopOptions): HarnessGraph;
+
+/**
+ * Harness wiring (roadmap §9.0).
+ *
+ * Reactive collaboration loop: static-topology, flowing data.
+ * Composes orchestration (gate), AI (promptNode), reduction (scorer/stratify),
+ * and messaging (TopicGraph/bridge) into a 7-stage loop.
+ *
+ * @module
+ */
+
+declare const index$1_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
+declare const index$1_DEFAULT_QUEUE_CONFIGS: typeof DEFAULT_QUEUE_CONFIGS;
+declare const index$1_DEFAULT_SEVERITY_WEIGHTS: typeof DEFAULT_SEVERITY_WEIGHTS;
+type index$1_ErrorClass = ErrorClass;
+type index$1_ErrorClassifier = ErrorClassifier;
+type index$1_EvalIntakeBridgeOptions = EvalIntakeBridgeOptions;
+type index$1_EvalJudgeScore = EvalJudgeScore;
+type index$1_EvalResult = EvalResult;
+type index$1_EvalTaskResult = EvalTaskResult;
+type index$1_ExecuteOutput = ExecuteOutput;
+type index$1_ExecutionResult = ExecutionResult;
+type index$1_HarnessGraph = HarnessGraph;
+declare const index$1_HarnessGraph: typeof HarnessGraph;
+type index$1_HarnessLoopOptions = HarnessLoopOptions;
+type index$1_IntakeItem = IntakeItem;
+type index$1_IntakeSource = IntakeSource;
+type index$1_Intervention = Intervention;
+type index$1_PrioritySignals = PrioritySignals;
+type index$1_QueueConfig = QueueConfig;
+type index$1_QueueRoute = QueueRoute;
+type index$1_RootCause = RootCause;
+type index$1_Severity = Severity;
+type index$1_StrategyEntry = StrategyEntry;
+type index$1_StrategyKey = StrategyKey;
+type index$1_StrategyModelBundle = StrategyModelBundle;
+type index$1_StrategySnapshot = StrategySnapshot;
+type index$1_TriagedItem = TriagedItem;
+type index$1_VerifyResult = VerifyResult;
+declare const index$1_defaultErrorClassifier: typeof defaultErrorClassifier;
+declare const index$1_evalIntakeBridge: typeof evalIntakeBridge;
+declare const index$1_harnessLoop: typeof harnessLoop;
+declare const index$1_priorityScore: typeof priorityScore;
+declare const index$1_strategyKey: typeof strategyKey;
+declare const index$1_strategyModel: typeof strategyModel;
+declare namespace index$1 {
+  export { index$1_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index$1_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index$1_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, type index$1_ErrorClass as ErrorClass, type index$1_ErrorClassifier as ErrorClassifier, type index$1_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index$1_EvalJudgeScore as EvalJudgeScore, type index$1_EvalResult as EvalResult, type index$1_EvalTaskResult as EvalTaskResult, type index$1_ExecuteOutput as ExecuteOutput, type index$1_ExecutionResult as ExecutionResult, index$1_HarnessGraph as HarnessGraph, type index$1_HarnessLoopOptions as HarnessLoopOptions, type index$1_IntakeItem as IntakeItem, type index$1_IntakeSource as IntakeSource, type index$1_Intervention as Intervention, type index$1_PrioritySignals as PrioritySignals, type index$1_QueueConfig as QueueConfig, type index$1_QueueRoute as QueueRoute, type index$1_RootCause as RootCause, type index$1_Severity as Severity, type index$1_StrategyEntry as StrategyEntry, type index$1_StrategyKey as StrategyKey, type index$1_StrategyModelBundle as StrategyModelBundle, type index$1_StrategySnapshot as StrategySnapshot, type index$1_TriagedItem as TriagedItem, type index$1_VerifyResult as VerifyResult, index$1_defaultErrorClassifier as defaultErrorClassifier, index$1_evalIntakeBridge as evalIntakeBridge, index$1_harnessLoop as harnessLoop, index$1_priorityScore as priorityScore, index$1_strategyKey as strategyKey, index$1_strategyModel as strategyModel };
+}
+
 /**
  * Reduction primitives (roadmap §8.1).
  *
@@ -2394,7 +2706,7 @@ declare const index_messaging: typeof messaging;
 declare const index_orchestration: typeof orchestration;
 declare const index_reduction: typeof reduction;
 declare namespace index {
-  export { index_ai as ai, index_cqrs as cqrs, demoShell$1 as demoShell, index_domainTemplates as domainTemplates, index_graphspec as graphspec, index$b as layout, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration, index_reduction as reduction };
+  export { index_ai as ai, index_cqrs as cqrs, demoShell$1 as demoShell, index_domainTemplates as domainTemplates, index_graphspec as graphspec, index$1 as harness, index$c as layout, index_memory as memory, index_messaging as messaging, index_orchestration as orchestration, index_reduction as reduction };
 }
 
 /**
@@ -2402,4 +2714,4 @@ declare namespace index {
  */
 declare const version = "0.0.0";
 
-export { Actor, AutoCheckpointAdapter, DistillBundle, Extraction, Graph, GraphAutoCheckpointHandle, GraphAutoCheckpointOptions, GraphOptions, Node, NodeActions, NodeFn, NodeInput, NodeOptions, ReactiveListSnapshot, ReactiveLogSnapshot, ReactiveMapSnapshot, ai, index$1 as compat, cqrs, demoShell$1 as demoShell, domainTemplates, graphspec, index$9 as jotai, index$b as layout, memory, messaging, index$8 as nanostores, index$a as nestjs, orchestration, index as patterns, index$7 as react, reduction, index$6 as signals, index$5 as solid, index$4 as svelte, version, index$3 as vue, index$2 as zustand };
+export { Actor, AutoCheckpointAdapter, DistillBundle, Extraction, Graph, GraphAutoCheckpointHandle, GraphAutoCheckpointOptions, GraphOptions, Node, NodeActions, NodeFn, NodeInput, NodeOptions, ReactiveListSnapshot, ReactiveLogSnapshot, ReactiveMapSnapshot, ai, index$2 as compat, cqrs, demoShell$1 as demoShell, domainTemplates, graphspec, index$1 as harness, index$a as jotai, index$c as layout, memory, messaging, index$9 as nanostores, index$b as nestjs, orchestration, index as patterns, index$8 as react, reduction, index$7 as signals, index$6 as solid, index$5 as svelte, version, index$4 as vue, index$3 as zustand };