@tangle-network/agent-runtime 0.37.0 → 0.39.0

package/dist/{otel-export-DgFMwsVy.d.ts → kb-gate-YdPNEagq.d.ts}

@@ -1,7 +1,6 @@
 import { CoderOutput, CoderTask } from './profiles.js';
-import { L as LoopSandboxClient } from './types-CmTjKLyB.js';
+import { L as LoopSandboxClient } from './types-B9O7l-ij.js';
 import { SandboxInstance } from '@tangle-network/sandbox';
-import { O as OpenAIChatTool } from './types-CsCCryln.js';
 
 /**
  * @experimental
@@ -364,189 +363,76 @@ declare function createDefaultCoderDelegate(options: CreateDefaultCoderDelegateO
 /**
  * @experimental
  *
- * OpenAI Chat Completions `tools[]` projection of the 5 agent-runtime MCP
- * delegation tools.
+ * `createKbGate` — the valid-only knowledge-base growth gate, distilled from
+ * physim's KB-research subsystem. A research-in-a-loop delegate (or any KB
+ * writer) runs candidate facts through this before persisting, so the KB grows
+ * with ONLY grounded facts — hallucinated, unsourced, or laundered claims are
+ * vetoed at the gate.
  *
- * Use when configuring `createOpenAICompatibleBackend({ tools: ... })` so the
- * model can call `delegate_code`, `delegate_research`, `delegate_feedback`,
- * `delegation_status`, and `delegation_history` through the OpenAI-compat
- * transport (tcloud, OpenRouter, OpenAI direct, cli-bridge). The runtime
- * surfaces tool calls as `tool_call` stream events — execution is the
- * caller's responsibility (typically the parent sandbox runtime's MCP
- * mount).
+ * Fail-closed by construction: every judge must `accept`; the FIRST veto wins
+ * and the fact is rejected. The non-negotiable floor (always on, can't be
+ * disabled) is the **passage-present guard** — a fact's `verbatimPassage` MUST
+ * literally appear in its `sourceText`. That single check kills the dominant
+ * failure mode (a confident claim decoupled from any real source).
  *
- * Sandbox-SDK callers do NOT need this helper: the sandbox runtime mounts
- * MCP servers natively and the in-sandbox harness discovers tools via the
- * runtime, not via an OpenAI tools array.
- *
- * Tool name + description + JSON-schema are pulled from the canonical
- * `DELEGATE_*` constants exported by `./tools/*` so the projection cannot
- * drift from the server's own validators.
- */
-
-/**
- * @experimental
- *
- * Returns the 5 delegation tools projected into OpenAI Chat Completions
- * `tools[]` shape. The order is stable: `delegate_code`,
- * `delegate_research`, `delegate_feedback`, `delegation_status`,
- * `delegation_history`.
- */
-declare function mcpToolsForRuntimeMcp(): OpenAIChatTool[];
-/**
- * @experimental
- *
- * Subset filter — return only the projected tools whose `function.name`
- * appears in `names`. Useful for curated mounts (e.g. only the queue-bound
- * delegation tools, omitting `delegate_feedback`). Unknown names are
- * silently ignored; pass an empty array to get an empty result.
+ * Pure + dependency-free: it operates on fact candidates, not on a store, so it
+ * composes with `@tangle-network/agent-knowledge` or any persistence layer
+ * without importing it. The remediation policy (correct-on-veto vs
+ * escalate-as-unverified) is the caller's — this returns the verdict; it never
+ * drops a fact silently.
  */
-declare function mcpToolsForRuntimeMcpSubset(names: ReadonlyArray<string>): OpenAIChatTool[];
-
-/**
- * OTEL span exporter — streams LoopTraceEvents to an OTLP/HTTP collector.
- *
- * Reads OTEL_EXPORTER_OTLP_ENDPOINT + OTEL_EXPORTER_OTLP_HEADERS from env
- * when no explicit config is given. Keeps the runtime dep-free from
- * @opentelemetry/sdk-trace-base — minimal OTLP/JSON serializer.
- *
- * The exporter accepts both raw OtelSpan objects and LoopTraceEvents
- * (which get converted to OTLP spans automatically).
- */
-interface OtelExportConfig {
-    /** OTLP endpoint. Reads OTEL_EXPORTER_OTLP_ENDPOINT env by default. */
-    endpoint?: string;
-    /** OTLP headers. Reads OTEL_EXPORTER_OTLP_HEADERS env by default. */
-    headers?: Record<string, string>;
-    /** Batch size before flush. Default 64. */
-    batchSize?: number;
-    /** Flush interval ms. Default 5000. */
-    flushIntervalMs?: number;
-    /** Resource attributes stamped on every export. */
-    resourceAttributes?: Record<string, string | number | boolean>;
-    /** Service name. Default 'agent-runtime'. */
-    serviceName?: string;
+/** @experimental A fact proposed for the KB, with its grounding. */
+interface FactCandidate {
+    /** The atomic claim text. */
+    claim: string;
+    /** Optional extracted value (number or string) the claim asserts. */
+    value?: string | number;
+    /** Verbatim span lifted from the source that backs the claim. */
+    verbatimPassage: string;
+    /** The raw source text the passage must be grounded in. */
+    sourceText: string;
+    /** Where the fact claims to come from — checked for circular/self citations. */
+    citation?: string;
 }
-interface OtelExporter {
-    /** Export a span. */
-    exportSpan(span: OtelSpan): void;
-    /** Force flush pending spans. */
-    flush(): Promise<void>;
-    /** Shutdown cleanly. */
-    shutdown(): Promise<void>;
+/** @experimental */
+interface FactJudgeVerdict {
+    accept: boolean;
+    reason?: string;
 }
-interface OtelSpan {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
+/** @experimental A pluggable fact validator. Throw is NOT allowed — return a
+ *  verdict; a thrown judge is a programmer error, not a veto. */
+interface FactJudge {
     name: string;
-    kind?: number;
-    startTimeUnixNano: string;
-    endTimeUnixNano: string;
-    attributes?: OtelAttribute[];
-    status?: {
-        code: number;
-        message?: string;
-    };
-}
-interface OtelAttribute {
-    key: string;
-    value: {
-        stringValue?: string;
-        intValue?: string;
-        doubleValue?: number;
-        boolValue?: boolean;
-    };
+    judge(candidate: FactCandidate): FactJudgeVerdict | Promise<FactJudgeVerdict>;
 }
-/**
- * Create an OTEL exporter. Returns undefined when no endpoint is configured.
- */
-declare function createOtelExporter(config?: OtelExportConfig): OtelExporter | undefined;
-/**
- * Convert a LoopTraceEvent into an OtelSpan for export.
- */
-declare function loopEventToOtelSpan(event: {
-    kind: string;
-    runId: string;
-    timestamp: number;
-    payload: object;
-}, traceId: string, parentSpanId?: string): OtelSpan;
-/**
- * Build a nested, real-duration OTLP span tree for ONE loop run from its full
- * ordered `LoopTraceEvent` stream. Unlike `loopEventToOtelSpan` (one flat,
- * zero-duration span per event), this reconstructs the topology hierarchy a
- * GenAI trace viewer renders natively:
- *
- *   loop (invoke_workflow)
- *     └─ loop.round[k] (invoke_workflow)   ← tangle.loop.move.{kind,width,rationale}
- *          ├─ loop.iteration[i] (invoke_agent)  ← gen_ai.agent.name + usage + verdict + placement
- *          └─ …
- *
- * Attributes follow the current GenAI semconv (`gen_ai.*`) where they apply and
- * a namespaced `tangle.loop.*` / `tangle.cost.usd` extension for topology /
- * verdict / placement / cost (not yet standardized). Pure: feed it a buffered
- * per-runId event array (e.g. flushed on `loop.ended`) and export the result.
- */
-declare function buildLoopOtelSpans(events: ReadonlyArray<{
-    kind: string;
-    runId: string;
-    timestamp: number;
-    payload: object;
-}>, traceId: string, rootParentSpanId?: string): OtelSpan[];
-/** Wire version the eval-runs ingest enforces (X-Tangle-Wire-Version + body). */
-declare const INTELLIGENCE_WIRE_VERSION = "2026-05-26.v1";
-interface EvalRunGeneration {
-    /** 0-based ordinal of this generation within the run (required by ingest). */
-    index: number;
-    /** Identity of the proposed surface change (content-addressed hash). */
-    surfaceHash: string;
-    /** Arbitrary provenance for this generation (rationale, evidence, source). */
-    surface?: unknown;
-    /** Per-scenario results; empty until the generation is measured. */
-    cells?: unknown[];
-    /** Mean composite score (0 when unmeasured — pair with labels.measured). */
-    compositeMean: number;
-    costUsd: number;
-    durationMs: number;
-}
-interface EvalRunEvent {
-    runId: string;
-    runDir: string;
-    /** ISO timestamp. */
-    timestamp: string;
-    status: 'started' | 'baseline-complete' | 'generation-complete' | 'gate-decided' | 'finished' | 'errored';
-    labels?: Record<string, string>;
-    baseline?: EvalRunGeneration;
-    generations?: EvalRunGeneration[];
-    gateDecision?: 'ship' | 'hold' | 'need_more_work' | 'model_ceiling' | 'arch_ceiling';
-    holdoutLift?: number;
-    totalCostUsd: number;
-    totalDurationMs: number;
-    errorMessage?: string;
-}
-interface EvalRunsExportConfig {
-    /** Bearer key — tenant is resolved server-side from it. Reads TANGLE_API_KEY. */
-    apiKey?: string;
-    /** Intelligence base. Reads INTELLIGENCE_BASE env, else prod. */
-    base?: string;
-    /** Idempotency-Key header (e.g. the runId) — safe retries + upsert. */
-    idempotencyKey?: string;
+/** @experimental */
+interface KbGateResult {
+    accepted: boolean;
+    /** Name of the judge that vetoed; undefined when accepted. */
+    vetoedBy?: string;
+    reason?: string;
 }
-interface EvalRunsExportResult {
-    ok: boolean;
-    status: number;
-    accepted: number;
-    rejected: Array<{
-        index: number;
-        reason: string;
-    }>;
+/** @experimental */
+interface CreateKbGateOptions {
+    /** Extra judges appended after the built-in floor (e.g. an LLM judge). */
+    judges?: FactJudge[];
+    /** Minimum verbatim-passage length. Default 12 — kills empty/stub passages. */
+    minPassageChars?: number;
+    /**
+     * Citation tokens that denote a SELF-generated artifact (e.g. `'spec'`,
+     * `'cad_params'`, `'requirements'`). A citation naming one is circular
+     * (laundering) — the fact cites a derived artifact, not a real source.
+     * Default `[]` (no circular check unless the consumer declares its kinds).
+     */
+    selfArtifactKinds?: string[];
 }
 /**
- * Ship self-improvement eval-run events to Tangle Intelligence. Unlike the
- * best-effort span exporter, this RESOLVES with the ingest verdict (accepted /
- * rejected per event) so a consumer's loop can assert its provenance landed.
- * Throws only on a missing key or network failure.
+ * @experimental
+ *
+ * Build a fail-closed KB gate. The returned function runs the built-in floor
+ * (passage-non-empty → passage-present → value-in-passage → no-circular-citation)
+ * then any consumer judges, returning on the first veto.
  */
-declare function exportEvalRuns(events: EvalRunEvent[], config?: EvalRunsExportConfig): Promise<EvalRunsExportResult>;
+declare function createKbGate(options?: CreateKbGateOptions): (candidate: FactCandidate) => Promise<KbGateResult>;
 
-export { type FeedbackRefersTo as A, type FleetWorkspaceExecutorOptions as B, type CoderDelegate as C, type DelegationExecutor as D, type ResearchOutputShape as E, type FleetHandle as F, createDefaultCoderDelegate as G, createFleetWorkspaceExecutor as H, createSiblingSandboxExecutor as I, mcpToolsForRuntimeMcp as J, mcpToolsForRuntimeMcpSubset as K, type EvalRunEvent as L, type EvalRunGeneration as M, type EvalRunsExportConfig as N, type OtelExporter as O, type EvalRunsExportResult as P, INTELLIGENCE_WIRE_VERSION as Q, type ResearcherDelegate as R, type SiblingSandboxExecutorOptions as S, type OtelAttribute as T, type OtelExportConfig as U, type OtelSpan as V, buildLoopOtelSpans as W, createOtelExporter as X, exportEvalRuns as Y, loopEventToOtelSpan as Z, type DelegateFeedbackArgs as a, type DelegationFeedbackSnapshot as b, type DelegationProfile as c, type DelegateCodeArgs as d, type DelegateResearchArgs as e, type DelegationStatus as f, type DelegationProgress as g, type DelegationResultPayload as h, type DelegationError as i, type DelegationStatusResult as j, type DelegationHistoryArgs as k, type DelegationHistoryEntry as l, type DelegateCodeResult as m, type DelegateFeedbackResult as n, type ResearchSource as o, type DelegateResearchResult as p, type DelegationHistoryResult as q, type DelegationStatusArgs as r, type CoderReview as s, type CoderReviewer as t, type CoderWinnerSelection as u, type CreateDefaultCoderDelegateOptions as v, type DelegateCodeConfig as w, type DelegateResearchConfig as x, type DelegateRunCtx as y, type FeedbackRating as z };
+export { type DelegateRunCtx as A, type FactJudge as B, type CoderReviewer as C, type DelegateCodeArgs as D, type FactJudgeVerdict as E, type FactCandidate as F, type FeedbackRating as G, type FeedbackRefersTo as H, type FleetWorkspaceExecutorOptions as I, type ResearchOutputShape as J, type KbGateResult as K, createDefaultCoderDelegate as L, createFleetWorkspaceExecutor as M, createKbGate as N, createSiblingSandboxExecutor as O, type ResearcherDelegate as R, type SiblingSandboxExecutorOptions as S, type CoderWinnerSelection as a, type CreateKbGateOptions as b, type FleetHandle as c, type DelegationExecutor as d, type DelegateFeedbackArgs as e, type DelegationFeedbackSnapshot as f, type DelegationProfile as g, type DelegateResearchArgs as h, type DelegationStatus as i, type DelegationProgress as j, type DelegationResultPayload as k, type DelegationError as l, type DelegationStatusResult as m, type DelegationHistoryArgs as n, type DelegationHistoryEntry as o, type CoderDelegate as p, type DelegateCodeResult as q, type DelegateFeedbackResult as r, type ResearchSource as s, type DelegateResearchResult as t, type DelegationHistoryResult as u, type DelegationStatusArgs as v, type CoderReview as w, type CreateDefaultCoderDelegateOptions as x, type DelegateCodeConfig as y, type DelegateResearchConfig as z };

package/dist/loop-runner-bin-DgZj0zfJ.d.ts

@@ -0,0 +1,192 @@
+import { Scenario } from '@tangle-network/agent-eval/campaign';
+import { R as RunAnalystLoopOpts, a as RunAnalystLoopResult } from './types-p8dWBIXL.js';
+import { O as OptimizePromptOptions, a as OptimizePromptResult } from './optimize-prompt-D-urF2wW.js';
+import { T as TopologyPlanner, D as DynamicDecision } from './dynamic-DcrwVGuV.js';
+import { L as LoopSandboxClient, O as OutputAdapter, V as Validator, A as AgentRunSpec, a as LoopResult } from './types-B9O7l-ij.js';
+import { D as DelegateCodeArgs, C as CoderReviewer, a as CoderWinnerSelection, F as FactCandidate, b as CreateKbGateOptions } from './kb-gate-YdPNEagq.js';
+import { CoderOutput } from './profiles.js';
+
+/**
+ * @experimental
+ *
+ * `runDelegatedLoop` — the configured delegated loop-runner.
+ *
+ * One typed entrypoint a worker agent (or a scheduled routine) calls to run a
+ * disciplined loop in a chosen MODE, over agent-runtime's hardened engines:
+ *
+ *   code         → build-in-a-loop via the coder delegate (no-op + secret floor,
+ *                  optional reviewer gate, winner-selection)
+ *   review       → code mode with a REQUIRED reviewer (the gate is the point)
+ *   research     → research-in-a-loop with valid-only KB growth (createKbGate)
+ *   audit        → analyze trace/run data → findings (runAnalystLoop, caller-wired)
+ *   self-improve → identity-gated prompt optimization (optimizePrompt, caller-wired)
+ *   dynamic      → agent-authored topology (runLoop + createDynamicDriver)
+ *
+ * It is intentionally a thin façade: the value is that EVERY product reuses the
+ * one hardened engine instead of forking delegation logic. The dispatcher owns
+ * mode routing, timing, fail-loud on an unregistered mode, and a uniform result
+ * shape; each mode's engine is a pre-configured runner in the registry (build it
+ * with the factories below, or inject your own / a stub).
+ */
+
+/** @experimental Every delegated-loop mode, for validation + CLI surfaces. */
+declare const DELEGATED_LOOP_MODES: readonly ["code", "review", "research", "audit", "self-improve", "dynamic"];
+/** @experimental */
+type DelegatedLoopMode = (typeof DELEGATED_LOOP_MODES)[number];
+/** @experimental Type guard for an untrusted mode string (CLI / config input). */
+declare function isDelegatedLoopMode(value: unknown): value is DelegatedLoopMode;
+/** @experimental A pre-configured loop for one mode. Returns the mode's raw
+ *  output; the dispatcher wraps it in a {@link DelegatedLoopResult}. */
+type DelegatedLoopRunner<T = unknown> = (signal: AbortSignal) => Promise<T>;
+/** @experimental Mode → configured runner. Partial: only register the modes a
+ *  given product/routine actually uses. */
+type DelegatedLoopRegistry = Partial<Record<DelegatedLoopMode, DelegatedLoopRunner>>;
+/** @experimental Uniform result — never throws from a registered runner; a
+ *  thrown engine becomes `{ ok: false, error }` so a routine can record + move on. */
+interface DelegatedLoopResult<T = unknown> {
+    mode: DelegatedLoopMode;
+    ok: boolean;
+    output?: T;
+    error?: string;
+    durationMs: number;
+}
+/** @experimental */
+interface RunDelegatedLoopOptions {
+    signal?: AbortSignal;
+    /** Clock override for deterministic tests. */
+    now?: () => number;
+}
+/**
+ * @experimental
+ *
+ * Dispatch a configured loop by mode. Fails loud (throws `ConfigError`) when no
+ * runner is registered for the mode — a routine pointed at an unwired mode is a
+ * config bug, not a silent no-op. A runner that throws is captured as
+ * `{ ok: false }` so unattended runs record the failure rather than crash.
+ */
+declare function runDelegatedLoop<T = unknown>(mode: DelegatedLoopMode, registry: DelegatedLoopRegistry, options?: RunDelegatedLoopOptions): Promise<DelegatedLoopResult<T>>;
+/** @experimental Options for the default `code`/`review` runner. */
+interface CoderLoopRunnerOptions {
+    sandboxClient: LoopSandboxClient;
+    /** What to build — the delegate args (goal, repoRoot, variants, config, …). */
+    args: DelegateCodeArgs;
+    /** Adversarial reviewer. REQUIRED for `review` mode (see `reviewLoopRunner`). */
+    reviewer?: CoderReviewer;
+    /** Winner-selection strategy. Default `highest-score`. */
+    winnerSelection?: CoderWinnerSelection;
+    /** Harnesses for `variants > 1` fanout. */
+    fanoutHarnesses?: string[];
+}
+/** @experimental Build a `code`-mode runner over the hardened coder delegate. */
+declare function coderLoopRunner(options: CoderLoopRunnerOptions): DelegatedLoopRunner<CoderOutput>;
+/**
+ * @experimental
+ *
+ * `review` mode = `code` with a REQUIRED reviewer. The gate is the whole point,
+ * so the type forces a reviewer (a "review loop" with no reviewer is a code loop).
+ */
+declare function reviewLoopRunner(options: CoderLoopRunnerOptions & {
+    reviewer: CoderReviewer;
+}): DelegatedLoopRunner<CoderOutput>;
+/** @experimental Options for the default `dynamic` runner. */
+interface DynamicLoopRunnerOptions<Task, Output> {
+    sandboxClient: LoopSandboxClient;
+    /** The agent-authored topology planner (e.g. `createSandboxPlanner(...)`). */
+    planner: TopologyPlanner<Task, Output>;
+    task: Task;
+    output: OutputAdapter<Output>;
+    validator?: Validator<Output>;
+    /** Exactly one of `agentRun` / `agentRuns` (runLoop validates). */
+    agentRun?: AgentRunSpec<Task>;
+    agentRuns?: AgentRunSpec<Task>[];
+    maxIterations?: number;
+    maxFanout?: number;
+}
+/** @experimental `dynamic` mode — agent-authored topology over `runLoop`. */
+declare function dynamicLoopRunner<Task, Output>(o: DynamicLoopRunnerOptions<Task, Output>): DelegatedLoopRunner<LoopResult<Task, Output, DynamicDecision>>;
+/** @experimental A fact rejected at the KB gate — surfaced, never dropped. */
+interface VetoedFact {
+    candidate: FactCandidate;
+    vetoedBy?: string;
+    reason?: string;
+}
+/** @experimental */
+interface ResearchLoopResult {
+    /** Facts that passed the fail-closed gate — safe to write to the KB. */
+    accepted: FactCandidate[];
+    /** Facts the gate vetoed in the final round — escalate, do not silently drop. */
+    vetoed: VetoedFact[];
+    /** Research rounds actually run. */
+    rounds: number;
+}
+/** @experimental Options for the default `research` runner. */
+interface ResearchLoopRunnerOptions {
+    /**
+     * The research engine (the consumer's web/doc searcher + extractor). Called
+     * each round with the prior round's vetoes so it can re-research the gaps.
+     * Returns fact candidates carrying their grounding (`verbatimPassage` +
+     * `sourceText`).
+     */
+    research: (round: number, vetoed: VetoedFact[]) => Promise<FactCandidate[]>;
+    /** Gate config (extra judges, self-artifact kinds, …). The floor is always on. */
+    gate?: CreateKbGateOptions;
+    /** Max research rounds (correct-on-veto remediation). Default 1. */
+    maxRounds?: number;
+}
+/**
+ * @experimental `research` mode — research-in-a-loop with valid-only KB growth.
+ *
+ * Each round: research → gate every candidate (fail-closed; passage MUST be in
+ * the source) → accept the clean ones → re-research the vetoed ones next round,
+ * up to `maxRounds`. Vetoed facts in the final round are RETURNED (escalate,
+ * never silently dropped) so the caller audits vs retries.
+ */
+declare function researchLoopRunner(o: ResearchLoopRunnerOptions): DelegatedLoopRunner<ResearchLoopResult>;
+/** @experimental `self-improve` mode — identity-gated prompt optimization. */
+declare function selfImproveLoopRunner<TScenario extends Scenario, TArtifact>(options: OptimizePromptOptions<TScenario, TArtifact>): DelegatedLoopRunner<OptimizePromptResult<TArtifact, TScenario>>;
+/** @experimental `audit` mode — analyst loop over captured trace/run data. */
+declare function auditLoopRunner<TProposal = unknown, TEdit = unknown>(options: RunAnalystLoopOpts): DelegatedLoopRunner<RunAnalystLoopResult<TProposal, TEdit>>;
+
+/**
+ * @experimental
+ *
+ * `agent-runtime-loop` — the schedulable entrypoint for the configured
+ * delegated loop-runner. A cron job / routine / Makefile target invokes:
+ *
+ *   agent-runtime-loop --mode research --config ./loops.config.js
+ *
+ * The config module wires the registry (with full access to env / creds —
+ * which is why the deps live there, not in this generic bin). It must default-
+ * export a `DelegatedLoopRegistry`, or a `() => DelegatedLoopRegistry | Promise<…>`.
+ * The bin runs the selected mode, prints the `DelegatedLoopResult` as JSON, and
+ * exits 0 on `ok`, 1 on a recorded failure, 2 on a usage/config error.
+ */
+
+/** @experimental Parsed CLI invocation. */
+interface LoopRunnerCliArgs {
+    mode: string;
+    /** Loads the registry — the bin wires this from `--config`; tests inject a stub. */
+    loadRegistry: () => Promise<DelegatedLoopRegistry> | DelegatedLoopRegistry;
+    now?: () => number;
+}
+/** @experimental */
+interface LoopRunnerCliResult {
+    exitCode: number;
+    result?: DelegatedLoopResult;
+    error?: string;
+}
+/**
+ * @experimental
+ *
+ * Pure CLI core (no process / argv / IO) so it's unit-testable: validate the
+ * mode, load the registry, dispatch, map to an exit code (0 ok / 1 failed /
+ * 2 usage). Exported for embedding in custom runners + tests.
+ */
+declare function runLoopRunnerCli(args: LoopRunnerCliArgs): Promise<LoopRunnerCliResult>;
+/** Parse `--mode X --config Y` from an argv tail (`process.argv.slice(2)`). */
+declare function parseLoopRunnerArgv(argv: string[]): {
+    mode?: string;
+    config?: string;
+};
+
+export { type CoderLoopRunnerOptions as C, DELEGATED_LOOP_MODES as D, type LoopRunnerCliArgs as L, type ResearchLoopResult as R, type VetoedFact as V, type DelegatedLoopMode as a, type DelegatedLoopRegistry as b, type DelegatedLoopResult as c, type DelegatedLoopRunner as d, type DynamicLoopRunnerOptions as e, type LoopRunnerCliResult as f, type ResearchLoopRunnerOptions as g, type RunDelegatedLoopOptions as h, auditLoopRunner as i, coderLoopRunner as j, dynamicLoopRunner as k, isDelegatedLoopMode as l, reviewLoopRunner as m, runDelegatedLoop as n, runLoopRunnerCli as o, parseLoopRunnerArgv as p, researchLoopRunner as r, selfImproveLoopRunner as s };

package/dist/loop-runner-bin.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+export { L as LoopRunnerCliArgs, f as LoopRunnerCliResult, p as parseLoopRunnerArgv, o as runLoopRunnerCli } from './loop-runner-bin-DgZj0zfJ.js';
+import '@tangle-network/agent-eval/campaign';
+import './types-p8dWBIXL.js';
+import '@tangle-network/agent-eval';
+import './optimize-prompt-D-urF2wW.js';
+import './dynamic-DcrwVGuV.js';
+import './types-B9O7l-ij.js';
+import '@tangle-network/sandbox';
+import './types-CsCCryln.js';
+import './kb-gate-YdPNEagq.js';
+import './profiles.js';

package/dist/loop-runner-bin.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import {
+  parseLoopRunnerArgv,
+  runLoopRunnerCli
+} from "./chunk-AXWGLYSF.js";
+import "./chunk-XBUG326M.js";
+import "./chunk-VOX6Z3II.js";
+import "./chunk-FNMGYYSS.js";
+import "./chunk-VLXRXMTF.js";
+import "./chunk-7JBDJQLO.js";
+import "./chunk-3HMHSN22.js";
+import "./chunk-PY6NMZYX.js";
+import "./chunk-SQSCRJ7U.js";
+import "./chunk-DGUM43GV.js";
+export {
+  parseLoopRunnerArgv,
+  runLoopRunnerCli
+};
+//# sourceMappingURL=loop-runner-bin.js.map

package/dist/loop-runner-bin.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/loops.d.ts

@@ -1,115 +1,14 @@
 import { AgentProfile, SandboxEvent } from '@tangle-network/sandbox';
 export { AgentProfile, CreateSandboxOptions, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
-import { I as Iteration, D as Driver, L as LoopSandboxClient, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, a as LoopWinner, b as LoopResult } from './types-CmTjKLyB.js';
-export { c as LoopDecisionPayload, d as LoopEndedPayload, e as LoopIterationDispatchPayload, f as LoopIterationEndedPayload, g as LoopIterationStartedPayload, h as LoopPlanDescription, i as LoopPlanPayload, j as LoopSandboxPlacement, k as LoopStartedPayload, l as LoopTokenUsage, m as LoopTraceEmitter, n as LoopTraceEvent, o as ValidationCtx } from './types-CmTjKLyB.js';
+import { P as PlannerContext, T as TopologyPlanner } from './dynamic-DcrwVGuV.js';
+export { C as CreateDynamicDriverOptions, D as DynamicDecision, a as TopologyMove, c as createDynamicDriver, s as summarizeHistory } from './dynamic-DcrwVGuV.js';
+import { D as Driver, I as Iteration, L as LoopSandboxClient, A as AgentRunSpec, O as OutputAdapter, V as Validator, E as ExecCtx, b as LoopWinner, a as LoopResult } from './types-B9O7l-ij.js';
+export { c as LoopDecisionPayload, d as LoopEndedPayload, e as LoopIterationDispatchPayload, f as LoopIterationEndedPayload, g as LoopIterationStartedPayload, h as LoopPlanDescription, i as LoopPlanPayload, j as LoopSandboxPlacement, k as LoopStartedPayload, l as LoopTokenUsage, m as LoopTraceEmitter, n as LoopTraceEvent, o as ValidationCtx } from './types-B9O7l-ij.js';
 import { DefaultVerdict, AgentProfile as AgentProfile$1 } from '@tangle-network/agent-eval';
 export { DefaultVerdict } from '@tangle-network/agent-eval';
 import { Scenario, DispatchFn, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
 import './types-CsCCryln.js';
 
-/**
- * @experimental
- *
- * Dynamic driver — the agent authors the loop topology at runtime.
- *
- * Where `refine` and `fanout-vote` encode a fixed shape as a pure function of
- * history, this driver delegates the per-round shape to an injected
- * `TopologyPlanner`. Each round the planner inspects the task + iteration
- * history and emits one `TopologyMove`:
- *   - `refine` → one task next round (optionally rewritten from the prior attempt)
- *   - `fanout` → N tasks next round (the kernel round-robins `agentRuns`, so a
- *     2-harness fanout dispatches branch 0 to harness A and branch 1 to harness B)
- *   - `stop`   → terminate; the kernel selects the winner across all iterations
- *
- * The planner is the brain; this driver is the structure. It maps moves onto
- * the kernel's `plan`/`decide` contract, enforces the iteration + fanout caps,
- * and fails loud on a malformed move. The planner is injected exactly like
- * `refine`'s `refineTask` and `fanout-vote`'s `selector` — so a test can drive
- * a deterministic policy through the real kernel, and production can wire it to
- * an LLM via `createSandboxPlanner`.
- *
- * Topology is orthogonal to harness: the planner never names a backend. Which
- * harness runs a branch is decided by the `AgentRunSpec` the kernel round-robins
- * to, so one dynamic driver works across claude-code, codex, opencode, pi —
- * including fanning a single round across several at once.
- */
-
-/** Terminal once `decide` returns `'done'` (a kernel terminal decision). */
-type DynamicDecision = 'continue' | 'done';
-/**
- * One topology decision for the next round. `fanout` carries explicit tasks
- * rather than a count so the planner can issue heterogeneous branches (a
- * different sub-task per harness); pass N copies of one task for a homogeneous
- * fanout that relies on `agentRuns` diversity instead.
- *
- * @experimental
- */
-type TopologyMove<Task> = {
-    kind: 'refine';
-    task: Task;
-    rationale?: string;
-} | {
-    kind: 'fanout';
-    tasks: Task[];
-    rationale?: string;
-} | {
-    kind: 'stop';
-    rationale?: string;
-};
-/** @experimental */
-interface PlannerContext<Task, Output> {
-    /** The root task the loop was invoked with — stable across rounds. */
-    task: Task;
-    /** Every iteration so far, in dispatch order, with outputs + verdicts. */
-    history: ReadonlyArray<Iteration<Task, Output>>;
-    /** `history.length` — iterations already spent. */
-    iterationsSpent: number;
-    /** Iterations left before the driver's `maxIterations` cap forces a stop. */
-    iterationsRemaining: number;
-}
-/**
- * Chooses the next topology move from the task + history. Sync or async; an
- * async planner is where an LLM call goes (see `createSandboxPlanner`).
- *
- * @experimental
- */
-type TopologyPlanner<Task, Output> = (ctx: PlannerContext<Task, Output>) => TopologyMove<Task> | Promise<TopologyMove<Task>>;
-/** @experimental */
-interface CreateDynamicDriverOptions<Task, Output> {
-    /** The agent-authored topology policy. Invoked once per round in `plan`. */
-    planner: TopologyPlanner<Task, Output>;
-    /**
-     * Hard safety cap on total iterations. When reached, the driver stops before
-     * consulting the planner. Default 8. Set the kernel's `runLoop`
-     * `maxIterations >= ` this so the driver's cap governs and the loop closes on
-     * a clean `'done'` rather than a truncated `'continue'`.
-     */
-    maxIterations?: number;
-    /** Max branches a single `fanout` move may dispatch. Default 4. */
-    maxFanout?: number;
-    /** Stable identifier surfaced in trace events. Default `'dynamic'`. */
-    name?: string;
-}
-/** @experimental */
-declare function createDynamicDriver<Task, Output>(options: CreateDynamicDriverOptions<Task, Output>): Driver<Task, Output, DynamicDecision>;
-/**
- * Compact, planner-friendly view of iteration history — what an LLM planner
- * needs to choose the next move without the raw event streams. Output is
- * truncated so a long run's prompt stays bounded.
- *
- * @experimental
- */
-declare function summarizeHistory<Task, Output>(history: ReadonlyArray<Iteration<Task, Output>>, opts?: {
-    maxOutputChars?: number;
-}): Array<{
-    index: number;
-    agentRunName: string;
-    valid?: boolean;
-    score?: number;
-    error?: string;
-    output?: string;
-}>;
-
 /**
  * @experimental
  *
@@ -413,4 +312,4 @@ interface UsageSink {
  */
 declare function reportLoopUsage<Task, Output, Decision>(cost: UsageSink, result: Pick<LoopResult<Task, Output, Decision>, 'costUsd' | 'tokenUsage'>, source?: string): void;
 
-export { AgentRunSpec, type CreateDynamicDriverOptions, type CreateFanoutVoteDriverOptions, type CreateRefineDriverOptions, type CreateSandboxPlannerOptions, Driver, type DynamicDecision, ExecCtx, type FanoutVoteDecision, type FanoutVoteScored, Iteration, type LoopDispatchOptions, type LoopOptionsForDispatch, LoopResult, LoopSandboxClient, LoopWinner, OutputAdapter, type PlannerContext, type RefineDecision, type RunLoopOptions, type TopologyMove, type TopologyMoveEnvelope, type TopologyPlanner, type UsageSink, Validator, createDynamicDriver, createFanoutVoteDriver, createRefineDriver, createSandboxPlanner, loopCampaignDispatch, loopDispatch, refineWinnerIndex, reportLoopUsage, runLoop, scoreFanoutVoteIterations, summarizeHistory };
+export { AgentRunSpec, type CreateFanoutVoteDriverOptions, type CreateRefineDriverOptions, type CreateSandboxPlannerOptions, Driver, ExecCtx, type FanoutVoteDecision, type FanoutVoteScored, Iteration, type LoopDispatchOptions, type LoopOptionsForDispatch, LoopResult, LoopSandboxClient, LoopWinner, OutputAdapter, PlannerContext, type RefineDecision, type RunLoopOptions, type TopologyMoveEnvelope, TopologyPlanner, type UsageSink, Validator, createFanoutVoteDriver, createRefineDriver, createSandboxPlanner, loopCampaignDispatch, loopDispatch, refineWinnerIndex, reportLoopUsage, runLoop, scoreFanoutVoteIterations };

package/dist/mcp/bin.js

@@ -2,10 +2,11 @@
 import {
   createMcpServer,
   detectExecutor
-} from "../chunk-M65QJD35.js";
+} from "../chunk-PK5DYSNO.js";
+import "../chunk-HSX6PFZR.js";
 import {
   createDefaultCoderDelegate
-} from "../chunk-V6GURW4W.js";
+} from "../chunk-VLXRXMTF.js";
 import "../chunk-GLR25NG7.js";
 import {
   runLoop