@graphrefly/graphrefly 0.44.0 → 0.45.0

package/dist/index-BxNs2HB9.d.cts

@@ -1,1858 +0,0 @@
-import { NodeInput } from './extra/sources.cjs';
-import { N as Node } from './node-kK3CvTrR.cjs';
-import { L as LLMAdapter } from './types-C0_yquda.cjs';
-import { J as JobEnvelope, a as JobFlowGraph, b as JobQueueGraph } from './index-DV_1YuVk.cjs';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-C5ri2Axc.cjs';
-import { a as GraphOptions, G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-CWvEUQAq.cjs';
-import { G as GateController } from './pipeline-graph-CIKhynsF.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).
- *
- * 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.
- *
- * Runtime constants and helpers live in `./defaults.ts`. The harness barrel
- * (`./index.ts`) re-exports both so external consumers see a single surface.
- *
- * @module
- */
-
-/** 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. Closed union — iterated via `QUEUE_NAMES`. */
-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.
- *
- * `$`-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;
-    summary: string;
-    evidence: string;
-    affectsAreas: string[];
-    affectsEvalTasks?: string[];
-    severity?: Severity;
-    /**
-     * Stable identity carrier for retry / reingestion paths. Per qa D1
-     * (2026-04-29), `relatedTo[0]` MUST be the original tracking key for
-     * items derived from a prior publish so the harness's `routeJobIds`
-     * map preserves identity across decorated retry summaries. First-time
-     * publishes leave this `undefined`; the tracking key falls back to
-     * `summary`. Two first-time publishes with identical `summary` collide
-     * on key — see `trackingKey` JSDoc in `patterns/_internal/index.ts`
-     * for the uniqueness caller contract.
-     */
-    relatedTo?: string[];
-    /** Item-carried reingestion count. Incremented on each full-loop reingestion. */
-    $reingestions?: number;
-}
-/** Output of the TRIAGE stage — enriched intake item with classification. */
-interface TriagedItem extends IntakeItem {
-    rootCause: RootCause;
-    intervention: Intervention;
-    route: QueueRoute;
-    priority: number;
-    triageReasoning?: string;
-    /** Item-carried retry count. Incremented on each fast-retry pass. */
-    $retries?: number;
-}
-/** 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}`;
-/**
- * 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> = {
-    /**
-     * Execution outcome classification:
-     *
-     * - `"success"`: execution completed cleanly and the artifact (if any) is
-     *   ready for verification. The verifier should proceed with a full
-     *   evaluation pass.
-     * - `"failure"`: execution did not produce a usable artifact — the actuator
-     *   threw, a prompt parse failed, or `shouldApply` skipped the item. The
-     *   verifier should treat this as a non-result and route accordingly.
-     * - `"partial"`: execution produced a candidate that converged but did not
-     *   fully meet verification criteria. Used by `refineExecutor` when the
-     *   iteration cap is reached without full convergence; the artifact holds
-     *   the best candidate achieved.
-     */
-    outcome: "success" | "failure" | "partial";
-    detail: string;
-    /**
-     * Optional opaque artifact that a custom executor (e.g. `refineExecutor`)
-     * may attach so downstream verifiers can re-run evaluation against the
-     * thing that was produced. LLM-backed default executors never populate
-     * this — it's an escape hatch for reactive executors carrying structured
-     * output (a refined prompt, a patched spec, a generated template, ...).
-     */
-    artifact?: A;
-};
-/** Full execution result assembled downstream (LLM output + context). */
-interface ExecutionResult<A = unknown> {
-    item: TriagedItem;
-    /**
-     * Execution outcome classification. Same semantics as
-     * {@link ExecuteOutput.outcome}:
-     *
-     * - `"success"`: execution completed cleanly; artifact is ready for
-     *   verification.
-     * - `"failure"`: no usable artifact was produced.
-     * - `"partial"`: best candidate produced but convergence criteria not met
-     *   (iteration cap reached in `refineExecutor`).
-     */
-    outcome: "success" | "failure" | "partial";
-    detail: string;
-    /**
-     * Passthrough of {@link ExecuteOutput.artifact} when the executor emitted
-     * one. Reactive executors like `refineExecutor` populate this; LLM-backed
-     * default executors leave it undefined.
-     */
-    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;
-/** Result of the VERIFY stage. */
-interface VerifyResult<A = unknown> {
-    item: TriagedItem;
-    execution: ExecutionResult<A>;
-    verified: boolean;
-    findings: string[];
-    errorClass?: ErrorClass;
-}
-/**
- * Verifier output shape — what a custom verifier emits. The harness
- * assembles this into the full {@link VerifyResult} using the triaged
- * item + execute output sampled from `executeContextNode`.
- */
-interface VerifyOutput {
-    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;
-}
-
-/** 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? Only meaningful when `gated: true`. */
-    startOpen?: boolean;
-}
-/**
- * Accumulating per-job payload threaded through the harness's
- * `executeFlow` ({@link harnessLoop} Tier 6.5 C2 lock). Each stage's work fn
- * receives the prior payload and returns a new one with its own field
- * filled in:
- *
- * - The `enqueueEffect` seeds with `{ item }` only.
- * - The execute work fn fills `execution`.
- * - The verify work fn fills `verify`.
- *
- * The post-completed dispatch effect reads `verify.verified` /
- * `verify.errorClass` to route the item to `verifyResults` /
- * `retryTopic.publish(...)` / `intake.publish(...)` (3-way verdict).
- *
- * Carrying `item` through stage payloads (rather than re-pairing via a
- * separate `withLatestFrom` node) is the C2 deviation from today's
- * `executeContextNode` design: each `JobEnvelope` is self-contained, so the
- * verify pump can run multiple in-flight jobs in parallel without an
- * external pairing node.
- */
-interface HarnessJobPayload<A = unknown> {
-    /** The triaged item flowing through execute → verify → dispatch. */
-    item: TriagedItem;
-    /** Filled by the execute work fn. Verify reads this; dispatch routes. */
-    execution?: ExecutionResult<A>;
-    /** Filled by the verify work fn. Dispatch reads `verified` / `errorClass`. */
-    verify?: VerifyOutput;
-}
-/**
- * Pluggable EXECUTE work fn — receives a {@link JobEnvelope} carrying a
- * {@link HarnessJobPayload} (with `item` set, `execution` / `verify`
- * unset), returns a {@link NodeInput} that emits the same payload with
- * `execution` filled.
- *
- * **C2 contract (Tier 6.5 lock, 2026-04-28):**
- * 1. Emit DATA exactly once per claimed job. The JobFlow pump subscribes
- *    once, takes the first DATA, then unsubscribes. Subsequent emissions
- *    are ignored.
- * 2. Errors must be caught and surfaced as a `failure` outcome inside the
- *    payload — never throw / return ERROR. A pump nack would drop the
- *    item from JobFlow before the dispatch effect could route it.
- * 3. The work fn runs once per claim — no internal `switchMap` needed.
- *    Per-item subgraphs (e.g. a fresh `refineLoop` per claim) are
- *    instantiated inside the work fn body.
- *
- * `defaultLlmExecutor` (in `defaults.ts`) is a thin `adapter.invoke()`
- * wrapper. `refineExecutor` builds a per-claim `refineLoop`.
- * `actuatorExecutor` runs a side-effecting `apply(item, signal)`.
- */
-type HarnessExecutor<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>, opts?: {
-    signal: AbortSignal;
-}) => NodeInput<HarnessJobPayload<A>>;
-/**
- * Pluggable VERIFY work fn — receives a {@link JobEnvelope} whose payload
- * has `item` + `execution` populated, returns a {@link NodeInput} that
- * emits the same payload with `verify` filled.
- *
- * Same C2 contract rules 1–3 as {@link HarnessExecutor}. The dispatch
- * effect downstream reads `verify.verified` (success → ack +
- * verifyResults publish), `verify.errorClass === "self-correctable"`
- * (retry → republish to retry topic with `$retries` bumped), or anything
- * else (structural → reingest to intake if budget remains).
- *
- * Verify-LLM-call failures (parse error, adapter throw, timeout) MUST be
- * caught and surfaced as a structural-failure `verify` payload (`{
- * verified: false, findings: [...], errorClass: "structural" }`) so the
- * dispatch effect can route the item rather than silently drop it.
- */
-type HarnessVerifier<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>, opts?: {
-    signal: AbortSignal;
-}) => NodeInput<HarnessJobPayload<A>>;
-/** 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<A = unknown> {
-    /** LLM adapter for promptNode-based stages (triage + any default executor/verifier). */
-    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 | ExecutePromptFn;
-    /**
-     * Verify prompt — sugar over the default LLM verifier. Ignored when
-     * `verifier` is set.
-     */
-    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<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<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). */
-    maxRetries?: number;
-    /** Global retry cap across all items — circuit breaker (default maxRetries × 10). */
-    maxTotalRetries?: number;
-    /** Max re-ingestions from verify→intake before giving up (default 1). */
-    maxReingestions?: number;
-    /** Global reingestion cap across all items — circuit breaker (default maxReingestions × 10). */
-    maxTotalReingestions?: number;
-    /** Retained limit for topic logs (default 1000). */
-    retainedLimit?: number;
-    /**
-     * Per-pump-tick claim cap on the internal `executeFlow` JobFlow's `execute`
-     * stage (Tier 6.5 C2). Default `Number.MAX_SAFE_INTEGER` — every pending
-     * claim is processed in one tick (matches today's unbounded `merge()`
-     * parallelism). Lower this to bound LLM cost spikes on bursty intake.
-     *
-     * **Caveat.** This caps **claims per pump tick**, not total concurrent
-     * inflight. Bounded-inflight is a separate primitive concern — see
-     * `docs/optimizations.md` "Tier 6.5 follow-up — bounded concurrent inflight
-     * on JobFlow stages".
-     */
-    executeMaxPerPump?: number;
-    /**
-     * Per-pump-tick claim cap on the internal `executeFlow` JobFlow's
-     * `verify` stage. Default `Number.MAX_SAFE_INTEGER`. Same caveat as
-     * {@link HarnessLoopOptions.executeMaxPerPump}. Honored independently
-     * of the execute cap via `StageDef.maxPerPump` (Tier 6.5 D1).
-     */
-    verifyMaxPerPump?: number;
-}
-
-/**
- * actuatorExecutor — bridge a side-effecting actuator into the harness
- * EXECUTE work fn.
- *
- * `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-claim lifecycle:
- *
- * 1. **One DATA per claim.** The producer captures the first DATA from
- *    the bridged `apply` result, emits a {@link HarnessJobPayload} with
- *    `execution` filled in, and completes. Subsequent inner DATAs are
- *    ignored.
- * 2. **Cancel-on-teardown.** When the JobFlow pump unsubscribes (after
- *    capturing first DATA, or on graph teardown), the producer's cleanup
- *    fires `ac.abort()` which propagates into `apply`'s `signal`.
- * 3. **Errors surfaced as failure payload.** A thrown / ERROR result is
- *    mapped via `onError` into a `failure`-outcome `ExecuteOutput` so the
- *    dispatch effect can route the item rather than silently dropping it.
- *
- * **What `apply` may return.** Anything `fromAny` accepts: `Promise<R>`,
- * `Node<R>`, `AsyncIterable<R>`, `Iterable<R>`, or a synchronous `R`.
- * `Promise<R>` is the typical shape (`writeFile`, `fetch`, `db.execute`).
- *
- * **Pairing with `evalVerifier`.** `ExecuteOutput.artifact` is set to
- * the actuation record; an `evalVerifier<R>` whose `extractArtifact`
- * returns the record (or the post-apply world state) closes EXECUTE →
- * VERIFY 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.
- */
-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 the
-     * pump's teardown 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"`. Use to route interventions the actuator can't
-     * handle into the failure path.
-     */
-    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>`.
-     */
-    toOutput?: (record: R, item: TriagedItem) => ExecuteOutput<R>;
-    /**
-     * Map a thrown / ERROR result into an `ExecuteOutput<R>`.
-     */
-    onError?: (err: unknown, item: TriagedItem) => ExecuteOutput<R>;
-    /** Node name prefix for `describe()` introspection. */
-    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>({ ... }),
- * });
- * ```
- */
-declare function actuatorExecutor<R>(config: ActuatorExecutorConfig<R>): HarnessExecutor<R>;
-/**
- * Apply callback shape consumed by {@link dispatchActuator}. Same shape as
- * {@link ActuatorExecutorConfig.apply}.
- */
-type ActuatorApplyFn<R> = (item: TriagedItem, opts: {
-    signal: AbortSignal;
-}) => ActuatorResult<R>;
-/** Configuration for {@link dispatchActuator}. */
-interface DispatchActuatorConfig<R> {
-    /**
-     * Per-intervention apply callbacks. Keyed by `TriagedItem.intervention`.
-     * Items whose intervention is not in `routes` fall through to `default`
-     * (when set) or emit a skip-failure `ExecuteOutput`.
-     */
-    routes: Readonly<Partial<Record<TriagedItem["intervention"], ActuatorApplyFn<R>>>>;
-    /** Fallback apply callback for items whose intervention is not in `routes`. */
-    default?: ActuatorApplyFn<R>;
-    /** Node name prefix for `describe()` introspection. */
-    name?: string;
-}
-/**
- * Multi-intervention actuator — dispatches each `TriagedItem` to one of
- * several `apply` callbacks based on `item.intervention`.
- *
- * Internally builds a single `actuatorExecutor` whose `apply` resolves the
- * intervention → callback at call-time. Items with no matching route and no
- * `default` emit a skip-failure with detail
- * `"no route for intervention 'X'"`.
- */
-declare function dispatchActuator<R>(config: DispatchActuatorConfig<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).
- *
- * Intake bridges, eval source wrapper, before/after comparison,
- * affected-task filter, code-change bridge, and notification effect.
- * All are compositions of existing primitives — no new abstractions.
- *
- * @module
- */
-
-/** Options for {@link createIntakeBridge}. */
-interface IntakeBridgeOptions {
-    /** Name for the effect node (default "intake-bridge"). */
-    name?: string;
-}
-/**
- * Generic source→intake bridge factory.
- *
- * Watches a source node for new values, passes each through a user-supplied
- * `parser` that produces zero or more `IntakeItem`s, and publishes them to
- * the given intake topic.
- *
- * This is the generalized pattern behind {@link evalIntakeBridge}. Use it for
- * CI results, test failures, Slack messages, monitoring alerts, or any domain
- * where structured results should flow into a harness loop.
- *
- * @param source - Reactive node emitting domain-specific data.
- * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
- * @param parser - Converts source data into IntakeItem[]. Return empty array to skip.
- * @param opts - Optional configuration.
- * @returns The effect node (for lifecycle management).
- */
-declare function createIntakeBridge<T>(source: Node<T>, intakeTopic: TopicGraph<IntakeItem>, parser: (value: T) => IntakeItem[], opts?: IntakeBridgeOptions): Node<unknown>;
-/**
- * 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 EvalRunResult {
-    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 EvalRunResult (or EvalRunResult[]).
- * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
- * @param opts - Optional configuration.
- * @returns The effect node (for lifecycle management).
- */
-declare function evalIntakeBridge(evalSource: Node<EvalRunResult | EvalRunResult[]>, intakeTopic: TopicGraph<IntakeItem>, opts?: EvalIntakeBridgeOptions): Node<unknown>;
-/**
- * Wrap any eval runner as a reactive producer node.
- *
- * When `trigger` emits, calls `runner()` and emits the result downstream.
- * Uses `switchMap` + `fromAny` — the async boundary stays in the source
- * layer (spec §5.10). A new trigger cancels any in-flight run.
- *
- * ```ts
- * const trigger = state(0);         // bump to trigger a new run
- * const results = evalSource(trigger, () => runEvals(config));
- * results.subscribe(msgs => { ... });
- * trigger.emit(1);                   // fires the runner
- * ```
- *
- * @param trigger - Any node; each new DATA emission fires the runner.
- * @param runner  - Returns an EvalRunResult (or promise of one).
- */
-declare function evalSource<T extends EvalRunResult>(trigger: Node<unknown>, runner: () => T | Promise<T>): Node<T>;
-/** Per-task delta produced by {@link beforeAfterCompare}. */
-interface EvalTaskDelta {
-    taskId: string;
-    before: boolean;
-    after: boolean;
-    /** Score-level diff (after − before), undefined if no scores present. */
-    scoreDiff?: number;
-}
-/** Output of {@link beforeAfterCompare}. */
-interface EvalDelta {
-    /** Task IDs that newly fail in `after` (were passing in `before`). */
-    newFailures: string[];
-    /** Task IDs that now pass in `after` (were failing in `before`). */
-    resolved: string[];
-    /** Full per-task breakdown. */
-    taskDeltas: EvalTaskDelta[];
-    /** True when net resolutions > net failures. */
-    overallImproved: boolean;
-}
-/**
- * Derived node that computes before/after eval deltas.
- *
- * Pure computation: no LLM, no async. Compares per-task validity and
- * pass counts between two `EvalRunResult` snapshots.
- *
- * @param before - Node holding the baseline eval result.
- * @param after  - Node holding the new eval result.
- */
-declare function beforeAfterCompare(before: Node<EvalRunResult>, after: Node<EvalRunResult>): Node<EvalDelta>;
-/**
- * Derived node that selects which eval task IDs to re-run.
- *
- * Collects `affectsEvalTasks` from all triaged items, deduplicates, then
- * optionally intersects with `fullTaskSet`. Returns a sorted array of IDs.
- *
- * Use this to avoid re-running the full eval suite after each fix: only the
- * tasks that the triaged items claim to affect are returned.
- *
- * @param issues      - Node holding the current list of triaged items.
- * @param fullTaskSet - Optional node (or plain array) of all known task IDs.
- *                      When provided, output is the intersection.
- */
-declare function affectedTaskFilter(issues: Node<readonly TriagedItem[]>, fullTaskSet?: Node<readonly string[]> | readonly string[]): Node<string[]>;
-/** A single lint error emitted by a CI tool. */
-interface LintError {
-    file: string;
-    line: number;
-    col: number;
-    rule: string;
-    message: string;
-}
-/** A single test failure emitted by a test runner. */
-interface TestFailure {
-    testId: string;
-    file: string;
-    message: string;
-}
-/** Structured code-change / CI event. */
-interface CodeChange {
-    /** Files touched by the change. */
-    files: string[];
-    lintErrors?: LintError[];
-    testFailures?: TestFailure[];
-}
-/** Options for {@link codeChangeBridge}. */
-interface CodeChangeBridgeOptions {
-    /** Name for the effect node (default "code-change-bridge"). */
-    name?: string;
-    /** Default severity for generated IntakeItems (default "high"). */
-    defaultSeverity?: Severity;
-}
-/**
- * Intake bridge for code-change / CI events.
- *
- * Watches a source node for `CodeChange` events and publishes one
- * `IntakeItem` per lint error and per test failure to the intake topic.
- * Pass a custom `parser` to override the default mapping.
- *
- * @param source      - Node emitting CodeChange events.
- * @param intakeTopic - TopicGraph to publish IntakeItem entries to.
- * @param parser      - Optional custom parser (overrides default).
- * @param opts        - Optional configuration.
- */
-declare function codeChangeBridge(source: Node<CodeChange>, intakeTopic: TopicGraph<IntakeItem>, parser?: (change: CodeChange) => IntakeItem[], opts?: CodeChangeBridgeOptions): Node<unknown>;
-/** Transport function for {@link notifyEffect}. Sync or async. */
-type NotifyTransport<T> = (item: T) => void | Promise<void>;
-/** Options for {@link notifyEffect}. */
-interface NotifyEffectOptions {
-    /** Name for the effect node (default "notify-effect"). */
-    name?: string;
-}
-/**
- * Effect node that sends each new topic entry to an external channel.
- *
- * The `transport` function is called for every item published to `topic`.
- * Async transports are bridged via `fromAny` (spec §5.10 compliant).
- *
- * Typical use: Slack webhook, GitHub PR comment, email notification, etc.
- * The factory provides reactive wiring; the transport supplies domain logic.
- *
- * ```ts
- * notifyEffect(alertQueue, async (item) => {
- *   await fetch(SLACK_WEBHOOK, { method: 'POST', body: JSON.stringify({ text: item.summary }) });
- * });
- * ```
- *
- * @param topic     - TopicGraph whose latest entry triggers the notification.
- * @param transport - Called with each new item. May return a Promise.
- * @param opts      - Optional configuration.
- */
-declare function notifyEffect<T>(topic: TopicGraph<T>, transport: NotifyTransport<T>, opts?: NotifyEffectOptions): Node<unknown>;
-
-/**
- * `effectivenessTracker` — action×context → success rate tracker.
- *
- * Demoted from `patterns/reduction` to `patterns/harness/` per Tier 2.3
- * (consolidation plan §1 Rule 6). The only in-tree consumer is the harness
- * strategy model, so the primitive moves alongside it. Building-block status
- * is dropped: this is a harness-shaped preset (a small composition over
- * `reactiveMap` with attempt-counting semantics) rather than an orthogonal
- * primitive.
- *
- * @module
- */
-
-/** A single effectiveness record for an action×context pair. */
-type EffectivenessEntry = {
-    readonly key: string;
-    readonly attempts: number;
-    readonly successes: number;
-    readonly successRate: number;
-};
-/** Snapshot shape for the effectiveness tracker node. */
-type EffectivenessSnapshot = ReadonlyMap<string, EffectivenessEntry>;
-/** Bundle returned by {@link effectivenessTracker}. */
-interface EffectivenessTrackerBundle {
-    /** Reactive node — current effectiveness map snapshot. */
-    readonly node: Node<EffectivenessSnapshot>;
-    /** Record a completed action (success or failure). */
-    record(key: string, success: boolean): void;
-    /** Look up effectiveness for a specific key. */
-    lookup(key: string): EffectivenessEntry | undefined;
-    /** Tear down internal keepalive subscriptions. */
-    dispose(): void;
-}
-/** Options for {@link effectivenessTracker}. */
-type EffectivenessTrackerOptions = {
-    /** Name for the reactive map (default "effectiveness-entries"). */
-    name?: string;
-};
-/**
- * Generic action×context → success rate tracker.
- *
- * Generalized from the harness `strategyModel` pattern. Tracks attempts and
- * successes per string key, exposes a reactive snapshot node, and provides
- * `record()` / `lookup()` methods.
- *
- * Use cases: A/B testing, routing optimization, cache policy tuning, retry
- * strategy selection — any domain that tracks effectiveness per action.
- *
- * @param opts - Optional configuration.
- * @returns Bundle with reactive node, record(), lookup(), dispose().
- */
-declare function effectivenessTracker(opts?: EffectivenessTrackerOptions): EffectivenessTrackerBundle;
-
-/**
- * refineLoop — universal prompt/artifact optimization loop as a reactive Graph.
- *
- * Roadmap §9.8 (Wave 2.5). The loop is a 4-topic reactive pipeline:
- *
- *   iterationTrigger ──▶ GENERATE ──▶ EVALUATE ──▶ ANALYZE ──▶ DECIDE
- *                            │                                   │
- *                            └───────  feedback + trigger  ◀─────┘
- *
- * Each stage is a `TopicGraph` so dispatches stay O(1) per subscriber (cursor-
- * based) and every iteration is observable, replayable, and checkpointable.
- *
- * Composition invariants (from COMPOSITION-GUIDE):
- *  - §7 feedback cycle: only `iterationTrigger` drives re-generation. Strategy
- *    + feedback + dataset are read via closure updaters (§28 factory-time seed)
- *    so mid-run swaps apply to the NEXT iteration, never retrigger the current.
- *  - §28 factory-time seed: strategy, lastFeedback, prevCandidates, dataset
- *    closures captured at wiring time + updated via subscribe handlers so the
- *    first activation doesn't drop the initial pair.
- *  - §32 nested-drain state-mirror: the decide-effect writes `lastFeedback`
- *    BEFORE bumping `iterationTrigger` inside its `batch()`, guaranteeing the
- *    mirror is current when the next-iteration wave reaches the generate fn.
- *  - §19 terminal-emission: history / best emit once per iteration (settled),
- *    not on every intermediate wave.
- *  - §27 attachSnapshotStorage: the whole graph is checkpointable — pause overnight,
- *    resume tomorrow from the exact iteration count, candidate set, strategy.
- *
- * Scope clamp (v1): core factory + `RefineStrategy<T>` + `blindVariation` and
- * `errorCritique` built-ins + budget gating + checkpoint/resume.
- * `mutateAndRefine` / registry / `autoSelectStrategy` / `optimizeCatalog` /
- * `refineExecutor` are deferred.
- *
- * @module
- */
-
-/** A single task row — the unit the evaluator scores one candidate against. */
-interface DatasetItem {
-    readonly id: string;
-    readonly [k: string]: unknown;
-}
-/**
- * One candidate's score on one task. Higher is better by convention.
- *
- * Set `candidateIndex` when the evaluator fans out scores across multiple
- * candidates (e.g. `candidates × tasks`). `pickBest` aggregates mean scores
- * per `candidateIndex` when present; when absent, falls back to positional
- * alignment (`scores[i]` ↔ `candidates[i]`).
- */
-interface EvalResult {
-    readonly taskId: string;
-    readonly score: number;
-    readonly error?: string;
-    readonly detail?: unknown;
-    /** 0-based index into the `candidates` batch this score belongs to. */
-    readonly candidateIndex?: number;
-}
-/** Aggregated feedback the strategy produces from a scores batch. */
-interface Feedback {
-    readonly summary: string;
-    readonly critique?: unknown;
-    readonly weakTasks?: readonly string[];
-    readonly score: number;
-}
-/**
- * Strategy interface — plain object, no base class. Strategies implement three
- * pure hooks; the loop infrastructure wraps them in reactive nodes so every
- * decision is visible in `describe()`.
- *
- * `generate` may be sync or async. Async generates yield a microtask per
- * iteration — that's what gives `pause()` / `setStrategy()` a window to
- * interleave. **A fully synchronous `generate` will drain the entire loop
- * during factory activation** (all iterations run before `refineLoop()`
- * returns), which is usually not what you want for observable, steerable
- * loops. Real strategies that call LLMs / evals are async and Just Work;
- * custom sync strategies for tests are fine but should be marked `async`
- * to match real cadence.
- */
-interface RefineStrategy<T> {
-    readonly name: string;
-    /** Produce initial candidates from the seed. Called at iteration 0. */
-    seed(seed: T): readonly T[];
-    /** Reduce scores to feedback. Pure function. */
-    analyze(scores: readonly EvalResult[], candidates: readonly T[]): Feedback;
-    /**
-     * Generate next-iteration candidates from feedback + prior candidates.
-     * Async allowed — the loop awaits via `fromAny`.
-     */
-    generate(feedback: Feedback, candidates: readonly T[]): Promise<readonly T[]> | readonly T[];
-}
-/**
- * Evaluator shape — Shape 4 (2026-04-22): both `candidates` and `dataset` are
- * reactive nodes; the evaluator's returned node IS the EVALUATE topic's source
- * (no glue). Implementers can batch-eval (e.g. `funnel` with concurrency) or
- * map per-candidate — user's code.
- *
- * **`EvalResult.candidateIndex` semantics.** Optional per-result field.
- * When present, multi-candidate aggregators ({@link errorCritique}'s
- * `pickBest`) score per index, picking the candidate with the highest
- * mean score. When absent across all results, those aggregators fall back
- * to positional matching against `candidates[0]` — meaning a strategy that
- * generates >1 candidate but emits unindexed scores effectively only ever
- * critiques the first candidate. Set `candidateIndex` whenever the
- * evaluator's score corresponds to a specific candidate in the batch.
- */
-type Evaluator<T> = (candidates: Node<readonly T[]>, dataset: Node<readonly DatasetItem[]>) => Node<readonly EvalResult[]>;
-/**
- * Early-stop controls. Each field fans into its own derived node; the four
- * combine via `||` into `converged: Node<boolean>`. Callers see exactly
- * which rule tripped via `status` / the DECIDE topic's `reason`.
- */
-interface ConvergenceOptions {
-    /** Stop when aggregate score has not improved for N iterations. */
-    patience?: number;
-    /** Stop when aggregate score reaches or exceeds this. */
-    minScore?: number;
-    /** Stop when absolute delta between consecutive scores falls below this. */
-    minDelta?: number;
-    /** Stop after N total evaluations (iteration count × per-iter candidates). */
-    maxEvaluations?: number;
-    /** Stop after N iterations. Always set a finite bound in production. */
-    maxIterations?: number;
-}
-/** Emitted to the GENERATE topic each time the strategy produces a batch. */
-interface GenerateEvent<T> {
-    readonly iteration: number;
-    readonly candidates: readonly T[];
-    readonly timestamp_ns: number;
-}
-/** Emitted to the EVALUATE topic when scores settle for an iteration. */
-interface EvaluateEvent<T> {
-    readonly iteration: number;
-    readonly candidates: readonly T[];
-    readonly scores: readonly EvalResult[];
-    readonly timestamp_ns: number;
-}
-/** Emitted to the ANALYZE topic — strategy's reduction over scores. */
-interface AnalyzeEvent<T> {
-    readonly iteration: number;
-    readonly candidates: readonly T[];
-    readonly feedback: Feedback;
-    readonly timestamp_ns: number;
-}
-/** Emitted to the DECIDE topic — branch taken this iteration. */
-interface DecideEvent {
-    readonly iteration: number;
-    readonly decision: "continue" | "converged" | "budget" | "paused";
-    readonly reason?: string;
-    readonly timestamp_ns: number;
-}
-type RefineStatus = "running" | "converged" | "budget" | "paused" | "errored";
-interface Iteration<T> {
-    readonly n: number;
-    readonly candidates: readonly T[];
-    readonly scores: readonly EvalResult[];
-    readonly feedback: Feedback;
-    /** `null` iff the candidate batch for this iteration was empty. */
-    readonly best: T | null;
-    readonly bestScore: number;
-    readonly timestamp_ns: number;
-}
-interface RefineLoopOptions extends ConvergenceOptions {
-    /** Reactive dataset OR a plain array (auto-wrapped into `state`). */
-    dataset: NodeInput<readonly DatasetItem[]> | readonly DatasetItem[];
-    /** Total teacher calls cap across iterations. Default: unlimited. */
-    budget?: number;
-    /** Graph name. Default: `"refine-loop"`. */
-    name?: string;
-    /** Extra graph options forwarded to the underlying `Graph`. */
-    graph?: GraphOptions;
-}
-/**
- * Return type — extends Graph so all observability tools (`describe`,
- * `explain`, `observe`, `attachSnapshotStorage`, `snapshot`) Just Work.
- */
-interface RefineLoopGraph<T> extends Graph {
-    readonly best: Node<T | null>;
-    readonly score: Node<number>;
-    readonly status: Node<RefineStatus>;
-    readonly history: Node<readonly Iteration<T>[]>;
-    readonly strategy: Node<RefineStrategy<T>>;
-    readonly iteration: Node<number>;
-    /** Stage topics — subscribe for per-stage streaming / cursor consumers. */
-    readonly generate: TopicGraph<GenerateEvent<T>>;
-    readonly evaluate: TopicGraph<EvaluateEvent<T>>;
-    readonly analyze: TopicGraph<AnalyzeEvent<T>>;
-    readonly decide: TopicGraph<DecideEvent>;
-    /** Swap the active strategy mid-run (human-in-the-loop handoff). */
-    setStrategy(next: RefineStrategy<T>): void;
-    /** Pause after the current iteration completes. */
-    pause(): void;
-    /** Resume a paused loop. */
-    resume(): void;
-}
-declare function refineLoop<T>(seed: T, evaluator: Evaluator<T>, initialStrategy: RefineStrategy<T>, opts: RefineLoopOptions): RefineLoopGraph<T>;
-/**
- * Context passed to a `blindVariation` teacher per call. `reportCost` is a
- * per-call hook — see `BlindVariationOptions.tokens`.
- */
-interface BlindVariationContext<T> {
-    readonly prior: T;
-    /**
-     * Report tokens consumed by this teacher call. Aggregated per iteration
-     * and flushed to `opts.tokens` in the strategy's `finally` block so
-     * partial spend is preserved when the teacher throws mid-batch.
-     */
-    readonly reportCost: (tokens: number) => void;
-}
-interface BlindVariationOptions<T> {
-    /** Name — default: `"blindVariation"`. */
-    name?: string;
-    /** Number of candidates generated per iteration. Default: 4. */
-    width?: number;
-    /**
-     * Run teacher calls in parallel via `Promise.all`. Default `true` — the
-     * common case (independent LLM calls). Set `false` to run sequentially
-     * via `for/await` when teachers share stateful resources (rate limiters,
-     * rolling context, serial API ordering) that don't tolerate concurrency.
-     */
-    parallel?: boolean;
-    /**
-     * Optional cost counter node. Running total tokens reported via
-     * `ctx.reportCost` during each iteration is added to this node in the
-     * strategy's `finally` block — fires on success AND on teacher throw so
-     * partial spend is never lost. User owns the node; wire to `budgetGate`,
-     * `attachSnapshotStorage`, telemetry, etc.
-     */
-    tokens?: Node<number>;
-    /**
-     * Teacher — given `{prior, reportCost}`, produce one variant. Async
-     * allowed. Called `width` times per iteration. Call `ctx.reportCost(n)`
-     * to track tokens consumed per call (optional, no-op if `opts.tokens`
-     * is not set).
-     */
-    teacher: (ctx: BlindVariationContext<T>) => Promise<T> | T;
-}
-/**
- * Simplest built-in strategy: generate N variants per iteration via the
- * supplied `teacher`; no feedback-informed steering (equivalent to Random
- * Search). Validates the loop infrastructure end-to-end and is the baseline
- * every other strategy should outperform.
- *
- * `analyze` records the mean score and flags the worst task — strategies that
- * care about per-task critique layer on top.
- */
-declare function blindVariation<T>(opts: BlindVariationOptions<T>): RefineStrategy<T>;
-/**
- * Context passed to an `errorCritique` teacher. `critique` is the pre-formatted
- * summary a prompt template can drop in verbatim; `failures` carries the
- * structured evidence (per-task error / score / detail) for richer prompts.
- */
-interface ErrorCritiqueContext<T> {
-    readonly prior: T;
-    readonly critique: string;
-    readonly failures: readonly EvalResult[];
-    /**
-     * Report tokens consumed by this teacher call. Aggregated per iteration
-     * and flushed to `opts.tokens` in the strategy's `finally` block so
-     * partial spend is preserved when the teacher throws mid-batch.
-     */
-    readonly reportCost: (tokens: number) => void;
-}
-interface ErrorCritiqueOptions<T> {
-    /** Name — default: `"errorCritique"`. */
-    name?: string;
-    /** Number of candidates generated per iteration. Default: 4. */
-    width?: number;
-    /**
-     * Cut-off below which a task is classified as a failure and fed into the
-     * critique. Default: the batch mean — any task scoring below the batch
-     * mean is a failure. Pass a number for an absolute cut-off, or a function
-     * for per-batch computation (e.g. a percentile). When the default mean
-     * is non-finite (NaN / ±Infinity from a degenerate evaluator), ALL scores
-     * are treated as failures so the critique loop continues to steer.
-     */
-    failureThreshold?: number | ((scores: readonly EvalResult[]) => number);
-    /** Cap on failure samples packed into the critique. Default: 5. */
-    maxFailureSamples?: number;
-    /**
-     * Format failures into the `critique` string passed to the teacher. Default
-     * joins `- taskId (score=N) | error: …` lines. Override to shape LLM prompts.
-     *
-     * **Note:** the `feedback` argument is a shell with `{score, weakTasks}`
-     * populated; `summary` is empty because `analyze` computes the final summary
-     * AFTER `formatCritique` runs (the summary embeds the formatted count).
-     * Rely on `failures` and `feedback.score` — do not read `feedback.summary`
-     * here.
-     */
-    formatCritique?: (failures: readonly EvalResult[], feedback: Feedback) => string;
-    /**
-     * Run teacher calls in parallel via `Promise.all`. Default `true` — the
-     * common case (independent LLM calls). Set `false` to run sequentially
-     * via `for/await` when teachers share stateful resources (rate limiters,
-     * rolling context, serial API ordering) that don't tolerate concurrency.
-     */
-    parallel?: boolean;
-    /**
-     * Optional cost counter node. Running total tokens reported via
-     * `ctx.reportCost` during each iteration is added to this node in the
-     * strategy's `finally` block — fires on success AND on teacher throw so
-     * partial spend is never lost. User owns the node; wire to `budgetGate`,
-     * `attachSnapshotStorage`, telemetry, etc.
-     */
-    tokens?: Node<number>;
-    /**
-     * Teacher — given `{prior, critique, failures, reportCost}`, produce one
-     * refined variant. Called `width` times per iteration. Async allowed.
-     * Call `ctx.reportCost(n)` to track tokens consumed per call (optional,
-     * no-op if `opts.tokens` is not set).
-     */
-    teacher: (ctx: ErrorCritiqueContext<T>) => Promise<T> | T;
-}
-/**
- * Critique-driven strategy (ProTeGi-style "textual gradient"). Each iteration:
- *   1. `analyze` classifies tasks scoring below a threshold as failures, picks
- *      the best candidate from the batch, and packs both plus a formatted
- *      critique string into `feedback.critique` as a private payload.
- *   2. `generate` unpacks that payload and calls the teacher with
- *      `{prior, critique, failures, reportCost}` `width` times, returning the
- *      refined batch.
- *
- * The teacher receives a pre-formatted string (drop into an LLM prompt) AND
- * the structured failure list (for richer prompts that want per-task detail).
- * Throws on empty candidate batches — matches `blindVariation`'s contract
- * (no silent zero-candidate cycles).
- *
- * When `setStrategy()` swaps this strategy in mid-run, the first `generate`
- * may receive a `Feedback` produced by the prior strategy (no private payload);
- * the fallback path uses `candidates[last]` as the prior and the feedback
- * summary as the critique, so the loop keeps running without a stall. When a
- * private payload IS present, `priv.critiqueText` takes precedence over any
- * edits a caller made to `feedback.summary` — treat `critique` as the
- * strategy-owned channel.
- */
-declare function errorCritique<T>(opts: ErrorCritiqueOptions<T>): RefineStrategy<T>;
-
-/**
- * evalVerifier — re-run the affected eval tasks against the execute-stage
- * artifact instead of asking an LLM to opine on the fix.
- *
- * Pairs naturally with {@link refineExecutor}: refineExecutor emits an
- * `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.
- *
- * **C2 lifecycle (Tier 6.5).** The work fn is invoked once per claimed
- * verify-stage job. A fresh single-candidate eval subgraph is mounted
- * inside the work fn and tears down when the JobFlow pump ack/unsubs.
- *
- * @module
- */
-
-/** Summary of the re-eval wave passed to a custom `toOutput` mapper. */
-interface EvalVerifierSummary {
-    readonly scores: readonly EvalResult[];
-    readonly meanScore: number;
-    readonly passCount: number;
-    readonly total: number;
-    readonly threshold: number;
-    /**
-     * True when the EXECUTE stage did not produce an artifact (i.e.
-     * `extractArtifact` returned `null` / `undefined`). Downstream mappers
-     * can distinguish this from "evaluator ran but everything scored zero".
-     */
-    readonly missingArtifact?: boolean;
-}
-/** Configuration for {@link evalVerifier}. */
-interface EvalVerifierConfig<T> {
-    /**
-     * Pull the artifact that should be re-evaluated out of the execute-stage
-     * output. Default: `(exec) => exec.artifact as T` — works out-of-the-box
-     * with `refineExecutor` (which populates `artifact` by default).
-     */
-    extractArtifact?: (exec: ExecuteOutput<T>, item: TriagedItem) => T | null | undefined;
-    /**
-     * Reactive evaluator — same contract as `refineLoop`'s `Evaluator<T>`.
-     */
-    evaluator: Evaluator<T>;
-    /**
-     * Resolve which dataset rows to score this verification against.
-     */
-    datasetFor: (item: TriagedItem) => readonly DatasetItem[];
-    /** Mean score required to pass verification. Default `0.5`. */
-    threshold?: number;
-    /** Optional output mapper — override the default findings / errorClass shape. */
-    toOutput?: (summary: EvalVerifierSummary) => VerifyOutput;
-    /** Node name prefix for introspection. */
-    name?: string;
-}
-/**
- * Build a {@link HarnessVerifier} that re-runs the eval suite against the
- * artifact produced by EXECUTE.
- *
- * Reads `job.payload.execution` (filled by the upstream execute work fn)
- * and runs the evaluator against `extractArtifact(execution, item)`.
- * Returns the same payload with `verify` filled in.
- *
- * @example Pair with refineExecutor for end-to-end eval consistency.
- * ```ts
- * const evaluator: Evaluator<CatalogEntry> = (cands, ds) => runEval(cands, ds);
- * const harness = harnessLoop("repair", {
- *   adapter,
- *   executor: refineExecutor({ ..., evaluator, ...strategyConfig }),
- *   verifier: evalVerifier({ evaluator, datasetFor, threshold: 0.8 }),
- * });
- * ```
- */
-declare function evalVerifier<T>(config: EvalVerifierConfig<T>): HarnessVerifier<T>;
-/**
- * Config for {@link harnessEvalPair} — the typed bundle that produces a
- * matched `refineExecutor<T>` + `evalVerifier<T>` pair sharing one
- * {@link Evaluator} and one `datasetFor` resolver.
- */
-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;
-}
-/**
- * Typed factory that returns a matched `{ executor, verifier }` pair.
- *
- * 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`).
- */
-declare function harnessEvalPair<T>(config: HarnessEvalPairConfig<T>): {
-    executor: HarnessExecutor<T>;
-    verifier: HarnessVerifier<T>;
-};
-
-/**
- * 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.
- *
- * **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()`.
- *
- * **EXECUTE/VERIFY via JobFlow (Tier 6.5 C2 lock, 2026-04-28).** The
- * stages 5–6 EXECUTE → VERIFY pair runs through an internal `executeFlow`
- * JobFlow with two stages (`execute`, `verify`). Each stage's pump owns
- * `claim → work → ack` for one claim; the verify stage's payload contains
- * `{ item, execution, verify }` so the post-completed dispatch effect can
- * route the 3-way verdict (verified / self-correctable retry / structural
- * + reingest) without any cross-wave `withLatestFrom` pairing. Items
- * arriving from per-route topics + retry feedback enter via a single
- * `enqueueEffect` that pushes to `executeFlow.queue("execute")`.
- *
- * @module
- */
-
-/**
- * Build the default EXECUTE work fn — calls `adapter.invoke()` once per
- * claimed job, parses the JSON response into an `ExecuteOutput<A>`, and
- * returns a {@link HarnessJobPayload} with `execution` filled in.
- *
- * Errors (parse failure, adapter throw, malformed JSON) are caught and
- * surfaced as a `failure`-outcome payload — the dispatch effect routes
- * the item rather than dropping it via pump nack (see C2 contract on
- * {@link HarnessExecutor}).
- *
- * Subsumes the pre-Tier-6.5 `promptNode`-based default: per-claim LLM
- * calls don't benefit from `promptNode`'s cross-wave switchMap, and a
- * fresh per-claim subgraph would be wasteful. Direct `adapter.invoke`
- * is the right shape inside JobFlow pumps.
- *
- * @param adapter - LLMAdapter for the execute call.
- * @param prompt  - Prompt template (string or `(item) => string`). Defaults
- *                   to the harness's built-in execute prompt.
- */
-declare function defaultLlmExecutor<A = unknown>(adapter: LLMAdapter, prompt?: string | ExecutePromptFn): HarnessExecutor<A>;
-/**
- * Build the default VERIFY work fn — calls `adapter.invoke()` once per
- * claimed job to review the prior-stage execution, parses the JSON
- * response into a `VerifyOutput`, and returns a {@link HarnessJobPayload}
- * with `verify` filled in.
- *
- * Same C2 error semantics as {@link defaultLlmExecutor}: parse / adapter
- * failures are surfaced as a structural-failure verify payload so the
- * dispatch effect routes the item.
- */
-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), plus an `executeFlow` JobFlow that owns the
- * EXECUTE → VERIFY pipeline (Tier 6.5 C2). 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;
-    /**
-     * EXECUTE → VERIFY JobFlow (Tier 6.5 C2). Pumps own claim/ack/nack
-     * lifecycle for each stage. Inspect via:
-     * - `harness.executeFlow.queue("execute").pending` — pending depth.
-     * - `harness.executeFlow.queue("verify").pending` — items mid-execute.
-     * - `harness.executeFlow.completed` — verified items waiting for the
-     *   dispatch effect's 3-way routing.
-     * - `harness.executeFlow.completedCount` — total terminal completions.
-     */
-    readonly executeFlow: JobFlowGraph<HarnessJobPayload<A>>;
-    /**
-     * Per-route JobQueueGraph audit mirrors. Each triaged item that reaches
-     * a queue is also enqueued here, giving reactive `depth` + `pending` +
-     * `jobs` observables per route. The dispatch effect ack/removeBy-id's
-     * the matching job on terminal verdict. The executeFlow JobFlow handles
-     * the EXECUTE → VERIFY data flow; this is a parallel audit-side ledger
-     * for per-route depth metrics. Inspect via
-     * `harness.jobs.get(route).depth.cache` for backpressure metrics.
-     */
-    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.
-     */
-    readonly queueTopics: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
-    /** Strategy model bundle — record outcomes, lookup effectiveness. */
-    readonly strategy: StrategyModelBundle;
-    /** 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>;
-    /**
-     * 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>>;
-    /**
-     * REFLECT-stage tick marker — emits one DATA per terminal verdict observed
-     * on `executeFlow.completed`. `equals: () => false` so each completion
-     * produces an observable tick (no Object.is collapse on identical
-     * `null` payloads). Inspection tools (`harnessTrace`, dashboards) can
-     * subscribe directly here instead of resolving by string path
-     * (`harness.node("reflect")`) — the field is the lock against rename
-     * drift.
-     */
-    readonly reflect: Node<null>;
-    constructor(name: string, queues: MessagingHubGraph, executeFlow: JobFlowGraph<HarnessJobPayload<A>>, queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, reflect: Node<null>, 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.
-     *
-     * Decouples inspection tools (`harnessTrace`, `harnessProfile`, custom
-     * dashboards) from mount-structure churn: hub migration, future stage
-     * splits, gate remounting, or the Tier 6.5 C2 JobFlow rewire shouldn't
-     * require edits to `trace.ts` as long as this method stays accurate.
-     *
-     * Each stage yields `{ label, paths }`; consumers iterate paths per
-     * stage and attach observers. Tier 6.5: EXECUTE / VERIFY paths now
-     * resolve to the `executeFlow` stage queues + the `verify-dispatch`
-     * effect node.
-     */
-    stageNodes(): ReadonlyArray<{
-        label: string;
-        paths: readonly string[];
-    }>;
-}
-/**
- * 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** — JobFlow `execute` stage; user-supplied or default work fn
- * 6. **VERIFY** — JobFlow `verify` stage; verifies the executed artifact
- * 7. **REFLECT** — strategy model records outcomes; dispatch effect routes 3-way
- *
- * @param name - Graph name.
- * @param opts - Configuration.
- * @returns HarnessGraph with controller accessors.
- */
-declare function harnessLoop<A = unknown>(name: string, opts: HarnessLoopOptions<A>): HarnessGraph<A>;
-
-/**
- * Harness-specific graph profiling (roadmap §9.0).
- *
- * Extends {@link graphProfile} with harness domain counters:
- * queue depths, strategy entries, retry/reingestion tracker sizes.
- *
- * @module
- */
-
-/** Harness-specific profile extending the base graph profile. */
-interface HarnessProfileResult extends GraphProfileResult {
-    /** Per-queue retained item counts. */
-    queueDepths: Record<QueueRoute, number>;
-    /** Number of rootCause→intervention entries in the strategy model. */
-    strategyEntries: number;
-    /** Global retry count across all items. */
-    totalRetries: number;
-    /** Global reingestion count across all items. */
-    totalReingestions: number;
-}
-/**
- * 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.
- */
-declare function harnessProfile(harness: HarnessGraph, opts?: GraphProfileOptions): HarnessProfileResult;
-
-/**
- * refineExecutor — bridge a `refineLoop` into the harness EXECUTE work fn.
- *
- * Each claimed job mounts a fresh `refineLoop`; when the loop reaches a
- * terminal status (`converged` / `budget` / `errored`), the work fn emits a
- * single {@link HarnessJobPayload} with `execution` filled in. The JobFlow
- * pump subscribes once, takes the first DATA, then unsubscribes — so the
- * inner loop tears down cleanly when the harness acks the job.
- *
- * **C2 lifecycle (Tier 6.5).** The work fn is invoked once per claim, so
- * no internal `switchMap` is needed (the prior pre-C2 shape used switchMap
- * to handle a stream of items). The pump owns the per-claim lifecycle:
- * activation when the work fn returns, teardown when the result Node is
- * unsubscribed.
- *
- * **Cross-item learning:** a fresh refineLoop per item means
- * `errorCritique`-style failure sampling does NOT accumulate across items
- * sharing a `rootCause`. A persistent-loop + re-seed surface is filed in
- * `docs/optimizations.md` as a long-term follow-up.
- *
- * @module
- */
-
-/** Terminal-run snapshot passed to a custom `toOutput` mapper. */
-interface RefineExecutorResult<T> {
-    /** Best candidate the inner loop converged on. `null` if no candidates were scored. */
-    readonly best: T | null;
-    /** Aggregate score at termination. `-Infinity` if the batch was empty. */
-    readonly score: number;
-    /** Reason the loop terminated. */
-    readonly status: RefineStatus;
-}
-/** Configuration for {@link refineExecutor}. */
-interface RefineExecutorConfig<T> {
-    /** Map a triaged item to the seed candidate (e.g. a catalog entry, prompt, patch). */
-    seedFrom: (item: TriagedItem) => T;
-    /** Reactive evaluator — same shape as passed to `refineLoop`. */
-    evaluator: Evaluator<T>;
-    /** Strategy (e.g. `errorCritique(teacher)`). Applied to every item's inner loop. */
-    strategy: RefineStrategy<T>;
-    /** Map a triaged item to the dataset rows the evaluator should score against. */
-    datasetFor: (item: TriagedItem) => readonly DatasetItem[];
-    /**
-     * Optional mapper from the inner loop's terminal snapshot to an
-     * `ExecuteOutput<T>`. Default: converged→success, budget→partial,
-     * errored→failure.
-     */
-    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"`. */
-    name?: string;
-}
-/**
- * Build a {@link HarnessExecutor} backed by a `refineLoop` per claimed
- * job.
- *
- * @example Eval-driven repair loop in the harness EXECUTE slot.
- * ```ts
- * const harness = harnessLoop("repair", {
- *   adapter,
- *   executor: refineExecutor({
- *     seedFrom: (item) => initialCatalogEntry(item),
- *     datasetFor: (item) => pickAffectedTasks(item, allTasks),
- *     evaluator: (cands, tasks) => runEvalBatch(cands, tasks),
- *     strategy: errorCritique({ teacher, width: 3 }),
- *     refine: { maxIterations: 5, minScore: 0.9 },
- *   }),
- * });
- * ```
- */
-declare function refineExecutor<T>(config: RefineExecutorConfig<T>): HarnessExecutor<T>;
-
-/**
- * Harness pipeline trace — thin sugar over `graph.observe({ format: "stage-log" })`.
- *
- * Since 2026-04-22 (D2), stage-labeled tracing is a first-class observe format
- * on {@link Graph}. `harnessTrace` wires that format over the 7 pipeline stages
- * (INTAKE → TRIAGE → QUEUE → GATE → EXECUTE → VERIFY → STRATEGY) with sensible
- * defaults so harness consumers don't need to restate the stage map.
- *
- * For non-harness graphs, call `graph.observe({ format: "stage-log", stageLabels })`
- * directly — the format is domain-agnostic.
- *
- * @module
- */
-
-/** Event type captured by structured trace. */
-type TraceEventType = "data" | "error" | "complete";
-/** A single structured trace event. */
-interface TraceEvent {
-    /** Elapsed seconds since trace was created. */
-    elapsed: number;
-    /** Pipeline stage label (INTAKE, TRIAGE, QUEUE, GATE, EXECUTE, VERIFY, STRATEGY). */
-    stage: string;
-    /** Event type. */
-    type: TraceEventType;
-    /** Data payload (present for "data" and "error" events). Omitted at "summary" detail. */
-    data?: unknown;
-    /** Human-readable summary of the data. Present at "standard" and "full" detail. */
-    summary?: string;
-}
-/** Detail level for trace output. */
-type TraceDetail = 
-/** Stage + elapsed only. No data preview. Lowest overhead. */
-"summary"
-/** Stage + elapsed + truncated data preview. Default. */
- | "standard"
-/** Stage + elapsed + full raw data. Use for debugging, not production. */
- | "full";
-/** Handle returned by {@link harnessTrace}. Call `dispose()` to stop tracing. */
-interface HarnessTraceHandle {
-    /** Stop tracing and detach all observers. Safe to call multiple times. */
-    dispose(): void;
-    /**
-     * Structured trace events collected since creation. Plain array — no
-     * subscription needed (COMPOSITION-GUIDE §1: avoid lazy-activation
-     * friction for inspection tools). Populated reactively via observe().
-     */
-    readonly events: readonly TraceEvent[];
-}
-/** Options for {@link harnessTrace}. */
-interface HarnessTraceOptions {
-    /** Sink for rendered trace lines. Default: `console.log`. Pass `null` for structured-only. */
-    logger?: ((line: string) => void) | null;
-    /** Detail level for both string and structured output. Default: `"summary"`. */
-    detail?: TraceDetail;
-}
-/**
- * Attach a stage-log trace over the harness pipeline. Delegates to
- * `harness.observe({ format: "stage-log", ... })` for each stage path —
- * every event is captured in `handle.events` (structured) AND rendered via
- * the `logger` (string output).
- *
- * **Detail levels:**
- * - `"summary"` — stage + elapsed only. Minimal overhead.
- * - `"standard"` (default) — stage + elapsed + truncated data preview.
- * - `"full"` — stage + elapsed + full raw data object in events.
- *
- * Elapsed timestamps are relative to the `harnessTrace()` invocation time,
- * not the first event.
- */
-declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions): HarnessTraceHandle;
-
-/**
- * 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
- */
-
-type index_ActuatorApplyFn<R> = ActuatorApplyFn<R>;
-type index_ActuatorExecutorConfig<R> = ActuatorExecutorConfig<R>;
-type index_ActuatorResult<R> = ActuatorResult<R>;
-type index_AnalyzeEvent<T> = AnalyzeEvent<T>;
-type index_AutoSolidifyConfig<R, T = R> = AutoSolidifyConfig<R, T>;
-type index_BlindVariationContext<T> = BlindVariationContext<T>;
-type index_BlindVariationOptions<T> = BlindVariationOptions<T>;
-type index_CodeChange = CodeChange;
-type index_CodeChangeBridgeOptions = CodeChangeBridgeOptions;
-type index_ConvergenceOptions = ConvergenceOptions;
-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_DatasetItem = DatasetItem;
-type index_DecideEvent = DecideEvent;
-type index_DispatchActuatorConfig<R> = DispatchActuatorConfig<R>;
-type index_EffectivenessEntry = EffectivenessEntry;
-type index_EffectivenessSnapshot = EffectivenessSnapshot;
-type index_EffectivenessTrackerBundle = EffectivenessTrackerBundle;
-type index_EffectivenessTrackerOptions = EffectivenessTrackerOptions;
-type index_ErrorClass = ErrorClass;
-type index_ErrorClassifier = ErrorClassifier;
-type index_ErrorCritiqueContext<T> = ErrorCritiqueContext<T>;
-type index_ErrorCritiqueOptions<T> = ErrorCritiqueOptions<T>;
-type index_EvalDelta = EvalDelta;
-type index_EvalIntakeBridgeOptions = EvalIntakeBridgeOptions;
-type index_EvalJudgeScore = EvalJudgeScore;
-type index_EvalResult = EvalResult;
-type index_EvalRunResult = EvalRunResult;
-type index_EvalTaskDelta = EvalTaskDelta;
-type index_EvalTaskResult = EvalTaskResult;
-type index_EvalVerifierConfig<T> = EvalVerifierConfig<T>;
-type index_EvalVerifierSummary = EvalVerifierSummary;
-type index_EvaluateEvent<T> = EvaluateEvent<T>;
-type index_Evaluator<T> = Evaluator<T>;
-type index_ExecuteOutput<A = unknown> = ExecuteOutput<A>;
-type index_ExecutePromptFn = ExecutePromptFn;
-type index_ExecutionResult<A = unknown> = ExecutionResult<A>;
-type index_Feedback = Feedback;
-type index_GenerateEvent<T> = GenerateEvent<T>;
-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_HarnessJobPayload<A = unknown> = HarnessJobPayload<A>;
-type index_HarnessLoopOptions<A = unknown> = HarnessLoopOptions<A>;
-type index_HarnessProfileResult = HarnessProfileResult;
-type index_HarnessTraceHandle = HarnessTraceHandle;
-type index_HarnessTraceOptions = HarnessTraceOptions;
-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_Iteration<T> = Iteration<T>;
-type index_KnownIntakeSource = KnownIntakeSource;
-type index_LintError = LintError;
-type index_NotifyEffectOptions = NotifyEffectOptions;
-type index_NotifyTransport<T> = NotifyTransport<T>;
-type index_PrioritySignals = PrioritySignals;
-declare const index_QUEUE_NAMES: typeof QUEUE_NAMES;
-type index_QueueConfig = QueueConfig;
-type index_QueueRoute = QueueRoute;
-type index_RefineExecutorConfig<T> = RefineExecutorConfig<T>;
-type index_RefineExecutorResult<T> = RefineExecutorResult<T>;
-type index_RefineLoopGraph<T> = RefineLoopGraph<T>;
-type index_RefineLoopOptions = RefineLoopOptions;
-type index_RefineStatus = RefineStatus;
-type index_RefineStrategy<T> = RefineStrategy<T>;
-type index_RootCause = RootCause;
-type index_Severity = Severity;
-type index_StrategyEntry = StrategyEntry;
-type index_StrategyKey = StrategyKey;
-type index_StrategyModelBundle = StrategyModelBundle;
-type index_StrategySnapshot = StrategySnapshot;
-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_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_blindVariation: typeof blindVariation;
-declare const index_codeChangeBridge: typeof codeChangeBridge;
-declare const index_createIntakeBridge: typeof createIntakeBridge;
-declare const index_defaultErrorClassifier: typeof defaultErrorClassifier;
-declare const index_defaultLlmExecutor: typeof defaultLlmExecutor;
-declare const index_defaultLlmVerifier: typeof defaultLlmVerifier;
-declare const index_dispatchActuator: typeof dispatchActuator;
-declare const index_effectivenessTracker: typeof effectivenessTracker;
-declare const index_errorCritique: typeof errorCritique;
-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_refineLoop: typeof refineLoop;
-declare const index_resolvePromptFn: typeof resolvePromptFn;
-declare const index_strategyKey: typeof strategyKey;
-declare const index_strategyModel: typeof strategyModel;
-declare namespace index {
-  export { type index_ActuatorApplyFn as ActuatorApplyFn, type index_ActuatorExecutorConfig as ActuatorExecutorConfig, type index_ActuatorResult as ActuatorResult, type index_AnalyzeEvent as AnalyzeEvent, type index_AutoSolidifyConfig as AutoSolidifyConfig, type index_BlindVariationContext as BlindVariationContext, type index_BlindVariationOptions as BlindVariationOptions, type index_CodeChange as CodeChange, type index_CodeChangeBridgeOptions as CodeChangeBridgeOptions, type index_ConvergenceOptions as ConvergenceOptions, 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_DatasetItem as DatasetItem, type index_DecideEvent as DecideEvent, type index_DispatchActuatorConfig as DispatchActuatorConfig, type index_EffectivenessEntry as EffectivenessEntry, type index_EffectivenessSnapshot as EffectivenessSnapshot, type index_EffectivenessTrackerBundle as EffectivenessTrackerBundle, type index_EffectivenessTrackerOptions as EffectivenessTrackerOptions, type index_ErrorClass as ErrorClass, type index_ErrorClassifier as ErrorClassifier, type index_ErrorCritiqueContext as ErrorCritiqueContext, type index_ErrorCritiqueOptions as ErrorCritiqueOptions, type index_EvalDelta as EvalDelta, type index_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index_EvalJudgeScore as EvalJudgeScore, type index_EvalResult as EvalResult, type index_EvalRunResult as EvalRunResult, type index_EvalTaskDelta as EvalTaskDelta, type index_EvalTaskResult as EvalTaskResult, type index_EvalVerifierConfig as EvalVerifierConfig, type index_EvalVerifierSummary as EvalVerifierSummary, type index_EvaluateEvent as EvaluateEvent, type index_Evaluator as Evaluator, type index_ExecuteOutput as ExecuteOutput, type index_ExecutePromptFn as ExecutePromptFn, type index_ExecutionResult as ExecutionResult, type index_Feedback as Feedback, type index_GenerateEvent as GenerateEvent, type index_HarnessEvalPairConfig as HarnessEvalPairConfig, type index_HarnessExecutor as HarnessExecutor, index_HarnessGraph as HarnessGraph, type index_HarnessJobPayload as HarnessJobPayload, 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_Iteration as Iteration, 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_RefineLoopGraph as RefineLoopGraph, type index_RefineLoopOptions as RefineLoopOptions, type index_RefineStatus as RefineStatus, type index_RefineStrategy as RefineStrategy, 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_blindVariation as blindVariation, index_codeChangeBridge as codeChangeBridge, index_createIntakeBridge as createIntakeBridge, index_defaultErrorClassifier as defaultErrorClassifier, index_defaultLlmExecutor as defaultLlmExecutor, index_defaultLlmVerifier as defaultLlmVerifier, index_dispatchActuator as dispatchActuator, index_effectivenessTracker as effectivenessTracker, index_errorCritique as errorCritique, 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_refineLoop as refineLoop, index_resolvePromptFn as resolvePromptFn, index_strategyKey as strategyKey, index_strategyModel as strategyModel };
-}
-
-export { type IntakeBridgeOptions as $, type ActuatorApplyFn as A, type BlindVariationContext as B, type CodeChange as C, DEFAULT_DECAY_RATE as D, type EffectivenessEntry as E, type EvalResult as F, type EvalRunResult as G, type EvalTaskDelta as H, type EvalTaskResult as I, type EvalVerifierConfig as J, type EvalVerifierSummary as K, type EvaluateEvent as L, type Evaluator as M, type ExecuteOutput as N, type ExecutePromptFn as O, type ExecutionResult as P, type Feedback as Q, type GenerateEvent as R, type HarnessEvalPairConfig as S, type HarnessExecutor as T, HarnessGraph as U, type HarnessJobPayload as V, type HarnessLoopOptions as W, type HarnessProfileResult as X, type HarnessTraceHandle as Y, type HarnessTraceOptions as Z, type HarnessVerifier as _, type ActuatorExecutorConfig as a, type IntakeItem as a0, type IntakeSource as a1, type Intervention as a2, type Iteration as a3, type KnownIntakeSource as a4, type LintError as a5, type NotifyEffectOptions as a6, type NotifyTransport as a7, type PrioritySignals as a8, QUEUE_NAMES as a9, beforeAfterCompare as aA, blindVariation as aB, codeChangeBridge as aC, createIntakeBridge as aD, defaultErrorClassifier as aE, defaultLlmExecutor as aF, defaultLlmVerifier as aG, dispatchActuator as aH, effectivenessTracker as aI, errorCritique as aJ, evalIntakeBridge as aK, evalSource as aL, evalVerifier as aM, harnessEvalPair as aN, harnessLoop as aO, harnessProfile as aP, harnessTrace as aQ, notifyEffect as aR, priorityScore as aS, refineExecutor as aT, refineLoop as aU, resolvePromptFn as aV, strategyKey as aW, strategyModel as aX, type QueueConfig as aa, type QueueRoute as ab, type RefineExecutorConfig as ac, type RefineExecutorResult as ad, type RefineLoopGraph as ae, type RefineLoopOptions as af, type RefineStatus as ag, type RefineStrategy as ah, type RootCause as ai, type Severity as aj, type StrategyEntry as ak, type StrategyKey as al, type StrategyModelBundle as am, type StrategySnapshot as an, type TestFailure as ao, type TraceDetail as ap, type TraceEvent as aq, type TraceEventType as ar, type TriagePromptFn as as, type TriagedItem as at, type VerifyOutput as au, type VerifyPromptFn as av, type VerifyResult as aw, actuatorExecutor as ax, affectedTaskFilter as ay, autoSolidify as az, type ActuatorResult as b, type AnalyzeEvent as c, type AutoSolidifyConfig as d, type BlindVariationOptions as e, type CodeChangeBridgeOptions as f, type ConvergenceOptions as g, DEFAULT_EXECUTE_PROMPT as h, index as i, DEFAULT_QUEUE_CONFIGS as j, DEFAULT_SEVERITY_WEIGHTS as k, DEFAULT_TRIAGE_PROMPT as l, DEFAULT_VERIFY_PROMPT as m, type DatasetItem as n, type DecideEvent as o, type DispatchActuatorConfig as p, type EffectivenessSnapshot as q, type EffectivenessTrackerBundle as r, type EffectivenessTrackerOptions as s, type ErrorClass as t, type ErrorClassifier as u, type ErrorCritiqueContext as v, type ErrorCritiqueOptions as w, type EvalDelta as x, type EvalIntakeBridgeOptions as y, type EvalJudgeScore as z };