@graphrefly/graphrefly 0.44.0 → 0.46.0

package/dist/{index-UPSiS-X7.d.cts → utils/ai/index.d.ts}

@@ -1,18 +1,25 @@
-import { T as TokenUsage, L as LLMAdapter, P as PricingFn, C as ChatMessage, a as LLMInvokeOptions, d as ToolDefinition, b as LLMResponse, S as StreamDelta, c as ToolCall, e as CapabilitiesRegistry, M as ModelCapabilities, f as ModelFeatures, g as ModelLimits, h as ModelPricing, i as PriceBreakdown, j as PricingRegistry, R as Rate, k as TieredRate, l as composePricing, m as computePrice, n as createCapabilitiesRegistry, o as createPricingRegistry, p as pricingFor, r as registryPricing, z as zeroPrice } from './types-C0_yquda.cjs';
-import { a as CascadeExhaustionReport, A as AdapterProvider, b as AdapterTier, d as AllTiersExhaustedError, C as CascadingLlmAdapterOptions, e as CreateAdapterOptions, O as OpenAICompatAdapterOptions, f as OpenAICompatPreset, g as OpenAISdkLike, h as cascadingLlmAdapter, c as createAdapter, o as openAICompatAdapter, t as tier } from './cascading-BglDkMdX.cjs';
-import { N as Node, A as Actor } from './node-kK3CvTrR.cjs';
-import { a as ReactiveLogBundle } from './reactive-log-DIGdYqQ6.cjs';
-import { b as CircuitBreakerOptions, C as CircuitBreaker, c as CircuitOpenError } from './index-C1T3d7V-.cjs';
-import { NodeInput } from './extra/sources.cjs';
-import { W as WithReplayCacheOptions, F as FallbackAdapterOptions, a as FallbackFixture, b as FallbackMissError, c as FallbackMissPolicy, R as ReplayCacheKeyContext, d as ReplayCacheMissError, e as ReplayCacheMode, f as canonicalJson, g as fallbackAdapter, w as withReplayCache } from './fallback-74oxi34l.cjs';
-import { E as Extraction, a as DistillOptions, D as DistillBundle, f as DEFAULT_DECAY_RATE } from './decay-CFlLvXUT.cjs';
-import { G as Graph, a as GraphOptions, i as GraphCheckpointRecord, h as GraphAttachStorageOptions } from './graph-CWvEUQAq.cjs';
-import { T as TopicGraph } from './index-C5ri2Axc.cjs';
-import { G as GateController, c as GateOptions } from './pipeline-graph-CIKhynsF.cjs';
-import { V as VectorSearchResult, C as CollectionGraph, a as VectorIndexGraph, K as KnowledgeGraph } from './index-B17QddL1.cjs';
-import { StorageHandle } from './extra/storage-core.cjs';
-import { SnapshotStorageTier } from './extra/storage-tiers.cjs';
-import { c as GraphSpecCatalog } from './index-CS0LTlB8.cjs';
+import { i as TokenUsage, L as LLMAdapter, g as PricingFn, a as ChatMessage, b as LLMInvokeOptions, k as ToolDefinition, c as LLMResponse, S as StreamDelta } from '../../types-BB5Lw-pB.js';
+export { C as CapabilitiesRegistry, M as ModelCapabilities, d as ModelFeatures, e as ModelLimits, f as ModelPricing, P as PriceBreakdown, h as PricingRegistry, R as Rate, T as TieredRate, j as ToolCall, l as composePricing, m as computePrice, n as createCapabilitiesRegistry, o as createPricingRegistry, p as pricingFor, r as registryPricing, z as zeroPrice } from '../../types-BB5Lw-pB.js';
+import { C as CascadeExhaustionReport } from '../../cascading-CSSbKGrJ.js';
+export { A as AdapterProvider, a as AdapterTier, b as AllTiersExhaustedError, c as CascadingLlmAdapterOptions, d as CreateAdapterOptions, O as OpenAICompatAdapterOptions, e as OpenAICompatPreset, f as OpenAISdkLike, g as cascadingLlmAdapter, h as createAdapter, o as openAICompatAdapter, t as tier } from '../../cascading-CSSbKGrJ.js';
+import { Node, Actor } from '@graphrefly/pure-ts/core';
+import { ReactiveLogBundle, NodeInput } from '@graphrefly/pure-ts/extra';
+import { a as CircuitBreakerOptions, C as CircuitBreaker } from '../../breaker-C9skL3d8.js';
+export { b as CircuitOpenError } from '../../breaker-C9skL3d8.js';
+import { R as RateLimitSignal, A as AdaptiveRateLimiterBundle } from '../../adaptive-rate-limiter-Dch_xYIi.js';
+import { W as WithReplayCacheOptions } from '../../fallback-pIWW8A2d.js';
+export { F as FallbackAdapterOptions, a as FallbackFixture, b as FallbackMissError, c as FallbackMissPolicy, R as ReplayCacheKeyContext, d as ReplayCacheMissError, e as ReplayCacheMode, f as fallbackAdapter, w as withReplayCache } from '../../fallback-pIWW8A2d.js';
+import { E as Extraction } from '../../distill-De6Rnn15.js';
+import { Graph } from '@graphrefly/pure-ts/graph';
+import { TopicGraph } from '../messaging/index.js';
+import { G as GateController, c as GateOptions } from '../../pipeline-graph-DXCwY9vG.js';
+export { C as ChatStreamGraph, a as ChatStreamOptions, M as MemoryRetrievalGraph, b as MemoryRetrievalOptions, c as MemoryTier, d as MemoryTiersBundle, e as MemoryTiersOptions, f as MemoryWithKGGraph, g as MemoryWithKGOptions, h as MemoryWithTiersGraph, i as MemoryWithTiersOptions, j as MemoryWithVectorsGraph, k as MemoryWithVectorsOptions, R as RetrievalEntry, l as RetrievalPipelineOptions, m as RetrievalQuery, n as RetrievalTrace, T as ToolExecutionOptions, o as ToolRegistryGraph, p as ToolRegistryOptions, q as ToolResult, r as chatStream, s as memoryRetrieval, t as memoryWithKG, u as memoryWithTiers, v as memoryWithVectors, w as toolExecution, x as toolRegistry } from '../../memory-composers-CVQqPYEV.js';
+import { GraphSpecCatalog } from '../graphspec/index.js';
+export { DEFAULT_DECAY_RATE } from '../../base/utils/index.js';
+import '../../_internal-B23BagFd.js';
+import '../../backoff-Bnb9OoPh.js';
+import '../../base/mutation/index.js';
+import '../memory/index.js';
 
 /**
  * Observable adapter wrapper — the "inverted statistics" surface.
@@ -104,7 +111,7 @@ interface WithBreakerOptions extends CircuitBreakerOptions {
      */
     breaker?: CircuitBreaker;
 }
-declare function withBreaker(inner: LLMAdapter, opts?: WithBreakerOptions): {
+declare function withLLMBreaker(inner: LLMAdapter, opts?: WithBreakerOptions): {
     adapter: LLMAdapter;
     breaker: CircuitBreaker;
 };
@@ -149,11 +156,28 @@ interface BudgetTotals {
     outputTokens: number;
     usd: number;
 }
-interface BudgetGateBundle {
+interface LLMBudgetGateBundle {
     totals: Node<BudgetTotals>;
     isOpen: Node<boolean>;
     log: ReactiveLogBundle<CallStatsEvent>;
     reset(): void;
+    /**
+     * QA D2 (Phase 13.6.B QA pass): release every long-lived
+     * subscription this gate holds — `keepalive(isOpen)`, the optional
+     * `onExhausted` subscription, and the Lock 3.C abort fan-out
+     * subscription on `isOpen`. Aborts any in-flight controllers as a
+     * defensive last gasp so callers waiting on a soon-to-be-disposed
+     * adapter don't hang.
+     *
+     * Idempotent: subsequent calls are no-ops. After `dispose()` the
+     * adapter wrapper continues to wrap `inner.invoke` / `inner.stream`
+     * but the budget machinery is best-effort: `record()` no longer
+     * emits `totals` updates, abort fan-out no longer fires. Treat the
+     * bundle as terminated once disposed; long-running apps should
+     * `dispose()` per gate instance to avoid the sub-leak documented
+     * in `docs/optimizations.md`.
+     */
+    dispose(): void;
 }
 interface WithBudgetGateOptions {
     caps: BudgetCaps;
@@ -181,7 +205,7 @@ interface WithBudgetGateOptions {
  */
 declare function withBudgetGate(inner: LLMAdapter, opts: WithBudgetGateOptions): {
     adapter: LLMAdapter;
-    budget: BudgetGateBundle;
+    budget: LLMBudgetGateBundle;
 };
 
 /**
@@ -218,90 +242,6 @@ interface WithDryRunBundle {
 }
 declare function withDryRun(inner: LLMAdapter, opts: WithDryRunOptions): WithDryRunBundle;
 
-/**
- * Adaptive rate limiter — reactive, live-tunable, 429-aware.
- *
- * Wraps two `tokenBucket` instances (requests, tokens) with:
- *   - Reactive `rpm` / `tpm` knobs that can be re-tuned at runtime via `NodeInput<number>`.
- *   - An adaptation signal input (`Node<RateLimitSignal>`) that feeds back
- *     provider 429 / retry-after / x-ratelimit-* headers to tighten limits.
- *   - A `clampCooldownMs` TTL on signal-induced caps so a transient 429 doesn't
- *     permanently throttle — caps decay back to user-configured values after
- *     the cooldown elapses.
- *   - TPM-miss recovery: consumed RPM tokens are returned to the request
- *     bucket when the TPM admit fails, via `TokenBucket.putBack`.
- *   - Imperative `acquire()` for bridging to Promise-based call paths
- *     (used by the `withRateLimiter` adapter middleware).
- *
- * **Timer policy:** sleeps use `ResettableTimer` (documented spec §5.10
- * escape hatch in `src/extra/timer.ts`) rather than `fromTimer` to avoid
- * allocating a new Node per acquire cycle.
- *
- * Design lives in `docs/optimizations.md` § "Reactive adaptive rate limiter".
- */
-
-/**
- * Rate-limit signal emitted by an adaptation source (e.g., an HTTP 429 parser).
- *
- * Any subset of fields may be present. The adaptive rate limiter uses:
- * - `retryAfterMs` — blocks acquire() for this duration.
- * - `rpmCap` / `tpmCap` — tightens effective rpm/tpm to this value (decays
- *   back to the user-configured cap after `clampCooldownMs`).
- * - `usageHint` — updates the last-known rpm/tpm usage ratio for logging.
- */
-interface RateLimitSignal {
-    /** Throttle duration — pause acquire() for this long. */
-    retryAfterMs?: number;
-    /** Hard cap for requests-per-minute; effective rpm = min(current, rpmCap) while clamp is active. */
-    rpmCap?: number;
-    /** Hard cap for tokens-per-minute; effective tpm = min(current, tpmCap) while clamp is active. */
-    tpmCap?: number;
-    /** Observed usage-percentage hint (0..1) — for observability, not gating. */
-    usageHint?: {
-        rpm?: number;
-        tpm?: number;
-    };
-    /** Free-form provider-specific payload. */
-    metadata?: Record<string, unknown>;
-}
-interface AdaptiveRateLimiterBundle {
-    /** Effective requests-per-minute (post-signal-clamp). Reactive. */
-    readonly effectiveRpm: Node<number>;
-    /** Effective tokens-per-minute (post-signal-clamp). Reactive. */
-    readonly effectiveTpm: Node<number>;
-    /** Last adaptation signal observed. */
-    readonly lastSignal: Node<RateLimitSignal>;
-    /** Pending `acquire()` callers waiting for capacity. */
-    readonly pending: Node<number>;
-    /** Current request-token-bucket fill (approximate). */
-    readonly rpmAvailable: Node<number>;
-    /** Current token-bucket fill (approximate). */
-    readonly tpmAvailable: Node<number>;
-    /**
-     * Imperative bridge: wait until `requestCost` request-tokens and
-     * `tokenCost` tokens are available, then consume them. Honors the
-     * most recent `retryAfterMs` from adaptation signals. Rejects with
-     * an `AbortError`-named error if `signal` aborts while waiting.
-     * `requestCost` defaults to 1; `tokenCost` defaults to 0 (rpm-only gating).
-     */
-    acquire(opts?: {
-        requestCost?: number;
-        tokenCost?: number;
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * Feed back observed token usage (post-call) so the TPM bucket reflects
-     * real consumption rather than the pre-call estimate. A positive `delta`
-     * debits additional TPM (undershot estimate); a negative `delta` credits
-     * back overshoot (`putBack`).
-     */
-    recordUsage(delta: number): void;
-    /** Manually feed an adaptation signal — useful for tests. */
-    recordSignal(sig: RateLimitSignal): void;
-    /** Dispose internal subscriptions and pending timers. */
-    dispose(): void;
-}
-
 /**
  * HTTP 429 / rate-limit parser.
  *
@@ -429,7 +369,7 @@ declare function withRetry(inner: LLMAdapter, opts?: WithRetryOptions): LLMAdapt
 
 /**
  * `resilientAdapter` — compose `withRateLimiter` + `withBudgetGate` +
- * `withBreaker` + `withTimeout` + `withRetry` + fallback over an {@link LLMAdapter}.
+ * `withLLMBreaker` + `withLLMTimeout` + `withRetry` + fallback over an {@link LLMAdapter}.
  *
  * Call-path peer of {@link resilientPipeline} (which operates on a reactive
  * `Node<T>` chain). Use `resilientPipeline` when composing graph sources; use
@@ -518,7 +458,7 @@ interface ResilientAdapterBundle {
     /** Rate-limiter internals (for dashboards). Present only when `opts.rateLimit` was set. */
     rateLimiter?: AdaptiveRateLimiterBundle;
     /** Budget gate internals (for dashboards). Present only when `opts.budget` was set. */
-    budget?: BudgetGateBundle;
+    budget?: LLMBudgetGateBundle;
     /** Circuit breaker (for dashboards). Present only when `opts.breaker` was set. */
     breaker?: CircuitBreaker;
 }
@@ -544,7 +484,7 @@ interface ResilientAdapterBundle {
 declare function resilientAdapter(inner: LLMAdapter, opts?: ResilientAdapterOptions): ResilientAdapterBundle;
 
 /**
- * `withTimeout` — cancel `invoke()` / `stream()` after `ms` elapse.
+ * `withLLMTimeout` — cancel `invoke()` / `stream()` after `ms` elapse.
  *
  * Wires a child AbortSignal so provider adapters can honor the cancellation
  * (all shipped adapters forward `signal` through to their fetch / SDK call).
@@ -558,7 +498,7 @@ declare class LLMTimeoutError extends Error {
     name: string;
     constructor(ms: number);
 }
-declare function withTimeout(inner: LLMAdapter, ms: number): LLMAdapter;
+declare function withLLMTimeout(inner: LLMAdapter, ms: number): LLMAdapter;
 
 /**
  * AnthropicAdapter — default fetch-backed, optional SDK-backed.
@@ -883,7 +823,7 @@ type PromptCallOptions = {
     maxTokens?: number;
     /**
      * Optional name forwarded to the underlying `promptNode` (used as the
-     * `<name>::messages` / `<name>::call` / `<name>::output` path prefix).
+     * `<name>::messages` / `<name>::response` / `<name>::output` path prefix).
      * Defaults differ per call site so multiple `promptCall`s wired into the
      * same graph don't collide on `prompt_node::output`.
      */
@@ -891,14 +831,14 @@ type PromptCallOptions = {
 };
 /**
  * Build a one-shot LLM JSON-call factory: each invocation wraps `input` in a
- * fresh `state(input)`, delegates to `promptNode({format: "json"})`, and
+ * fresh `node([], { initial: input })`, delegates to `promptNode({format: "json"})`, and
  * returns a `NodeInput<TOut>` that the caller plugs into `distill` /
  * `agentLoop` / any reactive composition that accepts `NodeInput`.
  *
  * **Per-call lifecycle.** The returned `NodeInput<TOut>` is a producer that
  * emits exactly one `DATA` per upstream input (per Tier 1.2 Session C lock —
  * `promptNode` guarantees one DATA per wave). When the consumer's switchMap
- * supersedes it, the per-call `state(input)` and the inner `prompt_node::call`
+ * supersedes it, the per-call `node([], { initial: input })` and the inner `prompt_node::response`
  * tear down together.
  *
  * @param systemPrompt - System message sent on every call.
@@ -942,17 +882,20 @@ declare function llmConsolidator<TMem>(systemPrompt: string, opts: LLMConsolidat
 /**
  * `promptNode` — universal LLM transform as a reactive derived node.
  *
- * The shape: `deps → messagesNode (derived) → switchMap → call (producer) → output`.
+ * The shape: `deps → messagesNode (derived) → switchMap → response (producer) → output`.
  * Each upstream wave is one LLM call; superseding waves cancel the in-flight
  * call via the abort signal threaded through `nodeSignal(opts.abort)`.
  *
  * The producer-shape on the inner is load-bearing: it emits exactly one DATA
  * + COMPLETE per wave, so the outer switchMap sees one DATA per wave (matches
- * the `HarnessExecutor` contract). A `derived([call], parse)` would have its
+ * the `HarnessExecutor` contract). A `node([response], (batchData, actions, ctx) => {
+ *   const data = ...; actions.emit(parse(data[0]));
+ * }, { describeKind: "derived" })` would have its
  * own first-run / push-on-subscribe semantics that can leak a transient null
  * before the real response arrives — observed and reverted in an earlier
  * attempt; see SESSION-ai-harness-module-review.md line 3654 for context.
- * Locked as path (b) producer-based by Session C (2026-04-27).
+ * Locked as path (b) producer-based by Session C (2026-04-27); inner-node
+ * naming aligned to `prompt_node::response` per the C+D widening (2026-04-30).
  *
  * **Retry / replay-cache.** Stack middleware on the adapter:
  *
@@ -973,7 +916,7 @@ declare function llmConsolidator<TMem>(systemPrompt: string, opts: LLMConsolidat
  * survives across new outer DATAs — `promptNode`'s cached value persists
  * until the next wave fully resolves. Consumers that need to distinguish
  * "fresh value for THIS session" from "stale cache from a prior session"
- * (e.g. `agentLoop` resetting on new `run()`) must add a `state()` mirror
+ * (e.g. `agentLoop` resetting on new `run()`) must add a `node([])` mirror
  * at their session boundary and depend on the mirror, not the `promptNode`
  * output directly. `promptNode` itself stays primitive — it does not
  * embed a state-mirror.
@@ -1011,7 +954,7 @@ type PromptNodeOptions = {
      *
      * **Activation note:** since `tools` is a real declared dep, `messagesNode`
      * waits for the tools Node to DATA at least once before firing
-     * (push-on-subscribe SENTINEL gate). Pass a `state<ToolDefinition[]>([])`
+     * (push-on-subscribe SENTINEL gate). Pass a `node<ToolDefinition[]>([], { initial: [] })`
      * if you want immediate activation with no tools, or the latest published
      * `toolSelector.tools` Node.
      */
@@ -1039,9 +982,9 @@ type PromptNodeOptions = {
  *
  * **Topology** (visible in `describe()`):
  * ```
- * <deps...>, [tools?]  → <name>::messages   (derived, meta.ai = prompt_node)
+ * <deps...>, [tools?]  → <name>::messages   (derived, meta.ai = prompt_node::messages)
  * <name>::messages     → <name>::output     (switchMap product, meta.ai = prompt_node::output)
- *   per-wave inner:    <name>::call         (producer, meta.ai = prompt_node::call)
+ *   per-wave inner:    <name>::response     (producer, meta.ai = prompt_node::response)
  * ```
  * When `opts.tools` is supplied, the tools `Node` is appended to
  * `messagesNode`'s declared deps so it appears as a real edge in `describe()`
@@ -1433,23 +1376,6 @@ type RedactorOptions = {
  */
 declare function redactor(accumulatedText: Node<string>, patterns: RegExp[], replaceFn?: (match: string, pattern: RegExp) => string, opts?: RedactorOptions): Node<string>;
 
-type ChatStreamOptions = {
-    graph?: GraphOptions;
-    maxMessages?: number;
-};
-declare class ChatStreamGraph extends Graph {
-    private readonly _log;
-    readonly messages: Node<readonly ChatMessage[]>;
-    readonly latest: Node<ChatMessage | null>;
-    readonly messageCount: Node<number>;
-    constructor(name: string, opts?: ChatStreamOptions);
-    append(role: ChatMessage["role"], content: string, extra?: Partial<ChatMessage>): void;
-    appendToolResult(callId: string, content: string): void;
-    clear(): void;
-    allMessages(): readonly ChatMessage[];
-}
-declare function chatStream(name: string, opts?: ChatStreamOptions): ChatStreamGraph;
-
 /**
  * Options for {@link handoff}.
  */
@@ -1521,142 +1447,6 @@ type HandoffOptions = {
  */
 declare function handoff<T>(from: NodeInput<T | null>, toFactory: (input: Node<T>) => Node<T | null>, opts?: HandoffOptions): Node<T | null>;
 
-type ToolRegistryOptions = {
-    graph?: GraphOptions;
-};
-/**
- * `ToolRegistryGraph` — name-keyed registry of {@link ToolDefinition}s.
- *
- * **Reactive-only execution.** The only execution path is
- * {@link executeReactive}, which returns a `Node<unknown>` for the handler
- * result. Composing factories (`toolExecution`, `agentLoop`) consume it
- * directly inside `retrySource` / `switchMap` chains. There is intentionally
- * no imperative `execute()` Promise method — the registry was originally a
- * dual-boundary class (imperative + reactive) and the imperative path was
- * the only thing in the codebase bridging through `Promise.resolve().then()`
- * to feed `fromAny`. Removing it left every consumer on a single
- * reactive-all-the-way path with real abort propagation.
- *
- * For non-reactive callers (debug scripts, one-shot tests), bridge with
- * `awaitSettled(toolRegistry.executeReactive(name, args))`.
- *
- * **Wave A Unit 6 refactor:** internal storage migrated from `state<Map>`
- * (O(N) Map-copy per mutation) to `ReactiveMapBundle<string, ToolDefinition>`
- * (O(1) mutations + version counter).
- */
-declare class ToolRegistryGraph extends Graph {
-    readonly definitions: Node<ReadonlyMap<string, ToolDefinition>>;
-    readonly schemas: Node<readonly ToolDefinition[]>;
-    private readonly _bundle;
-    constructor(name: string, opts?: ToolRegistryOptions);
-    register(tool: ToolDefinition): void;
-    unregister(name: string): void;
-    /**
-     * Reactive execution — returns a `Node<unknown>` that emits the handler
-     * result. The returned node is a `producer` that:
-     *
-     * 1. Mints a per-call `AbortController` whose `signal` is threaded into
-     *    the handler call AND into `fromAny` (so a `fromPromise` /
-     *    `fromAsyncIter` inner abandons cleanly when the consumer
-     *    unsubscribes).
-     * 2. Runs `tool.handler(args, {signal})` inside a try/catch — a
-     *    synchronous throw surfaces as `[[ERROR, err]]` downstream instead
-     *    of escaping the producer.
-     * 3. Forwards every message from the inner `fromAny` chain to the
-     *    producer's outputs.
-     * 4. On teardown (subscriber count drops to zero, e.g. `switchMap`
-     *    supersede) calls `ac.abort()` and unsubscribes the inner.
-     *    Signal-aware handlers (e.g. `fetch(url, {signal})`) actually stop.
-     *
-     * Each call mints a fresh node tied to a fresh `handler(args, ...)`
-     * invocation — call `executeReactive` again for repeated invocations.
-     *
-     * @throws `Error` synchronously when `name` is not registered (no node is
-     *   constructed — the caller gets a pre-wiring failure rather than a
-     *   silent ERROR wave on an empty graph).
-     */
-    executeReactive(name: string, args: Record<string, unknown>): Node<unknown>;
-    getDefinition(name: string): ToolDefinition | undefined;
-}
-declare function toolRegistry(name: string, opts?: ToolRegistryOptions): ToolRegistryGraph;
-
-/**
- * `toolExecution` — reactive per-tool-call executor with retry + rescue.
- *
- * Lifted from the inlined `executeToolReactively` helper inside `agent-loop.ts`
- * so it can be consumed standalone by any caller with a reactive `toolCalls`
- * batch — not just `agentLoop`. The shape is: one input `Node<readonly
- * ToolCall[]>` + a `ToolRegistryGraph` → one output `Node<readonly
- * ToolResult[]>`. Each call maps to a per-call `retrySource(executeReactive)`
- * → optional `rescue` chain that emits the handler result on success, or a
- * JSON-wrapped `{ error }` payload on terminal failure so the LLM can see the
- * error as tool output and decide whether to try again via another tool call.
- *
- * **Cancellation.** `executeReactive` mints a per-call `AbortController` and
- * threads its signal into the handler call. When `switchMap` supersedes the
- * inner (a fresh `toolCalls` batch arrives) or the outer graph tears down,
- * the per-call node unsubscribes and `ac.abort()` fires. Signal-aware
- * handlers (`fetch(url, {signal})`, child-process kill, DB cancel) actually
- * stop in-flight work; handlers that ignore the signal still complete to
- * their original termination, but their result is discarded.
- *
- * @module
- */
-
-/** A single tool execution outcome: `{id, content}` where content is a JSON string. */
-interface ToolResult {
-    readonly id: string;
-    readonly content: string;
-}
-type ToolExecutionOptions = {
-    /**
-     * Reactive tool-call batch. Each non-empty emission triggers a fresh
-     * per-call execution fan-out; superseding emissions cancel the prior fan.
-     */
-    toolCalls: Node<readonly ToolCall[]>;
-    /** Registry that resolves tool name → handler. */
-    tools: ToolRegistryGraph;
-    /**
-     * Retry count per individual tool call. `retrySource({count: N})` retries
-     * up to N times on error (N retries = N+1 total attempts). Default: 1.
-     */
-    retryCount?: number;
-    /**
-     * How to surface a terminal error after retries are exhausted.
-     * - `"rescue"` (default): emit `{id, content: JSON.stringify({error})}`
-     *   so the LLM sees the failure as structured tool output and can decide
-     *   how to react. Sibling calls in the same batch continue to their own
-     *   completion; one call's failure does not affect the others.
-     * - `"propagate"`: let the ERROR propagate downstream. **Blast radius:**
-     *   the per-batch `derived` join auto-errors when any per-call node
-     *   terminates with ERROR, so one call's failure discards every sibling's
-     *   DATA (even ones that already settled with a valid ToolResult). Use
-     *   `"propagate"` only when a single tool failure should be fatal for the
-     *   whole batch; prefer `"rescue"` when you want the LLM to see partial
-     *   results plus per-call error markers.
-     */
-    onError?: "rescue" | "propagate";
-};
-/**
- * Reactive executor for a batch of LLM tool calls.
- *
- * Each DATA emission on `toolCalls` dispatches a fresh per-call fan-out: for
- * every call in the batch, construct a `retrySource(fromAny(tools.execute(
- * name, args)))` node, optionally `rescue` it into a JSON error shape, and
- * join the results via a `derived` whose first-run gate waits for every call
- * to settle before emitting the batch. Empty batches (`calls.length === 0`)
- * are a caller-side invariant violation (the upstream gate should emit
- * RESOLVED for empty batches, not DATA) and trigger a loud error — callers
- * that want to accept empty batches should upstream-filter them first.
- *
- * Reference-equality + content-equality dedup is applied to the output batch
- * so duplicate re-emissions from a completing retrySource don't propagate.
- *
- * @param opts - `{ toolCalls, tools, retryCount?, onError? }`.
- * @returns `Node<readonly ToolResult[]>` — one ToolResult per input ToolCall.
- */
-declare function toolExecution(opts: ToolExecutionOptions): Node<readonly ToolResult[]>;
-
 /**
  * Options for {@link toolSelector}.
  */
@@ -1683,11 +1473,20 @@ interface ToolSelectorOptions {
  *
  * @example
  * ```ts
- * const hasBudget = derived([costMeter], (c) => c.total < BUDGET);
+ * const hasBudget = node([costMeter], (batchData, actions, ctx) => {
+ *   const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
+ *   actions.emit((data[0] as CostMeter).total < BUDGET);
+ * }, { describeKind: "derived" });
  * const canDestroy = state(false, { name: "destructive-allowed" });
  * const tools = toolSelector(registry.schemas, [
- *   derived([hasBudget], (b) => (t) => !t.meta?.expensive || b === true),
- *   derived([canDestroy], (c) => (t) => !t.meta?.destructive || c === true),
+ *   node([hasBudget], (batchData, actions, ctx) => {
+ *     const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
+ *     actions.emit((t) => !t.meta?.expensive || data[0] === true);
+ *   }, { describeKind: "derived" }),
+ *   node([canDestroy], (batchData, actions, ctx) => {
+ *     const data = batchData.map((batch, i) => batch != null && batch.length > 0 ? batch.at(-1) : ctx.prevData[i]);
+ *     actions.emit((t) => !t.meta?.destructive || data[0] === true);
+ *   }, { describeKind: "derived" }),
  * ]);
  * const agent = promptNode(graph, "agent", { ..., tools });
  * ```
@@ -1748,508 +1547,6 @@ type AdmissionScore3DOptions = {
  */
 declare function admissionFilter3D(opts: AdmissionScore3DOptions): (raw: unknown) => boolean;
 
-type RetrievalQuery = {
-    readonly text?: string;
-    readonly vector?: readonly number[];
-    readonly entityIds?: readonly string[];
-    /**
-     * Optional hierarchical context breadcrumb — e.g.
-     * `["projects", "auth", "tokens"]`. When both the query and a candidate
-     * entry supply a `context`, the retrieval pipeline applies a score boost
-     * proportional to `contextWeight` for entries whose context overlaps
-     * (shared prefix). Entries or queries without `context` are scored
-     * flatly (backward-compatible).
-     */
-    readonly context?: readonly string[];
-};
-type RetrievalPipelineOptions<TMem> = {
-    /** Max candidates from vector search (default 20). */
-    topK?: number;
-    /** KG expansion depth in hops (default 1). */
-    graphDepth?: number;
-    /** Token budget for final packing (default 2000). */
-    budget?: number;
-    /** Cost function for budget packing. */
-    cost: (mem: TMem) => number;
-    /** Score function for ranking. */
-    score: (mem: TMem, context: unknown) => number;
-    /**
-     * Optional accessor: extracts the hierarchical context breadcrumb from a
-     * memory entry. Used with {@link RetrievalQuery.context} and
-     * `contextWeight` to boost entries whose context overlaps the query.
-     * Entries that don't expose context stay at flat behavior.
-     */
-    contextOf?: (mem: TMem) => readonly string[] | undefined;
-    /**
-     * Boost multiplier applied to a candidate's score when its `context`
-     * shares a prefix with the query's `context`. Score is multiplied by
-     * `(1 + contextWeight * sharedDepth / queryDepth)`. Default: 0 (no
-     * context boost).
-     */
-    contextWeight?: number;
-};
-/** A single entry in the retrieval result, with causal trace metadata. */
-type RetrievalEntry<TMem> = {
-    readonly key: string;
-    readonly value: TMem;
-    readonly score: number;
-    readonly sources: ReadonlyArray<"vector" | "graph" | "store">;
-    /**
-     * Hierarchical context breadcrumb for this entry, when
-     * `RetrievalPipelineOptions.contextOf` is supplied and returns a value.
-     */
-    readonly context?: readonly string[];
-};
-/** Causal trace for a retrieval run. */
-type RetrievalTrace<TMem> = {
-    readonly vectorCandidates: ReadonlyArray<VectorSearchResult<TMem>>;
-    readonly graphExpanded: ReadonlyArray<string>;
-    readonly ranked: ReadonlyArray<RetrievalEntry<TMem>>;
-    readonly packed: ReadonlyArray<RetrievalEntry<TMem>>;
-};
-
-type MemoryTier = "permanent" | "active" | "archived";
-type MemoryTiersOptions<TMem> = {
-    /** Exponential decay rate per second for active tier.
-     *  Default: 7-day half-life ≈ ln(2)/(7×86400) ≈ 0.00000114. */
-    decayRate?: number;
-    /** Max entries in the active tier before archiving lowest-scored (default 1000). */
-    maxActive?: number;
-    /** Score threshold below which active entries get archived (default 0.1). */
-    archiveThreshold?: number;
-    /** Predicate: true → entry belongs in permanent tier (default: never). */
-    permanentFilter?: (key: string, mem: TMem) => boolean;
-    /** Storage tier for the archive. Omit to disable archiving. */
-    archiveTier?: SnapshotStorageTier<GraphCheckpointRecord>;
-    /** Options forwarded to `graph.attachSnapshotStorage` for the archive tier. */
-    archiveStorageOptions?: GraphAttachStorageOptions;
-};
-
-type MemoryTiersBundle<TMem> = {
-    /**
-     * Permanent tier: never evicted. Backed by a `collection({ranked:false})`
-     * Graph (Tier 2.3 — was previously a `LightCollectionBundle`; the no-Graph
-     * bundle shape was folded into the unified `CollectionGraph`).
-     */
-    readonly permanent: CollectionGraph<TMem>;
-    /** Active entries node (reactive, holds ReadonlyMap). */
-    readonly activeEntries: Node<unknown>;
-    /** Archive storage handle (null if no tier configured). */
-    readonly archiveHandle: StorageHandle | null;
-    /** Classify a key into its current tier. */
-    tierOf: (key: string) => MemoryTier;
-    /** Move a key to the permanent tier. */
-    markPermanent: (key: string, value: TMem) => void;
-};
-
-type MemoryWithVectorsOptions<TMem> = {
-    /** Embedding dimension. Must match the `embedFn` output length. */
-    dimension: number;
-    /** Extract an embedding vector for a memory entry. */
-    embedFn: (mem: TMem) => readonly number[] | undefined;
-};
-/**
- * Attach a vector index to a `DistillBundle`. Indexes every entry in the
- * store as it changes. Returns the `VectorIndexGraph` so retrieval can read
- * its `entries` and call `search()`.
- *
- * The indexer's keepalive is registered with `graph.addDisposer` so it tears
- * down on `graph.destroy()`. The returned `dispose()` is also available for
- * early release without destroying the parent graph.
- */
-declare function memoryWithVectors<TMem>(graph: Graph, store: DistillBundle<TMem>, opts: MemoryWithVectorsOptions<TMem>): {
-    vectors: VectorIndexGraph<TMem>;
-    dispose: () => void;
-};
-type MemoryWithKGOptions<TMem> = {
-    /**
-     * Mount path for the KG subgraph on the parent graph. Defaults to `name`.
-     * Pass a different value when the parent graph reserves a stable mount
-     * path (e.g. `agentMemory` mounts at `"kg"` regardless of outer name).
-     */
-    mountPath?: string;
-    /**
-     * Extract entities + relations for a memory entry. Omit to mount an empty
-     * KG without an indexer effect — caller upserts entities / relations
-     * directly on the returned `kg` handle.
-     */
-    entityFn?: (key: string, mem: TMem) => {
-        entities?: Array<{
-            id: string;
-            value: unknown;
-        }>;
-        relations?: Array<{
-            from: string;
-            to: string;
-            relation: string;
-            weight?: number;
-        }>;
-    } | undefined;
-};
-/**
- * Attach a knowledge graph alongside a `DistillBundle`. Inner graph is named
- * `${name}-kg`; mount path defaults to `name` but can be overridden via
- * `opts.mountPath` so a parent factory (e.g. `agentMemory`) can keep a stable
- * mount path independent of the inner graph's identity.
- *
- * If `opts.entityFn` is omitted, no indexer effect is wired — the empty KG is
- * mounted for manual `upsertEntity` / `link` use.
- *
- * Indexer keepalive (when present) is registered with `graph.addDisposer`;
- * explicit `dispose()` is also available.
- */
-declare function memoryWithKG<TMem>(graph: Graph, store: DistillBundle<TMem>, name: string, opts: MemoryWithKGOptions<TMem>): {
-    kg: KnowledgeGraph<unknown, string>;
-    dispose: () => void;
-};
-/**
- * Full options for {@link memoryWithTiers} (Tier 4.1 B + 4.3 B refactor,
- * 2026-04-29). Combines tier-policy options with the distill-side options
- * needed to construct the underlying store — `memoryWithTiers` is now the
- * **construction site** for the distill bundle so it can wire
- * `reactiveMap.retention` into the store at construction (eliminating the
- * §7 feedback cycle the previous `tierClassifier` effect carried).
- *
- * The retention config built internally maps tier policy to the substrate:
- * - `archiveThreshold` → `retention.archiveThreshold`
- * - `maxActive` → `retention.maxSize`
- * - per-entry `decay(score(mem, ctx), age, decayRate)` → `retention.score`
- *   (capturing `latestCtx` + `entryCreatedAtNs` via closure-mirror; permanent
- *   entries score `Infinity` to bypass eviction).
- */
-type MemoryWithTiersOptions<TMem> = MemoryTiersOptions<TMem> & Omit<DistillOptions<TMem>, "mapOptions" | "score" | "context"> & {
-    /** Score function — same signature as `agentMemory.score`. */
-    score: (mem: TMem, context: unknown) => number;
-    /** Optional reactive context node (passed to `score`). */
-    context?: NodeInput<unknown>;
-};
-/**
- * Attach 3-tier storage (active / archived / permanent) to a fresh distill
- * store, wiring `reactiveMap.retention` at construction so archival happens
- * synchronously inside the substrate's mutation pipeline (no §7 feedback
- * cycle). Promotes `permanentKeys` and `entryCreatedAtNs` to reactive maps
- * mounted on the graph (Tier 4.3 B — Unit 7 Q3) so `describe()`/`explain()`
- * can walk to "why was X archived?".
- *
- * **API shape** (Tier 4.1 B, 2026-04-29 — breaking change vs. pre-refactor):
- * `memoryWithTiers` constructs the distill bundle internally rather than
- * accepting a pre-built one. Callers pass `(graph, source, extractFn,
- * opts)`. The bundle is exposed as `result.store` for downstream composers
- * (vectors / KG / retrieval).
- *
- * - `permanentFilter`-matching entries score `Infinity` in retention →
- *   never archived. Independent permanent-promotion effect upserts them
- *   into the `permanent` collection.
- * - Below-threshold entries → retention archives synchronously.
- * - Over-`maxActive` entries → retention's `maxSize` evicts lowest-scored.
- */
-declare function memoryWithTiers<TRaw, TMem>(graph: Graph, source: NodeInput<TRaw>, extractFn: (raw: Node<TRaw>, existing: Node<ReadonlyMap<string, TMem>>) => NodeInput<Extraction<TMem>>, opts: MemoryWithTiersOptions<TMem>): {
-    store: DistillBundle<TMem>;
-    tiers: MemoryTiersBundle<TMem>;
-    dispose: () => void;
-};
-type MemoryRetrievalOptions<TMem> = {
-    /** Score function (same shape as `agentMemory.score`). */
-    score: (mem: TMem, context: unknown) => number;
-    /** Cost function for budget packing. */
-    cost: (mem: TMem) => number;
-    /** Token / cost budget. Default 2000. */
-    budget?: number;
-    /** Top-K vector candidates. Default 20. */
-    topK?: number;
-    /** KG expansion depth in hops. Default 1. */
-    graphDepth?: number;
-    /** Hierarchical-context boost weight. Default 0. */
-    contextWeight?: number;
-    /** Hierarchical-context accessor for entries. */
-    contextOf?: (mem: TMem) => readonly string[] | undefined;
-    /** Optional reactive context node (passed to `score`). */
-    context?: NodeInput<unknown>;
-};
-type MemoryRetrievalBundle<TMem> = {
-    /** State node mirroring the latest packed retrieval result. */
-    readonly retrieval: Node<ReadonlyArray<RetrievalEntry<TMem>>>;
-    /** State node mirroring the latest retrieval trace. */
-    readonly retrievalTrace: Node<RetrievalTrace<TMem> | null>;
-    /** Imperative consumer API — synchronous; reads cache at call time. */
-    readonly retrieve: (query: RetrievalQuery) => ReadonlyArray<RetrievalEntry<TMem>>;
-    /** Reactive sibling — chain into the graph. Mirrors observability state. */
-    readonly retrieveReactive: (queryInput: NodeInput<RetrievalQuery | null>) => Node<ReadonlyArray<RetrievalEntry<TMem>>>;
-};
-/**
- * Build the retrieval pipeline (vector + KG + budget packing) over a
- * `DistillBundle` and optional `vectors` / `kg` bundles.
- *
- * Both consumer surfaces (`retrieve`, `retrieveReactive`) write to the same
- * `retrieval` + `retrievalTrace` state nodes — observers subscribed to those
- * see ALL queries regardless of which API issued them.
- */
-declare function memoryRetrieval<TMem>(graph: Graph, store: DistillBundle<TMem>, vectors: VectorIndexGraph<TMem> | null, kg: KnowledgeGraph<unknown, string> | null, opts: MemoryRetrievalOptions<TMem>): MemoryRetrievalBundle<TMem>;
-
-/**
- * Reactive agent loop — autonomous multi-turn LLM agent with tool execution.
- */
-type AgentLoopStatus = "idle" | "thinking" | "acting" | "done" | "error";
-
-type AgentLoopOptions = {
-    graph?: GraphOptions;
-    adapter: LLMAdapter;
-    tools?: readonly ToolDefinition[];
-    systemPrompt?: string;
-    maxTurns?: number;
-    stopWhen?: (response: LLMResponse) => boolean;
-    onToolCall?: (call: ToolCall) => void;
-    maxMessages?: number;
-    model?: string;
-    temperature?: number;
-    maxTokens?: number;
-    /**
-     * Reactive tool-call splice (COMPOSITION-GUIDE §31 "interception is security").
-     * When set, the raw `toolCalls` node is piped through this transform before
-     * reaching the executor. The transform is a pure reactive composition —
-     * `(calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]>` — so the
-     * gate is visible in `describe()` / `explain()` as a real edge (no hidden
-     * imperative wraps; §24).
-     *
-     * Typical uses:
-     * - **Filter / block** — `derived([calls, policy], ([raw, p]) => raw.filter(p))`
-     * - **Throttle / debounce** — `throttle(calls, windowMs)`
-     * - **Human-in-the-loop approval** — pipe through a `gate` controller so
-     *   calls wait for human approval before reaching the executor.
-     *
-     * The public `agent.toolCalls` node surfaces the POST-intercept stream, so
-     * audit / telemetry consumers see what the executor actually runs. The raw
-     * pre-intercept stream is not exposed — tests that need it should run
-     * without `interceptToolCalls` set (the identity case).
-     */
-    interceptToolCalls?: (calls: Node<readonly ToolCall[]>) => Node<readonly ToolCall[]>;
-};
-/**
- * Reactive agent loop.
- *
- * The loop is a reactive state machine wired entirely from graph primitives:
- * `chat.messages` + `tools.schemas` + gating state feed a `promptInput`
- * derived; `switchMap` turns non-null inputs into an LLM invocation via
- * `fromAny(adapter.invoke(...))`. The LLM response drives chat writes and
- * status transitions via effects. Tool calls flow through a reactive
- * executor (`retrySource` + `rescue`) that retries once on error and
- * surfaces terminal errors as JSON-shaped `ToolResult` payloads for the
- * LLM to react to.
- *
- * **No imperative control flow inside the reactive layer** (spec §5.8-5.12):
- * no `while` loops, no manual `await adapter.invoke`, no polling.
- * `agent.run()` is a thin `awaitSettled` bridge so callers can still `await`
- * the loop if they want a Promise.
- *
- * Public surface:
- * - `chat` / `tools` — subgraphs (imperative `append` at boundary, reactive `executeReactive` for tool invocation)
- * - `status` / `turn` / `aborted` — state nodes with explicit initials
- * - `lastResponse` / `toolCalls` / `toolResults` — reactive outputs (SENTINEL until first emission; callers use `awaitSettled` / `subscribe`)
- * - `run(userMessage?, signal?)` — optional user append + Promise bridge
- * - `abort()` — imperative abort shim; flips `aborted` state
- *
- * **Lifecycle: single-mount.** `AgentLoopGraph` instances expect to be
- * constructed once and used until `destroy()`. The internal closure mirrors
- * (`latestTurn` / `latestAborted` / `latestStatus` / `latestMessages` /
- * `latestSchemas`) are wired by subscribe-and-capture at construction time;
- * their corresponding `addDisposer`-registered subscriptions are torn down
- * on subgraph unmount or `destroy()`. After teardown the mirrors freeze at
- * their last value, so re-using a destroyed instance — calling `run()`
- * again, or remounting under a new parent — would silently feed stale
- * mirror data into `promptInput`. If you need to "reset" an agent, build a
- * fresh `AgentLoopGraph` instance instead of recycling.
- */
-declare class AgentLoopGraph extends Graph {
-    readonly chat: ChatStreamGraph;
-    readonly tools: ToolRegistryGraph;
-    /** Current agent status. `initial: "idle"` — always has a real value. */
-    readonly status: Node<AgentLoopStatus>;
-    /** Turn count (completed LLM invocations this run). `initial: 0`. */
-    readonly turn: Node<number>;
-    /** Aborted flag; flipped by `abort()` or external `AbortSignal`. `initial: false`. */
-    readonly aborted: Node<boolean>;
-    /**
-     * Most recent LLM response. State-backed mirror driven by the response
-     * effect. `initial: null` — subscribers can read the cache synchronously;
-     * `awaitSettled(lastResponse)` or `firstWhere(lastResponse, v => v != null)`
-     * bridges to the first non-null value as a Promise.
-     */
-    readonly lastResponse: Node<LLMResponse | null>;
-    /** Tool-call batch emitted by the most recent LLM response. SENTINEL. */
-    readonly toolCalls: Node<readonly ToolCall[]>;
-    /** Tool-result batch (one entry per call) after reactive execution. SENTINEL. */
-    readonly toolResults: Node<readonly ToolResult[]>;
-    private readonly _terminalResult;
-    private readonly _disposeRunWiring;
-    /** Guards against overlapping `run()` calls. */
-    private _running;
-    /**
-     * Abort controller for the currently-running `adapter.invoke`. Minted per
-     * switchMap project; aborted when the reactive `aborted` node flips true
-     * OR when the caller's external `AbortSignal` fires. Threaded into
-     * `adapter.invoke({ signal })` AND `fromAny(promise, { signal })`, so the
-     * reactive layer sees ERROR when the wire call is cancelled.
-     */
-    private _currentAbortController;
-    constructor(name: string, opts: AgentLoopOptions);
-    /**
-     * Bridge to `Promise<LLMResponse>` over the reactive pipeline.
-     *
-     * - If `userMessage` is provided, appends it as a user message and
-     *   transitions status to `"thinking"` to kick the loop.
-     * - If `signal` is provided, binds it to the reactive `aborted` node
-     *   AND threads into `adapter.invoke({ signal })` so the wire call can
-     *   cancel mid-flight. The reactive `aborted` state + effect 3 guarantee
-     *   that even an adapter that ignores `signal` will stop emitting into
-     *   the agent graph.
-     * - Resolves when `status === "done"` with the final LLM response.
-     *   Rejects with `AbortError` when the abort signal fires pre-response.
-     *   Rejects with the stage error when `status === "error"`.
-     *
-     * **Concurrency:** `run()` refuses to overlap with a pending call on the
-     * same agent. Attempting to call `run()` while a previous `run()` is
-     * still in-flight throws a `RangeError` immediately. Stale-resolution
-     * safety is provided by `awaitSettled({skipCurrent: true})`, which
-     * ignores the cached initial DATA from any previous run and resolves
-     * only on a fresh post-subscribe emission of `_terminalResult`.
-     */
-    run(userMessage?: string, signal?: AbortSignal): Promise<LLMResponse | null>;
-    /**
-     * Flip the reactive `aborted` state. Equivalent to setting an external
-     * `AbortSignal` — the pipeline observes and transitions to `"done"`.
-     */
-    abort(): void;
-    destroy(): void;
-}
-declare function agentLoop(name: string, opts: AgentLoopOptions): AgentLoopGraph;
-
-type AgentMemoryOptions<TMem = unknown> = {
-    graph?: GraphOptions;
-    /** LLM adapter for extraction and consolidation. */
-    adapter?: LLMAdapter;
-    /** System prompt for the extractor LLM. */
-    extractPrompt?: string;
-    /** Custom extractFn (overrides adapter + extractPrompt). */
-    extractFn?: (raw: unknown, existing: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-    /** System prompt for the consolidation LLM. */
-    consolidatePrompt?: string;
-    /** Custom consolidateFn (overrides adapter + consolidatePrompt). */
-    consolidateFn?: (entries: ReadonlyMap<string, TMem>) => NodeInput<Extraction<TMem>>;
-    /** Reactive trigger for consolidation (caller supplies e.g. `fromTimer`). */
-    consolidateTrigger?: NodeInput<unknown>;
-    /** Score function for budget packing (required). */
-    score: (mem: TMem, context: unknown) => number;
-    /** Cost function for budget packing (required). */
-    cost: (mem: TMem) => number;
-    /** Token budget for compact view (default 2000). */
-    budget?: number;
-    /** Context node for scoring. */
-    context?: NodeInput<unknown>;
-    /** Admission filter (default: admit all). */
-    admissionFilter?: (candidate: unknown) => boolean;
-    /** Vector index dimensions (> 0 enables vector index for retrieval). */
-    vectorDimensions?: number;
-    /**
-     * B12: optional accessor for an entry's hierarchical context breadcrumb
-     * (e.g. `["projects", "auth", "tokens"]`). When supplied alongside
-     * `contextWeight > 0`, retrieval applies a score boost for entries whose
-     * context shares a prefix with the query's `context`. Entries without
-     * a breadcrumb are scored flatly.
-     */
-    contextOf?: (mem: TMem) => readonly string[] | undefined;
-    /**
-     * B12: hierarchical context boost multiplier. Score is scaled by
-     * `(1 + contextWeight * sharedDepth / queryDepth)` when both the query
-     * and entry supply a `context`. Default: 0.
-     */
-    contextWeight?: number;
-    /** Extract embedding vector from a memory entry (enables vector index). */
-    embedFn?: (mem: TMem) => readonly number[] | undefined;
-    /** Enable knowledge graph for entity/relation tracking. */
-    enableKnowledgeGraph?: boolean;
-    /** Extract entities and relations from a memory entry. */
-    entityFn?: (key: string, mem: TMem) => {
-        entities?: Array<{
-            id: string;
-            value: unknown;
-        }>;
-        relations?: Array<{
-            from: string;
-            to: string;
-            relation: string;
-            weight?: number;
-        }>;
-    } | undefined;
-    /** 3-tier storage configuration. Omit to use single-tier (existing behavior). */
-    tiers?: MemoryTiersOptions<TMem>;
-    /** Retrieval pipeline configuration. Requires vector index or knowledge graph. */
-    retrieval?: {
-        /** Max candidates from vector search (default 20). */
-        topK?: number;
-        /** KG expansion depth in hops (default 1). */
-        graphDepth?: number;
-    };
-    /** Periodic reflection/consolidation configuration. */
-    reflection?: {
-        /** Interval in ms between consolidation runs (default 300_000 = 5 min). */
-        interval?: number;
-        /** Enable/disable periodic reflection (default true when consolidateFn is available). */
-        enabled?: boolean;
-    };
-};
-type AgentMemoryGraph<TMem = unknown> = Graph & {
-    readonly distillBundle: DistillBundle<TMem>;
-    readonly compact: Node<Array<{
-        key: string;
-        value: TMem;
-        score: number;
-    }>>;
-    readonly size: Node<number>;
-    /** Vector index bundle (null if not enabled). */
-    readonly vectors: VectorIndexGraph<TMem> | null;
-    /** Knowledge graph (null if not enabled). */
-    readonly kg: KnowledgeGraph<unknown, string> | null;
-    /** Memory tiers bundle (null if not configured). */
-    readonly memoryTiers: MemoryTiersBundle<TMem> | null;
-    /** Retrieval result node (null if no retrieval pipeline configured). */
-    readonly retrieval: Node<ReadonlyArray<RetrievalEntry<TMem>>> | null;
-    /** Latest retrieval trace for observability (null if no retrieval pipeline). */
-    readonly retrievalTrace: Node<RetrievalTrace<TMem> | null> | null;
-    /**
-     * Execute a retrieval query (null if no retrieval pipeline).
-     *
-     * **Synchronous consumer API** — returns the result immediately and batch-writes
-     * `retrieval` and `retrievalTrace` state nodes for observers. Reads the store
-     * snapshot and context value **at call time** (external-boundary read).
-     *
-     * **Do not call from inside a reactive fn body** (derived fn, subscribe callback,
-     * effect body). The cache reads would become transitive protocol violations and
-     * may observe wave-progressive rather than wave-final state.
-     *
-     * **Caller-batch caveat:** if invoked inside a caller's `batch(() => ...)` alongside
-     * upstream store mutations, the store snapshot reflects what has been committed to
-     * `store.entries.cache` at call time. State-backed stores update cache synchronously
-     * so batched inserts are visible; derived-backed store transforms may defer. If you
-     * need fresh state after batched mutations, call `retrieve` after the batch returns.
-     */
-    readonly retrieve: ((query: RetrievalQuery) => ReadonlyArray<RetrievalEntry<TMem>>) | null;
-    /**
-     * Reactive sibling of {@link retrieve}. Given a reactive
-     * `RetrievalQuery | null` source, returns a `Node` emitting the packed
-     * retrieval results. Composable with graph topology — subscribe it,
-     * chain it into `promptNode`, or switchMap over a user-input node.
-     * Null when no retrieval pipeline is configured.
-     */
-    readonly retrieveReactive: ((queryInput: NodeInput<RetrievalQuery | null>) => Node<ReadonlyArray<RetrievalEntry<TMem>>>) | null;
-};
-/**
- * Pre-wired agentic memory graph. Sugar over `distill` plus the
- * `memoryWithVectors` / `memoryWithKG` / `memoryWithTiers` / `memoryRetrieval`
- * composers. Power users who want a subset of capabilities can call those
- * composers directly; this factory bundles them into one ergonomic call.
- */
-declare function agentMemory<TMem = unknown>(name: string, source: NodeInput<unknown>, opts: AgentMemoryOptions<TMem>): AgentMemoryGraph<TMem>;
-
 type GaugesAsContextOptions = {
     /** Group gauges by `meta.tags` (default true). */
     groupByTags?: boolean;
@@ -2316,7 +1613,7 @@ declare function graphFromSpec(naturalLanguage: string, adapter: LLMAdapter, opt
  * Reactive variant of {@link graphFromSpec}: re-invokes the LLM and
  * recompiles the graph whenever `input` emits a new natural-language
  * description. Useful inside the harness or refine loop when the spec text
- * itself is a reactive value (e.g. fed by a `state(...)` knob, a memory
+ * itself is a reactive value (e.g. fed by a `node([], { initial: ... })` knob, a memory
  * snapshot, or an upstream `promptNode` output).
  *
  * **Supersede:** when the input changes mid-flight, switchMap tears the
@@ -2477,204 +1774,4 @@ type GraphDefValidation = {
  */
 declare function validateGraphDef(def: unknown): GraphDefValidation;
 
-/**
- * AI surface patterns (roadmap §4.4).
- *
- * Domain-layer factories for LLM-backed agents, chat, tool registries, and
- * agentic memory. Composed from core + extra + Phase 3–4.3 primitives.
- *
- * This file is the public barrel — it re-exports symbols from the sibling
- * folders (`prompts/`, `extractors/`, `safety/`, `agents/`, `memory/`,
- * `graph-integration/`, and the existing `adapters/` tree). No implementation
- * code lives here; see each sibling folder for the actual primitives.
- *
- * @module
- */
-
-declare const index_AdapterProvider: typeof AdapterProvider;
-type index_AdapterStats = AdapterStats;
-declare const index_AdapterTier: typeof AdapterTier;
-type index_AdmissionScore3DOptions = AdmissionScore3DOptions;
-type index_AdmissionScoredOptions<Dims extends string, TRaw = unknown> = AdmissionScoredOptions<Dims, TRaw>;
-type index_AdmissionScores = AdmissionScores;
-type index_AdmissionThresholds<Dims extends string> = AdmissionThresholds<Dims>;
-type index_AgentLoopGraph = AgentLoopGraph;
-declare const index_AgentLoopGraph: typeof AgentLoopGraph;
-type index_AgentLoopOptions = AgentLoopOptions;
-type index_AgentLoopStatus = AgentLoopStatus;
-type index_AgentMemoryGraph<TMem = unknown> = AgentMemoryGraph<TMem>;
-type index_AgentMemoryOptions<TMem = unknown> = AgentMemoryOptions<TMem>;
-declare const index_AllTiersExhaustedError: typeof AllTiersExhaustedError;
-type index_AnthropicAdapterOptions = AnthropicAdapterOptions;
-type index_AnthropicSdkLike = AnthropicSdkLike;
-type index_BudgetCaps = BudgetCaps;
-type index_BudgetExhaustedError = BudgetExhaustedError;
-declare const index_BudgetExhaustedError: typeof BudgetExhaustedError;
-type index_BudgetGateBundle = BudgetGateBundle;
-type index_BudgetTotals = BudgetTotals;
-type index_CallStatsEvent = CallStatsEvent;
-declare const index_CapabilitiesRegistry: typeof CapabilitiesRegistry;
-declare const index_CascadeExhaustionReport: typeof CascadeExhaustionReport;
-declare const index_CascadingLlmAdapterOptions: typeof CascadingLlmAdapterOptions;
-declare const index_ChatMessage: typeof ChatMessage;
-type index_ChatStreamGraph = ChatStreamGraph;
-declare const index_ChatStreamGraph: typeof ChatStreamGraph;
-type index_ChatStreamOptions = ChatStreamOptions;
-declare const index_CircuitOpenError: typeof CircuitOpenError;
-type index_ContentDecision = ContentDecision;
-type index_ContentGateOptions = ContentGateOptions;
-type index_CostMeterOptions = CostMeterOptions;
-type index_CostMeterReading = CostMeterReading;
-declare const index_CreateAdapterOptions: typeof CreateAdapterOptions;
-declare const index_DEFAULT_DECAY_RATE: typeof DEFAULT_DECAY_RATE;
-type index_DryRunAdapterOptions = DryRunAdapterOptions;
-type index_ExtractedToolCall = ExtractedToolCall;
-declare const index_FallbackAdapterOptions: typeof FallbackAdapterOptions;
-declare const index_FallbackFixture: typeof FallbackFixture;
-declare const index_FallbackMissError: typeof FallbackMissError;
-declare const index_FallbackMissPolicy: typeof FallbackMissPolicy;
-type index_FrozenContextOptions = FrozenContextOptions;
-type index_GatedStreamHandle<T> = GatedStreamHandle<T>;
-type index_GatedStreamOptions = GatedStreamOptions;
-type index_GaugesAsContextOptions = GaugesAsContextOptions;
-type index_GoogleAdapterOptions = GoogleAdapterOptions;
-type index_GoogleSdkLike = GoogleSdkLike;
-type index_GoogleSdkRequestConfig = GoogleSdkRequestConfig;
-type index_GoogleSdkRequestParams = GoogleSdkRequestParams;
-type index_GraphDefValidation = GraphDefValidation;
-type index_GraphFromSpecOptions = GraphFromSpecOptions;
-type index_HandoffOptions = HandoffOptions;
-type index_HttpErrorLike = HttpErrorLike;
-type index_KeywordFlag = KeywordFlag;
-type index_KeywordFlagExtractorOptions = KeywordFlagExtractorOptions;
-type index_KnobsAsToolsResult = KnobsAsToolsResult;
-declare const index_LLMAdapter: typeof LLMAdapter;
-type index_LLMConsolidatorOptions = LLMConsolidatorOptions;
-type index_LLMExtractorOptions = LLMExtractorOptions;
-declare const index_LLMInvokeOptions: typeof LLMInvokeOptions;
-declare const index_LLMResponse: typeof LLMResponse;
-type index_LLMTimeoutError = LLMTimeoutError;
-declare const index_LLMTimeoutError: typeof LLMTimeoutError;
-type index_McpToolSchema = McpToolSchema;
-type index_MemoryRetrievalBundle<TMem> = MemoryRetrievalBundle<TMem>;
-type index_MemoryRetrievalOptions<TMem> = MemoryRetrievalOptions<TMem>;
-type index_MemoryTier = MemoryTier;
-type index_MemoryTiersBundle<TMem> = MemoryTiersBundle<TMem>;
-type index_MemoryTiersOptions<TMem> = MemoryTiersOptions<TMem>;
-type index_MemoryWithKGOptions<TMem> = MemoryWithKGOptions<TMem>;
-type index_MemoryWithTiersOptions<TMem> = MemoryWithTiersOptions<TMem>;
-type index_MemoryWithVectorsOptions<TMem> = MemoryWithVectorsOptions<TMem>;
-declare const index_ModelCapabilities: typeof ModelCapabilities;
-declare const index_ModelFeatures: typeof ModelFeatures;
-declare const index_ModelLimits: typeof ModelLimits;
-declare const index_ModelPricing: typeof ModelPricing;
-declare const index_OpenAICompatAdapterOptions: typeof OpenAICompatAdapterOptions;
-declare const index_OpenAICompatPreset: typeof OpenAICompatPreset;
-declare const index_OpenAISdkLike: typeof OpenAISdkLike;
-type index_OpenAIToolSchema = OpenAIToolSchema;
-declare const index_PriceBreakdown: typeof PriceBreakdown;
-declare const index_PricingFn: typeof PricingFn;
-declare const index_PricingRegistry: typeof PricingRegistry;
-type index_PromptCallOptions = PromptCallOptions;
-type index_PromptNodeOptions = PromptNodeOptions;
-declare const index_Rate: typeof Rate;
-type index_RedactorOptions = RedactorOptions;
-declare const index_ReplayCacheKeyContext: typeof ReplayCacheKeyContext;
-declare const index_ReplayCacheMissError: typeof ReplayCacheMissError;
-declare const index_ReplayCacheMode: typeof ReplayCacheMode;
-type index_ResilientAdapterBundle = ResilientAdapterBundle;
-type index_ResilientAdapterOptions = ResilientAdapterOptions;
-type index_RetrievalEntry<TMem> = RetrievalEntry<TMem>;
-type index_RetrievalPipelineOptions<TMem> = RetrievalPipelineOptions<TMem>;
-type index_RetrievalQuery = RetrievalQuery;
-type index_RetrievalTrace<TMem> = RetrievalTrace<TMem>;
-type index_StampedDelta = StampedDelta;
-type index_StrategyOperation = StrategyOperation;
-type index_StrategyPlan = StrategyPlan;
-declare const index_StreamDelta: typeof StreamDelta;
-type index_StreamingPromptNodeHandle<T> = StreamingPromptNodeHandle<T>;
-type index_StreamingPromptNodeOptions = StreamingPromptNodeOptions;
-type index_SuggestStrategyOptions = SuggestStrategyOptions;
-type index_SystemPromptHandle = SystemPromptHandle;
-declare const index_TieredRate: typeof TieredRate;
-declare const index_TokenUsage: typeof TokenUsage;
-declare const index_ToolCall: typeof ToolCall;
-declare const index_ToolDefinition: typeof ToolDefinition;
-type index_ToolExecutionOptions = ToolExecutionOptions;
-type index_ToolRegistryGraph = ToolRegistryGraph;
-declare const index_ToolRegistryGraph: typeof ToolRegistryGraph;
-type index_ToolRegistryOptions = ToolRegistryOptions;
-type index_ToolResult = ToolResult;
-type index_ToolSelectorOptions = ToolSelectorOptions;
-type index_WithBreakerOptions = WithBreakerOptions;
-type index_WithBudgetGateOptions = WithBudgetGateOptions;
-type index_WithDryRunBundle = WithDryRunBundle;
-type index_WithDryRunOptions = WithDryRunOptions;
-type index_WithRateLimiterOptions = WithRateLimiterOptions;
-declare const index_WithReplayCacheOptions: typeof WithReplayCacheOptions;
-type index_WithRetryOptions = WithRetryOptions;
-declare const index_admissionFilter3D: typeof admissionFilter3D;
-declare const index_admissionScored: typeof admissionScored;
-declare const index_agentLoop: typeof agentLoop;
-declare const index_agentMemory: typeof agentMemory;
-declare const index_anthropicAdapter: typeof anthropicAdapter;
-declare const index_canonicalJson: typeof canonicalJson;
-declare const index_cascadingLlmAdapter: typeof cascadingLlmAdapter;
-declare const index_chatStream: typeof chatStream;
-declare const index_composePricing: typeof composePricing;
-declare const index_computePrice: typeof computePrice;
-declare const index_contentGate: typeof contentGate;
-declare const index_costMeterExtractor: typeof costMeterExtractor;
-declare const index_createAdapter: typeof createAdapter;
-declare const index_createCapabilitiesRegistry: typeof createCapabilitiesRegistry;
-declare const index_createPricingRegistry: typeof createPricingRegistry;
-declare const index_dryRunAdapter: typeof dryRunAdapter;
-declare const index_fallbackAdapter: typeof fallbackAdapter;
-declare const index_frozenContext: typeof frozenContext;
-declare const index_gatedStream: typeof gatedStream;
-declare const index_gaugesAsContext: typeof gaugesAsContext;
-declare const index_googleAdapter: typeof googleAdapter;
-declare const index_graphFromSpec: typeof graphFromSpec;
-declare const index_graphFromSpecReactive: typeof graphFromSpecReactive;
-declare const index_handoff: typeof handoff;
-declare const index_keywordFlagExtractor: typeof keywordFlagExtractor;
-declare const index_knobsAsTools: typeof knobsAsTools;
-declare const index_llmConsolidator: typeof llmConsolidator;
-declare const index_llmExtractor: typeof llmExtractor;
-declare const index_memoryRetrieval: typeof memoryRetrieval;
-declare const index_memoryWithKG: typeof memoryWithKG;
-declare const index_memoryWithTiers: typeof memoryWithTiers;
-declare const index_memoryWithVectors: typeof memoryWithVectors;
-declare const index_observableAdapter: typeof observableAdapter;
-declare const index_openAICompatAdapter: typeof openAICompatAdapter;
-declare const index_parseRateLimitFromError: typeof parseRateLimitFromError;
-declare const index_pricingFor: typeof pricingFor;
-declare const index_promptCall: typeof promptCall;
-declare const index_promptNode: typeof promptNode;
-declare const index_redactor: typeof redactor;
-declare const index_registryPricing: typeof registryPricing;
-declare const index_resilientAdapter: typeof resilientAdapter;
-declare const index_streamExtractor: typeof streamExtractor;
-declare const index_streamingPromptNode: typeof streamingPromptNode;
-declare const index_suggestStrategy: typeof suggestStrategy;
-declare const index_suggestStrategyReactive: typeof suggestStrategyReactive;
-declare const index_systemPromptBuilder: typeof systemPromptBuilder;
-declare const index_tier: typeof tier;
-declare const index_toolCallExtractor: typeof toolCallExtractor;
-declare const index_toolExecution: typeof toolExecution;
-declare const index_toolRegistry: typeof toolRegistry;
-declare const index_toolSelector: typeof toolSelector;
-declare const index_validateGraphDef: typeof validateGraphDef;
-declare const index_withBreaker: typeof withBreaker;
-declare const index_withBudgetGate: typeof withBudgetGate;
-declare const index_withDryRun: typeof withDryRun;
-declare const index_withRateLimiter: typeof withRateLimiter;
-declare const index_withReplayCache: typeof withReplayCache;
-declare const index_withRetry: typeof withRetry;
-declare const index_withTimeout: typeof withTimeout;
-declare const index_zeroPrice: typeof zeroPrice;
-declare namespace index {
-  export { index_AdapterProvider as AdapterProvider, type index_AdapterStats as AdapterStats, index_AdapterTier as AdapterTier, type index_AdmissionScore3DOptions as AdmissionScore3DOptions, type index_AdmissionScoredOptions as AdmissionScoredOptions, type index_AdmissionScores as AdmissionScores, type index_AdmissionThresholds as AdmissionThresholds, index_AgentLoopGraph as AgentLoopGraph, type index_AgentLoopOptions as AgentLoopOptions, type index_AgentLoopStatus as AgentLoopStatus, type index_AgentMemoryGraph as AgentMemoryGraph, type index_AgentMemoryOptions as AgentMemoryOptions, index_AllTiersExhaustedError as AllTiersExhaustedError, type index_AnthropicAdapterOptions as AnthropicAdapterOptions, type index_AnthropicSdkLike as AnthropicSdkLike, type index_BudgetCaps as BudgetCaps, index_BudgetExhaustedError as BudgetExhaustedError, type index_BudgetGateBundle as BudgetGateBundle, type index_BudgetTotals as BudgetTotals, type index_CallStatsEvent as CallStatsEvent, index_CapabilitiesRegistry as CapabilitiesRegistry, index_CascadeExhaustionReport as CascadeExhaustionReport, index_CascadingLlmAdapterOptions as CascadingLlmAdapterOptions, index_ChatMessage as ChatMessage, index_ChatStreamGraph as ChatStreamGraph, type index_ChatStreamOptions as ChatStreamOptions, index_CircuitOpenError as CircuitOpenError, type index_ContentDecision as ContentDecision, type index_ContentGateOptions as ContentGateOptions, type index_CostMeterOptions as CostMeterOptions, type index_CostMeterReading as CostMeterReading, index_CreateAdapterOptions as CreateAdapterOptions, index_DEFAULT_DECAY_RATE as DEFAULT_DECAY_RATE, type index_DryRunAdapterOptions as DryRunAdapterOptions, type index_ExtractedToolCall as ExtractedToolCall, index_FallbackAdapterOptions as FallbackAdapterOptions, index_FallbackFixture as FallbackFixture, index_FallbackMissError as FallbackMissError, index_FallbackMissPolicy as FallbackMissPolicy, type index_FrozenContextOptions as FrozenContextOptions, type index_GatedStreamHandle as GatedStreamHandle, type index_GatedStreamOptions as GatedStreamOptions, type index_GaugesAsContextOptions as GaugesAsContextOptions, type index_GoogleAdapterOptions as GoogleAdapterOptions, type index_GoogleSdkLike as GoogleSdkLike, type index_GoogleSdkRequestConfig as GoogleSdkRequestConfig, type index_GoogleSdkRequestParams as GoogleSdkRequestParams, type index_GraphDefValidation as GraphDefValidation, type index_GraphFromSpecOptions as GraphFromSpecOptions, type index_HandoffOptions as HandoffOptions, type index_HttpErrorLike as HttpErrorLike, type index_KeywordFlag as KeywordFlag, type index_KeywordFlagExtractorOptions as KeywordFlagExtractorOptions, type index_KnobsAsToolsResult as KnobsAsToolsResult, index_LLMAdapter as LLMAdapter, type index_LLMConsolidatorOptions as LLMConsolidatorOptions, type index_LLMExtractorOptions as LLMExtractorOptions, index_LLMInvokeOptions as LLMInvokeOptions, index_LLMResponse as LLMResponse, index_LLMTimeoutError as LLMTimeoutError, type index_McpToolSchema as McpToolSchema, type index_MemoryRetrievalBundle as MemoryRetrievalBundle, type index_MemoryRetrievalOptions as MemoryRetrievalOptions, type index_MemoryTier as MemoryTier, type index_MemoryTiersBundle as MemoryTiersBundle, type index_MemoryTiersOptions as MemoryTiersOptions, type index_MemoryWithKGOptions as MemoryWithKGOptions, type index_MemoryWithTiersOptions as MemoryWithTiersOptions, type index_MemoryWithVectorsOptions as MemoryWithVectorsOptions, index_ModelCapabilities as ModelCapabilities, index_ModelFeatures as ModelFeatures, index_ModelLimits as ModelLimits, index_ModelPricing as ModelPricing, index_OpenAICompatAdapterOptions as OpenAICompatAdapterOptions, index_OpenAICompatPreset as OpenAICompatPreset, index_OpenAISdkLike as OpenAISdkLike, type index_OpenAIToolSchema as OpenAIToolSchema, index_PriceBreakdown as PriceBreakdown, index_PricingFn as PricingFn, index_PricingRegistry as PricingRegistry, type index_PromptCallOptions as PromptCallOptions, type index_PromptNodeOptions as PromptNodeOptions, index_Rate as Rate, type index_RedactorOptions as RedactorOptions, index_ReplayCacheKeyContext as ReplayCacheKeyContext, index_ReplayCacheMissError as ReplayCacheMissError, index_ReplayCacheMode as ReplayCacheMode, type index_ResilientAdapterBundle as ResilientAdapterBundle, type index_ResilientAdapterOptions as ResilientAdapterOptions, type index_RetrievalEntry as RetrievalEntry, type index_RetrievalPipelineOptions as RetrievalPipelineOptions, type index_RetrievalQuery as RetrievalQuery, type index_RetrievalTrace as RetrievalTrace, type index_StampedDelta as StampedDelta, type index_StrategyOperation as StrategyOperation, type index_StrategyPlan as StrategyPlan, index_StreamDelta as StreamDelta, type index_StreamingPromptNodeHandle as StreamingPromptNodeHandle, type index_StreamingPromptNodeOptions as StreamingPromptNodeOptions, type index_SuggestStrategyOptions as SuggestStrategyOptions, type index_SystemPromptHandle as SystemPromptHandle, index_TieredRate as TieredRate, index_TokenUsage as TokenUsage, index_ToolCall as ToolCall, index_ToolDefinition as ToolDefinition, type index_ToolExecutionOptions as ToolExecutionOptions, index_ToolRegistryGraph as ToolRegistryGraph, type index_ToolRegistryOptions as ToolRegistryOptions, type index_ToolResult as ToolResult, type index_ToolSelectorOptions as ToolSelectorOptions, type index_WithBreakerOptions as WithBreakerOptions, type index_WithBudgetGateOptions as WithBudgetGateOptions, type index_WithDryRunBundle as WithDryRunBundle, type index_WithDryRunOptions as WithDryRunOptions, type index_WithRateLimiterOptions as WithRateLimiterOptions, index_WithReplayCacheOptions as WithReplayCacheOptions, type index_WithRetryOptions as WithRetryOptions, index_admissionFilter3D as admissionFilter3D, index_admissionScored as admissionScored, index_agentLoop as agentLoop, index_agentMemory as agentMemory, index_anthropicAdapter as anthropicAdapter, index_canonicalJson as canonicalJson, index_cascadingLlmAdapter as cascadingLlmAdapter, index_chatStream as chatStream, index_composePricing as composePricing, index_computePrice as computePrice, index_contentGate as contentGate, index_costMeterExtractor as costMeterExtractor, index_createAdapter as createAdapter, index_createCapabilitiesRegistry as createCapabilitiesRegistry, index_createPricingRegistry as createPricingRegistry, index_dryRunAdapter as dryRunAdapter, index_fallbackAdapter as fallbackAdapter, index_frozenContext as frozenContext, index_gatedStream as gatedStream, index_gaugesAsContext as gaugesAsContext, index_googleAdapter as googleAdapter, index_graphFromSpec as graphFromSpec, index_graphFromSpecReactive as graphFromSpecReactive, index_handoff as handoff, index_keywordFlagExtractor as keywordFlagExtractor, index_knobsAsTools as knobsAsTools, index_llmConsolidator as llmConsolidator, index_llmExtractor as llmExtractor, index_memoryRetrieval as memoryRetrieval, index_memoryWithKG as memoryWithKG, index_memoryWithTiers as memoryWithTiers, index_memoryWithVectors as memoryWithVectors, index_observableAdapter as observableAdapter, index_openAICompatAdapter as openAICompatAdapter, index_parseRateLimitFromError as parseRateLimitFromError, index_pricingFor as pricingFor, index_promptCall as promptCall, index_promptNode as promptNode, index_redactor as redactor, index_registryPricing as registryPricing, index_resilientAdapter as resilientAdapter, index_streamExtractor as streamExtractor, index_streamingPromptNode as streamingPromptNode, index_suggestStrategy as suggestStrategy, index_suggestStrategyReactive as suggestStrategyReactive, index_systemPromptBuilder as systemPromptBuilder, index_tier as tier, index_toolCallExtractor as toolCallExtractor, index_toolExecution as toolExecution, index_toolRegistry as toolRegistry, index_toolSelector as toolSelector, index_validateGraphDef as validateGraphDef, index_withBreaker as withBreaker, index_withBudgetGate as withBudgetGate, index_withDryRun as withDryRun, index_withRateLimiter as withRateLimiter, index_withReplayCache as withReplayCache, index_withRetry as withRetry, index_withTimeout as withTimeout, index_zeroPrice as zeroPrice };
-}
-
-export { type OpenAIToolSchema as $, type AdapterStats as A, type BudgetCaps as B, type CallStatsEvent as C, type DryRunAdapterOptions as D, type ExtractedToolCall as E, type FrozenContextOptions as F, type GatedStreamHandle as G, type GoogleSdkRequestParams as H, type GraphDefValidation as I, type GraphFromSpecOptions as J, type HandoffOptions as K, type HttpErrorLike as L, type KeywordFlag as M, type KeywordFlagExtractorOptions as N, type KnobsAsToolsResult as O, type LLMConsolidatorOptions as P, type LLMExtractorOptions as Q, LLMTimeoutError as R, type McpToolSchema as S, type MemoryRetrievalBundle as T, type MemoryRetrievalOptions as U, type MemoryTier as V, type MemoryTiersBundle as W, type MemoryTiersOptions as X, type MemoryWithKGOptions as Y, type MemoryWithTiersOptions as Z, type MemoryWithVectorsOptions as _, type AdmissionScore3DOptions as a, toolExecution as a$, type PromptCallOptions as a0, type PromptNodeOptions as a1, type RedactorOptions as a2, type ResilientAdapterBundle as a3, type ResilientAdapterOptions as a4, type RetrievalEntry as a5, type RetrievalPipelineOptions as a6, type RetrievalQuery as a7, type RetrievalTrace as a8, type StampedDelta as a9, frozenContext as aA, gatedStream as aB, gaugesAsContext as aC, googleAdapter as aD, graphFromSpec as aE, graphFromSpecReactive as aF, handoff as aG, keywordFlagExtractor as aH, knobsAsTools as aI, llmConsolidator as aJ, llmExtractor as aK, memoryRetrieval as aL, memoryWithKG as aM, memoryWithTiers as aN, memoryWithVectors as aO, observableAdapter as aP, parseRateLimitFromError as aQ, promptCall as aR, promptNode as aS, redactor as aT, resilientAdapter as aU, streamExtractor as aV, streamingPromptNode as aW, suggestStrategy as aX, suggestStrategyReactive as aY, systemPromptBuilder as aZ, toolCallExtractor as a_, type StrategyOperation as aa, type StrategyPlan as ab, type StreamingPromptNodeHandle as ac, type StreamingPromptNodeOptions as ad, type SuggestStrategyOptions as ae, type SystemPromptHandle as af, type ToolExecutionOptions as ag, ToolRegistryGraph as ah, type ToolRegistryOptions as ai, type ToolResult as aj, type ToolSelectorOptions as ak, type WithBreakerOptions as al, type WithBudgetGateOptions as am, type WithDryRunBundle as an, type WithDryRunOptions as ao, type WithRateLimiterOptions as ap, type WithRetryOptions as aq, admissionFilter3D as ar, admissionScored as as, agentLoop as at, agentMemory as au, anthropicAdapter as av, chatStream as aw, contentGate as ax, costMeterExtractor as ay, dryRunAdapter as az, type AdmissionScoredOptions as b, toolRegistry as b0, toolSelector as b1, validateGraphDef as b2, withBreaker as b3, withBudgetGate as b4, withDryRun as b5, withRateLimiter as b6, withRetry as b7, withTimeout as b8, type AdmissionScores as c, type AdmissionThresholds as d, AgentLoopGraph as e, type AgentLoopOptions as f, type AgentLoopStatus as g, type AgentMemoryGraph as h, index as i, type AgentMemoryOptions as j, type AnthropicAdapterOptions as k, type AnthropicSdkLike as l, BudgetExhaustedError as m, type BudgetGateBundle as n, type BudgetTotals as o, ChatStreamGraph as p, type ChatStreamOptions as q, type ContentDecision as r, type ContentGateOptions as s, type CostMeterOptions as t, type CostMeterReading as u, type GatedStreamOptions as v, type GaugesAsContextOptions as w, type GoogleAdapterOptions as x, type GoogleSdkLike as y, type GoogleSdkRequestConfig as z };
+export { type AdapterStats, type AdmissionScore3DOptions, type AdmissionScoredOptions, type AdmissionScores, type AdmissionThresholds, type AnthropicAdapterOptions, type AnthropicSdkLike, type BudgetCaps, BudgetExhaustedError, type BudgetTotals, type CallStatsEvent, CascadeExhaustionReport, ChatMessage, type ContentDecision, type ContentGateOptions, type CostMeterOptions, type CostMeterReading, type DryRunAdapterOptions, type ExtractedToolCall, type FrozenContextOptions, type GatedStreamHandle, type GatedStreamOptions, type GaugesAsContextOptions, type GoogleAdapterOptions, type GoogleSdkLike, type GoogleSdkRequestConfig, type GoogleSdkRequestParams, type GraphDefValidation, type GraphFromSpecOptions, type HandoffOptions, type HttpErrorLike, type KeywordFlag, type KeywordFlagExtractorOptions, type KnobsAsToolsResult, LLMAdapter, type LLMBudgetGateBundle, type LLMConsolidatorOptions, type LLMExtractorOptions, LLMInvokeOptions, LLMResponse, LLMTimeoutError, type McpToolSchema, type OpenAIToolSchema, PricingFn, type PromptCallOptions, type PromptNodeOptions, type RedactorOptions, type ResilientAdapterBundle, type ResilientAdapterOptions, type StampedDelta, type StrategyOperation, type StrategyPlan, StreamDelta, type StreamingPromptNodeHandle, type StreamingPromptNodeOptions, type SuggestStrategyOptions, type SystemPromptHandle, TokenUsage, ToolDefinition, type ToolSelectorOptions, type WithBreakerOptions, type WithBudgetGateOptions, type WithDryRunBundle, type WithDryRunOptions, type WithRateLimiterOptions, WithReplayCacheOptions, type WithRetryOptions, admissionFilter3D, admissionScored, anthropicAdapter, contentGate, costMeterExtractor, dryRunAdapter, frozenContext, gatedStream, gaugesAsContext, googleAdapter, graphFromSpec, graphFromSpecReactive, handoff, keywordFlagExtractor, knobsAsTools, llmConsolidator, llmExtractor, observableAdapter, parseRateLimitFromError, promptCall, promptNode, redactor, resilientAdapter, streamExtractor, streamingPromptNode, suggestStrategy, suggestStrategyReactive, systemPromptBuilder, toolCallExtractor, toolSelector, validateGraphDef, withBudgetGate, withDryRun, withLLMBreaker, withLLMTimeout, withRateLimiter, withRetry };