@graphrefly/graphrefly 0.40.0 → 0.41.0

package/dist/{index-DJ_MPOJ5.d.cts → index-DuRsN9ae.d.cts}

@@ -1,11 +1,11 @@
 import { NodeInput } from './extra/sources.cjs';
 import { N as Node } from './node-BYInONRr.cjs';
 import { L as LLMAdapter } from './types-1Dhoi7HM.cjs';
+import { J as JobEnvelope, a as JobFlowGraph, b as JobQueueGraph } from './index-DGD4_fj6.cjs';
 import { T as TopicGraph, M as MessagingHubGraph } from './index-Cnr1WrlX.cjs';
 import { E as Evaluator, D as DatasetItem, a as EvalResult$1, R as RefineStrategy, b as RefineLoopOptions, c as RefineStatus } from './index-t6L2qpHh.cjs';
 import { G as Graph, t as GraphProfileResult, s as GraphProfileOptions } from './graph-E6likq7w.cjs';
 import { G as GateController } from './pipeline-graph-MWrQZXCq.cjs';
-import { J as JobQueueGraph } from './index-BTHOTC0Q.cjs';
 
 /**
  * Strategy model and priority scoring (roadmap §9.0).
@@ -278,37 +278,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 +407,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 +471,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 +483,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 +515,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 +537,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 +548,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>;
 
@@ -906,9 +922,9 @@ 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
  */
@@ -924,8 +940,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 +949,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 +1018,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 +1040,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 +1074,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 +1128,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 +1144,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 +1154,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 +1179,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 +1226,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 +1279,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
@@ -1409,6 +1413,7 @@ 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;
@@ -1468,7 +1473,7 @@ 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_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 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 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 };