@graphrefly/graphrefly 0.40.0 → 0.42.0

package/dist/{index-D1IEZUsj.d.ts → index-4Uz-e_fL.d.ts}

@@ -1,11 +1,10 @@
 import { NodeInput } from './extra/sources.js';
-import { N as Node } from './node-BYInONRr.js';
-import { L as LLMAdapter } from './types-39jk0kaV.js';
-import { T as TopicGraph, M as MessagingHubGraph } from './index-40ZT4MHj.js';
-import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-BgjS2b8N.js';
-import { G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-BkIkog4h.js';
-import { G as GateController } from './pipeline-graph-CB4La-UW.js';
-import { J as JobQueueGraph } from './index-IUCY0OFN.js';
+import { N as Node } from './node-ClS5yC-B.js';
+import { L as LLMAdapter } from './types-DkzUUs0H.js';
+import { J as JobEnvelope, a as JobFlowGraph, b as JobQueueGraph } from './index-CJQm0g38.js';
+import { T as TopicGraph, M as MessagingHubGraph } from './index-DBHK8O6H.js';
+import { a as GraphOptions, G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-7VguS7a4.js';
+import { G as GateController } from './pipeline-graph-v8fMvqNk.js';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).
@@ -278,37 +277,72 @@ interface QueueConfig {
     startOpen?: boolean;
 }
 /**
- * Pluggable EXECUTE slot. Given the reactive `executeInput` stream of
- * triaged items, produce a stream of `ExecuteOutput<A>` decisions.
- *
- * **Contract** (see design note in `docs/optimizations.md` / session log):
- * 1. Emit DATA exactly once per completed execution — not on input arrival.
- * 2. Cancel in-flight work when a new item supersedes the current one
- *    (`switchMap` is the idiomatic pattern).
- * 3. Do not bypass `input.cache` — the harness pairs output with item via
- *    `withLatestFrom(output, input)`. A side-state mirror of the item can
- *    desync under nested-drain ordering.
- * 4. The returned node IS the primary of a subsequent `withLatestFrom`;
- *    firing on input arrival (rather than result completion) causes verify
- *    to pair with a stale/null ExecuteOutput.
- *
- * `refineExecutor` makes all four rules structurally unreachable.
+ * 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.
  */
-type HarnessExecutor<A = unknown> = (input: Node<TriagedItem | null>) => Node<ExecuteOutput<A> | null>;
+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 VERIFY slot. Receives a pre-paired `[executeOutput, triagedItem]`
- * context node — the harness creates this via `withLatestFrom(executeNode,
- * executeInput)` once and shares it with both the verifier and the internal
- * fast-retry dispatcher, so verifier implementations do NOT need to build
- * their own pairing node (and doubling the `withLatestFrom` would pay the
- * subscription cost twice).
- *
- * Same contract rules 1–3 as {@link HarnessExecutor}. Rule 4 does not
- * apply (verify output isn't a primary to a further withLatestFrom).
- *
- * `evalVerifier` handles the re-evaluation case against affected eval tasks.
+ * 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 HarnessVerifier<A = unknown> = (context: Node<readonly [ExecuteOutput<A> | null, TriagedItem | null] | null>) => Node<VerifyOutput | null>;
+type HarnessExecutor<A = unknown> = (job: JobEnvelope<HarnessJobPayload<A>>) => 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>>) => NodeInput<HarnessJobPayload<A>>;
 /** Triage prompt callable shape — pair of `[intake item, strategy snapshot]`. */
 type TriagePromptFn = (pair: readonly [IntakeItem, StrategySnapshot]) => string;
 /** Execute prompt callable shape. */
@@ -372,55 +406,63 @@ interface HarnessLoopOptions<A = unknown> {
     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 slot.
+ * 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-item lifecycle that makes the four
- * {@link HarnessExecutor} contract rules structurally unreachable:
- *
- *  1. **One DATA per actuation.** The inner producer captures the first
- *     DATA from the bridged `apply` result, emits a single
- *     `ExecuteOutput<R>` carrying the actuation record as `artifact`, and
- *     completes. Subsequent inner DATAs are ignored.
- *  2. **Cancel-on-supersede.** A new triaged item supersedes via
- *     `switchMap`; the prior producer's cleanup fires `ac.abort()`, which
- *     propagates into `apply`'s `signal` (and through `fromAny`'s
- *     internal cancellation hooks) so signal-aware actuators stop
- *     in-flight work instead of double-writing.
- *  3. **Item via deps, not closure mirror.** The triaged item is captured
- *     in the `switchMap` callback's lexical scope, not mirrored to a
- *     side-state node — same shape as `refineExecutor`.
- *  4. **Fires on result, not input.** The producer emits exactly when
- *     `apply`'s bridged node settles (or fails). Input-arrival waves
- *     never produce an `ExecuteOutput`.
- *
- * **What `apply` may return.** Anything `fromAny` accepts: a
- * `Promise<R>`, a `Node<R>`, an `AsyncIterable<R>`, an `Iterable<R>`,
- * or a synchronous `R`. `Promise<R>` is the typical shape (`writeFile`,
- * `fetch`, `db.execute`); reactive composition through `Node<R>` is the
- * escape hatch when the actuator itself wants to surface intermediate
- * progress before settling.
+ * 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 a transform of it — typically the post-apply
- * world state needed by the evaluator) closes the EXECUTE → VERIFY loop
- * with consistent typing end-to-end.
+ * 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, so callers can write the most
- * direct shape for their case (Promise for async I/O, raw record for
- * pure in-memory mutation).
+ * raw `R` for synchronous side effects.
  */
 type ActuatorResult<R> = NodeInput<R>;
 /** Configuration for {@link actuatorExecutor}. */
@@ -428,8 +470,8 @@ interface ActuatorExecutorConfig<R> {
     /**
      * Apply the side effect for this triaged item. Receives the abort
      * signal — actuators that own real I/O should thread `signal` into
-     * `fetch`, `fs.writeFile`, child-process kills, etc. so that
-     * `switchMap` supersede actually cancels in-flight work.
+     * `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`.
@@ -440,28 +482,21 @@ interface ActuatorExecutorConfig<R> {
     /**
      * Optional gate — when provided and returning `false`, the actuator
      * is skipped and the executor emits an `ExecuteOutput` with
-     * `outcome: "failure"` and detail from `skipDetail` (default
-     * `"actuator skipped (shouldApply returned false)"`). Use this to
-     * route interventions the actuator can't handle (e.g. `intervention:
-     * "investigate"` items) into the failure path so the verifier sees
-     * them.
+     * `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>`.
-     * Default: `outcome: "success"`, `detail` references the intervention
-     * + summary, `artifact: record`.
      */
     toOutput?: (record: R, item: TriagedItem) => ExecuteOutput<R>;
     /**
-     * Map a thrown / ERROR result into an `ExecuteOutput<R>`. Default:
-     * `outcome: "failure"`, `detail` carries the error message,
-     * `artifact: undefined`.
+     * Map a thrown / ERROR result into an `ExecuteOutput<R>`.
      */
     onError?: (err: unknown, item: TriagedItem) => ExecuteOutput<R>;
-    /** Node name prefix for `describe()` introspection. Default `"actuator-executor"`. */
+    /** Node name prefix for `describe()` introspection. */
     name?: string;
 }
 /**
@@ -479,11 +514,7 @@ interface ActuatorExecutorConfig<R> {
  *     },
  *     shouldApply: (item) => item.intervention === "catalog-fn",
  *   }),
- *   verifier: evalVerifier<CatalogPatch>({
- *     evaluator,
- *     datasetFor,
- *     extractArtifact: (exec) => exec.artifact ?? null,
- *   }),
+ *   verifier: evalVerifier<CatalogPatch>({ ... }),
  * });
  * ```
  */
@@ -505,7 +536,7 @@ interface DispatchActuatorConfig<R> {
     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. Default `"dispatch-actuator"`. */
+    /** Node name prefix for `describe()` introspection. */
     name?: string;
 }
 /**
@@ -516,22 +547,6 @@ interface DispatchActuatorConfig<R> {
  * intervention → callback at call-time. Items with no matching route and no
  * `default` emit a skip-failure with detail
  * `"no route for intervention 'X'"`.
- *
- * @example Multi-intervention dogfood loop.
- * ```ts
- * const harness = harnessLoop("repair", {
- *   adapter,
- *   executor: dispatchActuator<CatalogPatch>({
- *     routes: {
- *       "catalog-fn": catalogFnActuator,
- *       "template": templateActuator,
- *       "docs": docEditActuator,
- *     },
- *     default: investigateActuator,
- *   }),
- *   verifier: evalVerifier<CatalogPatch>({ ... }),
- * });
- * ```
  */
 declare function dispatchActuator<R>(config: DispatchActuatorConfig<R>): HarnessExecutor<R>;
 
@@ -679,7 +694,7 @@ declare function createIntakeBridge<T>(source: Node<T>, intakeTopic: TopicGraph<
  * TS eval runner uses `EvalRun` from `evals/lib/types.ts` which is a superset
  * of this shape. The bridge only reads what it needs.
  */
-interface EvalResult {
+interface EvalRunResult {
     run_id: string;
     model: string;
     tasks: EvalTaskResult[];
@@ -707,12 +722,12 @@ interface EvalIntakeBridgeOptions {
  * Each failing judge criterion produces a separate IntakeItem — not one
  * item per task. This gives the triage stage granular findings to classify.
  *
- * @param evalSource - Node emitting EvalResult (or EvalResult[]).
+ * @param 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<EvalResult | EvalResult[]>, intakeTopic: TopicGraph<IntakeItem>, opts?: EvalIntakeBridgeOptions): Node<unknown>;
+declare function evalIntakeBridge(evalSource: Node<EvalRunResult | EvalRunResult[]>, intakeTopic: TopicGraph<IntakeItem>, opts?: EvalIntakeBridgeOptions): Node<unknown>;
 /**
  * Wrap any eval runner as a reactive producer node.
  *
@@ -728,9 +743,9 @@ declare function evalIntakeBridge(evalSource: Node<EvalResult | EvalResult[]>, i
  * ```
  *
  * @param trigger - Any node; each new DATA emission fires the runner.
- * @param runner  - Returns an EvalResult (or promise of one).
+ * @param runner  - Returns an EvalRunResult (or promise of one).
  */
-declare function evalSource<T extends EvalResult>(trigger: Node<unknown>, runner: () => T | Promise<T>): Node<T>;
+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;
@@ -754,12 +769,12 @@ interface EvalDelta {
  * Derived node that computes before/after eval deltas.
  *
  * Pure computation: no LLM, no async. Compares per-task validity and
- * pass counts between two `EvalResult` snapshots.
+ * 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<EvalResult>, after: Node<EvalResult>): Node<EvalDelta>;
+declare function beforeAfterCompare(before: Node<EvalRunResult>, after: Node<EvalRunResult>): Node<EvalDelta>;
 /**
  * Derived node that selects which eval task IDs to re-run.
  *
@@ -896,6 +911,341 @@ type EffectivenessTrackerOptions = {
  */
 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.
@@ -906,16 +1256,16 @@ declare function effectivenessTracker(opts?: EffectivenessTrackerOptions): Effec
  * into the same `Evaluator<T>` shape that `refineLoop` used. Consistent
  * scoring between EXECUTE and VERIFY — no "LLM said it looks fine" gap.
  *
- * Per-item lifecycle mirrors `refineExecutor`: each new execute-context
- * pair mounts a fresh eval subgraph inside `switchMap`, so a superseding
- * item cancels the prior run.
+ * **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$1[];
+    readonly scores: readonly EvalResult[];
     readonly meanScore: number;
     readonly passCount: number;
     readonly total: number;
@@ -924,8 +1274,6 @@ interface EvalVerifierSummary {
      * 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".
-     * When `true`, `scores` / `total` / `passCount` are all zero and
-     * `meanScore` is `-Infinity`.
      */
     readonly missingArtifact?: boolean;
 }
@@ -935,41 +1283,30 @@ 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).
-     *
-     * **Type trust:** the default cast assumes the caller's executor wrote
-     * a `T`-shaped value to `ExecuteOutput.artifact`. A wrong-typed artifact
-     * surfaces as a runtime error inside `evaluator`, not here — supply a
-     * narrowing `extractArtifact` if you need stricter validation.
      */
     extractArtifact?: (exec: ExecuteOutput<T>, item: TriagedItem) => T | null | undefined;
     /**
      * Reactive evaluator — same contract as `refineLoop`'s `Evaluator<T>`.
-     * Typically this is the SAME evaluator configured inside `refineExecutor`
-     * so EXECUTE and VERIFY scoring stay consistent.
      */
     evaluator: Evaluator<T>;
     /**
-     * Resolve which dataset rows to score this verification against. Use
-     * `affectedTaskFilter` or hand-roll per-item subset logic. Default:
-     * empty array (verifier emits a findings entry explaining this).
+     * 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. Default `"eval-verifier"`. */
+    /** Node name prefix for introspection. */
     name?: string;
 }
 /**
  * Build a {@link HarnessVerifier} that re-runs the eval suite against the
  * artifact produced by EXECUTE.
  *
- * Consumes the shared `[executeOutput, item]` context node that the
- * harness pre-pairs via `withLatestFrom` — no internal re-wrap here (QA
- * round: "defaultLlmVerifier double-wraps withLatestFrom"). The harness's
- * single `executeContextNode` is reused by both the verifier and the
- * fast-retry dispatcher, so exec + item are subscribed once per wave.
+ * 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
@@ -1015,18 +1352,6 @@ interface HarnessEvalPairConfig<T> {
  * 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`).
- *
- * @example
- * ```ts
- * const { executor, verifier } = harnessEvalPair<CatalogEntry>({
- *   seedFrom: (item) => initialCatalogEntry(item),
- *   evaluator: (cands, ds) => runEvalBatch(cands, ds),
- *   strategy: errorCritique({ teacher, width: 3 }),
- *   datasetFor: affectedTasksFor,
- *   threshold: 0.8,
- * });
- * const harness = harnessLoop<CatalogEntry>("repair", { adapter, executor, verifier });
- * ```
  */
 declare function harnessEvalPair<T>(config: HarnessEvalPairConfig<T>): {
     executor: HarnessExecutor<T>;
@@ -1049,18 +1374,33 @@ declare function harnessEvalPair<T>(config: HarnessEvalPairConfig<T>): {
  * (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 slot — a `promptNode` driven by the given
- * adapter and prompt template. This is the factory behind the harness's
- * zero-config execute stage.
+ * 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}).
  *
- * Obeys all four rules of the {@link HarnessExecutor} contract: `promptNode`
- * internally uses `switchMap` + `fromAny` for cancellation (rule 2), emits
- * once per resolved LLM invocation (rules 1 + 4), and reads the triaged
- * item exclusively through its `deps` argument (rule 3).
+ * 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
@@ -1068,37 +1408,45 @@ declare function harnessEvalPair<T>(config: HarnessEvalPairConfig<T>): {
  */
 declare function defaultLlmExecutor<A = unknown>(adapter: LLMAdapter, prompt?: string | ExecutePromptFn): HarnessExecutor<A>;
 /**
- * Build the default VERIFY slot — a `promptNode` that reviews a
- * pre-paired `[executeOutput, item]` context node. The harness creates
- * the pairing (via `withLatestFrom(executeNode, executeInput)`) once and
- * shares it with both the verifier and the internal fast-retry
- * dispatcher, so the default verifier can consume the context directly
- * without building its own withLatestFrom.
- *
- * @param adapter - LLMAdapter for the verify call.
- * @param prompt  - Prompt template. Defaults to the harness's built-in
- *                   verify prompt (receives the full pair, extracts both).
+ * 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). Sugar getters expose the canonical topics so the
- * surface stays ergonomic.
+ * 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;
     /**
-     * Per-route JobQueueGraph mirrors (Unit 20 D). Each triaged item that
-     * reaches a queue is also enqueued here, giving reactive `depth` +
-     * `pending` + `jobs` observables. `fastRetry` terminal decisions
-     * {@link JobQueueGraph.ack ack} / {@link JobQueueGraph.nack nack} the
-     * matching job. The executor dataflow is unchanged — claim/ack/nack
-     * runs as an audit-side layer (per Unit 21's "interface unchanged"
-     * decision). Inspect via `harness.jobs.get(route).depth.cache` for
-     * backpressure metrics.
+     * 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). */
@@ -1114,13 +1462,6 @@ declare class HarnessGraph<A = unknown> extends Graph {
      * `intake` (use {@link intake}), `verify-results` (use
      * {@link verifyResults}), `retry` (use {@link retry}), `__unrouted`
      * (use {@link unrouted}), and the internal `triage-output` fan-in.
-     *
-     * **Why this exists.** `for (const [, topic] of harness.queues)`
-     * appears to iterate via `Graph[Symbol.iterator]`, but that yields
-     * locally-registered nodes only — and `MessagingHubGraph` mounts
-     * topics as child graphs rather than registering them locally, so
-     * the loop yields nothing. This map gives a typed, working
-     * iteration path.
      */
     readonly queueTopics: ReadonlyMap<QueueRoute, TopicGraph<TriagedItem>>;
     /** Strategy model bundle — record outcomes, lookup effectiveness. */
@@ -1137,7 +1478,7 @@ declare class HarnessGraph<A = unknown> extends Graph {
      * in to priority scoring.
      */
     readonly priorityScores?: ReadonlyMap<QueueRoute, Node<number>>;
-    constructor(name: string, queues: MessagingHubGraph, queueTopics: Map<QueueRoute, TopicGraph<TriagedItem>>, jobs: Map<QueueRoute, JobQueueGraph<TriagedItem>>, gates: Map<QueueRoute, GateController<TriagedItem>>, strategy: StrategyModelBundle, totalRetries: Node<number>, totalReingestions: Node<number>, priorityScores?: Map<QueueRoute, Node<number>>);
+    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>, 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. */
@@ -1147,17 +1488,17 @@ declare class HarnessGraph<A = unknown> extends Graph {
     /** Dead-letter topic for items whose LLM-chosen route is unknown. */
     get unrouted(): TopicGraph<TriagedItem>;
     /**
-     * Stage-label → observe-path map for the 7 pipeline stages (Unit 22 C).
+     * 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, or gate remounting won't require edits to `trace.ts` as long
-     * as this method stays accurate. Returned paths are resolvable via
-     * `harness.observe(path)` / `harness.resolve(path)`.
+     * 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 }` because QUEUE and GATE legitimately
-     * have multiple paths (one per route). Consumers iterate paths per stage
-     * and attach observers as needed.
+     * 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;
@@ -1172,9 +1513,9 @@ declare class HarnessGraph<A = unknown> extends Graph {
  * 2. **TRIAGE** — promptNode classifies, routes, and prioritizes
  * 3. **QUEUE** — 4 priority-ordered TopicGraphs (auto-fix, needs-decision, investigation, backlog)
  * 4. **GATE** — human approval on configurable queues
- * 5. **EXECUTE** — promptNode or human implements the fix
- * 6. **VERIFY** — promptNode reviews + optional fast-retry
- * 7. **REFLECT** — strategy model records outcomes
+ * 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.
@@ -1219,28 +1560,24 @@ interface HarnessProfileResult extends GraphProfileResult {
 declare function harnessProfile(harness: HarnessGraph, opts?: GraphProfileOptions): HarnessProfileResult;
 
 /**
- * refineExecutor — bridge a `refineLoop` into the harness EXECUTE slot.
- *
- * Per-item lifecycle (Option A from the design note): on each new triaged
- * item, a fresh `refineLoop` is mounted via `switchMap`; when the loop
- * reaches a terminal status (`converged` / `budget` / `errored`), the
- * executor emits a single `ExecuteOutput`. The switchMap cancels any
- * in-flight loop when a newer item supersedes it.
- *
- * This shape makes all four {@link HarnessExecutor} contract rules
- * structurally unreachable:
- *  1. Terminal-status filter guarantees exactly one `ExecuteOutput` per
- *     completed refinement run.
- *  2. `switchMap` cancels the prior inner loop when the next item arrives.
- *  3. The item is captured in the switchMap closure, not mirrored to a
- *     side-state.
- *  4. The wrapped `derived([status, best, score], ...)` only returns
- *     non-null on terminal transitions — it never emits on input arrival.
- *
- * **Cross-item learning:** Option A creates a fresh refineLoop per item,
- * so `errorCritique`-style failure sampling does NOT accumulate across
- * items sharing a `rootCause`. A persistent-loop + re-seed surface is
- * tracked in `docs/optimizations.md` as the long-term follow-up.
+ * 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
  */
@@ -1276,7 +1613,8 @@ interface RefineExecutorConfig<T> {
     name?: string;
 }
 /**
- * Build a {@link HarnessExecutor} backed by a `refineLoop` per triaged item.
+ * Build a {@link HarnessExecutor} backed by a `refineLoop` per claimed
+ * job.
  *
  * @example Eval-driven repair loop in the harness EXECUTE slot.
  * ```ts
@@ -1378,15 +1716,21 @@ declare function harnessTrace(harness: HarnessGraph, opts?: HarnessTraceOptions)
 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;
@@ -1394,21 +1738,29 @@ 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;
@@ -1418,6 +1770,7 @@ 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;
@@ -1428,6 +1781,10 @@ 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;
@@ -1447,6 +1804,7 @@ 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;
@@ -1454,6 +1812,7 @@ 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;
@@ -1464,11 +1823,12 @@ 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_AutoSolidifyConfig as AutoSolidifyConfig, type index_CodeChange as CodeChange, type index_CodeChangeBridgeOptions as CodeChangeBridgeOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, index_DEFAULT_EXECUTE_PROMPT as DEFAULT_EXECUTE_PROMPT, index_DEFAULT_QUEUE_CONFIGS as DEFAULT_QUEUE_CONFIGS, index_DEFAULT_SEVERITY_WEIGHTS as DEFAULT_SEVERITY_WEIGHTS, index_DEFAULT_TRIAGE_PROMPT as DEFAULT_TRIAGE_PROMPT, index_DEFAULT_VERIFY_PROMPT as DEFAULT_VERIFY_PROMPT, type index_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_EvalDelta as EvalDelta, type index_EvalIntakeBridgeOptions as EvalIntakeBridgeOptions, type index_EvalJudgeScore as EvalJudgeScore, type index_EvalResult as EvalResult, type index_EvalTaskDelta as EvalTaskDelta, type index_EvalTaskResult as EvalTaskResult, type index_EvalVerifierConfig as EvalVerifierConfig, type index_EvalVerifierSummary as EvalVerifierSummary, type index_ExecuteOutput as ExecuteOutput, type index_ExecutePromptFn as ExecutePromptFn, type index_ExecutionResult as ExecutionResult, type index_HarnessEvalPairConfig as HarnessEvalPairConfig, type index_HarnessExecutor as HarnessExecutor, index_HarnessGraph as HarnessGraph, type index_HarnessLoopOptions as HarnessLoopOptions, type index_HarnessProfileResult as HarnessProfileResult, type index_HarnessTraceHandle as HarnessTraceHandle, type index_HarnessTraceOptions as HarnessTraceOptions, type index_HarnessVerifier as HarnessVerifier, type index_IntakeBridgeOptions as IntakeBridgeOptions, type index_IntakeItem as IntakeItem, type index_IntakeSource as IntakeSource, type index_Intervention as Intervention, type index_KnownIntakeSource as KnownIntakeSource, type index_LintError as LintError, type index_NotifyEffectOptions as NotifyEffectOptions, type index_NotifyTransport as NotifyTransport, type index_PrioritySignals as PrioritySignals, index_QUEUE_NAMES as QUEUE_NAMES, type index_QueueConfig as QueueConfig, type index_QueueRoute as QueueRoute, type index_RefineExecutorConfig as RefineExecutorConfig, type index_RefineExecutorResult as RefineExecutorResult, type index_RootCause as RootCause, type index_Severity as Severity, type index_StrategyEntry as StrategyEntry, type index_StrategyKey as StrategyKey, type index_StrategyModelBundle as StrategyModelBundle, type index_StrategySnapshot as StrategySnapshot, type index_TestFailure as TestFailure, type index_TraceDetail as TraceDetail, type index_TraceEvent as TraceEvent, type index_TraceEventType as TraceEventType, type index_TriagePromptFn as TriagePromptFn, type index_TriagedItem as TriagedItem, type index_VerifyOutput as VerifyOutput, type index_VerifyPromptFn as VerifyPromptFn, type index_VerifyResult as VerifyResult, index_actuatorExecutor as actuatorExecutor, index_affectedTaskFilter as affectedTaskFilter, index_autoSolidify as autoSolidify, index_beforeAfterCompare as beforeAfterCompare, index_codeChangeBridge as codeChangeBridge, index_createIntakeBridge as createIntakeBridge, index_defaultErrorClassifier as defaultErrorClassifier, index_defaultLlmExecutor as defaultLlmExecutor, index_defaultLlmVerifier as defaultLlmVerifier, index_dispatchActuator as dispatchActuator, index_effectivenessTracker as effectivenessTracker, index_evalIntakeBridge as evalIntakeBridge, index_evalSource as evalSource, index_evalVerifier as evalVerifier, index_harnessEvalPair as harnessEvalPair, index_harnessLoop as harnessLoop, index_harnessProfile as harnessProfile, index_harnessTrace as harnessTrace, index_notifyEffect as notifyEffect, index_priorityScore as priorityScore, index_refineExecutor as refineExecutor, index_resolvePromptFn as resolvePromptFn, index_strategyKey as strategyKey, index_strategyModel as strategyModel };
+  export { 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 RootCause as $, type ActuatorApplyFn as A, type ExecutionResult as B, type CodeChange as C, DEFAULT_DECAY_RATE as D, type EffectivenessEntry as E, type HarnessExecutor as F, HarnessGraph as G, type HarnessEvalPairConfig as H, type HarnessLoopOptions as I, type HarnessProfileResult as J, type HarnessTraceHandle as K, type HarnessTraceOptions as L, type HarnessVerifier as M, type IntakeBridgeOptions as N, type IntakeItem as O, type IntakeSource as P, type Intervention as Q, type KnownIntakeSource as R, type LintError as S, type NotifyEffectOptions as T, type NotifyTransport as U, type PrioritySignals as V, QUEUE_NAMES as W, type QueueConfig as X, type QueueRoute as Y, type RefineExecutorConfig as Z, type RefineExecutorResult as _, type ActuatorExecutorConfig as a, type Severity as a0, type StrategyEntry as a1, type StrategyKey as a2, type StrategyModelBundle as a3, type StrategySnapshot as a4, type TestFailure as a5, type TraceDetail as a6, type TraceEvent as a7, type TraceEventType as a8, type TriagePromptFn as a9, strategyKey as aA, strategyModel as aB, type TriagedItem as aa, type VerifyOutput as ab, type VerifyPromptFn as ac, type VerifyResult as ad, actuatorExecutor as ae, affectedTaskFilter as af, autoSolidify as ag, beforeAfterCompare as ah, codeChangeBridge as ai, createIntakeBridge as aj, defaultErrorClassifier as ak, defaultLlmExecutor as al, defaultLlmVerifier as am, dispatchActuator as an, effectivenessTracker as ao, evalIntakeBridge as ap, evalSource as aq, evalVerifier as ar, harnessEvalPair as as, harnessLoop as at, harnessProfile as au, harnessTrace as av, notifyEffect as aw, priorityScore as ax, refineExecutor as ay, resolvePromptFn as az, type ActuatorResult as b, type AutoSolidifyConfig as c, type CodeChangeBridgeOptions as d, DEFAULT_EXECUTE_PROMPT as e, DEFAULT_QUEUE_CONFIGS as f, DEFAULT_SEVERITY_WEIGHTS as g, DEFAULT_TRIAGE_PROMPT as h, index as i, DEFAULT_VERIFY_PROMPT as j, type DispatchActuatorConfig as k, type EffectivenessSnapshot as l, type EffectivenessTrackerBundle as m, type EffectivenessTrackerOptions as n, type ErrorClass as o, type ErrorClassifier as p, type EvalDelta as q, type EvalIntakeBridgeOptions as r, type EvalJudgeScore as s, type EvalResult as t, type EvalTaskDelta as u, type EvalTaskResult as v, type EvalVerifierConfig as w, type EvalVerifierSummary as x, type ExecuteOutput as y, type ExecutePromptFn as z };
+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 };