@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/utils/harness/index.d.cts

@@ -0,0 +1,542 @@
+import { NodeInput } from '@graphrefly/pure-ts/extra';
+import { k as QueueRoute, Q as QueueConfig, S as Severity, a as ErrorClassifier, P as PresetId, R as RootCause, i as Intervention, m as StrategyKey, p as TriagedItem, b as ExecuteOutput, H as HarnessExecutor, r as VerifyResult, I as IntakeItem } from '../../types-vCq7ShIm.cjs';
+export { D as DEFAULT_PRESET_ID, E as ErrorClass, c as ExecutePromptFn, d as ExecutionResult, e as HarnessJobPayload, f as HarnessLoopOptions, g as HarnessVerifier, h as IntakeSource, K as KnownIntakeSource, j as PrioritySignals, l as StrategyEntry, n as StrategyModelGraph, o as StrategySnapshot, T as TriagePromptFn, V as VerifyOutput, q as VerifyPromptFn, s as priorityScore, t as strategyModel } from '../../types-vCq7ShIm.cjs';
+import { Node } from '@graphrefly/pure-ts/core';
+import { Graph } from '@graphrefly/pure-ts/graph';
+import { TopicGraph } from '../messaging/index.cjs';
+export { DEFAULT_DECAY_RATE } from '../../base/utils/index.cjs';
+import '../../types-BB5Lw-pB.cjs';
+import '../job-queue/index.cjs';
+import '../../base/mutation/index.cjs';
+
+/**
+ * Harness runtime defaults (roadmap §9.0).
+ *
+ * Split out from `types.ts` in Wave B Unit 15 G so the type file holds
+ * only type declarations and plug-in contracts. Runtime constants and
+ * helpers live here; the harness barrel (`index.ts`) re-exports both so
+ * external consumers see a single surface.
+ *
+ * @module
+ */
+
+/** Ordered queue route names for iteration. */
+declare const QUEUE_NAMES: readonly QueueRoute[];
+/** Default queue configurations. */
+declare const DEFAULT_QUEUE_CONFIGS: Record<QueueRoute, QueueConfig>;
+/** Default severity weights. */
+declare const DEFAULT_SEVERITY_WEIGHTS: Record<Severity, number>;
+
+/**
+ * Canonical 3-axis composite-key factory: `${presetId}|${rootCause}→${intervention}`.
+ *
+ * **Phase 13.I axis extension (DS-13.I, 2026-05-01).** Pre-multi-agent
+ * callers without a preset registry pass {@link DEFAULT_PRESET_ID}
+ * (`"default"`) for the first arg. Pre-1.0 breaking signature change;
+ * persisted strategy-model snapshots from before this date are NOT portable.
+ */
+declare function strategyKey(presetId: PresetId, rootCause: RootCause, intervention: Intervention): StrategyKey;
+/** Default error classifier: parse/config errors are self-correctable. */
+declare const defaultErrorClassifier: ErrorClassifier;
+/** Default TRIAGE prompt — LLM classifies intake items into root-cause + intervention + route + priority. */
+declare const DEFAULT_TRIAGE_PROMPT = "You are a triage classifier for a reactive collaboration harness.\n\nGiven an intake item, classify it and output JSON:\n{\n  \"rootCause\": \"composition\" | \"missing-fn\" | \"bad-docs\" | \"schema-gap\" | \"regression\" | \"unknown\",\n  \"intervention\": \"template\" | \"catalog-fn\" | \"docs\" | \"wrapper\" | \"schema-change\" | \"investigate\",\n  \"route\": \"auto-fix\" | \"needs-decision\" | \"investigation\" | \"backlog\",\n  \"priority\": <number 0-100>,\n  \"triageReasoning\": \"<one sentence>\"\n}\n\nStrategy model (past effectiveness):\n{{strategy}}\n\nIntake item:\n{{item}}";
+/** Default EXECUTE prompt — LLM produces a fix given a triaged issue. */
+declare const DEFAULT_EXECUTE_PROMPT = "You are an implementation agent.\n\nGiven a triaged issue with root cause and intervention type, produce a fix.\n\nIssue:\n{{item}}\n\nOutput JSON:\n{\n  \"outcome\": \"success\" | \"failure\" | \"partial\",\n  \"detail\": \"<description of what was done or what failed>\"\n}";
+/** Default VERIFY prompt — LLM reviews an execution result against the original issue. */
+declare const DEFAULT_VERIFY_PROMPT = "You are a QA reviewer.\n\nGiven an execution result, verify whether the fix is correct.\n\nExecution:\n{{execution}}\n\nOriginal issue:\n{{item}}\n\nOutput JSON:\n{\n  \"verified\": true/false,\n  \"findings\": [\"<finding1>\", ...],\n  \"errorClass\": \"self-correctable\" | \"structural\"  // only if verified=false\n}";
+/**
+ * Collapse the `string | ((input: In) => string) | undefined` prompt-template
+ * pattern into a single `(input: In) => string`. A function `raw` is used as-is
+ * (the caller opted into full control). Otherwise `raw ?? fallbackTemplate`
+ * is fed through `substitute`, which does the placeholder replacement.
+ *
+ * Used by the three harness stages (TRIAGE / EXECUTE / VERIFY), which each
+ * accept a `string | function` config but use different placeholder schemes
+ * (`{{item}}`, `{{execution}}`, `{{strategy}}`). The helper absorbs only the
+ * branch logic; the per-stage placeholder substitution lives at the call site.
+ */
+declare function resolvePromptFn<In>(raw: string | ((input: In) => string) | undefined, fallbackTemplate: string, substitute: (template: string, input: In) => string): (input: In) => string;
+
+/**
+ * actuatorExecutor — bridge a side-effecting actuator into the harness
+ * EXECUTE work fn.
+ *
+ * `refineExecutor` covers the artifact-typed case (refine a candidate
+ * `T` against an evaluator); `actuatorExecutor` covers the side-effecting
+ * case (write a catalog entry, mutate a template registry, edit a doc on
+ * disk). The user's `apply` callback owns the side effect; the executor
+ * wraps it in the per-claim lifecycle:
+ *
+ * 1. **One DATA per claim.** The producer captures the first DATA from
+ *    the bridged `apply` result, emits a {@link HarnessJobPayload} with
+ *    `execution` filled in, and completes. Subsequent inner DATAs are
+ *    ignored.
+ * 2. **Cancel-on-teardown.** When the JobFlow pump unsubscribes (after
+ *    capturing first DATA, or on graph teardown), the producer's cleanup
+ *    fires `ac.abort()` which propagates into `apply`'s `signal`.
+ * 3. **Errors surfaced as failure payload.** A thrown / ERROR result is
+ *    mapped via `onError` into a `failure`-outcome `ExecuteOutput` so the
+ *    dispatch effect can route the item rather than silently dropping it.
+ *
+ * **What `apply` may return.** Anything `fromAny` accepts: `Promise<R>`,
+ * `Node<R>`, `AsyncIterable<R>`, `Iterable<R>`, or a synchronous `R`.
+ * `Promise<R>` is the typical shape (`writeFile`, `fetch`, `db.execute`).
+ *
+ * **Pairing with `evalVerifier`.** `ExecuteOutput.artifact` is set to
+ * the actuation record; an `evalVerifier<R>` whose `extractArtifact`
+ * returns the record (or the post-apply world state) closes EXECUTE →
+ * VERIFY with consistent typing end-to-end.
+ *
+ * @module
+ */
+
+/**
+ * What an actuator's `apply` may return. Mirrors `NodeInput<R>` plus a
+ * raw `R` for synchronous side effects.
+ */
+type ActuatorResult<R> = NodeInput<R>;
+/** Configuration for {@link actuatorExecutor}. */
+interface ActuatorExecutorConfig<R> {
+    /**
+     * Apply the side effect for this triaged item. Receives the abort
+     * signal — actuators that own real I/O should thread `signal` into
+     * `fetch`, `fs.writeFile`, child-process kills, etc. so that the
+     * pump's teardown actually cancels in-flight work.
+     *
+     * The first DATA emitted by the bridged result wins; later DATAs are
+     * discarded. ERROR (or a synchronous throw) is mapped via `onError`.
+     */
+    apply: (item: TriagedItem, opts: {
+        signal: AbortSignal;
+    }) => ActuatorResult<R>;
+    /**
+     * Optional gate — when provided and returning `false`, the actuator
+     * is skipped and the executor emits an `ExecuteOutput` with
+     * `outcome: "failure"`. Use to route interventions the actuator can't
+     * handle into the failure path.
+     */
+    shouldApply?: (item: TriagedItem) => boolean;
+    /** Detail string for the skip path. Default: includes intervention name. */
+    skipDetail?: (item: TriagedItem) => string;
+    /**
+     * Map a successfully-applied actuation record into an `ExecuteOutput<R>`.
+     */
+    toOutput?: (record: R, item: TriagedItem) => ExecuteOutput<R>;
+    /**
+     * Map a thrown / ERROR result into an `ExecuteOutput<R>`.
+     */
+    onError?: (err: unknown, item: TriagedItem) => ExecuteOutput<R>;
+    /** Node name prefix for `describe()` introspection. */
+    name?: string;
+}
+/**
+ * Build a {@link HarnessExecutor} backed by a side-effecting actuator.
+ *
+ * @example File-system actuator that writes a catalog entry and emits the diff.
+ * ```ts
+ * const harness = harnessLoop("repair", {
+ *   adapter,
+ *   executor: actuatorExecutor<CatalogPatch>({
+ *     async apply(item, { signal }) {
+ *       const patch = patchFromItem(item);
+ *       await fs.writeFile(patch.path, patch.contents, { signal });
+ *       return patch;
+ *     },
+ *     shouldApply: (item) => item.intervention === "catalog-fn",
+ *   }),
+ *   verifier: evalVerifier<CatalogPatch>({ ... }),
+ * });
+ * ```
+ */
+declare function actuatorExecutor<R>(config: ActuatorExecutorConfig<R>): HarnessExecutor<R>;
+/**
+ * Apply callback shape consumed by {@link dispatchActuator}. Same shape as
+ * {@link ActuatorExecutorConfig.apply}.
+ */
+type ActuatorApplyFn<R> = (item: TriagedItem, opts: {
+    signal: AbortSignal;
+}) => ActuatorResult<R>;
+/** Configuration for {@link dispatchActuator}. */
+interface DispatchActuatorConfig<R> {
+    /**
+     * Per-intervention apply callbacks. Keyed by `TriagedItem.intervention`.
+     * Items whose intervention is not in `routes` fall through to `default`
+     * (when set) or emit a skip-failure `ExecuteOutput`.
+     */
+    routes: Readonly<Partial<Record<TriagedItem["intervention"], ActuatorApplyFn<R>>>>;
+    /** Fallback apply callback for items whose intervention is not in `routes`. */
+    default?: ActuatorApplyFn<R>;
+    /** Node name prefix for `describe()` introspection. */
+    name?: string;
+}
+/**
+ * Multi-intervention actuator — dispatches each `TriagedItem` to one of
+ * several `apply` callbacks based on `item.intervention`.
+ *
+ * Internally builds a single `actuatorExecutor` whose `apply` resolves the
+ * intervention → callback at call-time. Items with no matching route and no
+ * `default` emit a skip-failure with detail
+ * `"no route for intervention 'X'"`.
+ */
+declare function dispatchActuator<R>(config: DispatchActuatorConfig<R>): HarnessExecutor<R>;
+
+/**
+ * autoSolidify — promote successful VERIFY runs into a durable artifact
+ * (catalog entry, skill, template, doc edit, …).
+ *
+ * Closes the dogfood retrospective loop: when the harness's VERIFY
+ * stage reports `verified: true`, the validated intervention should
+ * become an authoring artifact the next loop run can rely on. This
+ * primitive is the generic substrate — pass a `write` callback that
+ * does the actual promotion (e.g. `overlay.upsertTemplate` for the
+ * dogfood catalog overlay; `fs.writeFile` for a doc edit; `ctx.skill`
+ * for a Hermes-style skill registry).
+ *
+ * @example Wire the catalog overlay as the solidify target.
+ * ```ts
+ * const solidified = autoSolidify({
+ *   verifyResults: harness.verifyResults.latest,
+ *   extract: (vr) => vr.execution.artifact ?? null,
+ *   write: (entry, vr) => overlay.upsertFn(`learned-${vr.item.summary}`, entry),
+ * });
+ * solidified.subscribe(() => {}); // keep alive for log
+ * ```
+ *
+ * **Why a node and not just an effect.** The returned `Node<R>` emits
+ * each promoted artifact, so callers can pipe solidifications through
+ * the standard reactive surface (`describe()`, `observe()`, replay
+ * buffers) instead of side-channel logging. An audit / dashboard that
+ * wants "what was learned this run?" subscribes to the returned node;
+ * the `write` callback owns the durable side effect.
+ *
+ * **Idempotency is the caller's responsibility.** The primitive
+ * promotes every `verified: true` wave that passes the predicate. If
+ * the harness re-verifies the same item (e.g. via reingestion), the
+ * `write` callback is invoked again. Wrap your write fn with a
+ * dedup-by-key guard if your target store would otherwise bloat. The
+ * inner `seen` set inside this factory is intentionally absent — the
+ * harness already retains via topic logs and the user may want
+ * re-promotion semantics that are domain-specific.
+ *
+ * @module
+ */
+
+/**
+ * Configuration for {@link autoSolidify}.
+ *
+ * `R` is the artifact type the upstream EXECUTE stage produced (and
+ * `evalVerifier` carries through `execution.artifact`). `T` is the
+ * promotion shape — what `write` consumes and what the returned node
+ * emits. Often `T = R`, but they diverge when the actuator's raw
+ * artifact needs a transform before storing (e.g. wrap a `CatalogPatch`
+ * into a `CatalogEntry` with effectiveness metadata).
+ */
+interface AutoSolidifyConfig<R, T = R> {
+    /** Reactive verify-result stream. Typically `harness.verifyResults.latest`. */
+    verifyResults: Node<VerifyResult<R> | null>;
+    /**
+     * Pull the value-to-promote out of a verified VerifyResult.
+     * Default: `(vr) => vr.execution.artifact as T | null`. Return `null`
+     * to skip a particular VerifyResult even when `verified: true` (e.g.
+     * an LLM-default executor produces no artifact and there's nothing to
+     * solidify).
+     */
+    extract?: (vr: VerifyResult<R>) => T | null;
+    /**
+     * Optional gate beyond `verified === true`. When provided, the
+     * primitive only promotes when this returns `true`. Default: pass
+     * everything verified.
+     *
+     * Useful predicates:
+     *  - `(vr) => vr.item.intervention === "catalog-fn"` — only catalog work.
+     *  - `(vr) => (vr.findings ?? []).every(f => !/regression/i.test(f))` —
+     *    skip even-passes that mention regressions.
+     */
+    predicate?: (vr: VerifyResult<R>) => boolean;
+    /**
+     * Promote — usually a side effect (write to overlay, fs, KG, etc.).
+     * Receives the extracted artifact AND the originating VerifyResult so
+     * the writer can use any context it needs (item summary, eval task
+     * IDs, finding text, …) when shaping the durable record.
+     */
+    write: (artifact: T, vr: VerifyResult<R>) => void;
+    /** Node name for `describe()` introspection. Default `"auto-solidify"`. */
+    name?: string;
+}
+/**
+ * Build a `Node<T>` that subscribes to `verifyResults`, filters to
+ * verified passes that produced an extractable artifact, runs `write`,
+ * and emits the artifact. Use the returned node as a subscription
+ * point for audit / dashboard / log pipelines.
+ *
+ * **Terminal-on-error semantics.** A throw from `predicate`, `extract`,
+ * or `write` surfaces as `[[ERROR]]` on the returned node and
+ * **terminates** it — the upstream subscription tears down and no
+ * further DATA is emitted. This matches the spec's terminal-frame
+ * contract for ERROR. If you want the solidify node to stay live
+ * across user-callback throws, wrap your callbacks with try/catch
+ * internally and emit a sentinel value or no-op on failure. A future
+ * non-terminal `errors: Node<unknown>` companion may surface failures
+ * without terminating the success stream — flagged as a follow-up.
+ *
+ * @returns A `Node<T>` that emits one DATA per promoted artifact.
+ *   Stays live as long as `verifyResults` is live AND no user callback
+ *   has thrown.
+ */
+declare function autoSolidify<R, T = R>(config: AutoSolidifyConfig<R, T>): Node<T>;
+
+/**
+ * Harness bridge factories (roadmap §9.0).
+ *
+ * Intake bridges, eval source wrapper, before/after comparison,
+ * affected-task filter, code-change bridge, and notification effect.
+ * All are compositions of existing primitives — no new abstractions.
+ *
+ * @module
+ */
+
+/** Options for {@link createIntakeBridge}. */
+interface CreateIntakeBridgeOptions<T> {
+    /** Graph to register the effect node on (B.1 narrow-waist visibility). */
+    graph: Graph;
+    /** Reactive node emitting domain-specific data. */
+    source: Node<T>;
+    /** TopicGraph to publish IntakeItem entries to. */
+    intakeTopic: TopicGraph<IntakeItem>;
+    /** Converts source data into IntakeItem[]. Return empty array to skip. */
+    parser: (value: T) => IntakeItem[];
+    /** Effect-node name (default `"intake-bridge"`). */
+    name?: string;
+}
+/**
+ * Generic source→intake bridge factory.
+ *
+ * Watches a source node for new values, passes each through a user-supplied
+ * `parser` that produces zero or more `IntakeItem`s, and publishes them to
+ * the given intake topic.
+ *
+ * This is the generalized pattern behind {@link evalIntakeBridge}. Use it for
+ * CI results, test failures, Slack messages, monitoring alerts, or any domain
+ * where structured results should flow into a harness loop.
+ *
+ * The effect node is registered on the supplied `graph` so it appears in
+ * `describe()` and is owned by the graph's lifecycle.
+ *
+ * @returns The effect node (for lifecycle management).
+ */
+declare function createIntakeBridge<T>(opts: CreateIntakeBridgeOptions<T>): Node<unknown>;
+/**
+ * Minimal eval result shape accepted by the bridge.
+ *
+ * TS eval runner uses `EvalRun` from `evals/lib/types.ts` which is a superset
+ * of this shape. The bridge only reads what it needs.
+ */
+interface EvalRunResult {
+    run_id: string;
+    model: string;
+    tasks: EvalTaskResult[];
+}
+interface EvalTaskResult {
+    task_id: string;
+    valid: boolean;
+    judge_scores?: EvalJudgeScore[];
+}
+interface EvalJudgeScore {
+    claim: string;
+    pass: boolean;
+    reasoning: string;
+}
+interface EvalIntakeBridgeOptions {
+    /** Graph to register the effect node on (B.1 narrow-waist visibility). */
+    graph: Graph;
+    /** Node emitting EvalRunResult (or EvalRunResult[]). */
+    source: Node<EvalRunResult | EvalRunResult[]>;
+    /** TopicGraph to publish IntakeItem entries to. */
+    intakeTopic: TopicGraph<IntakeItem>;
+    /** Effect-node name (default `"eval-intake-bridge"`). */
+    name?: string;
+    /** Minimum severity for eval-sourced items (default `"medium"`). */
+    defaultSeverity?: Severity;
+}
+/**
+ * Create an effect node that watches an eval results source and publishes
+ * per-criterion findings to an intake topic.
+ *
+ * Each failing judge criterion produces a separate IntakeItem — not one
+ * item per task. This gives the triage stage granular findings to classify.
+ *
+ * The effect node is registered on the supplied `graph` so it appears in
+ * `describe()` and is owned by the graph's lifecycle.
+ *
+ * @returns The effect node (for lifecycle management).
+ */
+declare function evalIntakeBridge(opts: EvalIntakeBridgeOptions): Node<unknown>;
+/**
+ * Wrap any eval runner as a reactive producer node.
+ *
+ * When `trigger` emits, calls `runner()` and emits the result downstream.
+ * Uses `switchMap` + `fromAny` — the async boundary stays in the source
+ * layer (spec §5.10). A new trigger cancels any in-flight run.
+ *
+ * Pure transform via operator composition — does not construct an
+ * effect/derived node, so no `graph` parameter is needed.
+ *
+ * ```ts
+ * const trigger = state(0);         // bump to trigger a new run
+ * const results = evalSource(trigger, () => runEvals(config));
+ * results.subscribe(msgs => { ... });
+ * trigger.emit(1);                   // fires the runner
+ * ```
+ *
+ * @param trigger - Any node; each new DATA emission fires the runner.
+ * @param runner  - Returns an EvalRunResult (or promise of one).
+ */
+declare function evalSource<T extends EvalRunResult>(trigger: Node<unknown>, runner: () => T | Promise<T>): Node<T>;
+/** Per-task delta produced by {@link beforeAfterCompare}. */
+interface EvalTaskDelta {
+    taskId: string;
+    before: boolean;
+    after: boolean;
+    /** Score-level diff (after − before), undefined if no scores present. */
+    scoreDiff?: number;
+}
+/** Output of {@link beforeAfterCompare}. */
+interface EvalDelta {
+    /** Task IDs that newly fail in `after` (were passing in `before`). */
+    newFailures: string[];
+    /** Task IDs that now pass in `after` (were failing in `before`). */
+    resolved: string[];
+    /** Full per-task breakdown. */
+    taskDeltas: EvalTaskDelta[];
+    /** True when net resolutions > net failures. */
+    overallImproved: boolean;
+}
+/** Options for {@link beforeAfterCompare}. */
+interface BeforeAfterCompareOptions {
+    /** Graph to register the derived node on (B.1 narrow-waist visibility). */
+    graph: Graph;
+    /** Node holding the baseline eval result. */
+    before: Node<EvalRunResult>;
+    /** Node holding the new eval result. */
+    after: Node<EvalRunResult>;
+    /** Derived-node name (default `"eval-delta"`). */
+    name?: string;
+}
+/**
+ * Derived node that computes before/after eval deltas.
+ *
+ * Pure computation: no LLM, no async. Compares per-task validity and
+ * pass counts between two `EvalRunResult` snapshots.
+ *
+ * The derived node is registered on the supplied `graph` so it appears in
+ * `describe()` and is owned by the graph's lifecycle.
+ */
+declare function beforeAfterCompare(opts: BeforeAfterCompareOptions): Node<EvalDelta>;
+/** Options for {@link affectedTaskFilter}. */
+interface AffectedTaskFilterOptions {
+    /** Graph to register the derived node on (B.1 narrow-waist visibility). */
+    graph: Graph;
+    /** Node holding the current list of triaged items. */
+    issues: Node<readonly TriagedItem[]>;
+    /**
+     * Optional node (or plain array) of all known task IDs.
+     * When provided, output is the intersection.
+     */
+    fullTaskSet?: Node<readonly string[]> | readonly string[];
+    /** Derived-node name (default `"affected-task-filter"`). */
+    name?: string;
+}
+/**
+ * Derived node that selects which eval task IDs to re-run.
+ *
+ * Collects `affectsEvalTasks` from all triaged items, deduplicates, then
+ * optionally intersects with `fullTaskSet`. Returns a sorted array of IDs.
+ *
+ * Use this to avoid re-running the full eval suite after each fix: only the
+ * tasks that the triaged items claim to affect are returned.
+ *
+ * The derived node is registered on the supplied `graph` so it appears in
+ * `describe()` and is owned by the graph's lifecycle.
+ */
+declare function affectedTaskFilter(opts: AffectedTaskFilterOptions): Node<string[]>;
+/** A single lint error emitted by a CI tool. */
+interface LintError {
+    file: string;
+    line: number;
+    col: number;
+    rule: string;
+    message: string;
+}
+/** A single test failure emitted by a test runner. */
+interface TestFailure {
+    testId: string;
+    file: string;
+    message: string;
+}
+/** Structured code-change / CI event. */
+interface CodeChange {
+    /** Files touched by the change. */
+    files: string[];
+    lintErrors?: LintError[];
+    testFailures?: TestFailure[];
+}
+/** Options for {@link codeChangeBridge}. */
+interface CodeChangeBridgeOptions {
+    /** Graph to register the effect node on (B.1 narrow-waist visibility). */
+    graph: Graph;
+    /** Node emitting CodeChange events. */
+    source: Node<CodeChange>;
+    /** TopicGraph to publish IntakeItem entries to. */
+    intakeTopic: TopicGraph<IntakeItem>;
+    /** Optional custom parser (overrides default). */
+    parser?: (change: CodeChange) => IntakeItem[];
+    /** Effect-node name (default `"code-change-bridge"`). */
+    name?: string;
+    /** Default severity for generated IntakeItems (default `"high"`). */
+    defaultSeverity?: Severity;
+}
+/**
+ * Intake bridge for code-change / CI events.
+ *
+ * Watches a source node for `CodeChange` events and publishes one
+ * `IntakeItem` per lint error and per test failure to the intake topic.
+ * Pass a custom `parser` to override the default mapping.
+ *
+ * The effect node is registered on the supplied `graph` so it appears in
+ * `describe()` and is owned by the graph's lifecycle.
+ */
+declare function codeChangeBridge(opts: CodeChangeBridgeOptions): Node<unknown>;
+/** Transport function for {@link notifyEffect}. Sync or async. */
+type NotifyTransport<T> = (item: T) => void | Promise<void>;
+/** Options for {@link notifyEffect}. */
+interface NotifyEffectOptions<T> {
+    /** Graph to register the effect node on (B.1 narrow-waist visibility). */
+    graph: Graph;
+    /** TopicGraph whose latest entry triggers the notification. */
+    topic: TopicGraph<T>;
+    /** Called with each new item. May return a Promise. */
+    transport: NotifyTransport<T>;
+    /** Effect-node name (default `"notify-effect"`). */
+    name?: string;
+}
+/**
+ * Effect node that sends each new topic entry to an external channel.
+ *
+ * The `transport` function is called for every item published to `topic`.
+ * Async transports are bridged via `fromAny` (spec §5.10 compliant).
+ *
+ * Typical use: Slack webhook, GitHub PR comment, email notification, etc.
+ * The factory provides reactive wiring; the transport supplies domain logic.
+ *
+ * The effect node is registered on the supplied `graph` so it appears in
+ * `describe()` and is owned by the graph's lifecycle.
+ *
+ * ```ts
+ * notifyEffect({ graph, topic: alertQueue, transport: async (item) => {
+ *   await fetch(SLACK_WEBHOOK, { method: 'POST', body: JSON.stringify({ text: item.summary }) });
+ * }});
+ * ```
+ */
+declare function notifyEffect<T>(opts: NotifyEffectOptions<T>): Node<unknown>;
+
+export { type ActuatorApplyFn, type ActuatorExecutorConfig, type ActuatorResult, type AffectedTaskFilterOptions, type AutoSolidifyConfig, type BeforeAfterCompareOptions, type CodeChange, type CodeChangeBridgeOptions, type CreateIntakeBridgeOptions, DEFAULT_EXECUTE_PROMPT, DEFAULT_QUEUE_CONFIGS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRIAGE_PROMPT, DEFAULT_VERIFY_PROMPT, type DispatchActuatorConfig, ErrorClassifier, type EvalDelta, type EvalIntakeBridgeOptions, type EvalJudgeScore, type EvalRunResult, type EvalTaskDelta, type EvalTaskResult, ExecuteOutput, HarnessExecutor, IntakeItem, Intervention, type LintError, type NotifyEffectOptions, type NotifyTransport, PresetId, QUEUE_NAMES, QueueConfig, QueueRoute, RootCause, Severity, StrategyKey, type TestFailure, TriagedItem, VerifyResult, actuatorExecutor, affectedTaskFilter, autoSolidify, beforeAfterCompare, codeChangeBridge, createIntakeBridge, defaultErrorClassifier, dispatchActuator, evalIntakeBridge, evalSource, notifyEffect, resolvePromptFn, strategyKey };