@tangle-network/agent-runtime 0.44.0 → 0.46.0

package/dist/coder-DCWFQpmJ.d.ts

@@ -0,0 +1,114 @@
+import { AgentProfile } from '@tangle-network/sandbox';
+import { O as OutputAdapter, V as Validator, A as AgentRunSpec, D as Driver } from './types-DnYoHvvZ.js';
+
+/**
+ * @experimental
+ *
+ * `coderProfile` — opinionated preset for code-modification tasks.
+ *
+ * The agent is told to:
+ *   - work on a fresh branch inside the sandbox workspace
+ *   - keep the patch minimal (under `maxDiffLines`)
+ *   - avoid `forbiddenPaths`
+ *   - run `testCmd` and `typecheckCmd`
+ *   - emit a final JSON result the output adapter parses
+ *
+ * The profile is stateless and agent-agnostic — `harness` selects the
+ * sandbox-SDK backend (`claude-code`, `codex`, `opencode/*`). For
+ * heterogeneous fanout, use `multiHarnessCoderFanout`.
+ */
+
+/** @experimental */
+interface CoderTask {
+    /** What the agent must accomplish. Free-form prose. */
+    goal: string;
+    /** Absolute path inside the sandbox where the repo lives. */
+    repoRoot: string;
+    /** Default `main`. The branch the agent diffs against. */
+    baseBranch?: string;
+    /** Default `pnpm test --run`. */
+    testCmd?: string;
+    /** Default `pnpm typecheck`. */
+    typecheckCmd?: string;
+    /** Files the agent may inspect for context. Surfaced verbatim in the prompt. */
+    contextFiles?: string[];
+    /**
+     * Paths the agent must not touch. Validator hard-fails on any match.
+     * Use glob-free literal path prefixes for unambiguous enforcement.
+     */
+    forbiddenPaths?: string[];
+    /** Default 400. Hard cap; validator hard-fails when exceeded. */
+    maxDiffLines?: number;
+}
+/** @experimental */
+interface CoderOutput {
+    /** Branch the agent wrote the patch on. */
+    branch: string;
+    /** Unified diff (`git diff <base>..HEAD`). */
+    patch: string;
+    testResult: {
+        passed: boolean;
+        output: string;
+    };
+    typecheckResult: {
+        passed: boolean;
+        output: string;
+    };
+    diffStats: {
+        filesChanged: number;
+        insertions: number;
+        deletions: number;
+    };
+    /** Optional reviewer commentary surfaced by the agent. */
+    reviewerNotes?: string;
+}
+/** @experimental */
+interface CoderProfileOptions {
+    /** Sandbox-SDK backend.type. Default `'claude-code'`. */
+    harness?: string;
+    /** Default model id passed in `AgentProfile.model.default`. */
+    model?: string;
+    /** Custom system prompt replacement. Default = built-in coder preset. */
+    systemPrompt?: string;
+    /** Stable name for `AgentRunSpec.name`. Default = `coder-${harness}`. */
+    name?: string;
+}
+/**
+ * Build a coder preset.
+ *
+ * `validator` enforces test + typecheck + a 400-line default diff cap. For
+ * per-task `forbiddenPaths` / `maxDiffLines` enforcement, pass `task` here
+ * — the returned validator closes over its constraints. Without a task
+ * the validator falls back to the default cap and skips path enforcement.
+ *
+ * @experimental
+ */
+declare function coderProfile(options?: CoderProfileOptions & {
+    task?: CoderTask;
+}): {
+    profile: AgentProfile;
+    taskToPrompt: (task: CoderTask) => string;
+    output: OutputAdapter<CoderOutput>;
+    validator: Validator<CoderOutput>;
+    agentRunSpec: AgentRunSpec<CoderTask>;
+};
+/** @experimental */
+interface MultiHarnessCoderFanoutOptions {
+    /**
+     * Sandbox-SDK backend.type identifiers, one per parallel agent. Default:
+     * `['claude-code', 'codex', 'opencode/zai-coding-plan/glm-5.1']`.
+     */
+    harnesses?: string[];
+    /** Optional per-harness model override. Indexed parallel to `harnesses`. */
+    models?: (string | undefined)[];
+}
+/** @experimental */
+declare function multiHarnessCoderFanout(options?: MultiHarnessCoderFanoutOptions): {
+    agentRuns: AgentRunSpec<CoderTask>[];
+    output: OutputAdapter<CoderOutput>;
+    validator: Validator<CoderOutput>;
+    driver: Driver<CoderTask, CoderOutput, 'pick-winner' | 'fail'>;
+};
+declare function createCoderValidator(task: CoderTask): Validator<CoderOutput>;
+
+export { type CoderOutput as C, type MultiHarnessCoderFanoutOptions as M, type CoderTask as a, type CoderProfileOptions as b, coderProfile as c, createCoderValidator as d, multiHarnessCoderFanout as m };

package/dist/driver-C-mtBo7h.d.ts

@@ -0,0 +1,221 @@
+import { AnalystFinding } from '@tangle-network/agent-eval';
+import { I as Iteration, D as Driver } from './types-DnYoHvvZ.js';
+
+/**
+ * @experimental
+ *
+ * Completion / satisfiability — the OTHER output of the pluggable analyst (the steer output
+ * is `AnalystFinding[]` via the `analyze` hook; this is the "is it done?" output via the
+ * `complete` hook). A `CompletionAnalyst` reads a node's trace and returns a `CompletionVerdict`
+ * the PARENT (driver) acts on: end the node, or keep going. It fits ANY node and composes to
+ * any depth — a 1-deep loop has one; an N-deep tree has one per node.
+ *
+ * The verdict's authority scales with its DETERMINISM (the thing that varies by task):
+ *   - `deterministic` — build/test/lint pass, a proof checks, every claim's citation resolves:
+ *     ground truth, the driver TRUSTS it and ends. Not an opinion.
+ *   - `probabilistic` — a quality/soundness judgment (marketing, "the experiment is sound"):
+ *     ADVISORY. It passes to the driver with its reasons; the driver validates (here: a
+ *     confidence threshold; a richer driver may re-examine the reasons) before ending.
+ *
+ * Two stop-signal mechanisms, by node mode, both → one `CompletionVerdict`:
+ *   - sandbox-agent (text stream): a unique per-node STOP SENTINEL the agent emits when done
+ *     (`stopSentinel` / `sentinelCompletion`) — ralph-loop style; the seed makes it
+ *     unguessable + attributable, so it can't be spuriously emitted or confused with content.
+ *   - deterministic check (compile/test/citation/proof): `deterministicCompletion(check)` —
+ *     a verifier over the output, never the judge verdict (selector ≠ judge holds).
+ */
+
+/** Trace-derived evidence for a completion claim — an artifact (output) or a verifier metric,
+ *  never the judge's own verdict. Mirrors the steer-firewall's provenance discipline. */
+interface CompletionEvidence {
+    kind: 'artifact' | 'metric';
+    uri: string;
+}
+/** The "is it done?" verdict an analyst returns to the parent. */
+interface CompletionVerdict {
+    done: boolean;
+    /** How verifiable the claim is — sets whether the driver trusts it or validates it. */
+    determinism: 'deterministic' | 'probabilistic';
+    /** Why the analyst believes it is (or isn't) done — what the driver validates. */
+    reasons?: string;
+    /** 0..1, for probabilistic verdicts; the driver's validation threshold reads this. */
+    confidence?: number;
+    evidence?: ReadonlyArray<CompletionEvidence>;
+}
+/** Reads a node's trace → a completion verdict. Same input shape as the `analyze` hook, so
+ *  ONE analyst node can back both channels (findings for steer, a verdict for stop). */
+interface CompletionAnalyst<Task, Output> {
+    assess(input: {
+        task: Task;
+        history: ReadonlyArray<Iteration<Task, Output>>;
+    }): CompletionVerdict | Promise<CompletionVerdict>;
+}
+/** When a verdict authorizes the driver to END. Deterministic → trust (ground truth);
+ *  probabilistic → validate by confidence threshold (the driver's check). */
+interface CompletionPolicy {
+    /** Minimum confidence a PROBABILISTIC verdict must clear to end. Default 0.8. */
+    minConfidence?: number;
+}
+declare function completionAuthorizes(v: CompletionVerdict, policy?: CompletionPolicy): boolean;
+/**
+ * A unique, attributable stop sentinel for a node (ralph-loop style). Deterministic from the
+ * seed (no Math.random — reproducible + attributable to the node); the agent is instructed to
+ * emit it VERBATIM when it judges itself done. Unguessable enough that content never trips it.
+ */
+declare function stopSentinel(seed: string): string;
+/**
+ * Completion for a sandbox-agent node: done iff the latest output carries the node's stop
+ * sentinel. PROBABILISTIC (the agent's own self-judgment) — the driver validates it.
+ */
+declare function sentinelCompletion<Task>(sentinel: string, opts?: {
+    confidence?: number;
+}): CompletionAnalyst<Task, string>;
+/**
+ * Completion for a DETERMINISTIC check (build/test/lint/citation/proof): done iff the check
+ * passes. Ground truth — the driver ends directly, no validation. The check reads the output
+ * (a verifier), never the judge verdict — selector ≠ judge stays intact.
+ */
+declare function deterministicCompletion<Task, Output>(check: (output: Output, history: ReadonlyArray<Iteration<Task, Output>>) => {
+    passed: boolean;
+    reasons?: string;
+}): CompletionAnalyst<Task, Output>;
+
+/**
+ * @experimental
+ *
+ * Dynamic driver — the agent authors the loop topology at runtime.
+ *
+ * Where a fixed-shape driver encodes one topology 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 — so a test can
+ * drive a deterministic policy through the real kernel, and production can wire
+ * it to an LLM-backed, agent-authored planner.
+ *
+ * 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 DriverDecision = '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;
+    parentIndex?: number;
+} | {
+    kind: 'fanout';
+    tasks: Task[];
+    rationale?: string;
+    parentIndex?: number;
+} | {
+    kind: 'stop';
+    rationale?: string;
+} | {
+    kind: 'select';
+    index: number;
+    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;
+    /**
+     * Trace-analyst findings about the attempts so far — populated only when an
+     * `analyze` hook is wired into the driver (see CreateDriverOptions).
+     * This is the channel that lets the planner steer from the DIAGNOSIS
+     * (`f(trace, findings)`), not the verdict score alone. Undefined = no analyst
+     * wired (the planner runs exactly as before). @experimental
+     */
+    analyses?: ReadonlyArray<AnalystFinding>;
+}
+/**
+ * Chooses the next topology move from the task + history. Sync or async; an
+ * async planner is where an LLM call goes (an agent-authored topology planner).
+ *
+ * @experimental
+ */
+type TopologyPlanner<Task, Output> = (ctx: PlannerContext<Task, Output>) => TopologyMove<Task> | Promise<TopologyMove<Task>>;
+/**
+ * Input to the optional `analyze` hook: the root task + the trace so far. The
+ * hook turns this into `AnalystFinding[]` — the caller's seam to `runAnalystLoop`.
+ * @experimental
+ */
+interface AnalyzeInput<Task, Output> {
+    task: Task;
+    history: ReadonlyArray<Iteration<Task, Output>>;
+}
+/** @experimental */
+interface CreateDriverOptions<Task, Output> {
+    /** The agent-authored topology policy. Invoked once per round in `plan`. */
+    planner: TopologyPlanner<Task, Output>;
+    /**
+     * Optional trace-analyst hook. When set, the driver calls it each round AFTER
+     * the first (a trace must exist) and BEFORE the planner, then passes the
+     * findings to the planner via `PlannerContext.analyses` — so the planner
+     * decides from the diagnosis, not the verdict score alone. This is the seam to
+     * `runAnalystLoop`; it lives on the driver so `run-loop` stays analyst-free
+     * (the layering rule). Fail-loud: a throwing or non-array hook aborts the round
+     * (no silent empty findings).
+     */
+    analyze?: (input: AnalyzeInput<Task, Output>) => ReadonlyArray<AnalystFinding> | Promise<ReadonlyArray<AnalystFinding>>;
+    /**
+     * Optional completion analyst — the DEPLOYABLE, non-oracle stop. Each round (after a
+     * trace exists) the driver asks "is it done?"; if the verdict AUTHORIZES ending
+     * (deterministic = trust ground truth; probabilistic = clears `completionPolicy`'s
+     * confidence), the driver stops BEFORE consulting the planner. This is the satisfiability
+     * primitive — usable at 1 deep, composing to any depth (one per node). Fail-loud: a
+     * throwing or non-verdict assess aborts the round. Distinct from `analyze` (the steer
+     * channel) though one analyst node may back both.
+     */
+    complete?: CompletionAnalyst<Task, Output>;
+    /** Validation policy for a probabilistic completion verdict (the driver's check). */
+    completionPolicy?: CompletionPolicy;
+    /**
+     * 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 createDriver<Task, Output>(options: CreateDriverOptions<Task, Output>): Driver<Task, Output, DriverDecision>;
+/**
+ * Compact, planner-facing rendering of trace-analyst findings — the diagnosis the
+ * planner steers from. Empty input renders to '' (callers omit the section). Shows
+ * severity·area·claim·recommended_action·confidence; raw evidence_refs/metadata are
+ * for renderers that know the analyst, not the topology decision.
+ * @experimental
+ */
+declare function renderAnalyses(findings: ReadonlyArray<AnalystFinding>): string;
+
+export { type AnalyzeInput as A, type CreateDriverOptions as C, type DriverDecision as D, type PlannerContext as P, type TopologyPlanner as T, type CompletionAnalyst as a, type CompletionEvidence as b, type CompletionPolicy as c, type CompletionVerdict as d, type TopologyMove as e, completionAuthorizes as f, createDriver as g, deterministicCompletion as h, stopSentinel as i, renderAnalyses as r, sentinelCompletion as s };

package/dist/improvement.d.ts

@@ -1,7 +1,6 @@
 import { AnalystFinding } from '@tangle-network/agent-eval';
 import { L as LocalHarness, r as runLocalHarness } from './local-harness-KrdFTY5R.js';
 import { LabeledScenarioStore, WorktreeAdapter, ImprovementDriver } from '@tangle-network/agent-eval/campaign';
-export { O as OptimizePromptOptions, b as OptimizePromptReflection, a as OptimizePromptResult, o as optimizePrompt } from './optimize-prompt-D-urF2wW.js';
 import { S as SurfaceImprovementEdit } from './improvement-adapter-BC4HhuAR.js';
 import { I as ImprovementAdapter } from './types-p8dWBIXL.js';
 import 'node:child_process';

package/dist/improvement.js

@@ -1,10 +1,6 @@
 import {
   runLocalHarness
 } from "./chunk-GLR25NG7.js";
-import {
-  optimizePrompt
-} from "./chunk-VOX6Z3II.js";
-import "./chunk-SQSCRJ7U.js";
 import "./chunk-DGUM43GV.js";
 
 // src/improvement/agentic-generator.ts
@@ -160,7 +156,6 @@ function applyPatch(patch, cwd) {
 export {
   agenticGenerator,
   improvementDriver,
-  optimizePrompt,
   reflectiveGenerator
 };
 //# sourceMappingURL=improvement.js.map

package/dist/improvement.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/improvement/agentic-generator.ts","../src/improvement/improvement-driver.ts","../src/improvement/reflective-generator.ts"],"sourcesContent":["/**\n * @experimental\n *\n * `agenticGenerator` — the full-agentic `CandidateGenerator`: the\n * `shots=N, sandbox=on` setting of the one `improvementDriver`. It runs a real\n * coding harness (claude / codex / opencode) inside the candidate worktree the\n * driver already created, letting the agent read the codebase + the research\n * report and make the change in place. The driver then commits the worktree\n * into a `CodeSurface`.\n *\n * Mechanism: identical to the proven Phase-2.8 in-process executor — spawn the\n * harness as a subprocess with `cwd` = the worktree, on the same filesystem,\n * so edits land in place (no sandbox-mount round-trip). `runLocalHarness` is\n * the verified primitive. The OUTER sandbox is the improvement loop's own\n * execution context; the generator does not nest a second sandbox per\n * candidate (which would reintroduce a host↔sandbox worktree-transport\n * problem that does not need solving here).\n *\n * `maxShots` is the DEPTH dial: the harness runs once; if it produced no change\n * (the worktree stays clean), the generator refines the prompt and retries, up\n * to `maxShots` times. A harness that already changed files returns on shot 1.\n */\n\nimport { spawnSync } from 'node:child_process'\nimport type { AnalystFinding } from '@tangle-network/agent-eval'\nimport { type LocalHarness, runLocalHarness } from '../mcp/local-harness'\nimport type { CandidateGenerator } from './improvement-driver'\n\nexport interface AgenticGeneratorOptions {\n  /** Local coding harness to run in the worktree. Default `claude`. */\n  harness?: LocalHarness\n  /** Per-shot wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */\n  timeoutMs?: number\n  /** Build the harness task prompt from the report + findings. Override for\n   *  domain phrasing; the default turns findings into a concrete coder task. */\n  buildPrompt?: (args: { report: unknown; findings: AnalystFinding[] }) => string\n  /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */\n  runHarness?: typeof runLocalHarness\n  /** Test seam — inject the worktree-dirty check (defaults to `git status`). */\n  isDirty?: (worktreePath: string) => boolean\n}\n\nexport function agenticGenerator(opts: AgenticGeneratorOptions = {}): CandidateGenerator {\n  const harness = opts.harness ?? 'claude'\n  const buildPrompt = opts.buildPrompt ?? defaultBuildPrompt\n  const run = opts.runHarness ?? runLocalHarness\n  const dirty = opts.isDirty ?? worktreeDirty\n\n  return {\n    kind: `agentic:${harness}`,\n    async generate({ worktreePath, report, findings, maxShots, signal }) {\n      let prompt = buildPrompt({ report, findings })\n      const shots = Math.max(1, maxShots)\n\n      for (let shot = 0; shot < shots; shot++) {\n        if (signal.aborted) break\n        await run({\n          harness,\n          cwd: worktreePath,\n          taskPrompt: prompt,\n          timeoutMs: opts.timeoutMs,\n          signal,\n        })\n        // The worktree IS the signal: if the harness touched files, we have a\n        // candidate. We don't trust the harness's stdout — we trust the diff.\n        if (dirty(worktreePath)) {\n          return { applied: true, summary: summarize(findings) }\n        }\n        // No change this shot — give the next attempt explicit feedback.\n        prompt = refine(prompt)\n      }\n      return { applied: false, summary: '' }\n    },\n  }\n}\n\n/** Turn the analyst's findings (+ optional report) into a concrete coder task. */\nfunction defaultBuildPrompt(args: { report: unknown; findings: AnalystFinding[] }): string {\n  const lines: string[] = [\n    'You are improving this codebase based on an evaluation analysis.',\n    'Make the smallest set of edits that addresses the findings below, then stop.',\n    'Do not change unrelated code. Do not commit — leave changes in the working tree.',\n    '',\n    'Findings:',\n  ]\n  for (const f of args.findings) {\n    const where = f.subject ? ` [${f.subject}]` : ''\n    lines.push(`- (${f.severity})${where} ${f.claim}`)\n    if (f.recommended_action) lines.push(`    → ${f.recommended_action}`)\n  }\n  return lines.join('\\n')\n}\n\nfunction refine(prompt: string): string {\n  return `${prompt}\\n\\nNOTE: your previous attempt left the working tree unchanged. Make the concrete file edits now.`\n}\n\n/** A one-line summary for the commit message, derived from the findings. */\nfunction summarize(findings: AnalystFinding[]): string {\n  if (findings.length === 0) return 'agentic improvement'\n  if (findings.length === 1) return `agentic: ${truncate(findings[0]!.claim, 64)}`\n  return `agentic: ${findings.length} findings addressed`\n}\n\nfunction truncate(s: string, n: number): string {\n  return s.length <= n ? s : `${s.slice(0, n - 1)}…`\n}\n\n/** Non-empty `git status --porcelain` ⇒ the harness changed the worktree.\n *  Fails loud: the worktree is a fresh checkout, so a git error here means\n *  something is genuinely broken (git missing, corrupt index, killed mid-run).\n *  Folding that into `false` would silently discard a candidate and mask the\n *  real failure — forbidden by the no-silent-fallbacks doctrine. */\nfunction worktreeDirty(worktreePath: string): boolean {\n  const result = spawnSync('git', ['status', '--porcelain'], {\n    cwd: worktreePath,\n    encoding: 'utf-8',\n  })\n  if (result.error) {\n    throw new Error(\n      `agenticGenerator: git status failed to spawn in ${worktreePath}: ${result.error.message}`,\n    )\n  }\n  if (result.status !== 0) {\n    throw new Error(\n      `agenticGenerator: git status exited ${result.status} in ${worktreePath}: ${result.stderr.trim()}`,\n    )\n  }\n  return result.stdout.trim().length > 0\n}\n","/**\n * @experimental\n *\n * `improvementDriver` — the ONE reflective/agentic improvement driver for\n * agent-eval's improvement loop. It implements `ImprovementDriver` and owns\n * the candidate lifecycle (worktree create → generate → finalize/discard,\n * × populationSize); it delegates the only thing that genuinely varies — HOW\n * a candidate change is produced — to a pluggable `CandidateGenerator`.\n *\n * There is no separate \"analyst driver\" vs \"autoresearch driver\": those are\n * the SAME driver at two settings of a dial.\n *   - cheap reflective path  → `reflectiveGenerator` (shots=1, no sandbox;\n *                              applies pre-drafted patches)\n *   - full agentic path      → `agenticGenerator` (shots=N, sandbox runLoop;\n *                              an agent reads code + report and edits)\n * Both emit changes into a worktree the driver finalizes into a\n * `CodeSurface{ worktreeRef }` the loop measures on the holdout. See\n * agent-eval's `docs/design/self-improvement-engine.md`.\n */\n\nimport type { AnalystFinding } from '@tangle-network/agent-eval'\nimport type {\n  CodeSurface,\n  ImprovementDriver,\n  LabeledScenarioStore,\n  ProposeContext,\n  WorktreeAdapter,\n} from '@tangle-network/agent-eval/campaign'\n\n/** The byte-producing seam — the ONE thing that differs between the cheap\n *  reflective path and the full agentic path. A generator makes (uncommitted)\n *  changes inside `worktreePath`; the driver commits them via the worktree\n *  adapter's `finalize`. */\nexport interface CandidateGenerator {\n  kind: string\n  generate(args: {\n    /** The candidate worktree — a fresh checkout of baseRef. Write changes here. */\n    worktreePath: string\n    /** Phase-2 research report (analyst findings + diff), opaque. */\n    report: unknown\n    /** Findings resolved from the report or the loop context. */\n    findings: AnalystFinding[]\n    /** Handle to all captured data, to ground the change. */\n    dataset?: LabeledScenarioStore\n    /** DEPTH: max iterations the generator may take (agentic uses this; the\n     *  reflective generator ignores it). */\n    maxShots: number\n    signal: AbortSignal\n  }): Promise<{ applied: boolean; summary: string }>\n}\n\nexport interface ImprovementDriverOptions {\n  worktree: WorktreeAdapter\n  generator: CandidateGenerator\n  /** Base ref candidate worktrees fork from. Default `main`. */\n  baseRef?: string\n}\n\nexport function improvementDriver(\n  opts: ImprovementDriverOptions,\n): ImprovementDriver<AnalystFinding> {\n  const baseRef = opts.baseRef ?? 'main'\n\n  return {\n    kind: `improvement:${opts.generator.kind}`,\n    async propose(ctx) {\n      const findings = resolveFindings(ctx)\n      // No signal to act on — propose nothing rather than spin up worktrees.\n      if (findings.length === 0 && ctx.report === undefined) return []\n\n      const surfaces: CodeSurface[] = []\n      for (let i = 0; i < ctx.populationSize; i++) {\n        if (ctx.signal.aborted) break\n        const wt = await opts.worktree.create({\n          baseRef,\n          label: `${opts.generator.kind}-gen${ctx.generation}-cand${i}`,\n        })\n        // Once a worktree exists it MUST be accounted for: finalized into a\n        // surface, or discarded. A throw from generate()/finalize() must not\n        // leak the worktree + branch — discard best-effort, then rethrow loud.\n        try {\n          const { applied, summary } = await opts.generator.generate({\n            worktreePath: wt.path,\n            report: ctx.report,\n            findings,\n            dataset: ctx.dataset,\n            maxShots: ctx.maxImprovementShots ?? 1,\n            signal: ctx.signal,\n          })\n          if (!applied) {\n            await opts.worktree.discard(wt)\n            continue\n          }\n          surfaces.push(await opts.worktree.finalize(wt, summary))\n        } catch (err) {\n          // Best-effort cleanup; never mask the original failure.\n          await opts.worktree.discard(wt).catch(() => {})\n          throw err\n        }\n      }\n      return surfaces\n    },\n  }\n}\n\n/** Phase-2 report carries `findings` when present; else fall back to the\n *  loop's `ctx.findings`. The report is opaque to the substrate, so probe it\n *  structurally. */\nfunction resolveFindings(ctx: ProposeContext<AnalystFinding>): AnalystFinding[] {\n  const report = ctx.report\n  if (report && typeof report === 'object' && 'findings' in report) {\n    const f = (report as { findings: unknown }).findings\n    if (Array.isArray(f) && f.length > 0) return f as AnalystFinding[]\n  }\n  return ctx.findings\n}\n","/**\n * @experimental\n *\n * `reflectiveGenerator` — the cheap, no-sandbox `CandidateGenerator`. It drafts\n * surface edits via the existing improvement adapter (`proposeFromFindings`,\n * one LLM patch per finding) and applies them as ONE coherent improvement into\n * the candidate worktree. `maxShots` is ignored — reflection is single-shot by\n * construction (the patches are already drafted).\n *\n * This is the `shots=1, sandbox=off` setting of the one improvement driver.\n * The `agenticGenerator` (sandbox runLoop) is the `shots=N, sandbox=on`\n * setting — both plug into the same `improvementDriver`.\n */\n\nimport { spawnSync } from 'node:child_process'\nimport type { SurfaceImprovementEdit } from '../agent/improvement-adapter'\nimport type { ImprovementAdapter } from '../analyst-loop/types'\nimport type { CandidateGenerator } from './improvement-driver'\n\nexport interface ReflectiveGeneratorOptions {\n  improvementAdapter: ImprovementAdapter<SurfaceImprovementEdit>\n}\n\nexport function reflectiveGenerator(opts: ReflectiveGeneratorOptions): CandidateGenerator {\n  return {\n    kind: 'reflective',\n    async generate({ worktreePath, findings }) {\n      const batch = await opts.improvementAdapter.proposeFromFindings(findings)\n      if (batch.edits.length === 0) return { applied: false, summary: '' }\n\n      let applied = 0\n      for (const edit of batch.edits) {\n        if (applyPatch(edit.patch, worktreePath)) applied++\n      }\n      if (applied === 0) return { applied: false, summary: '' }\n\n      const summary =\n        batch.edits.length === 1\n          ? batch.edits[0]!.summary\n          : `analyst: ${applied} surface edit${applied === 1 ? '' : 's'}`\n      return { applied: true, summary }\n    },\n  }\n}\n\n/** Mirror the improvement adapter's proven apply invocation, run inside the\n *  candidate worktree (a fresh checkout of baseRef, so `-p0` paths match). */\nfunction applyPatch(patch: string, cwd: string): boolean {\n  const result = spawnSync('git', ['apply', '--whitespace=fix', '-p0', '-'], {\n    cwd,\n    input: patch,\n    encoding: 'utf-8',\n  })\n  return result.status === 0\n}\n"],"mappings":"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","names":["spawnSync"]}
+{"version":3,"sources":["../src/improvement/agentic-generator.ts","../src/improvement/improvement-driver.ts","../src/improvement/reflective-generator.ts"],"sourcesContent":["/**\n * @experimental\n *\n * `agenticGenerator` — the full-agentic `CandidateGenerator`: the\n * `shots=N, sandbox=on` setting of the one `improvementDriver`. It runs a real\n * coding harness (claude / codex / opencode) inside the candidate worktree the\n * driver already created, letting the agent read the codebase + the research\n * report and make the change in place. The driver then commits the worktree\n * into a `CodeSurface`.\n *\n * Mechanism: identical to the proven Phase-2.8 in-process executor — spawn the\n * harness as a subprocess with `cwd` = the worktree, on the same filesystem,\n * so edits land in place (no sandbox-mount round-trip). `runLocalHarness` is\n * the verified primitive. The OUTER sandbox is the improvement loop's own\n * execution context; the generator does not nest a second sandbox per\n * candidate (which would reintroduce a host↔sandbox worktree-transport\n * problem that does not need solving here).\n *\n * `maxShots` is the DEPTH dial: the harness runs once; if it produced no change\n * (the worktree stays clean), the generator refines the prompt and retries, up\n * to `maxShots` times. A harness that already changed files returns on shot 1.\n */\n\nimport { spawnSync } from 'node:child_process'\nimport type { AnalystFinding } from '@tangle-network/agent-eval'\nimport { type LocalHarness, runLocalHarness } from '../mcp/local-harness'\nimport type { CandidateGenerator } from './improvement-driver'\n\nexport interface AgenticGeneratorOptions {\n  /** Local coding harness to run in the worktree. Default `claude`. */\n  harness?: LocalHarness\n  /** Per-shot wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */\n  timeoutMs?: number\n  /** Build the harness task prompt from the report + findings. Override for\n   *  domain phrasing; the default turns findings into a concrete coder task. */\n  buildPrompt?: (args: { report: unknown; findings: AnalystFinding[] }) => string\n  /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */\n  runHarness?: typeof runLocalHarness\n  /** Test seam — inject the worktree-dirty check (defaults to `git status`). */\n  isDirty?: (worktreePath: string) => boolean\n}\n\nexport function agenticGenerator(opts: AgenticGeneratorOptions = {}): CandidateGenerator {\n  const harness = opts.harness ?? 'claude'\n  const buildPrompt = opts.buildPrompt ?? defaultBuildPrompt\n  const run = opts.runHarness ?? runLocalHarness\n  const dirty = opts.isDirty ?? worktreeDirty\n\n  return {\n    kind: `agentic:${harness}`,\n    async generate({ worktreePath, report, findings, maxShots, signal }) {\n      let prompt = buildPrompt({ report, findings })\n      const shots = Math.max(1, maxShots)\n\n      for (let shot = 0; shot < shots; shot++) {\n        if (signal.aborted) break\n        await run({\n          harness,\n          cwd: worktreePath,\n          taskPrompt: prompt,\n          timeoutMs: opts.timeoutMs,\n          signal,\n        })\n        // The worktree IS the signal: if the harness touched files, we have a\n        // candidate. We don't trust the harness's stdout — we trust the diff.\n        if (dirty(worktreePath)) {\n          return { applied: true, summary: summarize(findings) }\n        }\n        // No change this shot — give the next attempt explicit feedback.\n        prompt = refine(prompt)\n      }\n      return { applied: false, summary: '' }\n    },\n  }\n}\n\n/** Turn the analyst's findings (+ optional report) into a concrete coder task. */\nfunction defaultBuildPrompt(args: { report: unknown; findings: AnalystFinding[] }): string {\n  const lines: string[] = [\n    'You are improving this codebase based on an evaluation analysis.',\n    'Make the smallest set of edits that addresses the findings below, then stop.',\n    'Do not change unrelated code. Do not commit — leave changes in the working tree.',\n    '',\n    'Findings:',\n  ]\n  for (const f of args.findings) {\n    const where = f.subject ? ` [${f.subject}]` : ''\n    lines.push(`- (${f.severity})${where} ${f.claim}`)\n    if (f.recommended_action) lines.push(`    → ${f.recommended_action}`)\n  }\n  return lines.join('\\n')\n}\n\nfunction refine(prompt: string): string {\n  return `${prompt}\\n\\nNOTE: your previous attempt left the working tree unchanged. Make the concrete file edits now.`\n}\n\n/** A one-line summary for the commit message, derived from the findings. */\nfunction summarize(findings: AnalystFinding[]): string {\n  if (findings.length === 0) return 'agentic improvement'\n  if (findings.length === 1) return `agentic: ${truncate(findings[0]!.claim, 64)}`\n  return `agentic: ${findings.length} findings addressed`\n}\n\nfunction truncate(s: string, n: number): string {\n  return s.length <= n ? s : `${s.slice(0, n - 1)}…`\n}\n\n/** Non-empty `git status --porcelain` ⇒ the harness changed the worktree.\n *  Fails loud: the worktree is a fresh checkout, so a git error here means\n *  something is genuinely broken (git missing, corrupt index, killed mid-run).\n *  Folding that into `false` would silently discard a candidate and mask the\n *  real failure — forbidden by the no-silent-fallbacks doctrine. */\nfunction worktreeDirty(worktreePath: string): boolean {\n  const result = spawnSync('git', ['status', '--porcelain'], {\n    cwd: worktreePath,\n    encoding: 'utf-8',\n  })\n  if (result.error) {\n    throw new Error(\n      `agenticGenerator: git status failed to spawn in ${worktreePath}: ${result.error.message}`,\n    )\n  }\n  if (result.status !== 0) {\n    throw new Error(\n      `agenticGenerator: git status exited ${result.status} in ${worktreePath}: ${result.stderr.trim()}`,\n    )\n  }\n  return result.stdout.trim().length > 0\n}\n","/**\n * @experimental\n *\n * `improvementDriver` — the ONE reflective/agentic improvement driver for\n * agent-eval's improvement loop. It implements `ImprovementDriver` and owns\n * the candidate lifecycle (worktree create → generate → finalize/discard,\n * × populationSize); it delegates the only thing that genuinely varies — HOW\n * a candidate change is produced — to a pluggable `CandidateGenerator`.\n *\n * There is no separate \"analyst driver\" vs \"autoresearch driver\": those are\n * the SAME driver at two settings of a dial.\n *   - cheap reflective path  → `reflectiveGenerator` (shots=1, no sandbox;\n *                              applies pre-drafted patches)\n *   - full agentic path      → `agenticGenerator` (shots=N, sandbox runLoop;\n *                              an agent reads code + report and edits)\n * Both emit changes into a worktree the driver finalizes into a\n * `CodeSurface{ worktreeRef }` the loop measures on the holdout. See\n * agent-eval's `docs/design/self-improvement-engine.md`.\n */\n\nimport type { AnalystFinding } from '@tangle-network/agent-eval'\nimport type {\n  CodeSurface,\n  ImprovementDriver,\n  LabeledScenarioStore,\n  ProposeContext,\n  WorktreeAdapter,\n} from '@tangle-network/agent-eval/campaign'\n\n/** The byte-producing seam — the ONE thing that differs between the cheap\n *  reflective path and the full agentic path. A generator makes (uncommitted)\n *  changes inside `worktreePath`; the driver commits them via the worktree\n *  adapter's `finalize`. */\nexport interface CandidateGenerator {\n  kind: string\n  generate(args: {\n    /** The candidate worktree — a fresh checkout of baseRef. Write changes here. */\n    worktreePath: string\n    /** Phase-2 research report (analyst findings + diff), opaque. */\n    report: unknown\n    /** Findings resolved from the report or the loop context. */\n    findings: AnalystFinding[]\n    /** Handle to all captured data, to ground the change. */\n    dataset?: LabeledScenarioStore\n    /** DEPTH: max iterations the generator may take (agentic uses this; the\n     *  reflective generator ignores it). */\n    maxShots: number\n    signal: AbortSignal\n  }): Promise<{ applied: boolean; summary: string }>\n}\n\nexport interface ImprovementDriverOptions {\n  worktree: WorktreeAdapter\n  generator: CandidateGenerator\n  /** Base ref candidate worktrees fork from. Default `main`. */\n  baseRef?: string\n}\n\nexport function improvementDriver(\n  opts: ImprovementDriverOptions,\n): ImprovementDriver<AnalystFinding> {\n  const baseRef = opts.baseRef ?? 'main'\n\n  return {\n    kind: `improvement:${opts.generator.kind}`,\n    async propose(ctx) {\n      const findings = resolveFindings(ctx)\n      // No signal to act on — propose nothing rather than spin up worktrees.\n      if (findings.length === 0 && ctx.report === undefined) return []\n\n      const surfaces: CodeSurface[] = []\n      for (let i = 0; i < ctx.populationSize; i++) {\n        if (ctx.signal.aborted) break\n        const wt = await opts.worktree.create({\n          baseRef,\n          label: `${opts.generator.kind}-gen${ctx.generation}-cand${i}`,\n        })\n        // Once a worktree exists it MUST be accounted for: finalized into a\n        // surface, or discarded. A throw from generate()/finalize() must not\n        // leak the worktree + branch — discard best-effort, then rethrow loud.\n        try {\n          const { applied, summary } = await opts.generator.generate({\n            worktreePath: wt.path,\n            report: ctx.report,\n            findings,\n            dataset: ctx.dataset,\n            maxShots: ctx.maxImprovementShots ?? 1,\n            signal: ctx.signal,\n          })\n          if (!applied) {\n            await opts.worktree.discard(wt)\n            continue\n          }\n          surfaces.push(await opts.worktree.finalize(wt, summary))\n        } catch (err) {\n          // Best-effort cleanup; never mask the original failure.\n          await opts.worktree.discard(wt).catch(() => {})\n          throw err\n        }\n      }\n      return surfaces\n    },\n  }\n}\n\n/** Phase-2 report carries `findings` when present; else fall back to the\n *  loop's `ctx.findings`. The report is opaque to the substrate, so probe it\n *  structurally. */\nfunction resolveFindings(ctx: ProposeContext<AnalystFinding>): AnalystFinding[] {\n  const report = ctx.report\n  if (report && typeof report === 'object' && 'findings' in report) {\n    const f = (report as { findings: unknown }).findings\n    if (Array.isArray(f) && f.length > 0) return f as AnalystFinding[]\n  }\n  return ctx.findings\n}\n","/**\n * @experimental\n *\n * `reflectiveGenerator` — the cheap, no-sandbox `CandidateGenerator`. It drafts\n * surface edits via the existing improvement adapter (`proposeFromFindings`,\n * one LLM patch per finding) and applies them as ONE coherent improvement into\n * the candidate worktree. `maxShots` is ignored — reflection is single-shot by\n * construction (the patches are already drafted).\n *\n * This is the `shots=1, sandbox=off` setting of the one improvement driver.\n * The `agenticGenerator` (sandbox runLoop) is the `shots=N, sandbox=on`\n * setting — both plug into the same `improvementDriver`.\n */\n\nimport { spawnSync } from 'node:child_process'\nimport type { SurfaceImprovementEdit } from '../agent/improvement-adapter'\nimport type { ImprovementAdapter } from '../analyst-loop/types'\nimport type { CandidateGenerator } from './improvement-driver'\n\nexport interface ReflectiveGeneratorOptions {\n  improvementAdapter: ImprovementAdapter<SurfaceImprovementEdit>\n}\n\nexport function reflectiveGenerator(opts: ReflectiveGeneratorOptions): CandidateGenerator {\n  return {\n    kind: 'reflective',\n    async generate({ worktreePath, findings }) {\n      const batch = await opts.improvementAdapter.proposeFromFindings(findings)\n      if (batch.edits.length === 0) return { applied: false, summary: '' }\n\n      let applied = 0\n      for (const edit of batch.edits) {\n        if (applyPatch(edit.patch, worktreePath)) applied++\n      }\n      if (applied === 0) return { applied: false, summary: '' }\n\n      const summary =\n        batch.edits.length === 1\n          ? batch.edits[0]!.summary\n          : `analyst: ${applied} surface edit${applied === 1 ? '' : 's'}`\n      return { applied: true, summary }\n    },\n  }\n}\n\n/** Mirror the improvement adapter's proven apply invocation, run inside the\n *  candidate worktree (a fresh checkout of baseRef, so `-p0` paths match). */\nfunction applyPatch(patch: string, cwd: string): boolean {\n  const result = spawnSync('git', ['apply', '--whitespace=fix', '-p0', '-'], {\n    cwd,\n    input: patch,\n    encoding: 'utf-8',\n  })\n  return result.status === 0\n}\n"],"mappings":"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","names":["spawnSync"]}

package/dist/index.d.ts

@@ -1,16 +1,19 @@
 import { AgentEvalError, KnowledgeReadinessReport, RunRecord, ControlEvalResult, KnowledgeRequirement } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
-import { q as AgentBackendInput, r as AgentExecutionBackend, c as OpenAIChatTool, s as OpenAIChatToolChoice, t as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, u as RunAgentTaskOptions, v as AgentTaskRunResult, w as RunAgentTaskStreamOptions, x as AgentRuntimeEvent, y as AgentTaskStatus, z as RuntimeSessionStore, B as RuntimeSession } from './types-DbJzz2uf.js';
-export { C as AgentAdapter, F as AgentKnowledgeProvider, G as AgentRuntimeEventSink, H as AgentTaskContext, J as AgentTaskSpec, M as BackendErrorDetail, N as RuntimeRunHandle, P as RuntimeRunPersistenceAdapter, Q as RuntimeRunRow, S as startRuntimeRun } from './types-DbJzz2uf.js';
-export { C as CoderLoopRunnerOptions, D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, e as DynamicLoopRunnerOptions, L as LoopRunnerCliArgs, f as LoopRunnerCliResult, R as ResearchLoopResult, g as ResearchLoopRunnerOptions, h as RunDelegatedLoopOptions, V as VetoedFact, i as auditLoopRunner, j as coderLoopRunner, k as dynamicLoopRunner, l as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, m as reviewLoopRunner, n as runDelegatedLoop, o as runLoopRunnerCli, s as selfImproveLoopRunner } from './loop-runner-bin-BLMa8He3.js';
-export { E as EvalRunEvent, b as EvalRunGeneration, c as EvalRunsExportConfig, d as EvalRunsExportResult, I as INTELLIGENCE_WIRE_VERSION, e as OtelAttribute, f as OtelExportConfig, O as OtelExporter, g as OtelSpan, h as buildLoopOtelSpans, i as createOtelExporter, j as exportEvalRuns, l as loopEventToOtelSpan, m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './otel-export-wFDmmurL.js';
+import { g as AgentBackendInput, h as AgentExecutionBackend, d as OpenAIChatTool, i as OpenAIChatToolChoice, j as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, k as RunAgentTaskOptions, l as AgentTaskRunResult, m as RunAgentTaskStreamOptions, n as AgentRuntimeEvent, o as AgentTaskStatus, p as RuntimeSessionStore, q as RuntimeSession } from './types-DnYoHvvZ.js';
+export { r as AgentAdapter, s as AgentKnowledgeProvider, t as AgentRuntimeEventSink, u as AgentTaskContext, v as AgentTaskSpec, B as BackendErrorDetail, w as RuntimeRunHandle, x as RuntimeRunPersistenceAdapter, y as RuntimeRunRow, z as startRuntimeRun } from './types-DnYoHvvZ.js';
+export { C as CoderLoopRunnerOptions, D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, e as DynamicLoopRunnerOptions, L as LoopRunnerCliArgs, f as LoopRunnerCliResult, R as ResearchLoopResult, g as ResearchLoopRunnerOptions, h as RunDelegatedLoopOptions, V as VetoedFact, i as auditLoopRunner, j as coderLoopRunner, k as dynamicLoopRunner, l as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, m as reviewLoopRunner, n as runDelegatedLoop, o as runLoopRunnerCli, s as selfImproveLoopRunner } from './loop-runner-bin-D-K6bRp3.js';
+export { E as EvalRunEvent, b as EvalRunGeneration, c as EvalRunsExportConfig, d as EvalRunsExportResult, I as INTELLIGENCE_WIRE_VERSION, e as OtelAttribute, f as OtelExportConfig, O as OtelExporter, g as OtelSpan, h as buildLoopOtelSpans, i as createOtelExporter, j as exportEvalRuns, l as loopEventToOtelSpan, m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './otel-export-nurzFwuJ.js';
+import { R as RuntimeHooks } from './runtime-hooks-C7JwKb9E.js';
+export { b as RuntimeDecisionEvidenceRef, c as RuntimeDecisionKind, d as RuntimeDecisionPoint, e as RuntimeHookContext, f as RuntimeHookErrorContext, a as RuntimeHookEvent, g as RuntimeHookPhase, h as RuntimeHookTarget, i as composeRuntimeHooks, j as defineRuntimeHooks, n as notifyRuntimeDecisionPoint, k as notifyRuntimeHookEvent } from './runtime-hooks-C7JwKb9E.js';
 import '@tangle-network/sandbox';
 import '@tangle-network/agent-eval/campaign';
+import '@tangle-network/agent-eval/contract';
 import './types-p8dWBIXL.js';
-import './optimize-prompt-D-urF2wW.js';
-import './dynamic-wUgp6UKs.js';
-import './kb-gate-D0ZIhFOU.js';
-import './profiles.js';
+import './kb-gate-2Gwpz_27.js';
+import './coder-DCWFQpmJ.js';
+import './substrate-CUgk7F7s.js';
+import './driver-C-mtBo7h.js';
 
 /**
  * @stable
@@ -1295,4 +1298,114 @@ declare function readinessServerSentEvent(report: KnowledgeReadinessReport, opti
 /** @stable */
 declare function runtimeStreamServerSentEvent(event: RuntimeStreamEvent, options?: RuntimeTelemetryOptions & ServerSentEventOptions): string;
 
-export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, PlannerError, type PropagatedHeaders, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RuntimeEventCollector, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, getModels, handleChatTurn, isDepthExceeded, makePerAttemptSignal, readDepth, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, turnId, validateChatModelId };
+/**
+ * Bounded turn-level tool-dispatch loop.
+ *
+ * `runAgentTaskStream` runs ONE model turn; `runLoop` orchestrates DELEGATED
+ * multi-agent topologies (refine / fanout-vote). Neither is the everyday
+ * interactive shape: a chat turn where the model may emit tool calls, each is
+ * executed, the results are folded back, and the turn re-runs until the model
+ * stops (or a turn cap). Every agent app hand-rolls that loop — this is it,
+ * as a reusable primitive.
+ *
+ * Substrate-neutral by design: the caller supplies `streamTurn` (wrapping
+ * whatever backend / `runAgentTaskStream` it uses) and `executeToolCall`
+ * (routing to its executors). This module owns the LOOP; the caller owns the
+ * model and the executors. `Raw` (streaming variant) is the caller's own
+ * event type. The only imported contract is the runtime hook type: hooks are
+ * execution-scoped observers, not part of the agent profile.
+ */
+
+interface ToolLoopCall {
+    toolCallId?: string;
+    toolName: string;
+    args: Record<string, unknown>;
+}
+/** Outcome of one tool dispatch — structurally compatible with a hub/integration
+ *  tool-outcome union, so callers can fold either through the loop. */
+type ToolCallOutcome = {
+    ok: true;
+    result: unknown;
+} | {
+    ok: false;
+    code: string;
+    message: string;
+    status?: number;
+};
+type ToolLoopMessage = {
+    role: string;
+    content: string;
+};
+type ToolLoopEvent = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'tool_call';
+    call: ToolLoopCall;
+} | {
+    type: 'other';
+    event: unknown;
+};
+interface ToolLoopResult {
+    finalText: string;
+    toolResults: Array<{
+        call: ToolLoopCall;
+        label: string;
+        outcome: ToolCallOutcome;
+    }>;
+    turns: number;
+    cappedOut: boolean;
+}
+interface RunToolLoopOptions {
+    systemPrompt: string;
+    userMessage: string;
+    priorMessages?: ToolLoopMessage[];
+    streamTurn: (messages: ToolLoopMessage[]) => AsyncIterable<ToolLoopEvent>;
+    executeToolCall: (call: ToolLoopCall) => Promise<ToolCallOutcome>;
+    isExecutableTool: (toolName: string) => boolean;
+    maxToolTurns?: number;
+    renderResult?: (label: string, outcome: ToolCallOutcome) => string;
+    labelFor?: (call: ToolLoopCall) => string;
+    runId?: string;
+    scenarioId?: string;
+    hooks?: RuntimeHooks;
+}
+/** Run the bounded tool loop and return the final text + every executed tool
+ *  outcome. Awaitable — callers needing to stream events to a UI use
+ *  {@link streamToolLoop}. */
+declare function runToolLoop(opts: RunToolLoopOptions): Promise<ToolLoopResult>;
+type StreamToolLoopYield<Raw> = {
+    kind: 'event';
+    event: Raw;
+} | {
+    kind: 'tool_result';
+    toolName: string;
+    toolCallId?: string;
+    label: string;
+    outcome: ToolCallOutcome;
+} | {
+    kind: 'capped';
+    pending: number;
+};
+interface StreamToolLoopOptions<Raw> {
+    systemPrompt: string;
+    userMessage: string;
+    priorMessages?: ToolLoopMessage[];
+    streamTurn: (messages: ToolLoopMessage[]) => AsyncIterable<Raw>;
+    extractText: (event: Raw) => string;
+    extractToolCall: (event: Raw) => ToolLoopCall | null;
+    isExecutableTool: (toolName: string) => boolean;
+    executeToolCall: (call: ToolLoopCall) => Promise<ToolCallOutcome>;
+    maxToolTurns?: number;
+    renderResult?: (label: string, outcome: ToolCallOutcome) => string;
+    labelFor?: (call: ToolLoopCall) => string;
+    runId?: string;
+    scenarioId?: string;
+    hooks?: RuntimeHooks;
+}
+/** Streaming bounded tool loop: yields each raw turn event (the caller maps +
+ *  telemetries + re-emits it) and each executed `tool_result`; emits one
+ *  `capped` if it stops at the turn limit with calls still pending. */
+declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
+
+export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, PlannerError, type PropagatedHeaders, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, getModels, handleChatTurn, isDepthExceeded, makePerAttemptSignal, readDepth, readinessServerSentEvent, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, turnId, validateChatModelId };