@graphrefly/graphrefly 0.32.0 → 0.34.0

package/dist/{index-CNyiYQWF.d.ts → index-CQtnGFrZ.d.cts}

@@ -1,9 +1,110 @@
-import { a as Node } from './node-BVV7G1bq.js';
-import { T as TopicGraph } from './index-Dbmj0iYR.js';
-import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineStatus, c as RefineLoopOptions } from './index-CHfBm51k.js';
-import { G as Graph, s as GraphProfileResult, r as GraphProfileOptions } from './graph-BOhEGJ6E.js';
-import { L as LLMAdapter } from './types-CdfO2QTt.js';
-import { G as GateController } from './index-eYHRkoK-.js';
+import { NodeInput } from './extra/sources.cjs';
+import { a as Node } from './node-8qx0kgYt.cjs';
+import { L as LLMAdapter } from './types-Cp_4coR_.cjs';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-Ccv_61jG.cjs';
+import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-ChZvMC4M.cjs';
+import { G as Graph, s as GraphProfileResult, r as GraphProfileOptions } from './graph-DaoydJ_u.cjs';
+import { G as GateController } from './index-C2Dey3L-.cjs';
+import { J as JobQueueGraph } from './index-ClJUZAOr.cjs';
+
+/**
+ * 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;
+    /** Tear down internal keepalive subscriptions. */
+    dispose(): void;
+}
+/**
+ * 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.
+ *
+ * **Age sampling caveat.** The `ageSeconds` term is computed as
+ * `monotonicNs() - lastInteractionNs.cache` at *each reactive update*. If
+ * nothing upstream settles, the score node does not recompute — so a
+ * long-idle queue may show a stale score. Pass a `fromTimer(...)`-driven
+ * node as a dep (or re-emit on `lastInteractionNs`) when live age decay
+ * matters.
+ *
+ * **Not the same as `TriagedItem.priority`.** The LLM-emitted
+ * `priority: 0..100` field on each triaged item is decorative today — the
+ * queue consumption order ignores it (tracked in `docs/optimizations.md`
+ * as a priority-ordered queue enhancement). This function computes an
+ * orthogonal reactive score; it does NOT override the LLM's per-item
+ * priority, nor does it drive queue ordering. Wire it to
+ * `HarnessGraph.priorityScores` to surface per-route pressure.
+ *
+ * @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>;
+
+/**
+ * Harness runtime defaults (roadmap §9.0).
+ *
+ * Split out from `types.ts` in Wave B Unit 15 G so the type file holds
+ * only type declarations and plug-in contracts. Runtime constants and
+ * helpers live here; the harness barrel (`index.ts`) re-exports both so
+ * external consumers see a single surface.
+ *
+ * @module
+ */
+
+/** Ordered queue route names for iteration. */
+declare const QUEUE_NAMES: readonly QueueRoute[];
+/** Default queue configurations. */
+declare const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig>;
+/** Default severity weights. */
+declare const DEFAULT_SEVERITY_WEIGHTS: Record<Severity, number>;
+/** Default decay rate: ~7-day half-life. */
+declare const DEFAULT_DECAY_RATE: number;
+/** Canonical `${RootCause}→${Intervention}` join char; used by the `StrategyKey` template literal. */
+declare function strategyKey(rootCause: RootCause, intervention: Intervention): StrategyKey;
+/** Default error classifier: parse/config errors are self-correctable. */
+declare const defaultErrorClassifier: ErrorClassifier;
+/** Default TRIAGE prompt — LLM classifies intake items into root-cause + intervention + route + priority. */
+declare const DEFAULT_TRIAGE_PROMPT = "You are a triage classifier for a reactive collaboration harness.\n\nGiven an intake item, classify it and output JSON:\n{\n  \"rootCause\": \"composition\" | \"missing-fn\" | \"bad-docs\" | \"schema-gap\" | \"regression\" | \"unknown\",\n  \"intervention\": \"template\" | \"catalog-fn\" | \"docs\" | \"wrapper\" | \"schema-change\" | \"investigate\",\n  \"route\": \"auto-fix\" | \"needs-decision\" | \"investigation\" | \"backlog\",\n  \"priority\": <number 0-100>,\n  \"triageReasoning\": \"<one sentence>\"\n}\n\nStrategy model (past effectiveness):\n{{strategy}}\n\nIntake item:\n{{item}}";
+/** Default EXECUTE prompt — LLM produces a fix given a triaged issue. */
+declare const DEFAULT_EXECUTE_PROMPT = "You are an implementation agent.\n\nGiven a triaged issue with root cause and intervention type, produce a fix.\n\nIssue:\n{{item}}\n\nOutput JSON:\n{\n  \"outcome\": \"success\" | \"failure\" | \"partial\",\n  \"detail\": \"<description of what was done or what failed>\"\n}";
+/** Default VERIFY prompt — LLM reviews an execution result against the original issue. */
+declare const DEFAULT_VERIFY_PROMPT = "You are a QA reviewer.\n\nGiven an execution result, verify whether the fix is correct.\n\nExecution:\n{{execution}}\n\nOriginal issue:\n{{item}}\n\nOutput JSON:\n{\n  \"verified\": true/false,\n  \"findings\": [\"<finding1>\", ...],\n  \"errorClass\": \"self-correctable\" | \"structural\"  // only if verified=false\n}";
+/**
+ * Collapse the `string | ((input: In) => string) | undefined` prompt-template
+ * pattern into a single `(input: In) => string`. A function `raw` is used as-is
+ * (the caller opted into full control). Otherwise `raw ?? fallbackTemplate`
+ * is fed through `substitute`, which does the placeholder replacement.
+ *
+ * Used by the three harness stages (TRIAGE / EXECUTE / VERIFY), which each
+ * accept a `string | function` config but use different placeholder schemes
+ * (`{{item}}`, `{{execution}}`, `{{strategy}}`). The helper absorbs only the
+ * branch logic; the per-stage placeholder substitution lives at the call site.
+ */
+declare function resolvePromptFn<In>(raw: string | ((input: In) => string) | undefined, fallbackTemplate: string, substitute: (template: string, input: In) => string): (input: In) => string;
 
 /**
  * Harness wiring types (roadmap §9.0).
@@ -12,26 +113,39 @@ import { G as GateController } from './index-eYHRkoK-.js';
  * gate, execute, verify, reflect. These types are intentionally domain-agnostic
  * — the harness loop is not specific to eval workflows.
  *
+ * Runtime constants and helpers live in `./defaults.ts`. The harness barrel
+ * (`./index.ts`) re-exports both so external consumers see a single surface.
+ *
  * @module
  */
 
-/** Sources that can produce intake items. */
-type IntakeSource = "eval" | "test" | "human" | "code-change" | "hypothesis" | "parity";
+/** Known intake source tags. */
+type KnownIntakeSource = "eval" | "test" | "human" | "code-change" | "hypothesis" | "parity";
+/**
+ * Sources that can produce intake items. Open union — the known tags
+ * retain IDE autocomplete while user-supplied strings (e.g. `"schema"`,
+ * `"slack"`) pass through without a type change.
+ */
+type IntakeSource = KnownIntakeSource | (string & {});
 /** 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. */
+/** Routing destinations after triage. Closed union — iterated via `QUEUE_NAMES`. */
 type QueueRoute = "auto-fix" | "needs-decision" | "investigation" | "backlog";
-/** Ordered queue route names for iteration. */
-declare const QUEUE_NAMES: readonly QueueRoute[];
 /**
  * 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.
+ *
+ * `$`-prefix keys (`$reingestions`, `$retries` on {@link TriagedItem}) are
+ * framework-only — an LLM round-tripping the serialized item is far less
+ * likely to echo back a `$`-prefixed key than an `_`-prefixed one, which
+ * neutralizes the field-collision class that surfaced earlier in the
+ * router's spread order.
  */
 interface IntakeItem {
     source: IntakeSource;
@@ -42,7 +156,7 @@ interface IntakeItem {
     severity?: Severity;
     relatedTo?: string[];
     /** Item-carried reingestion count. Incremented on each full-loop reingestion. */
-    _reingestions?: number;
+    $reingestions?: number;
 }
 /** Output of the TRIAGE stage — enriched intake item with classification. */
 interface TriagedItem extends IntakeItem {
@@ -52,7 +166,7 @@ interface TriagedItem extends IntakeItem {
     priority: number;
     triageReasoning?: string;
     /** Item-carried retry count. Incremented on each fast-retry pass. */
-    _retries?: number;
+    $retries?: number;
 }
 /** Effectiveness record for a rootCause→intervention pair. */
 interface StrategyEntry {
@@ -64,9 +178,15 @@ interface StrategyEntry {
 }
 /** 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 = {
+/**
+ * LLM output shape from the EXECUTE stage (partial — lacks `item`).
+ *
+ * Generic over the artifact type `A` so typed executors like
+ * `refineExecutor<T>` can flow `T` through to an `evalVerifier<T>` without
+ * the caller casting `artifact` at the boundary. Defaults to `unknown`
+ * for escape-hatch executors that carry opaque state.
+ */
+type ExecuteOutput<A = unknown> = {
     outcome: "success" | "failure" | "partial";
     detail: string;
     /**
@@ -76,10 +196,10 @@ type ExecuteOutput = {
      * this — it's an escape hatch for reactive executors carrying structured
      * output (a refined prompt, a patched spec, a generated template, ...).
      */
-    artifact?: unknown;
+    artifact?: A;
 };
 /** Full execution result assembled downstream (LLM output + context). */
-interface ExecutionResult {
+interface ExecutionResult<A = unknown> {
     item: TriagedItem;
     outcome: "success" | "failure" | "partial";
     detail: string;
@@ -88,18 +208,16 @@ interface ExecutionResult {
      * one. Reactive executors like `refineExecutor` populate this; LLM-backed
      * default executors leave it undefined.
      */
-    artifact?: unknown;
+    artifact?: A;
 }
 /** 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 {
+interface VerifyResult<A = unknown> {
     item: TriagedItem;
-    execution: ExecutionResult;
+    execution: ExecutionResult<A>;
     verified: boolean;
     findings: string[];
     errorClass?: ErrorClass;
@@ -125,24 +243,19 @@ interface PrioritySignals {
     /** 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? */
+    /** Start the gate in open (auto-approve) mode? Only meaningful when `gated: true`. */
     startOpen?: boolean;
 }
-/** Default queue configurations. */
-declare const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig>;
 /**
  * Pluggable EXECUTE slot. Given the reactive `executeInput` stream of
- * triaged items, produce a stream of `ExecuteOutput` decisions.
+ * triaged items, produce a stream of `ExecuteOutput<A>` decisions.
  *
  * **Contract** (see design note in `docs/optimizations.md` / session log):
  * 1. Emit DATA exactly once per completed execution — not on input arrival.
@@ -157,50 +270,72 @@ declare const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig>;
  *
  * `refineExecutor` makes all four rules structurally unreachable.
  */
-type HarnessExecutor = (input: Node<TriagedItem | null>) => Node<ExecuteOutput | null>;
+type HarnessExecutor<A = unknown> = (input: Node<TriagedItem | null>) => Node<ExecuteOutput<A> | null>;
 /**
- * Pluggable VERIFY slot. Receives `[executeOutput, triagedItem]` pairs
- * sampled via `withLatestFrom(executeNode, executeInput)` and produces
- * `VerifyOutput` decisions.
+ * Pluggable VERIFY slot. Receives a pre-paired `[executeOutput, triagedItem]`
+ * context node — the harness creates this via `withLatestFrom(executeNode,
+ * executeInput)` once and shares it with both the verifier and the internal
+ * fast-retry dispatcher, so verifier implementations do NOT need to build
+ * their own pairing node (and doubling the `withLatestFrom` would pay the
+ * subscription cost twice).
  *
  * Same contract rules 1–3 as {@link HarnessExecutor}. Rule 4 does not
  * apply (verify output isn't a primary to a further withLatestFrom).
  *
  * `evalVerifier` handles the re-evaluation case against affected eval tasks.
  */
-type HarnessVerifier = (context: Node<[ExecuteOutput | null, TriagedItem | null]>) => Node<VerifyOutput | null>;
+type HarnessVerifier<A = unknown> = (context: Node<readonly [ExecuteOutput<A> | null, TriagedItem | null] | null>) => Node<VerifyOutput | null>;
+/** Triage prompt callable shape — pair of `[intake item, strategy snapshot]`. */
+type TriagePromptFn = (pair: readonly [IntakeItem, StrategySnapshot]) => string;
+/** Execute prompt callable shape. */
+type ExecutePromptFn = (item: TriagedItem) => string;
+/** Verify prompt callable shape — pair of `[execute output, triaged item]`. */
+type VerifyPromptFn<A = unknown> = (pair: readonly [ExecuteOutput<A> | null, TriagedItem | null]) => string;
 /** Options for {@link harnessLoop}. */
-interface HarnessLoopOptions {
+interface HarnessLoopOptions<A = unknown> {
     /** LLM adapter for promptNode-based stages (triage + any default executor/verifier). */
-    adapter: unknown;
-    /** Custom triage prompt (receives IntakeItem + strategy model as context). */
-    triagePrompt?: string | ((...args: unknown[]) => string);
+    adapter: LLMAdapter;
+    /** Custom triage prompt (receives IntakeItem + strategy snapshot as a tuple). */
+    triagePrompt?: string | TriagePromptFn;
     /**
      * Execute prompt — sugar over the default LLM executor. Ignored when
      * `executor` is set.
      */
-    executePrompt?: string | ((...args: unknown[]) => string);
+    executePrompt?: string | ExecutePromptFn;
     /**
      * Verify prompt — sugar over the default LLM verifier. Ignored when
      * `verifier` is set.
      */
-    verifyPrompt?: string | ((...args: unknown[]) => string);
+    verifyPrompt?: string | VerifyPromptFn<A>;
     /**
      * Pluggable EXECUTE slot. When omitted, the harness uses a `promptNode`
      * driven by `adapter` + `executePrompt`. Replace to plug in a
      * `refineExecutor`, tool-using agent, or any reactive execution pipeline.
      */
-    executor?: HarnessExecutor;
+    executor?: HarnessExecutor<A>;
     /**
      * Pluggable VERIFY slot. When omitted, the harness uses a `promptNode`
      * driven by `adapter` + `verifyPrompt`. Replace to plug in an
      * `evalVerifier` that re-runs affected eval tasks.
      */
-    verifier?: HarnessVerifier;
+    verifier?: HarnessVerifier<A>;
     /** Per-queue configuration overrides. */
     queues?: Partial<Record<QueueRoute, QueueConfig>>;
     /** Priority scoring signals. */
     priority?: PrioritySignals;
+    /**
+     * Reactive last-human-interaction timestamp (monotonic ns). Drives the
+     * priority score age-decay term for `HarnessGraph.priorityScores`.
+     *
+     * **Required when `opts.priority` is set.** Priority score nodes only
+     * re-derive when `topic.latest`, `strategy.node`, or this tick settles —
+     * an idle queue would freeze its age at construction time if we
+     * auto-defaulted. Typical sources:
+     *  - `fromTimer(60_000)` — steady tick, uniform decay.
+     *  - `state(monotonicNs())` — bumped from a human-interaction handler.
+     *  - A reactive view over a DB column / external metrics source.
+     */
+    lastInteractionNs?: Node<number>;
     /** Error classifier for fast-retry path. */
     errorClassifier?: ErrorClassifier;
     /** Max fast-retries per item before routing to full intake (default 2). */
@@ -215,6 +350,226 @@ interface HarnessLoopOptions {
     retainedLimit?: number;
 }
 
+/**
+ * actuatorExecutor — bridge a side-effecting actuator into the harness EXECUTE slot.
+ *
+ * `refineExecutor` covers the artifact-typed case (refine a candidate
+ * `T` against an evaluator); `actuatorExecutor` covers the side-effecting
+ * case (write a catalog entry, mutate a template registry, edit a doc on
+ * disk). The user's `apply` callback owns the side effect; the executor
+ * wraps it in the per-item lifecycle that makes the four
+ * {@link HarnessExecutor} contract rules structurally unreachable:
+ *
+ *  1. **One DATA per actuation.** The inner producer captures the first
+ *     DATA from the bridged `apply` result, emits a single
+ *     `ExecuteOutput<R>` carrying the actuation record as `artifact`, and
+ *     completes. Subsequent inner DATAs are ignored.
+ *  2. **Cancel-on-supersede.** A new triaged item supersedes via
+ *     `switchMap`; the prior producer's cleanup fires `ac.abort()`, which
+ *     propagates into `apply`'s `signal` (and through `fromAny`'s
+ *     internal cancellation hooks) so signal-aware actuators stop
+ *     in-flight work instead of double-writing.
+ *  3. **Item via deps, not closure mirror.** The triaged item is captured
+ *     in the `switchMap` callback's lexical scope, not mirrored to a
+ *     side-state node — same shape as `refineExecutor`.
+ *  4. **Fires on result, not input.** The producer emits exactly when
+ *     `apply`'s bridged node settles (or fails). Input-arrival waves
+ *     never produce an `ExecuteOutput`.
+ *
+ * **What `apply` may return.** Anything `fromAny` accepts: a
+ * `Promise<R>`, a `Node<R>`, an `AsyncIterable<R>`, an `Iterable<R>`,
+ * or a synchronous `R`. `Promise<R>` is the typical shape (`writeFile`,
+ * `fetch`, `db.execute`); reactive composition through `Node<R>` is the
+ * escape hatch when the actuator itself wants to surface intermediate
+ * progress before settling.
+ *
+ * **Pairing with `evalVerifier`.** `ExecuteOutput.artifact` is set to
+ * the actuation record; an `evalVerifier<R>` whose `extractArtifact`
+ * returns the record (or a transform of it — typically the post-apply
+ * world state needed by the evaluator) closes the EXECUTE → VERIFY loop
+ * with consistent typing end-to-end.
+ *
+ * @module
+ */
+
+/**
+ * What an actuator's `apply` may return. Mirrors `NodeInput<R>` plus a
+ * raw `R` for synchronous side effects, so callers can write the most
+ * direct shape for their case (Promise for async I/O, raw record for
+ * pure in-memory mutation).
+ */
+type ActuatorResult<R> = NodeInput<R>;
+/** Configuration for {@link actuatorExecutor}. */
+interface ActuatorExecutorConfig<R> {
+    /**
+     * Apply the side effect for this triaged item. Receives the abort
+     * signal — actuators that own real I/O should thread `signal` into
+     * `fetch`, `fs.writeFile`, child-process kills, etc. so that
+     * `switchMap` supersede actually cancels in-flight work.
+     *
+     * The first DATA emitted by the bridged result wins; later DATAs are
+     * discarded. ERROR (or a synchronous throw) is mapped via `onError`.
+     */
+    apply: (item: TriagedItem, opts: {
+        signal: AbortSignal;
+    }) => ActuatorResult<R>;
+    /**
+     * Optional gate — when provided and returning `false`, the actuator
+     * is skipped and the executor emits an `ExecuteOutput` with
+     * `outcome: "failure"` and detail from `skipDetail` (default
+     * `"actuator skipped (shouldApply returned false)"`). Use this to
+     * route interventions the actuator can't handle (e.g. `intervention:
+     * "investigate"` items) into the failure path so the verifier sees
+     * them.
+     */
+    shouldApply?: (item: TriagedItem) => boolean;
+    /** Detail string for the skip path. Default: includes intervention name. */
+    skipDetail?: (item: TriagedItem) => string;
+    /**
+     * Map a successfully-applied actuation record into an `ExecuteOutput<R>`.
+     * Default: `outcome: "success"`, `detail` references the intervention
+     * + summary, `artifact: record`.
+     */
+    toOutput?: (record: R, item: TriagedItem) => ExecuteOutput<R>;
+    /**
+     * Map a thrown / ERROR result into an `ExecuteOutput<R>`. Default:
+     * `outcome: "failure"`, `detail` carries the error message,
+     * `artifact: undefined`.
+     */
+    onError?: (err: unknown, item: TriagedItem) => ExecuteOutput<R>;
+    /** Node name prefix for `describe()` introspection. Default `"actuator-executor"`. */
+    name?: string;
+}
+/**
+ * Build a {@link HarnessExecutor} backed by a side-effecting actuator.
+ *
+ * @example File-system actuator that writes a catalog entry and emits the diff.
+ * ```ts
+ * const harness = harnessLoop("repair", {
+ *   adapter,
+ *   executor: actuatorExecutor<CatalogPatch>({
+ *     async apply(item, { signal }) {
+ *       const patch = patchFromItem(item);
+ *       await fs.writeFile(patch.path, patch.contents, { signal });
+ *       return patch;
+ *     },
+ *     shouldApply: (item) => item.intervention === "catalog-fn",
+ *   }),
+ *   verifier: evalVerifier<CatalogPatch>({
+ *     evaluator,
+ *     datasetFor,
+ *     extractArtifact: (exec) => exec.artifact ?? null,
+ *   }),
+ * });
+ * ```
+ */
+declare function actuatorExecutor<R>(config: ActuatorExecutorConfig<R>): HarnessExecutor<R>;
+
+/**
+ * autoSolidify — promote successful VERIFY runs into a durable artifact
+ * (catalog entry, skill, template, doc edit, …).
+ *
+ * Closes the dogfood retrospective loop: when the harness's VERIFY
+ * stage reports `verified: true`, the validated intervention should
+ * become an authoring artifact the next loop run can rely on. This
+ * primitive is the generic substrate — pass a `write` callback that
+ * does the actual promotion (e.g. `overlay.upsertTemplate` for the
+ * dogfood catalog overlay; `fs.writeFile` for a doc edit; `ctx.skill`
+ * for a Hermes-style skill registry).
+ *
+ * @example Wire the catalog overlay as the solidify target.
+ * ```ts
+ * const solidified = autoSolidify({
+ *   verifyResults: harness.verifyResults.latest,
+ *   extract: (vr) => vr.execution.artifact ?? null,
+ *   write: (entry, vr) => overlay.upsertFn(`learned-${vr.item.summary}`, entry),
+ * });
+ * solidified.subscribe(() => {}); // keep alive for log
+ * ```
+ *
+ * **Why a node and not just an effect.** The returned `Node<R>` emits
+ * each promoted artifact, so callers can pipe solidifications through
+ * the standard reactive surface (`describe()`, `observe()`, replay
+ * buffers) instead of side-channel logging. An audit / dashboard that
+ * wants "what was learned this run?" subscribes to the returned node;
+ * the `write` callback owns the durable side effect.
+ *
+ * **Idempotency is the caller's responsibility.** The primitive
+ * promotes every `verified: true` wave that passes the predicate. If
+ * the harness re-verifies the same item (e.g. via reingestion), the
+ * `write` callback is invoked again. Wrap your write fn with a
+ * dedup-by-key guard if your target store would otherwise bloat. The
+ * inner `seen` set inside this factory is intentionally absent — the
+ * harness already retains via topic logs and the user may want
+ * re-promotion semantics that are domain-specific.
+ *
+ * @module
+ */
+
+/**
+ * Configuration for {@link autoSolidify}.
+ *
+ * `R` is the artifact type the upstream EXECUTE stage produced (and
+ * `evalVerifier` carries through `execution.artifact`). `T` is the
+ * promotion shape — what `write` consumes and what the returned node
+ * emits. Often `T = R`, but they diverge when the actuator's raw
+ * artifact needs a transform before storing (e.g. wrap a `CatalogPatch`
+ * into a `CatalogEntry` with effectiveness metadata).
+ */
+interface AutoSolidifyConfig<R, T = R> {
+    /** Reactive verify-result stream. Typically `harness.verifyResults.latest`. */
+    verifyResults: Node<VerifyResult<R> | null>;
+    /**
+     * Pull the value-to-promote out of a verified VerifyResult.
+     * Default: `(vr) => vr.execution.artifact as T | null`. Return `null`
+     * to skip a particular VerifyResult even when `verified: true` (e.g.
+     * an LLM-default executor produces no artifact and there's nothing to
+     * solidify).
+     */
+    extract?: (vr: VerifyResult<R>) => T | null;
+    /**
+     * Optional gate beyond `verified === true`. When provided, the
+     * primitive only promotes when this returns `true`. Default: pass
+     * everything verified.
+     *
+     * Useful predicates:
+     *  - `(vr) => vr.item.intervention === "catalog-fn"` — only catalog work.
+     *  - `(vr) => (vr.findings ?? []).every(f => !/regression/i.test(f))` —
+     *    skip even-passes that mention regressions.
+     */
+    predicate?: (vr: VerifyResult<R>) => boolean;
+    /**
+     * Promote — usually a side effect (write to overlay, fs, KG, etc.).
+     * Receives the extracted artifact AND the originating VerifyResult so
+     * the writer can use any context it needs (item summary, eval task
+     * IDs, finding text, …) when shaping the durable record.
+     */
+    write: (artifact: T, vr: VerifyResult<R>) => void;
+    /** Node name for `describe()` introspection. Default `"auto-solidify"`. */
+    name?: string;
+}
+/**
+ * Build a `Node<T>` that subscribes to `verifyResults`, filters to
+ * verified passes that produced an extractable artifact, runs `write`,
+ * and emits the artifact. Use the returned node as a subscription
+ * point for audit / dashboard / log pipelines.
+ *
+ * **Terminal-on-error semantics.** A throw from `predicate`, `extract`,
+ * or `write` surfaces as `[[ERROR]]` on the returned node and
+ * **terminates** it — the upstream subscription tears down and no
+ * further DATA is emitted. This matches the spec's terminal-frame
+ * contract for ERROR. If you want the solidify node to stay live
+ * across user-callback throws, wrap your callbacks with try/catch
+ * internally and emit a sentinel value or no-op on failure. A future
+ * non-terminal `errors: Node<unknown>` companion may surface failures
+ * without terminating the success stream — flagged as a follow-up.
+ *
+ * @returns A `Node<T>` that emits one DATA per promoted artifact.
+ *   Stays live as long as `verifyResults` is live AND no user callback
+ *   has thrown.
+ */
+declare function autoSolidify<R, T = R>(config: AutoSolidifyConfig<R, T>): Node<T>;
+
 /**
  * Harness bridge factories (roadmap §9.0).
  *
@@ -423,7 +778,7 @@ declare function notifyEffect<T>(topic: TopicGraph<T>, transport: NotifyTranspor
  * artifact instead of asking an LLM to opine on the fix.
  *
  * Pairs naturally with {@link refineExecutor}: refineExecutor emits an
- * `ExecuteOutput.artifact` holding the converged candidate; evalVerifier
+ * `ExecuteOutput<T>.artifact` holding the converged candidate; evalVerifier
  * pulls it out via `extractArtifact` and feeds a single-candidate batch
  * into the same `Evaluator<T>` shape that `refineLoop` used. Consistent
  * scoring between EXECUTE and VERIFY — no "LLM said it looks fine" gap.
@@ -463,7 +818,7 @@ interface EvalVerifierConfig<T> {
      * surfaces as a runtime error inside `evaluator`, not here — supply a
      * narrowing `extractArtifact` if you need stricter validation.
      */
-    extractArtifact?: (exec: ExecuteOutput, item: TriagedItem) => T | null | undefined;
+    extractArtifact?: (exec: ExecuteOutput<T>, item: TriagedItem) => T | null | undefined;
     /**
      * Reactive evaluator — same contract as `refineLoop`'s `Evaluator<T>`.
      * Typically this is the SAME evaluator configured inside `refineExecutor`
@@ -487,6 +842,12 @@ interface EvalVerifierConfig<T> {
  * Build a {@link HarnessVerifier} that re-runs the eval suite against the
  * artifact produced by EXECUTE.
  *
+ * Consumes the shared `[executeOutput, item]` context node that the
+ * harness pre-pairs via `withLatestFrom` — no internal re-wrap here (QA
+ * round: "defaultLlmVerifier double-wraps withLatestFrom"). The harness's
+ * single `executeContextNode` is reused by both the verifier and the
+ * fast-retry dispatcher, so exec + item are subscribed once per wave.
+ *
  * @example Pair with refineExecutor for end-to-end eval consistency.
  * ```ts
  * const evaluator: Evaluator<CatalogEntry> = (cands, ds) => runEval(cands, ds);
@@ -497,49 +858,57 @@ interface EvalVerifierConfig<T> {
  * });
  * ```
  */
-declare function evalVerifier<T>(config: EvalVerifierConfig<T>): HarnessVerifier;
-
+declare function evalVerifier<T>(config: EvalVerifierConfig<T>): HarnessVerifier<T>;
 /**
- * Strategy model and priority scoring (roadmap §9.0).
- *
- * Pure-computation derived nodes — no LLM, no async.
- *
- * @module
+ * Config for {@link harnessEvalPair} — the typed bundle that produces a
+ * matched `refineExecutor<T>` + `evalVerifier<T>` pair sharing one
+ * {@link Evaluator} and one `datasetFor` resolver.
  */
-
-/** 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;
-    /** Tear down internal keepalive subscriptions. */
-    dispose(): void;
+interface HarnessEvalPairConfig<T> {
+    /** Map a triaged item to the seed candidate. */
+    seedFrom: (item: TriagedItem) => T;
+    /** The reactive evaluator used by BOTH executor and verifier. */
+    evaluator: Evaluator<T>;
+    /** The refinement strategy (e.g. `errorCritique(teacher)`). */
+    strategy: RefineStrategy<T>;
+    /** Resolve dataset rows per triaged item. */
+    datasetFor: (item: TriagedItem) => readonly DatasetItem[];
+    /** Pass-threshold for the verifier. Default `0.5`. */
+    threshold?: number;
+    /** Convergence / budget options forwarded to each inner `refineLoop`. */
+    refine?: Omit<RefineLoopOptions, "dataset" | "name">;
+    /**
+     * Shared node-name prefix — the executor becomes `${name}-exec` and the
+     * verifier `${name}-verify` for distinct but related describe() paths.
+     * Default `"harness-pair"`.
+     */
+    name?: string;
 }
 /**
- * Create a strategy model that tracks `rootCause × intervention → successRate`
- * over completed issues. Pure derived computation — no LLM.
+ * Typed factory that returns a matched `{ executor, verifier }` pair.
  *
- * The model feeds back into TRIAGE for routing hints.
- */
-declare function strategyModel(): StrategyModelBundle;
-/**
- * Create a priority scoring derived node for a single triaged item.
+ * Prevents the "executor wrote `A`, verifier expected `B`" class of runtime
+ * cast errors — `T` is threaded through both sides, so mixing up the
+ * configuration is a compile error instead of a silent `as T` in
+ * `extractArtifact`. Shares the evaluator so EXECUTE and VERIFY score with
+ * identical semantics (the whole point of `evalVerifier`).
  *
- * 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.
+ * @example
+ * ```ts
+ * const { executor, verifier } = harnessEvalPair<CatalogEntry>({
+ *   seedFrom: (item) => initialCatalogEntry(item),
+ *   evaluator: (cands, ds) => runEvalBatch(cands, ds),
+ *   strategy: errorCritique({ teacher, width: 3 }),
+ *   datasetFor: affectedTasksFor,
+ *   threshold: 0.8,
+ * });
+ * const harness = harnessLoop<CatalogEntry>("repair", { adapter, executor, verifier });
+ * ```
  */
-declare function priorityScore(item: Node<TriagedItem>, strategy: Node<StrategySnapshot>, lastInteractionNs: Node<number>, urgency?: Node<number>, signals?: PrioritySignals): Node<number>;
+declare function harnessEvalPair<T>(config: HarnessEvalPairConfig<T>): {
+    executor: HarnessExecutor<T>;
+    verifier: HarnessVerifier<T>;
+};
 
 /**
  * harnessLoop() factory (roadmap §9.0).
@@ -548,6 +917,15 @@ declare function priorityScore(item: Node<TriagedItem>, strategy: Node<StrategyS
  * EXECUTE → VERIFY → REFLECT. Static topology, flowing data — the Kafka
  * insight applied to human+LLM collaboration.
  *
+ * **Hub model (Wave B Unit 20 C + Q1).** All reactive-wire-crossing topics
+ * live in one `MessagingHubGraph` exposed as `HarnessGraph.queues`: the
+ * four per-route queues, an `__unrouted` dead-letter, plus `intake`,
+ * `retry`, `verify-results`, and the `triage-output` fan-in topic. The
+ * router is a single derived/effect pair that publishes to `triage-output`;
+ * per-route `topicBridge`s fan out by `map:` predicate. Routing is data
+ * (topic name), not code — every routing decision is a visible edge in
+ * `describe()` / `explain()`.
+ *
  * @module
  */
 
@@ -565,33 +943,103 @@ declare function priorityScore(item: Node<TriagedItem>, strategy: Node<StrategyS
  * @param prompt  - Prompt template (string or `(item) => string`). Defaults
  *                   to the harness's built-in execute prompt.
  */
-declare function defaultLlmExecutor(adapter: LLMAdapter, prompt?: HarnessLoopOptions["executePrompt"]): HarnessExecutor;
+declare function defaultLlmExecutor<A = unknown>(adapter: LLMAdapter, prompt?: string | ExecutePromptFn): HarnessExecutor<A>;
 /**
- * Build the default VERIFY slot — a `promptNode` that reviews the
- * `[executeOutput, item]` pair from the execute-context.
+ * Build the default VERIFY slot — a `promptNode` that reviews a
+ * pre-paired `[executeOutput, item]` context node. The harness creates
+ * the pairing (via `withLatestFrom(executeNode, executeInput)`) once and
+ * shares it with both the verifier and the internal fast-retry
+ * dispatcher, so the default verifier can consume the context directly
+ * without building its own withLatestFrom.
  *
  * @param adapter - LLMAdapter for the verify call.
  * @param prompt  - Prompt template. Defaults to the harness's built-in
  *                   verify prompt (receives the full pair, extracts both).
  */
-declare function defaultLlmVerifier(adapter: LLMAdapter, prompt?: HarnessLoopOptions["verifyPrompt"]): HarnessVerifier;
-/** 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>>;
+declare function defaultLlmVerifier<A = unknown>(adapter: LLMAdapter, prompt?: string | VerifyPromptFn<A>): HarnessVerifier<A>;
+/**
+ * The graph returned by {@link harnessLoop}. Wraps a single
+ * {@link MessagingHubGraph} that owns all reactive-wire-crossing topics
+ * (intake, per-route queues, `__unrouted`, retry, verify-results,
+ * triage-output). Sugar getters expose the canonical topics so the
+ * surface stays ergonomic.
+ */
+declare class HarnessGraph<A = unknown> extends Graph {
+    /** Messaging hub — the routing-data plane. Queue topics live here. */
+    readonly queues: MessagingHubGraph;
+    /**
+     * Per-route JobQueueGraph mirrors (Unit 20 D). Each triaged item that
+     * reaches a queue is also enqueued here, giving reactive `depth` +
+     * `pending` + `jobs` observables. `fastRetry` terminal decisions
+     * {@link JobQueueGraph.ack ack} / {@link JobQueueGraph.nack nack} the
+     * matching job. The executor dataflow is unchanged — claim/ack/nack
+     * runs as an audit-side layer (per Unit 21's "interface unchanged"
+     * decision). Inspect via `harness.jobs.get(route).depth.cache` for
+     * backpressure metrics.
+     */
+    readonly jobs: ReadonlyMap<QueueRoute, JobQueueGraph<TriagedItem>>;
     /** Per-route gate controllers (only for gated queues). */
     readonly gates: ReadonlyMap<QueueRoute, GateController<TriagedItem>>;
+    /**
+     * 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.
+     *
+     * **Why this exists.** `for (const [, topic] of harness.queues)`
+     * appears to iterate via `Graph[Symbol.iterator]`, but that yields
+     * locally-registered nodes only — and `MessagingHubGraph` mounts
+     * topics as child graphs rather than registering them locally, so
+     * the loop yields nothing. This map gives a typed, working
+     * iteration path.
+     */
+    readonly queueTopics: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
     /** Strategy model bundle — record outcomes, lookup effectiveness. */
     readonly strategy: StrategyModelBundle;
-    /** Verify results topic — subscribe to see verification outcomes. */
-    readonly verifyResults: TopicGraph<VerifyResult>;
     /** Global retry count across all items (circuit breaker). Reactive — subscribable. */
     readonly totalRetries: Node<number>;
     /** Global reingestion count across all items (circuit breaker). Reactive — subscribable. */
     readonly totalReingestions: Node<number>;
-    constructor(name: string, intake: TopicGraph<IntakeItem>, queues: Map<QueueRoute, TopicGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, verifyResults: TopicGraph<VerifyResult>, totalRetries: Node<number>, totalReingestions: Node<number>);
+    /**
+     * 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.
+     */
+    readonly priorityScores?: ReadonlyMap<QueueRoute, Node<number>>;
+    constructor(name: string, queues: MessagingHubGraph, queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, priorityScores?: Map<QueueRoute, Node<number>>);
+    /** Intake topic — publish items here to enter the loop. */
+    get intake(): TopicGraph<IntakeItem>;
+    /** Verify results topic — subscribe to see verification outcomes. */
+    get verifyResults(): TopicGraph<VerifyResult<A>>;
+    /** Retry feedback topic — fast-retry re-entry point. */
+    get retry(): TopicGraph<TriagedItem>;
+    /** Dead-letter topic for items whose LLM-chosen route is unknown. */
+    get unrouted(): TopicGraph<TriagedItem>;
+    /**
+     * Stage-label → observe-path map for the 7 pipeline stages (Unit 22 C).
+     *
+     * Decouples inspection tools (`harnessTrace`, `harnessProfile`, custom
+     * dashboards) from mount-structure churn: hub migration, future stage
+     * splits, or gate remounting won't require edits to `trace.ts` as long
+     * as this method stays accurate. Returned paths are resolvable via
+     * `harness.observe(path)` / `harness.resolve(path)`.
+     *
+     * Each stage yields `{ label, paths }` because QUEUE and GATE legitimately
+     * have multiple paths (one per route). Consumers iterate paths per stage
+     * and attach observers as needed.
+     */
+    stageNodes(): ReadonlyArray<{
+        label: string;
+        paths: readonly string[];
+    }>;
 }
 /**
  * Wire the reactive collaboration loop as a static-topology graph.
@@ -609,7 +1057,7 @@ declare class HarnessGraph extends Graph {
  * @param opts - Configuration.
  * @returns HarnessGraph with controller accessors.
  */
-declare function harnessLoop(name: string, opts: HarnessLoopOptions): HarnessGraph;
+declare function harnessLoop<A = unknown>(name: string, opts: HarnessLoopOptions<A>): HarnessGraph<A>;
 
 /**
  * Harness-specific graph profiling (roadmap §9.0).
@@ -634,6 +1082,13 @@ interface HarnessProfileResult extends GraphProfileResult {
 /**
  * Profile a harness graph with domain-specific counters.
  *
+ * **Snapshot caveat (Unit 22 B).** Reads `.cache` values from the
+ * strategy / retry / reingestion nodes + each queue topic's `.retained()`
+ * view. These are point-in-time reads and are not transactional — if you
+ * invoke this during an in-flight reactive wave the values may reflect
+ * a partially-settled frame. For end-of-wave accuracy, call from outside
+ * any batch boundary.
+ *
  * @param harness - The HarnessGraph to profile.
  * @param opts - Optional base profile options.
  * @returns Harness profile with queue depths, strategy stats, and tracker sizes.
@@ -688,10 +1143,10 @@ interface RefineExecutorConfig<T> {
     datasetFor: (item: TriagedItem) => readonly DatasetItem[];
     /**
      * Optional mapper from the inner loop's terminal snapshot to an
-     * `ExecuteOutput`. Default: converged→success, budget→partial,
+     * `ExecuteOutput<T>`. Default: converged→success, budget→partial,
      * errored→failure.
      */
-    toOutput?: (result: RefineExecutorResult<T>) => ExecuteOutput;
+    toOutput?: (result: RefineExecutorResult<T>) => ExecuteOutput<T>;
     /** Convergence / budget options forwarded to each inner `refineLoop`. */
     refine?: Omit<RefineLoopOptions, "dataset" | "name">;
     /** Node name prefix for introspection. Default `"refine-executor"`. */
@@ -714,7 +1169,7 @@ interface RefineExecutorConfig<T> {
  * });
  * ```
  */
-declare function refineExecutor<T>(config: RefineExecutorConfig<T>): HarnessExecutor;
+declare function refineExecutor<T>(config: RefineExecutorConfig<T>): HarnessExecutor<T>;
 
 /**
  * Harness pipeline trace — thin sugar over `graph.observe({ format: "stage-log" })`.
@@ -797,11 +1252,17 @@ declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions)
  * @module
  */
 
+type index_ActuatorExecutorConfig<R> = ActuatorExecutorConfig<R>;
+type index_ActuatorResult<R> = ActuatorResult<R>;
+type index_AutoSolidifyConfig<R, T = R> = AutoSolidifyConfig<R, T>;
 type index_CodeChange = CodeChange;
 type index_CodeChangeBridgeOptions = CodeChangeBridgeOptions;
 declare const index_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
+declare const index_DEFAULT_EXECUTE_PROMPT: typeof DEFAULT_EXECUTE_PROMPT;
 declare const index_DEFAULT_QUEUE_CONFIGS: typeof DEFAULT_QUEUE_CONFIGS;
 declare const index_DEFAULT_SEVERITY_WEIGHTS: typeof DEFAULT_SEVERITY_WEIGHTS;
+declare const index_DEFAULT_TRIAGE_PROMPT: typeof DEFAULT_TRIAGE_PROMPT;
+declare const index_DEFAULT_VERIFY_PROMPT: typeof DEFAULT_VERIFY_PROMPT;
 type index_ErrorClass = ErrorClass;
 type index_ErrorClassifier = ErrorClassifier;
 type index_EvalDelta = EvalDelta;
@@ -812,20 +1273,23 @@ type index_EvalTaskDelta = EvalTaskDelta;
 type index_EvalTaskResult = EvalTaskResult;
 type index_EvalVerifierConfig<T> = EvalVerifierConfig<T>;
 type index_EvalVerifierSummary = EvalVerifierSummary;
-type index_ExecuteOutput = ExecuteOutput;
-type index_ExecutionResult = ExecutionResult;
-type index_HarnessExecutor = HarnessExecutor;
-type index_HarnessGraph = HarnessGraph;
+type index_ExecuteOutput<A = unknown> = ExecuteOutput<A>;
+type index_ExecutePromptFn = ExecutePromptFn;
+type index_ExecutionResult<A = unknown> = ExecutionResult<A>;
+type index_HarnessEvalPairConfig<T> = HarnessEvalPairConfig<T>;
+type index_HarnessExecutor<A = unknown> = HarnessExecutor<A>;
+type index_HarnessGraph<A = unknown> = HarnessGraph<A>;
 declare const index_HarnessGraph: typeof HarnessGraph;
-type index_HarnessLoopOptions = HarnessLoopOptions;
+type index_HarnessLoopOptions<A = unknown> = HarnessLoopOptions<A>;
 type index_HarnessProfileResult = HarnessProfileResult;
 type index_HarnessTraceHandle = HarnessTraceHandle;
 type index_HarnessTraceOptions = HarnessTraceOptions;
-type index_HarnessVerifier = HarnessVerifier;
+type index_HarnessVerifier<A = unknown> = HarnessVerifier<A>;
 type index_IntakeBridgeOptions = IntakeBridgeOptions;
 type index_IntakeItem = IntakeItem;
 type index_IntakeSource = IntakeSource;
 type index_Intervention = Intervention;
+type index_KnownIntakeSource = KnownIntakeSource;
 type index_LintError = LintError;
 type index_NotifyEffectOptions = NotifyEffectOptions;
 type index_NotifyTransport<T> = NotifyTransport<T>;
@@ -845,10 +1309,14 @@ type index_TestFailure = TestFailure;
 type index_TraceDetail = TraceDetail;
 type index_TraceEvent = TraceEvent;
 type index_TraceEventType = TraceEventType;
+type index_TriagePromptFn = TriagePromptFn;
 type index_TriagedItem = TriagedItem;
 type index_VerifyOutput = VerifyOutput;
-type index_VerifyResult = VerifyResult;
+type index_VerifyPromptFn<A = unknown> = VerifyPromptFn<A>;
+type index_VerifyResult<A = unknown> = VerifyResult<A>;
+declare const index_actuatorExecutor: typeof actuatorExecutor;
 declare const index_affectedTaskFilter: typeof affectedTaskFilter;
+declare const index_autoSolidify: typeof autoSolidify;
 declare const index_beforeAfterCompare: typeof beforeAfterCompare;
 declare const index_codeChangeBridge: typeof codeChangeBridge;
 declare const index_createIntakeBridge: typeof createIntakeBridge;
@@ -858,16 +1326,18 @@ declare const index_defaultLlmVerifier: typeof defaultLlmVerifier;
 declare const index_evalIntakeBridge: typeof evalIntakeBridge;
 declare const index_evalSource: typeof evalSource;
 declare const index_evalVerifier: typeof evalVerifier;
+declare const index_harnessEvalPair: typeof harnessEvalPair;
 declare const index_harnessLoop: typeof harnessLoop;
 declare const index_harnessProfile: typeof harnessProfile;
 declare const index_harnessTrace: typeof harnessTrace;
 declare const index_notifyEffect: typeof notifyEffect;
 declare const index_priorityScore: typeof priorityScore;
 declare const index_refineExecutor: typeof refineExecutor;
+declare const index_resolvePromptFn: typeof resolvePromptFn;
 declare const index_strategyKey: typeof strategyKey;
 declare const index_strategyModel: typeof strategyModel;
 declare namespace index {
-  export { type index_CodeChange as CodeChange, type index_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, type index_ErrorClass as ErrorClass, type index_ErrorClassifier as ErrorClassifier, type index_EvalDelta as EvalDelta, type index_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index_EvalJudgeScore as EvalJudgeScore, type index_EvalResult as EvalResult, type index_EvalTaskDelta as EvalTaskDelta, type index_EvalTaskResult as EvalTaskResult, type index_EvalVerifierConfig as EvalVerifierConfig, type index_EvalVerifierSummary as EvalVerifierSummary, type index_ExecuteOutput as ExecuteOutput, type index_ExecutionResult as ExecutionResult, type index_HarnessExecutor as HarnessExecutor, index_HarnessGraph as HarnessGraph, type index_HarnessLoopOptions as HarnessLoopOptions, type index_HarnessProfileResult as HarnessProfileResult, type index_HarnessTraceHandle as HarnessTraceHandle, type index_HarnessTraceOptions as HarnessTraceOptions, type index_HarnessVerifier as HarnessVerifier, type index_IntakeBridgeOptions as IntakeBridgeOptions, type index_IntakeItem as IntakeItem, type index_IntakeSource as IntakeSource, type index_Intervention as Intervention, type index_LintError as LintError, type index_NotifyEffectOptions as NotifyEffectOptions, type index_NotifyTransport as NotifyTransport, type index_PrioritySignals as PrioritySignals, index_QUEUE_NAMES as QUEUE_NAMES, type index_QueueConfig as QueueConfig, type index_QueueRoute as QueueRoute, type index_RefineExecutorConfig as RefineExecutorConfig, type index_RefineExecutorResult as RefineExecutorResult, type index_RootCause as RootCause, type index_Severity as Severity, type index_StrategyEntry as StrategyEntry, type index_StrategyKey as StrategyKey, type index_StrategyModelBundle as StrategyModelBundle, type index_StrategySnapshot as StrategySnapshot, type index_TestFailure as TestFailure, type index_TraceDetail as TraceDetail, type index_TraceEvent as TraceEvent, type index_TraceEventType as TraceEventType, type index_TriagedItem as TriagedItem, type index_VerifyOutput as VerifyOutput, type index_VerifyResult as VerifyResult, index_affectedTaskFilter as affectedTaskFilter, index_beforeAfterCompare as beforeAfterCompare, index_codeChangeBridge as codeChangeBridge, index_createIntakeBridge as createIntakeBridge, index_defaultErrorClassifier as defaultErrorClassifier, index_defaultLlmExecutor as defaultLlmExecutor, index_defaultLlmVerifier as defaultLlmVerifier, index_evalIntakeBridge as evalIntakeBridge, index_evalSource as evalSource, index_evalVerifier as evalVerifier, index_harnessLoop as harnessLoop, index_harnessProfile as harnessProfile, index_harnessTrace as harnessTrace, index_notifyEffect as notifyEffect, index_priorityScore as priorityScore, index_refineExecutor as refineExecutor, index_strategyKey as strategyKey, index_strategyModel as strategyModel };
+  export { type index_ActuatorExecutorConfig as ActuatorExecutorConfig, type index_ActuatorResult as ActuatorResult, type index_AutoSolidifyConfig as AutoSolidifyConfig, type index_CodeChange as CodeChange, type index_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index_DEFAULT_EXECUTE_PROMPT as DEFAULT_EXECUTE_PROMPT, index_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, index_DEFAULT_TRIAGE_PROMPT as DEFAULT_TRIAGE_PROMPT, index_DEFAULT_VERIFY_PROMPT as DEFAULT_VERIFY_PROMPT, type index_ErrorClass as ErrorClass, type index_ErrorClassifier as ErrorClassifier, type index_EvalDelta as EvalDelta, type index_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index_EvalJudgeScore as EvalJudgeScore, type index_EvalResult as EvalResult, type index_EvalTaskDelta as EvalTaskDelta, type index_EvalTaskResult as EvalTaskResult, type index_EvalVerifierConfig as EvalVerifierConfig, type index_EvalVerifierSummary as EvalVerifierSummary, type index_ExecuteOutput as ExecuteOutput, type index_ExecutePromptFn as ExecutePromptFn, type index_ExecutionResult as ExecutionResult, type index_HarnessEvalPairConfig as HarnessEvalPairConfig, type index_HarnessExecutor as HarnessExecutor, index_HarnessGraph as HarnessGraph, type index_HarnessLoopOptions as HarnessLoopOptions, type index_HarnessProfileResult as HarnessProfileResult, type index_HarnessTraceHandle as HarnessTraceHandle, type index_HarnessTraceOptions as HarnessTraceOptions, type index_HarnessVerifier as HarnessVerifier, type index_IntakeBridgeOptions as IntakeBridgeOptions, type index_IntakeItem as IntakeItem, type index_IntakeSource as IntakeSource, type index_Intervention as Intervention, type index_KnownIntakeSource as KnownIntakeSource, type index_LintError as LintError, type index_NotifyEffectOptions as NotifyEffectOptions, type index_NotifyTransport as NotifyTransport, type index_PrioritySignals as PrioritySignals, index_QUEUE_NAMES as QUEUE_NAMES, type index_QueueConfig as QueueConfig, type index_QueueRoute as QueueRoute, type index_RefineExecutorConfig as RefineExecutorConfig, type index_RefineExecutorResult as RefineExecutorResult, type index_RootCause as RootCause, type index_Severity as Severity, type index_StrategyEntry as StrategyEntry, type index_StrategyKey as StrategyKey, type index_StrategyModelBundle as StrategyModelBundle, type index_StrategySnapshot as StrategySnapshot, type index_TestFailure as TestFailure, type index_TraceDetail as TraceDetail, type index_TraceEvent as TraceEvent, type index_TraceEventType as TraceEventType, type index_TriagePromptFn as TriagePromptFn, type index_TriagedItem as TriagedItem, type index_VerifyOutput as VerifyOutput, type index_VerifyPromptFn as VerifyPromptFn, type index_VerifyResult as VerifyResult, index_actuatorExecutor as actuatorExecutor, index_affectedTaskFilter as affectedTaskFilter, index_autoSolidify as autoSolidify, index_beforeAfterCompare as beforeAfterCompare, index_codeChangeBridge as codeChangeBridge, index_createIntakeBridge as createIntakeBridge, index_defaultErrorClassifier as defaultErrorClassifier, index_defaultLlmExecutor as defaultLlmExecutor, index_defaultLlmVerifier as defaultLlmVerifier, index_evalIntakeBridge as evalIntakeBridge, index_evalSource as evalSource, index_evalVerifier as evalVerifier, index_harnessEvalPair as harnessEvalPair, index_harnessLoop as harnessLoop, index_harnessProfile as harnessProfile, index_harnessTrace as harnessTrace, index_notifyEffect as notifyEffect, index_priorityScore as priorityScore, index_refineExecutor as refineExecutor, index_resolvePromptFn as resolvePromptFn, index_strategyKey as strategyKey, index_strategyModel as strategyModel };
 }
 
-export { codeChangeBridge as $, type QueueRoute as A, type RefineExecutorResult as B, type CodeChange as C, DEFAULT_DECAY_RATE as D, type ErrorClass as E, type RootCause as F, type StrategyEntry as G, type HarnessExecutor as H, type IntakeBridgeOptions as I, type StrategyKey as J, type StrategyModelBundle as K, type LintError as L, type StrategySnapshot as M, type NotifyEffectOptions as N, type TraceDetail as O, type PrioritySignals as P, QUEUE_NAMES as Q, type RefineExecutorConfig as R, type Severity as S, type TestFailure as T, type TraceEvent as U, type TraceEventType as V, type TriagedItem as W, type VerifyOutput as X, type VerifyResult as Y, affectedTaskFilter as Z, beforeAfterCompare as _, type CodeChangeBridgeOptions as a, createIntakeBridge as a0, defaultErrorClassifier as a1, defaultLlmExecutor as a2, defaultLlmVerifier as a3, evalIntakeBridge as a4, evalSource as a5, evalVerifier as a6, harnessLoop as a7, harnessProfile as a8, harnessTrace as a9, notifyEffect as aa, priorityScore as ab, refineExecutor as ac, strategyKey as ad, strategyModel as ae, DEFAULT_QUEUE_CONFIGS as b, DEFAULT_SEVERITY_WEIGHTS as c, type ErrorClassifier as d, type EvalDelta as e, type EvalIntakeBridgeOptions as f, type EvalJudgeScore as g, type EvalResult as h, index as i, type EvalTaskDelta as j, type EvalTaskResult as k, type EvalVerifierConfig as l, type EvalVerifierSummary as m, type ExecuteOutput as n, type ExecutionResult as o, HarnessGraph as p, type HarnessLoopOptions as q, type HarnessProfileResult as r, type HarnessTraceHandle as s, type HarnessTraceOptions as t, type HarnessVerifier as u, type IntakeItem as v, type IntakeSource as w, type Intervention as x, type NotifyTransport as y, type QueueConfig as z };
+export { type TestFailure as $, type ActuatorExecutorConfig as A, type HarnessTraceOptions as B, type CodeChange as C, DEFAULT_DECAY_RATE as D, type ErrorClass as E, type HarnessVerifier as F, type IntakeItem as G, type HarnessEvalPairConfig as H, type IntakeBridgeOptions as I, type IntakeSource as J, type Intervention as K, type KnownIntakeSource as L, type LintError as M, type NotifyEffectOptions as N, type NotifyTransport as O, type PrioritySignals as P, QUEUE_NAMES as Q, type QueueConfig as R, type QueueRoute as S, type RefineExecutorConfig as T, type RefineExecutorResult as U, type RootCause as V, type Severity as W, type StrategyEntry as X, type StrategyKey as Y, type StrategyModelBundle as Z, type StrategySnapshot as _, type ActuatorResult as a, type TraceDetail as a0, type TraceEvent as a1, type TraceEventType as a2, type TriagePromptFn as a3, type TriagedItem as a4, type VerifyOutput as a5, type VerifyPromptFn as a6, type VerifyResult as a7, actuatorExecutor as a8, affectedTaskFilter as a9, autoSolidify as aa, beforeAfterCompare as ab, codeChangeBridge as ac, createIntakeBridge as ad, defaultErrorClassifier as ae, defaultLlmExecutor as af, defaultLlmVerifier as ag, evalIntakeBridge as ah, evalSource as ai, evalVerifier as aj, harnessEvalPair as ak, harnessLoop as al, harnessProfile as am, harnessTrace as an, notifyEffect as ao, priorityScore as ap, refineExecutor as aq, resolvePromptFn as ar, strategyKey as as, strategyModel as at, type AutoSolidifyConfig as b, type CodeChangeBridgeOptions as c, DEFAULT_EXECUTE_PROMPT as d, DEFAULT_QUEUE_CONFIGS as e, DEFAULT_SEVERITY_WEIGHTS as f, DEFAULT_TRIAGE_PROMPT as g, DEFAULT_VERIFY_PROMPT as h, index as i, type ErrorClassifier as j, type EvalDelta as k, type EvalIntakeBridgeOptions as l, type EvalJudgeScore as m, type EvalResult as n, type EvalTaskDelta as o, type EvalTaskResult as p, type EvalVerifierConfig as q, type EvalVerifierSummary as r, type ExecuteOutput as s, type ExecutePromptFn as t, type ExecutionResult as u, type HarnessExecutor as v, HarnessGraph as w, type HarnessLoopOptions as x, type HarnessProfileResult as y, type HarnessTraceHandle as z };