@tangle-network/agent-runtime 0.89.0 → 0.90.1

package/dist/environment-provider.d.ts

@@ -1,9 +1,9 @@
 import { AgentProfile, AgentProfileValidationResult } from '@tangle-network/agent-interface';
-import { AgentEnvironmentProvider, AgentEnvironmentCapabilities, CreateAgentEnvironmentInput, AgentTurnInput, AgentProfileRef } from '@tangle-network/agent-interface/environment-provider';
+import { CreateAgentEnvironmentInput, AgentTurnInput, AgentEnvironmentProvider, AgentEnvironmentCapabilities, AgentProfileRef } from '@tangle-network/agent-interface/environment-provider';
 export { AgentEnvironment, AgentEnvironmentCapabilities, AgentEnvironmentEvent, AgentEnvironmentProvider, AgentEnvironmentQuery, AgentEnvironmentStatus, AgentEnvironmentSummary, AgentProfileRef, AgentSession, AgentSessionRef, AgentSessionStatus, AgentTurnInput, AgentTurnResult, CheckpointRef, CheckpointRequest, CreateAgentEnvironmentInput, ExecRequest, ExecResult, ForkRequest, PlacementInfo, ResourceRequest, WorkspaceRequest } from '@tangle-network/agent-interface/environment-provider';
 import { CreateSandboxOptions, BackendType } from '@tangle-network/sandbox';
-import { R as Runtime, E as ExecutorFactory } from './types-Driepl87.js';
-import { S as SandboxClient } from './types-ESeMOj94.js';
+import { R as Runtime, E as ExecutorFactory } from './types-eMNgWgFi.js';
+import { S as SandboxClient } from './types-SyuwunY_.js';
 import '@tangle-network/agent-eval';
 
 /** Provider object or registry name accepted by runtime provider adapters.

package/dist/index.d.ts

@@ -1,24 +1,32 @@
 import { AgentProfile, AgentEvalError, AnalystFinding, 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 { f as AgentBackendInput, O as OpenAIChatTool, g as OpenAIChatToolChoice, h as OpenAIChatResponseFormat, i as AgentExecutionBackend, j as AgentBackendContext, a 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, R as RuntimeHooks } from './types-ESeMOj94.js';
-export { r as AgentAdapter, s as AgentKnowledgeProvider, t as AgentRuntimeEventSink, u as AgentTaskContext, v as AgentTaskSpec, B as BackendErrorDetail, w as RuntimeDecisionEvidenceRef, x as RuntimeDecisionKind, y as RuntimeDecisionPoint, z as RuntimeHookContext, C as RuntimeHookErrorContext, D as RuntimeHookEvent, F as RuntimeHookPhase, G as RuntimeHookTarget, H as RuntimeRunHandle, J as RuntimeRunPersistenceAdapter, M as RuntimeRunRow, N as composeRuntimeHooks, P as defineRuntimeHooks, Q as notifyRuntimeDecisionPoint, T as notifyRuntimeHookEvent, U as startRuntimeRun } from './types-ESeMOj94.js';
-import { Scenario, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
-import { C as CandidateGenerator } from './mcp-serve-verifier-FL7-ZEb_.js';
-export { A as AgenticGeneratorOptions, I as ImprovementDriverOptions, M as McpServeSpec, V as Verifier, a as VerifyResult, b as agenticGenerator, c as commandVerifier, i as improvementDriver, m as mcpServeVerifier } from './mcp-serve-verifier-FL7-ZEb_.js';
-import { Scenario as Scenario$1, SurfaceProposer, JudgeConfig, MutableSurface, DispatchContext, SelfImproveBudget, SelfImproveLlm, SelfImproveResult } from '@tangle-network/agent-eval/contract';
+import { g as AgentBackendInput, O as OpenAIChatTool, h as OpenAIChatToolChoice, i as OpenAIChatResponseFormat, j as AgentExecutionBackend, k as AgentBackendContext, b as RuntimeStreamEvent, K as KnowledgeReadinessDecision, l as RunAgentTaskOptions, m as AgentTaskRunResult, n as RunAgentTaskStreamOptions, o as AgentRuntimeEvent, p as AgentTaskStatus, q as RuntimeSessionStore, r as RuntimeSession, R as RuntimeHooks } from './types-SyuwunY_.js';
+export { s as AgentAdapter, t as AgentKnowledgeProvider, u as AgentRuntimeEventSink, v as AgentTaskContext, w as AgentTaskSpec, B as BackendErrorDetail, x as RuntimeDecisionEvidenceRef, y as RuntimeDecisionKind, z as RuntimeDecisionPoint, C as RuntimeHookContext, F as RuntimeHookErrorContext, G as RuntimeHookEvent, H as RuntimeHookPhase, J as RuntimeHookTarget, M as RuntimeRunHandle, N as RuntimeRunPersistenceAdapter, P as RuntimeRunRow, Q as composeRuntimeHooks, T as defineRuntimeHooks, U as notifyRuntimeDecisionPoint, W as notifyRuntimeHookEvent, X as startRuntimeRun } from './types-SyuwunY_.js';
+import { Scenario, ProfileDispatchFn, MutableSurface as MutableSurface$1, SurfaceProposer as SurfaceProposer$1 } from '@tangle-network/agent-eval/campaign';
+import { V as Verifier, C as CandidateGenerator } from './mcp-serve-verifier-XsX8rkB9.js';
+export { A as AgenticGeneratorOptions, I as ImprovementDriverOptions, M as McpServeSpec, a as VerifyResult, b as agenticGenerator, c as commandVerifier, i as improvementDriver, m as mcpServeVerifier } from './mcp-serve-verifier-XsX8rkB9.js';
+import { Scenario as Scenario$1, SurfaceProposer, JudgeConfig, MutableSurface, DispatchContext, SelfImproveBudget, SelfImproveLlm, SelfImproveOptions, SelfImproveResult } from '@tangle-network/agent-eval/contract';
 import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
+import { L as LocalHarness } from './local-harness-dcD5WTTr.js';
 import { S as SurfaceImprovementEdit } from './improvement-adapter-CDR8QNVM.js';
 import { I as ImprovementAdapter } from './types-BC3bZpH0.js';
-export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-hQDUL8Ld.js';
-export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-BnrOmGjN.js';
-export { E as EvalRunEvent, a as EvalRunGeneration, b as EvalRunsExportConfig, c as EvalRunsExportResult, I as INTELLIGENCE_WIRE_VERSION, L as LoopSpanNode, d as OtelAttribute, e as OtelExportConfig, O as OtelExporter, f as OtelSpan, g as buildLoopOtelSpans, h as buildLoopSpanNodes, i as createOtelExporter, j as exportEvalRuns, l as loopEventToOtelSpan } from './otel-export-BKmNwiCb.js';
+import { S as StructuralRolloutPolicy } from './structural-rollout-MwlpgQ-6.js';
+export { AgentKnowledgeReadinessCheckOptions, KnowledgeImprovementJobMeasurement, KnowledgeImprovementJobResult, KnowledgeReadinessCheck, KnowledgeReadinessCheckInput, KnowledgeReadinessCheckResult, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, RunKnowledgeImprovementJobOptions, SupervisedKnowledgeUpdateInput, SupervisedKnowledgeUpdateOptions, SupervisedKnowledgeUpdateResult, SupervisedKnowledgeUpdater, createAgentKnowledgeReadinessCheck, createSupervisedKnowledgeUpdater, formatSupervisedKnowledgeTask, knowledgeReadinessDeliverable, runKnowledgeImprovementJob, runSupervisedKnowledgeUpdate } from './knowledge.js';
+export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-DTbZVGfM.js';
+export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-C4ZfUD4L.js';
+export { b0 as EvalRunEvent, b1 as EvalRunGeneration, b2 as EvalRunsExportConfig, b3 as EvalRunsExportResult, b4 as INTELLIGENCE_WIRE_VERSION, b5 as LoopSpanNode, b6 as OtelAttribute, b7 as OtelExportConfig, b8 as OtelExporter, b9 as OtelSpan, ba as buildLoopOtelSpans, bb as buildLoopSpanNodes, bc as createOtelExporter, bd as exportEvalRuns, be as loopEventToOtelSpan } from './coordination-rRj5hjJK.js';
 import '@tangle-network/sandbox';
-import './local-harness-sI0S_XNA.js';
 import 'node:child_process';
+import './worktree-fanout-BDFQIO-Y.js';
+import './types-eMNgWgFi.js';
+import './completion-gate-DkAnUmpb.js';
+import '@tangle-network/agent-knowledge';
+import './supervise-DPmYPk0j.js';
+import './router-client-DJImUDlm.js';
 import './kb-gate-CwHO0vz6.js';
-import './types-Driepl87.js';
-import './worktree-fanout-D6xR2CIA.js';
-import './worktree-harness-CX_McRLp.js';
+import './substrate-DO2GHNg2.js';
+import './environment-provider.js';
+import '@tangle-network/agent-interface/environment-provider';
 
 /**
  *
@@ -1175,6 +1183,11 @@ declare function mcpBuildPrompt(args: FindingsArg): string;
  *
  *   - `surface: 'prompt'` → `gepaProposer` mutates `profile.prompt.systemPrompt`.
  *   - `surface: 'skills'` → `skillOptProposer` mutates a skills document string.
+ *   - `surface: 'rollout-policy'` → `rolloutPolicyProposer` mutates the
+ *     inference-time `StructuralRolloutPolicy` dials ({ k, repairRounds, testgen })
+ *     persisted in `profile.extensions['structural-rollout']` — deterministic
+ *     bounded neighbor enumeration; the held-out gate does the deciding. No-op
+ *     (nothing proposed, nothing shipped) when the profile has no such extension.
  *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `code`} → no zero-config default
  *     proposer exists (a code/config proposer needs caller-supplied wiring — a
  *     worktree repo root, a candidate generator, a serializer). The facade
@@ -1189,8 +1202,10 @@ declare function mcpBuildPrompt(args: FindingsArg): string;
  */
 
 /** The agent-profile lever `improve` optimizes. Mirrors the AgentProfile-law
- *  profile levers; `code` is the implementation-tier surface. */
-type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'code';
+ *  profile levers; `code` is the implementation-tier surface, `rollout-policy`
+ *  the inference-time structuralRollout dials
+ *  (`profile.extensions['structural-rollout']`). */
+type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'code' | 'rollout-policy';
 interface ImproveOptions<TScenario extends Scenario$1, TArtifact> {
     /** Which profile lever to optimize. Default `'prompt'`. Selects the default
      *  generator + the baseline-surface extraction shape. */
@@ -1218,6 +1233,73 @@ interface ImproveOptions<TScenario extends Scenario$1, TArtifact> {
      *  (`llm.model`, or the default when unset) must be a member, or `improve()` throws
      *  a `ConfigError` before the generator is built. Unset = unrestricted. */
     allowedModels?: readonly string[];
+    /** Run directory passthrough to `selfImprove`. Pass a REAL path to make the loop
+     *  durable: campaign cells + the loop provenance record land on the filesystem as
+     *  they complete, so a multi-hour search survives a process/infra death instead of
+     *  losing every generation with it (the default `mem://` run keeps everything
+     *  in-process). */
+    runDir?: string;
+    /** Per-generation findings producer passthrough (see selfImprove.analyzeGeneration).
+     *  DEFAULT: the built-in failure distiller — after each generation it turns the
+     *  worst-scoring/errored cells into structured findings ({ scenario, composite,
+     *  notes, error }) for the NEXT proposal round, so the proposer reasons over what
+     *  actually failed instead of a static seed. Pass your own producer (e.g. a
+     *  trace-analyst over the runDir's traces) to replace it; pass `null` to disable
+     *  and keep the static `findings` all the way through. */
+    analyzeGeneration?: SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration'] | null;
+    /** META-HARNESS mode: instead of the ~400-char distilled findings, feed the
+     *  proposer RAW-TRACE FILESYSTEM CONTEXT — the PATHS into the prior generation's
+     *  real run traces under `runDir` (per-cell `spans.jsonl` event logs +
+     *  `cached-result.json` scores + artifacts) plus a `grep`/`cat`-to-diagnose
+     *  instruction — so the coding agent reads the actual failures itself rather than
+     *  a pre-summary. Requires a REAL `runDir` (that is where the traces live).
+     *  Ignored when `analyzeGeneration` is set explicitly (that wins) or is `null`
+     *  (disabled). Equivalent to `analyzeGeneration: rawTraceDistiller()`; this flag
+     *  is the one-line enable. Default `false` (the distiller stays the default). */
+    rawTraceContext?: boolean;
+    /** CODE-surface wiring with prompt-parity DX: name `surface: 'code'`, point at a
+     *  repo, and the facade assembles the whole candidate pipeline — git worktrees
+     *  (`gitWorktreeAdapter`) driven by `improvementDriver` with the full agentic
+     *  generator (a real coding harness edits each candidate worktree; a `verify`
+     *  hook gates candidates before they are ever measured). Ignored when
+     *  `opts.generator` is supplied. Without either, `surface: 'code'` still fails
+     *  loud — there is no safe zero-config repo to invent. */
+    code?: ImproveCodeOptions;
+    /** SKILLS-surface wiring for real skill-DOCUMENT optimization. Without this,
+     *  `surface: 'skills'` optimizes the profile's skills REFS array (file pointers)
+     *  — which `skillOptProposer` (a document patcher) cannot meaningfully edit.
+     *  Provide the document CONTENT to optimize + a `writeBack` to persist the
+     *  shipped winner (the profile ref points at a file the caller owns). This is
+     *  what makes skillOpt reachable through improve(). */
+    skills?: ImproveSkillsOptions;
+    /** Storage passthrough to `selfImprove`; overrides the default chosen from `runDir`. */
+    storage?: SelfImproveOptions<TScenario, TArtifact>['storage'];
+}
+interface ImproveSkillsOptions {
+    /** The skill document's current text — the baseline `skillOptProposer` patches. */
+    document: string;
+    /** Persist the shipped winner document (write the file the profile ref points at).
+     *  Called only on a ship verdict. When omitted, the winner is still returned in
+     *  `result.raw.winner.surface` for the caller to materialize. */
+    writeBack?: (winnerDocument: string) => void;
+}
+interface ImproveCodeOptions {
+    /** Repo root candidate worktrees fork from. */
+    repoRoot: string;
+    /** Base ref candidates fork from. Default `main`. */
+    baseRef?: string;
+    /** Directory worktrees are created under. Default `<repoRoot>/.worktrees`. */
+    worktreeDir?: string;
+    /** Coding harness the agentic generator runs in each worktree. Default `claude`. */
+    harness?: LocalHarness;
+    /** Verify a candidate worktree before it becomes a measurable surface; failures
+     *  feed the next shot (see `agenticGenerator.verify` / `commandVerifier`). */
+    verify?: Verifier;
+    /** Per-shot wall-clock timeout for the harness (ms). */
+    timeoutMs?: number;
+    /** Byte-producer override — the test seam and the escape hatch for custom
+     *  candidate production. When set, `harness`/`verify`/`timeoutMs` are unused. */
+    generator?: CandidateGenerator;
 }
 interface ImproveResult<TScenario extends Scenario$1, TArtifact> {
     /** The profile after improvement: the winner surface applied back into the
@@ -1247,6 +1329,75 @@ interface ImproveResult<TScenario extends Scenario$1, TArtifact> {
  */
 declare function improve<TScenario extends Scenario$1, TArtifact>(profile: AgentProfile$1, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
 
+/**
+ *
+ * `rawTraceDistiller` — the meta-harness `analyzeGeneration` producer.
+ *
+ * The default `generationFailureDistiller` (in `improve.ts`) COMPRESSES each
+ * generation's failing cells into ~400-char structured findings before the next
+ * proposal round. That is the ACE-style recipe: a small summary is the proposer's
+ * whole view of what went wrong. This producer does the opposite — the
+ * meta-harness recipe (yoonholee.com/meta-harness): it does NOT summarize. It
+ * points the coding-agent proposer at the generation's RAW run traces already on
+ * disk under `runDir` — the durable per-cell `spans.jsonl` event logs,
+ * `cached-result.json` scores, and any artifacts the substrate persisted — and
+ * instructs the agent to `grep`/`cat`/`ls` them to diagnose the failures itself
+ * (up to the harness's full context, ~millions of tokens, vs a ~400-char digest).
+ *
+ * It emits `AnalystFinding[]` so it drops into the SAME `opts.analyzeGeneration`
+ * slot the default distiller uses, and renders through the same
+ * `agenticGenerator` prompt path (`claim` + `recommended_action`). The findings
+ * carry ABSOLUTE paths — the coding harness runs with `cwd` = a candidate
+ * worktree, so a relative `runDir` would be uncattable from there.
+ *
+ * Runtime layout it reads (written by agent-eval's optimization loop):
+ *
+ *   <runDir>/gen-<N>/                     ← the generation dir (input.runDir)
+ *     candidate-<i>/                      ← one candidate campaign (campaign.runDir)
+ *       <sanitized cellId>/               ← one scenario×rep cell
+ *         spans.jsonl                     ← the raw trace (event/span log)
+ *         cached-result.json              ← the cell's score + artifact ref
+ *         <artifacts…>                    ← whatever the dispatch wrote
+ *
+ * @experimental
+ */
+
+interface RawTraceDistillerOptions {
+    /** Anchor the emitted paths at this run root instead of the generation `runDir`
+     *  the loop passes in. Normally unset — each call points at that generation's
+     *  own directory (`input.runDir`). Pass an absolute path when you construct the
+     *  producer ahead of the loop and want a fixed anchor (e.g. a test fixture). */
+    runDir?: string;
+    /** Max candidates to surface trace paths for, worst-scoring first. Default 12. */
+    maxCandidates?: number;
+    /** Max failing cells to enumerate per candidate before collapsing the rest into
+     *  an "ls the candidate dir" pointer. Default 8. */
+    maxCellsPerCandidate?: number;
+    /** Max concrete file paths to list per cell (the agent can always `ls` the dir
+     *  for the rest). Default 24. */
+    maxFilesPerCell?: number;
+    /** Findings to fall back to when the generation had NO failing cells, so a
+     *  clean round never wipes the proposer's steering context. Mirrors the default
+     *  distiller's static-seed fallback. Default: a single instruction finding. */
+    fallbackFindings?: unknown[];
+}
+/**
+ * Build an `analyzeGeneration` producer that feeds the proposer RAW-TRACE
+ * FILESYSTEM CONTEXT — paths into the prior generation's real run traces plus a
+ * grep/cat-to-diagnose instruction — instead of a pre-summarized digest.
+ *
+ * Drop-in for `opts.analyzeGeneration` on `improve()` / `selfImprove()`:
+ *
+ *   await improve(profile, seedFindings, {
+ *     surface: 'code',
+ *     code: { repoRoot },
+ *     runDir: '/abs/run',                 // MUST be a real path — the traces live here
+ *     analyzeGeneration: rawTraceDistiller(),
+ *     scenarios, judge, agent,
+ *   })
+ */
+declare function rawTraceDistiller<TScenario extends Scenario$1 = Scenario$1, TArtifact = unknown>(options?: RawTraceDistillerOptions): NonNullable<SelfImproveOptions<TScenario, TArtifact>['analyzeGeneration']>;
+
 /**
  *
  * `reflectiveGenerator` — the cheap, no-sandbox `CandidateGenerator`. It drafts
@@ -1268,6 +1419,94 @@ interface ReflectiveGeneratorOptions {
 /** Cheap no-sandbox `CandidateGenerator` (the `shots=1` setting): draft surface edits via the improvement adapter and apply them as one coherent candidate. */
 declare function reflectiveGenerator(opts: ReflectiveGeneratorOptions): CandidateGenerator;
 
+/**
+ * `rolloutPolicyProposer` — the `'rollout-policy'` surface for `improve()`: the
+ * inference-time `StructuralRolloutPolicy` dials { k, repairRounds, testgen } as a
+ * held-out-gated optimizable surface.
+ *
+ * Why this seam: agent-eval's loop contract is already generic — `MutableSurface`
+ * admits any string, documented as "serialized tool config" — so the policy rides
+ * the SAME serialize→propose→gate→parse-back cycle the tools/mcp/hooks surfaces
+ * use. No agent-eval changes; the only net-new piece is this proposer.
+ *
+ * Why deterministic: prompt-wording proposals are a measured zero on this stack,
+ * and the policy space is tiny and fully enumerable. The proposer emits bounded
+ * single-dial neighbors (k±2 in [1,10], repairRounds±1 in [0,3], testgen±3 in
+ * [0,10], ≤4 per generation) and lets the held-out gate do ALL the deciding — an
+ * LLM proposer would add cost and nondeterminism with nothing to reason about.
+ *
+ * Persistence: the policy lives in `profile.extensions['structural-rollout']`
+ * (AgentProfile's designed slot for runtime-specific config). A gated winner is
+ * written back there by `improve()`, the same profile-field write-back every other
+ * config surface gets; `structuralRolloutPolicyFromProfile` is the read side a
+ * runtime caller feeds to `structuralRollout({ policy })`.
+ *
+ * @experimental
+ */
+
+/** The profile extensions namespace the policy persists under. */
+declare const ROLLOUT_POLICY_EXTENSION = "structural-rollout";
+/** Proposal bounds per dial. These are the SEARCH bounds (what the proposer may
+ *  explore), chosen so every reachable value is a measured-sane recipe: k=1 is the
+ *  low-compute preset, testgen=0 disables check authoring, repairRounds caps where
+ *  the measured increment flattens (+1–3pp beyond round 2). */
+declare const ROLLOUT_POLICY_BOUNDS: {
+    readonly k: {
+        readonly min: 1;
+        readonly max: 10;
+        readonly step: 2;
+    };
+    readonly repairRounds: {
+        readonly min: 0;
+        readonly max: 3;
+        readonly step: 1;
+    };
+    readonly testgen: {
+        readonly min: 0;
+        readonly max: 10;
+        readonly step: 3;
+    };
+};
+/** Parse a serialized policy surface. Defensive by design — the proposer reads
+ *  `ctx.currentSurface`, which the loop types as `string | CodeSurface`. Returns
+ *  `undefined` (never throws) for non-strings, malformed JSON, or a shape that
+ *  violates the policy's own invariants: the no-op signal. Unknown dials are
+ *  dropped; `diverse`/`temperature` ride through untouched (the proposer never
+ *  mutates them — `diverse` is a measured paired null). */
+declare function parseRolloutPolicy(surface: MutableSurface$1): StructuralRolloutPolicy | undefined;
+/** Normalize an untyped policy bag (a parsed surface or a profile extension) into
+ *  a full `StructuralRolloutPolicy`, defaults merged. Returns `undefined` when any
+ *  present dial violates the policy invariants (mirrors `resolvePolicy`: integer
+ *  k ≥ 1, repairRounds ≥ 0, testgen ≥ 0) — a corrupt config must read as "not
+ *  configured", never as a fabricated recipe. */
+declare function normalizeRolloutPolicy(raw: unknown): StructuralRolloutPolicy | undefined;
+/** Stable serialization — dial order is fixed so identical policies produce
+ *  identical surfaces (the loop dedupes/hashes candidates by surface content). */
+declare function serializeRolloutPolicy(policy: StructuralRolloutPolicy): string;
+/** Read the persisted policy off the profile. `undefined` when the profile does
+ *  not opt into structural rollout — the improve() surface no-ops then, because
+ *  tuning dials nothing consumes would ship dead config. */
+declare function structuralRolloutPolicyFromProfile(profile: AgentProfile$1): StructuralRolloutPolicy | undefined;
+/** Persist a policy into the profile's extensions namespace. Shallow copy; never
+ *  mutates the input profile (the applyWinnerToProfile contract). */
+declare function applyRolloutPolicyToProfile(profile: AgentProfile$1, policy: StructuralRolloutPolicy): AgentProfile$1;
+/** All bounded single-dial neighbors of `policy`, in a fixed priority order: k
+ *  first (selection breadth carries 85–92% of the measured effect), then
+ *  repairRounds, then testgen. Steps clamp to the dial's bounds; clamped-to-no-op
+ *  and duplicate policies are dropped. */
+declare function enumerateNeighborPolicies(policy: StructuralRolloutPolicy): StructuralRolloutPolicy[];
+/**
+ * The deterministic `SurfaceProposer` for the `'rollout-policy'` surface.
+ *
+ * Each generation: parse the current policy surface, enumerate its bounded
+ * single-dial neighbors, and return at most `min(populationSize, 4)` of them,
+ * rotating the enumeration window by generation so successive generations explore
+ * different neighbors when nothing promoted. Proposes NOTHING when the surface
+ * carries no policy (the profile never opted in) — an empty proposal is the
+ * loop-native no-op, mirroring `improvementDriver`'s no-findings behavior.
+ */
+declare function rolloutPolicyProposer(): SurfaceProposer$1;
+
 /**
  *
  * Chat-model resolution + catalog validation — the shared primitive every
@@ -1802,4 +2041,4 @@ interface StreamToolLoopOptions<Raw> {
  *  `capped` if it stops for any non-completed reason with calls still pending. */
 declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
 
-export { AgentBackendContext, AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, 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, type ImproveOptions, type ImproveResult, type ImproveSurface, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatResponseFormat, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, getModels, handleChatTurn, improve, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, toolBuildPrompt, turnId, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, 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, type ImproveOptions, type ImproveResult, type ImproveSurface, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatResponseFormat, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, ROLLOUT_POLICY_BOUNDS, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, Verifier, applyRolloutPolicyToProfile, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, enumerateNeighborPolicies, getModels, handleChatTurn, improve, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, normalizeRolloutPolicy, parseRolloutPolicy, rawTraceDistiller, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, rolloutPolicyProposer, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, serializeRolloutPolicy, sleep, slugifySpeaker, streamToolLoop, structuralRolloutPolicyFromProfile, toolBuildPrompt, turnId, validateChatModelId };