@graphrefly/graphrefly 0.41.0 → 0.43.0

package/dist/{index-DfOK_oL5.d.ts → index-DwigL4lY.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 { J as JobEnvelope, a as JobFlowGraph, b as JobQueueGraph } from './index-CG33HeBW.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 { 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-CAC_rNzm.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-loP57TBA.js';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).
@@ -695,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[];
@@ -723,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.
  *
@@ -744,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;
@@ -770,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.
  *
@@ -912,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.
@@ -931,7 +1265,7 @@ declare function effectivenessTracker(opts?: EffectivenessTrackerOptions): Effec
 
 /** 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;
@@ -1144,7 +1478,17 @@ declare class HarnessGraph<A = unknown> extends Graph {
      * in to priority scoring.
      */
     readonly priorityScores?: ReadonlyMap<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>>);
+    /**
+     * 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. */
@@ -1382,15 +1726,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;
@@ -1398,17 +1748,24 @@ 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>;
@@ -1423,6 +1780,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;
@@ -1433,6 +1791,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;
@@ -1452,6 +1814,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;
@@ -1459,6 +1822,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;
@@ -1469,11 +1833,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_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_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 RefineExecutorResult 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 HarnessJobPayload as I, type HarnessLoopOptions as J, type HarnessProfileResult as K, type HarnessTraceHandle as L, type HarnessTraceOptions as M, type HarnessVerifier as N, type IntakeBridgeOptions as O, type IntakeItem as P, type IntakeSource as Q, type Intervention as R, type KnownIntakeSource as S, type LintError as T, type NotifyEffectOptions as U, type NotifyTransport as V, type PrioritySignals as W, QUEUE_NAMES as X, type QueueConfig as Y, type QueueRoute as Z, type RefineExecutorConfig as _, type ActuatorExecutorConfig as a, type RootCause as a0, type Severity as a1, type StrategyEntry as a2, type StrategyKey as a3, type StrategyModelBundle as a4, type StrategySnapshot as a5, type TestFailure as a6, type TraceDetail as a7, type TraceEvent as a8, type TraceEventType as a9, resolvePromptFn as aA, strategyKey as aB, strategyModel as aC, type TriagePromptFn as aa, type TriagedItem as ab, type VerifyOutput as ac, type VerifyPromptFn as ad, type VerifyResult as ae, actuatorExecutor as af, affectedTaskFilter as ag, autoSolidify as ah, beforeAfterCompare as ai, codeChangeBridge as aj, createIntakeBridge as ak, defaultErrorClassifier as al, defaultLlmExecutor as am, defaultLlmVerifier as an, dispatchActuator as ao, effectivenessTracker as ap, evalIntakeBridge as aq, evalSource as ar, evalVerifier as as, harnessEvalPair as at, harnessLoop as au, harnessProfile as av, harnessTrace as aw, notifyEffect as ax, priorityScore as ay, refineExecutor 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 };