@tangle-network/agent-runtime 0.102.0 → 0.102.2

package/dist/{completion-gate-C80jiRfN.d.ts → completion-gate-C6dhVN-N.d.ts}

@@ -1,6 +1,6 @@
 import { WorkspacePlanReceipt } from '@tangle-network/agent-profile-materialize';
-import { L as LocalHarness, C as CodexTokenUsage, c as CodexExecutionPolicy } from './local-harness-ZqCx51u7.js';
-import { c as Executor } from './types-CmnA2iL3.js';
+import { L as LocalHarness, C as CodexTokenUsage, c as CodexExecutionPolicy } from './local-harness-CtK9dSny.js';
+import { c as Executor } from './types-D870JlH0.js';
 
 /**
  *

package/dist/{coordination-BFE3Den7.d.ts → coordination-D9l_YmwW.d.ts}

@@ -1,13 +1,13 @@
-import { E as ExecutorFactory, e as ExecutorRegistry, i as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-CmnA2iL3.js';
+import { E as ExecutorFactory, h as ExecutorRegistry, e as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-D870JlH0.js';
 import { AgentProfile } from '@tangle-network/agent-interface';
-import { U as UiLens, a as UiFinding, C as CoderTask } from './substrate-DO2GHNg2.js';
-import { S as SandboxClient, E as ExecCtx, r as LoopTraceEmitter, b as LoopTraceEvent, A as AgentRunSpec } from './types-B3vAW0Oq.js';
+import { a as UiLens, U as UiFinding, C as CoderTask } from './substrate-Dyiqmd3o.js';
+import { S as SandboxClient, E as ExecCtx, d as LoopTraceEmitter, c as LoopTraceEvent, A as AgentRunSpec } from './types-CLat4bT9.js';
 import { BackendType, SandboxEvent, SandboxInstance } from '@tangle-network/sandbox';
 import { AgentEvalError } from '@tangle-network/agent-eval';
-import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-BTSsdBXw.js';
+import { b as ToolSpec, c as RuntimeTelemetryOptions, R as RouterConfig } from './sanitize-DEbPNtyI.js';
 import { R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
-import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-C80jiRfN.js';
-import { L as LocalHarness } from './local-harness-ZqCx51u7.js';
+import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-C6dhVN-N.js';
+import { L as LocalHarness } from './local-harness-CtK9dSny.js';
 import { ProviderExecutorOptions, AgentEnvironmentProviderRegistry } from './environment-provider.js';
 import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/environment-provider';
 

package/dist/environment-provider.d.ts

@@ -2,8 +2,8 @@ import { AgentProfile, AgentProfileValidationResult } from '@tangle-network/agen
 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-CmnA2iL3.js';
-import { S as SandboxClient } from './types-B3vAW0Oq.js';
+import { R as Runtime, E as ExecutorFactory } from './types-D870JlH0.js';
+import { S as SandboxClient } from './types-CLat4bT9.js';
 import '@tangle-network/agent-eval';
 import './types-BwoZWq-i.js';
 

package/dist/{improve-CIml6hT3.d.ts → improve-B40dRu0X.d.ts}

@@ -1,7 +1,7 @@
 import { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
 import { Scenario, SelfImproveOptions, SurfaceProposer as SurfaceProposer$1, MutableSurface, SelfImproveResult } from '@tangle-network/agent-eval/contract';
 import { AgentProfile, ReasoningEffort } from '@tangle-network/agent-interface';
-import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, b as LocalHarnessResult, r as runLocalHarness } from './local-harness-ZqCx51u7.js';
+import { L as LocalHarness, C as CodexTokenUsage, a as CodexExecutionEvidence, b as LocalHarnessResult, r as runLocalHarness } from './local-harness-CtK9dSny.js';
 import { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
 
 /**
@@ -135,7 +135,7 @@ interface VerifyResult {
 /** Verifies the edited worktree. Sync or async; throws only on a setup fault
  *  (a candidate that fails verification returns `{ok:false}`, it does not
  *  throw). */
-type Verifier = (worktreePath: string) => Promise<VerifyResult> | VerifyResult;
+type Verifier = (worktreePath: string, signal?: AbortSignal) => Promise<VerifyResult> | VerifyResult;
 interface AgenticGeneratorShotReceipt {
     readonly generation: number | null;
     readonly candidateIndex: number | null;
@@ -151,6 +151,8 @@ interface AgenticGeneratorShotReceipt {
     readonly durationMs: number;
     readonly exitCode: number | null;
     readonly timedOut: boolean;
+    /** True when caller cancellation reached the author process; absent in older receipts. */
+    readonly aborted?: boolean;
     readonly killedBySignal: NodeJS.Signals | null;
     readonly stdoutBytes: number | null;
     readonly stdoutSha256: `sha256:${string}` | null;
@@ -254,6 +256,12 @@ interface AgenticGeneratorOptions {
 }
 /** Full-agentic `CandidateGenerator` (the `shots=N, sandbox=on` setting): run a real coding harness inside the candidate worktree so the agent makes the change in place. */
 declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGenerator;
+/** Turn the analyst's findings (+ optional report) into a concrete coder task —
+ *  the senior scientific-method framing shared with the tool/MCP build prompts. */
+declare function defaultBuildPrompt(args: {
+    report: unknown;
+    findings: AnalystFinding[];
+}): string;
 /** A `Verifier` that runs a command in the worktree: exit 0 ⇒ ok, any other
  *  exit ⇒ failed with stdout+stderr as feedback. The common case — verify by
  *  `tsc --noEmit`, `pnpm build`, or a test command. A timeout is treated as a
@@ -278,6 +286,11 @@ declare function commandVerifier(command: string, args?: string[], timeoutMs?: n
  *   - `surface: 'skills'` → `skillOptProposer` mutates one named inline skill.
  *   - `surface: 'memory'` → `memoryCurationProposer` curates the profile's
  *     additional instructions as bounded durable lessons.
+ *   - `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: 'agent-profile'` → caller-supplied proposer mutates the complete
  *     canonical AgentProfile JSON in one candidate.
  *   - `surface` ∈ {`tools`, `mcp`, `hooks`, `subagents`, `agent-profile`} → no zero-config default
@@ -297,8 +310,10 @@ declare function commandVerifier(command: string, args?: string[], timeoutMs?: n
 
 /** The executable agent lever `improve` optimizes. Profile fields remain
  *  portable AgentProfile coordinates; implementation and orchestration files
- *  use the code surface so a winner can be sealed into an exact candidate. */
-type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code';
+ *  use the code surface so a winner can be sealed into an exact candidate.
+ *  `rollout-policy` is the inference-time structuralRollout dials
+ *  (`profile.extensions['structural-rollout']`). */
+type ImproveSurface = 'prompt' | 'skills' | 'tools' | 'mcp' | 'hooks' | 'subagents' | 'agent-profile' | 'memory' | 'code' | 'rollout-policy';
 type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOptions<TScenario, TArtifact>, 'analyzeGeneration' | 'baselineSurface' | 'findings' | 'gate' | 'proposer'> & {
     /** Which profile lever to optimize. Default `'prompt'`. Selects the default
      *  generator + the baseline-surface extraction shape. */
@@ -316,22 +331,26 @@ type ImproveOptions<TScenario extends Scenario, TArtifact> = Omit<SelfImproveOpt
      *  a `ConfigError` before the generator is built. Unset = unrestricted. */
     allowedModels?: readonly 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. */
+     *  DEFAULT: with a real (non-`mem://`) `runDir`, the raw-trace distiller
+     *  (`rawTraceDistiller`) — typed `AnalystFinding`s pointing the proposer at the
+     *  prior generation's actual on-disk traces; for in-memory runs (no traces on
+     *  disk to point at), the built-in failure distiller — the worst-scoring/errored
+     *  cells distilled into typed `AnalystFinding`s for the NEXT proposal round.
+     *  Pass your own producer to replace either; 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 ~1500-char distilled findings, feed the
-     *  proposer RAW-TRACE FILESYSTEM CONTEXT — the PATHS into the prior generation's
+    /** META-HARNESS mode: instead of the 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). */
+     *  a pre-summary. Unset (default): raw-trace findings whenever the run is durable
+     *  (a real `runDir` — that is where the traces live), the distilled failure digest
+     *  otherwise; the `memory` surface always defaults to its curation distiller.
+     *  `true` forces `rawTraceDistiller()` even for an in-memory run (it emits a loud
+     *  warning finding instead of paths); `false` forces the digest distiller even
+     *  with a real `runDir`. Ignored when `analyzeGeneration` is set explicitly
+     *  (that wins) or is `null` (disabled). */
     rawTraceContext?: boolean;
     /** CODE-surface wiring: name `surface: 'code'`, point at a repo, and the
      *  facade assembles the whole candidate pipeline — an isolated incumbent plus git worktrees
@@ -385,8 +404,10 @@ interface ImproveResult<TScenario extends Scenario, TArtifact> {
     candidate: ImprovementCandidate;
     /** Held-out decision for this search result. */
     decision: SelfImproveResult<TScenario, TArtifact>['gateDecision'];
-    /** Held-out lift (`winner − baseline` composite). */
-    lift: number;
+    /** Held-out lift (`winner − baseline` composite). Absent iff
+     *  `budget.holdout === 'deferred'` — no held-out measurement ran, so there
+     *  is no lift to report (never a fabricated 0). */
+    lift?: number;
     /** Full `selfImprove` result for advanced inspection. For code runs,
      *  `raw.winner.surface.worktreeRef` remains live after return whether the
      *  candidate passed or held; call `dispose()` after consuming it. */
@@ -410,4 +431,4 @@ interface ImproveResult<TScenario extends Scenario, TArtifact> {
  */
 declare function improve<TScenario extends Scenario, TArtifact>(profile: AgentProfile, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
 
-export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImproveOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type ImproveResult as a, type AgenticGeneratorOptions as b, type AgenticGeneratorShotDisposition as c, type AgenticGeneratorShotExecution as d, type AgenticGeneratorShotReceipt as e, type ImproveCodeOptions as f, type ImproveSkillsOptions as g, type ImproveSurface as h, type ImprovementCandidate as i, type ImprovementDriverOptions as j, type VerifyResult as k, agenticGenerator as l, commandVerifier as m, improve as n, improvementDriver as o };
+export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImproveOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type ImproveResult as a, type AgenticGeneratorOptions as b, type AgenticGeneratorShotDisposition as c, type AgenticGeneratorShotExecution as d, type AgenticGeneratorShotReceipt as e, type ImproveCodeOptions as f, type ImproveSkillsOptions as g, type ImproveSurface as h, type ImprovementCandidate as i, type ImprovementDriverOptions as j, type VerifyResult as k, agenticGenerator as l, commandVerifier as m, defaultBuildPrompt as n, improve as o, improvementDriver as p };

package/dist/index.d.ts

@@ -6,37 +6,38 @@ export { AGENT_CANDIDATE_EXECUTION_SUPPORT, AgentCandidateBundleInput, AgentCand
 export { a as AgentCandidateExecutionAttemptRecord, b as AgentCandidateExecutionAttemptRef, c as AgentCandidateExecutionClaim, d as AgentCandidateExecutionClaimResult, A as AgentCandidateExecutionClaimStore, e as AgentCandidateExecutionCleanupHandles, f as AgentCandidateExecutionFailureClass, g as AgentCandidateExecutionFinishResult, h as AgentCandidateExecutionLease, i as AgentCandidateExecutionPhase, j as AgentCandidateExecutionPhaseResult, k as AgentCandidateExecutionRecoveryEvidence, l as AgentCandidateExecutionStageResult, m as AgentCandidateExecutionTerminalRecord, n as AgentCandidateExecutionTerminalResult, o as AgentCandidatePreparationEvidence, q as AgentCandidateRetryRejection, E as ExecutePreparedAgentCandidateOptions, I as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, r as applyExactAgentProfileDiff, s as executePreparedAgentCandidate, t as parseExactAgentProfile, u as parseExactAgentProfileDiff, v as prepareAgentCandidateExecution } from './profile-DbfaMTdk.js';
 export { f as AgentCandidateArtifactPort, a as AgentCandidateBenchmarkGraderPort, g as AgentCandidateContainerPort, e as AgentCandidateExecutionPorts, h as AgentCandidateExecutorFinalCapture, i as AgentCandidateExecutorMemoryCapture, A as AgentCandidateExecutorPort, j as AgentCandidateExecutorProfileFile, k as AgentCandidateExecutorRequest, l as AgentCandidateExecutorStopRequest, m as AgentCandidateExecutorTaskOutcomeCapture, n as AgentCandidateExecutorWorkspaceFile, o as AgentCandidateExecutorWorkspaceInput, p as AgentCandidateMemoryPort, q as AgentCandidateMemoryResetResult, r as AgentCandidateModelLimits, s as AgentCandidateModelPort, b as AgentCandidateOutputArtifactPort, t as AgentCandidateOutputPurpose, u as AgentCandidateProtectedModelActivation, v as AgentCandidateProtectedModelReservation, w as AgentCandidateProtectedModelSettlement, x as AgentCandidateProtectedRunCapture, y as AgentCandidateRepositoryPort, c as AgentCandidateRunFinalization, d as AgentCandidateTaskExecution, z as AgentCandidateVerificationPorts, B as AgentCandidateWorkspacePort, C as CANDIDATE_TRACE_ENV, D as CANDIDATE_TRACE_TAGS, E as CanonicalCandidateDocument, P as PreparedAgentCandidateExecution, F as PreparedAgentCandidateInstruction, G as PreparedAgentCandidateKnowledge, H as PreparedAgentCandidateLaunch, I as PreparedAgentCandidateTrace, R as ResolvedAgentCandidateContainer, V as VerifiedAgentCandidate, J as VerifiedAgentCandidateTaskOutcome } from './types-CWqfCO8s.js';
 export { AuthSource, BackendCallPolicy, CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, Conversation, ConversationDriveState, ConversationJournal, ConversationJournalEntry, ConversationParticipant, ConversationPolicy, ConversationResult, ConversationStreamEvent, ConversationTurn, D1DatabaseLike, D1StmtLike, DEFAULT_MAX_DEPTH, DeadlineExceededError, FORWARD_HEADERS, FileConversationJournal, ForwardHeaderName, HaltContext, HaltPredicate, HaltReason, HaltSignal, InMemoryConversationJournal, PersonaConversationResult, PersonaDriver, PropagatedHeaders, RetryBackoff, RetryableErrorPredicate, RunConversationOptions, RunPersonaConfig, RunPersonaConversationOptions, SqlAdapter, SqlConversationJournal, TurnOrder, buildForwardHeaders, computeBackoff, createConversationBackend, d1ToSqlAdapter, defaultIsRetryable, defineConversation, isDepthExceeded, makePerAttemptSignal, readDepth, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, sleep, slugifySpeaker, turnId } from './conversation.js';
-import { V as Verifier, C as CandidateGenerator } from './improve-CIml6hT3.js';
-export { A as AGENTIC_PROFILE_RESOURCE_ROOT, b as AgenticGeneratorOptions, c as AgenticGeneratorShotDisposition, d as AgenticGeneratorShotExecution, e as AgenticGeneratorShotReceipt, f as ImproveCodeOptions, I as ImproveOptions, a as ImproveResult, g as ImproveSkillsOptions, h as ImproveSurface, i as ImprovementCandidate, j as ImprovementDriverOptions, M as ManagedImprovementDriver, k as VerifyResult, l as agenticGenerator, m as commandVerifier, n as improve, o as improvementDriver } from './improve-CIml6hT3.js';
-import { ProposeContext, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
+import { V as Verifier, C as CandidateGenerator } from './improve-B40dRu0X.js';
+export { A as AGENTIC_PROFILE_RESOURCE_ROOT, b as AgenticGeneratorOptions, c as AgenticGeneratorShotDisposition, d as AgenticGeneratorShotExecution, e as AgenticGeneratorShotReceipt, f as ImproveCodeOptions, I as ImproveOptions, a as ImproveResult, g as ImproveSkillsOptions, h as ImproveSurface, i as ImprovementCandidate, j as ImprovementDriverOptions, M as ManagedImprovementDriver, k as VerifyResult, l as agenticGenerator, m as commandVerifier, n as defaultBuildPrompt, o as improve, p as improvementDriver } from './improve-B40dRu0X.js';
+import { ProposeContext, SurfaceProposer, MutableSurface } from '@tangle-network/agent-eval/campaign';
+import { L as LocalHarness, r as runLocalHarness } from './local-harness-CtK9dSny.js';
+import { T as ToolLoopChat, c as RuntimeTelemetryOptions } from './sanitize-DEbPNtyI.js';
+export { d as RuntimeEventCollector, e as RuntimeStreamEventCollector, S as SanitizedKnowledgeReadinessReport, f as createRuntimeEventCollector, g as createRuntimeStreamEventCollector, s as sanitizeAgentRuntimeEvent, h as sanitizeKnowledgeReadinessReport, i as sanitizeRuntimeStreamEvent } from './sanitize-DEbPNtyI.js';
 import { AgentProfile, AgentProfileDiff } from '@tangle-network/agent-interface';
 export { AgentCandidateBenchmarkGraderIdentity } from '@tangle-network/agent-interface';
 import { Scenario, SelfImproveOptions } from '@tangle-network/agent-eval/contract';
 import { S as SurfaceImprovementEdit } from './improvement-adapter-HAZz-7vK.js';
 import { I as ImprovementProposalSource } from './types-CmYCMbFT.js';
+import { S as StructuralRolloutPolicy } from './structural-rollout-D7xik9XR.js';
 export { AgentKnowledgeReadinessCheckOptions, CreateKnowledgeImprovementActivationExecutorOptions, KnowledgeImprovementActivationExecutor, KnowledgeImprovementCandidatePair, KnowledgeImprovementExperimentBundles, KnowledgeImprovementJobMeasurement, KnowledgeImprovementJobResult, KnowledgeReadinessCheck, KnowledgeReadinessCheckInput, KnowledgeReadinessCheckResult, RESEARCH_SUPERVISOR_SYSTEM_PROMPT, RunKnowledgeImprovementJobOptions, SupervisedKnowledgeUpdateInput, SupervisedKnowledgeUpdateOptions, SupervisedKnowledgeUpdateResult, SupervisedKnowledgeUpdater, buildKnowledgeImprovementExperimentBundles, createAgentKnowledgeReadinessCheck, createKnowledgeImprovementActivationExecutor, 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-Cn1N2rRo.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-PnWslIw4.js';
 export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-fnj6SRVg.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 RuntimeEventOtelOptions, bb as buildLoopOtelSpans, bc as buildLoopSpanNodes, bd as buildRuntimeEventOtelSpans, be as createOtelExporter, bf as exportEvalRuns, bg as loopEventToOtelSpan } from './coordination-BFE3Den7.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 RuntimeEventOtelOptions, bb as buildLoopOtelSpans, bc as buildLoopSpanNodes, bd as buildRuntimeEventOtelSpans, be as createOtelExporter, bf as exportEvalRuns, bg as loopEventToOtelSpan } from './coordination-D9l_YmwW.js';
 import { K as KnowledgeReadinessDecision, A as AgentBackendInput, c as AgentExecutionBackend, h as RunAgentTaskOptions, i as AgentTaskRunResult, j as RunAgentTaskStreamOptions, R as RuntimeStreamEvent, k as RuntimeSessionStore, l as RuntimeSession } from './types-BwoZWq-i.js';
 export { m as AgentAdapter, d as AgentBackendContext, n as AgentKnowledgeProvider, e as AgentRuntimeEvent, o as AgentRuntimeEventSink, p as AgentTaskContext, g as AgentTaskSpec, f as AgentTaskStatus, B as BackendErrorDetail, b as OpenAIChatResponseFormat, O as OpenAIChatTool, a as OpenAIChatToolChoice } from './types-BwoZWq-i.js';
-import { R as RuntimeHooks } from './types-B3vAW0Oq.js';
-export { c as RuntimeDecisionEvidenceRef, d as RuntimeDecisionKind, e as RuntimeDecisionPoint, f as RuntimeHookContext, g as RuntimeHookErrorContext, h as RuntimeHookEvent, i as RuntimeHookPhase, j as RuntimeHookTarget, k as RuntimeRunHandle, l as RuntimeRunPersistenceAdapter, m as RuntimeRunRow, n as composeRuntimeHooks, o as defineRuntimeHooks, p as notifyRuntimeDecisionPoint, q as notifyRuntimeHookEvent, s as startRuntimeRun } from './types-B3vAW0Oq.js';
-import { c as RuntimeTelemetryOptions } from './sanitize-BTSsdBXw.js';
-export { d as RuntimeEventCollector, e as RuntimeStreamEventCollector, S as SanitizedKnowledgeReadinessReport, f as createRuntimeEventCollector, g as createRuntimeStreamEventCollector, s as sanitizeAgentRuntimeEvent, h as sanitizeKnowledgeReadinessReport, i as sanitizeRuntimeStreamEvent } from './sanitize-BTSsdBXw.js';
+import { R as RuntimeHooks } from './types-CLat4bT9.js';
+export { e as RuntimeDecisionEvidenceRef, f as RuntimeDecisionKind, g as RuntimeDecisionPoint, h as RuntimeHookContext, i as RuntimeHookErrorContext, j as RuntimeHookEvent, k as RuntimeHookPhase, l as RuntimeHookTarget, m as RuntimeRunHandle, n as RuntimeRunPersistenceAdapter, o as RuntimeRunRow, p as composeRuntimeHooks, q as defineRuntimeHooks, r as notifyRuntimeDecisionPoint, s as notifyRuntimeHookEvent, t as startRuntimeRun } from './types-CLat4bT9.js';
 import '@tangle-network/agent-interface/environment-provider';
-import './local-harness-ZqCx51u7.js';
 import 'node:child_process';
-import '@tangle-network/agent-knowledge';
-import './activation-Cm-9MMX1.js';
-import './supervise-BLPI50-w.js';
-import './types-CmnA2iL3.js';
+import './worktree-fanout-DsIR4d6w.js';
+import './types-D870JlH0.js';
 import '@tangle-network/sandbox';
-import './completion-gate-C80jiRfN.js';
+import './completion-gate-C6dhVN-N.js';
 import '@tangle-network/agent-profile-materialize';
+import '@tangle-network/agent-knowledge';
+import './activation-Cm-9MMX1.js';
+import './supervise-BQdNAXtK.js';
 import './kb-gate-CwHO0vz6.js';
-import './worktree-fanout-DCA3G4bO.js';
-import './substrate-DO2GHNg2.js';
+import './substrate-Dyiqmd3o.js';
 import './environment-provider.js';
 
 /**
@@ -259,11 +260,188 @@ type FindingsArg = {
     report: unknown;
     findings: AnalystFinding[];
 };
+/** Render findings as the ranked-evidence block every build prompt ends with. */
+declare function findingLines(findings: AnalystFinding[]): string[];
 /** Build the starting instruction for a coder agent tasked with implementing a new tool. */
 declare function toolBuildPrompt(args: FindingsArg): string;
 /** Build the starting instruction for a coder agent tasked with implementing a new MCP server. */
 declare function mcpBuildPrompt(args: FindingsArg): string;
 
+/**
+ * Campaign `spans.jsonl` → OTLP-flat JSONL — the missing converter between
+ * what the substrate RECORDS and what its trace analysts READ.
+ *
+ * agent-eval's `runCampaign` durably records one `spans.jsonl` per cell
+ * (`defaultBuildTraceWriter`): flat records
+ * `{ name, cellId, startMs, durationMs?, ...attributes }` with no trace/span
+ * ids. Its trace consumers (`OtlpFileTraceStore`, the trace-analyst registry,
+ * `haloProposer`/`traceAnalystProposer` via `resolveTraces`) read OTLP-flat
+ * JSONL (`trace_id`/`span_id`/ISO times/status/attributes — the shape
+ * `projectOtlpFlatLine` parses). Nothing shipped converts between the two, so
+ * the traces real optimization runs write could never reach the trace-native
+ * proposers. This module is that wire adapter:
+ *
+ *   - {@link campaignCellSpansToOtlp} — one cell's `spans.jsonl` content →
+ *     OTLP lines (a per-cell root AGENT anchor span + one child per record).
+ *   - {@link convertCampaignDirToOtlp} — walk any campaign run/generation dir
+ *     for `spans.jsonl` files and concatenate their OTLP lines.
+ *   - {@link campaignTraceResolver} — the `resolveTraces` implementation for
+ *     `traceAnalystProposer`/`haloProposer`: proposing generation g reads the
+ *     traces the loop just recorded (`gen-<g-1>`, or `baseline` for g = 0)
+ *     under the same `runDir` handed to `improve()`/`selfImprove()`.
+ *
+ * Trace identity: one trace per CELL, keyed on the cell's on-disk path — the
+ * same sanitized `cellId` recurs across the baseline and every candidate
+ * campaign, so folding the id alone would merge distinct runs into one trace.
+ * Ids are deterministic FNV-1a folds to OTLP's 32/16-hex width, so re-converts
+ * are stable and byte-identical.
+ */
+
+interface CampaignOtlpOptions {
+    /** OTLP `service.name` on every emitted span. Default `'campaign'`. */
+    serviceName?: string;
+}
+/**
+ * Convert ONE cell's `spans.jsonl` content to OTLP-flat JSONL lines.
+ * `cellKey` is the identity the trace id folds from — pass the cell's on-disk
+ * path (unique per campaign); `cellId` is the display/attribute label.
+ * Returns `[]` for empty/recordless content (a dispatch that never touched
+ * `ctx.trace`/`ctx.cost` writes an empty file — that is data, not an error).
+ */
+declare function campaignCellSpansToOtlp(content: string, cell: {
+    cellId: string;
+    cellKey?: string;
+}, opts?: CampaignOtlpOptions): string[];
+/**
+ * Walk `dir` (a campaign run dir, a generation dir, or a whole `selfImprove`
+ * run root) for `spans.jsonl` files and return their concatenated OTLP-flat
+ * JSONL — the exact string the `resolveTraces` contract expects. `''` when no
+ * spans exist (the proposers fail loud on empty by design).
+ */
+declare function convertCampaignDirToOtlp(dir: string, opts?: CampaignOtlpOptions): string;
+interface CampaignTraceResolverOptions extends CampaignOtlpOptions {
+    /** The `selfImprove`/`improve()` run root — the SAME `runDir` the loop
+     *  records under (`<runDir>/baseline/...`, `<runDir>/gen-<g>/candidate-<i>/...`).
+     *  Must be a real path; a `mem://` run records nothing to resolve. */
+    runDir: string;
+}
+/**
+ * Build the `resolveTraces` function `traceAnalystProposer`/`haloProposer`
+ * take: proposing generation g reads the traces of the campaigns the loop just
+ * scored — `gen-<g-1>` (or `baseline` when g = 0), falling back to every trace
+ * under the run root when that directory has none (e.g. a caller pointing at a
+ * single campaign dir rather than a loop root).
+ *
+ *   traceAnalystProposer({ ..., resolveTraces: campaignTraceResolver({ runDir }) })
+ */
+declare function campaignTraceResolver(opts: CampaignTraceResolverOptions): (ctx: Pick<ProposeContext, 'generation'>) => string;
+
+/**
+ * `driverLoopGenerator` — the driver→worker `CandidateGenerator`: the build
+ * loop run by the ATOM instead of the canned respawn.
+ *
+ * `agenticGenerator` steers with three hardcoded conditions picking a canned
+ * note (`EMPTY_TREE_NOTE` / `failureNote`) and respawns. This generator swaps
+ * that respawn brain for a real driver: an LLM on the canonical tool-loop seam
+ * (`runBrainLoop` + `ToolLoopChat` — the exact loop `driverAgent` runs its
+ * brain on) that AUTHORS each worker instruction, OBSERVES what the session
+ * actually produced (diff, files, verifier output), RATES it, and DECIDES
+ * refine / re-scope / decompose — prompted with the senior scientific-method
+ * doctrine (`buildDriverSystem`).
+ *
+ * The worker stays the proven primitive: `runLocalHarness` in the candidate
+ * worktree, same as `agenticGenerator` — only the brain between sessions
+ * changes. The worktree machinery (`worktreeBuildCandidate`) and verifiers
+ * (`commandVerifier` / `mcpServeVerifier`) are reused verbatim.
+ *
+ * Completion-oracle invariant (the supervisor doctrine, kept): the driver's
+ * prose NEVER decides the outcome. After the loop, code re-checks ground
+ * truth — tree dirty, raw-trace evidence present, verifier green — and only
+ * that decides `applied`. A driver that claims success over a failing verifier
+ * produces a discarded candidate, not a shipped one.
+ *
+ * @experimental
+ */
+
+interface DriverLoopGeneratorOptions {
+    /** The driver-LLM seam — ONE inference turn over the conversation + tool specs (the canonical
+     *  `ToolLoopChat`, same seam as `driverAgent`): `routerBrain(cfg)` in production, a scripted
+     *  mock in tests. */
+    brain: ToolLoopChat;
+    /** Local coding harness the driver's worker sessions run in the worktree. Default `claude`. */
+    harness?: LocalHarness;
+    /** Per-worker-session wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */
+    timeoutMs?: number;
+    /** Build the driver's task briefing (domain framing + method + findings) — the same senior
+     *  prompt the worker path uses (`toolBuildPrompt` / `mcpBuildPrompt`). The driver reads it and
+     *  folds what each worker needs into its instruction. Default `defaultBuildPrompt`. */
+    buildPrompt?: (args: {
+        report: unknown;
+        findings: AnalystFinding[];
+    }) => string;
+    /** Verify the worktree (the intrinsic check). Exposed to the driver as `run_verifier` AND
+     *  re-run by code as the final keep/discard gate. Omitted ⇒ the final gate is dirty-tree only
+     *  (legacy `agenticGenerator` behavior sans verifier). */
+    verify?: Verifier;
+    /** Max driver inference turns. Default `max(8, 2 + maxShots * 3)` — room for one
+     *  observe/rate/decide cycle per worker session plus orientation. */
+    maxTurns?: number;
+    /** The research seam (adopt-not-build): when set, the driver gets a
+     *  `research{query}` tool + the `researchDriverNote` doctrine, so it can
+     *  discover an EXISTING external MCP instead of building one. Wire a real
+     *  web/search backend here — none is provisioned by default (the build
+     *  harness has no live web access yet; flagged). */
+    research?: (query: string) => Promise<string>;
+    /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */
+    runHarness?: typeof runLocalHarness;
+    /** Test seam — inject the worktree diff reader (defaults to `git diff` in the worktree). */
+    readDiff?: (worktreePath: string) => string;
+    /** Test seam — inject the changed-paths reader (defaults to `git status --porcelain`). */
+    changedPaths?: (worktreePath: string) => string[];
+}
+/** Driver→worker `CandidateGenerator`: an LLM driver on the canonical tool-loop authors, observes, rates, and steers coding-harness sessions in the worktree until the verifier passes or the session budget is spent. */
+declare function driverLoopGenerator(opts: DriverLoopGeneratorOptions): CandidateGenerator;
+
+/**
+ * Typed-findings accessor — the one place `unknown[]` findings become
+ * `AnalystFinding[]`.
+ *
+ * agent-eval's `ProposeContext.findings` is `TFindings[] = unknown[]` on the
+ * wire: the loop threads whatever the previous `analyzeGeneration` producer (or
+ * the caller's static seed) returned. Consumers that need the typed envelope
+ * (`claim`/`severity`/`recommended_action`) were down-casting with a bare
+ * `as AnalystFinding[]` — a lie at runtime whenever the seed was a raw string
+ * or an ad-hoc digest, which then rendered `undefined` into build prompts.
+ *
+ * `toAnalystFindings` replaces that cast: real findings pass through
+ * unchanged (structural guard, fail-closed), and non-conforming values are
+ * LIFTED into a real `AnalystFinding` envelope via `makeFinding` — the most
+ * actionable text becomes the claim, the original value rides in `metadata.raw`
+ * — so everything downstream of the accessor handles exactly one shape.
+ */
+
+/** Analyst id stamped on findings lifted from untyped seed values. */
+declare const LIFTED_FINDING_ANALYST_ID = "lifted-seed";
+/** Structural guard for the schema-versioned `AnalystFinding` envelope.
+ *  Strict on the identity fields `makeFinding` always populates — a partial
+ *  look-alike is lifted (re-enveloped), not trusted. */
+declare function isAnalystFinding(value: unknown): value is AnalystFinding;
+interface ToAnalystFindingsOptions {
+    /** `analyst_id` stamped on lifted (non-conforming) values.
+     *  Default {@link LIFTED_FINDING_ANALYST_ID}. */
+    analystId?: string;
+    /** `area` stamped on lifted values. Default `'seed'`. */
+    area?: string;
+}
+/**
+ * Normalize a mixed `unknown[]` findings array to `AnalystFinding[]`:
+ * conforming findings pass through by reference; strings and finding-ish
+ * objects are lifted into envelopes (claim = most actionable text, original
+ * value under `metadata.raw`); values with no extractable text are dropped.
+ * Never throws — a malformed seed must not kill a proposal round.
+ */
+declare function toAnalystFindings(findings: readonly unknown[], opts?: ToAnalystFindingsOptions): AnalystFinding[];
+
 /**
  * `mcpServeVerifier` — the intrinsic verifier for a built MCP server: the
  * boot-and-probe checker named in docs/artifact-lifecycle-frontier.md. A
@@ -272,13 +450,15 @@ declare function mcpBuildPrompt(args: FindingsArg): string;
  * handshake: `initialize` → `notifications/initialized` → `tools/list`, and
  * asserts the server answers with at least `minTools` tools.
  *
+ * The spawn + handshake is the SHARED same-host stdio connection
+ * (`connectStdioMcp`) — the same code path that later serves the built server
+ * LIVE to a scored run (`materializeLocalMcp`), so "verified it serves" and
+ * "served while scored" can never drift apart.
+ *
  * Outcomes follow the `Verifier` contract: a server that fails to start, exits
  * early, errors the handshake, times out, or exposes no tools is a FAILED
  * candidate (`{ok:false}`, fed back into the next generation shot); a missing
  * start binary or spawn fault THROWS (a setup bug, never a silent fallback).
- *
- * Protocol matches the runtime's own stdio MCP server (src/mcp/server.ts):
- * newline-delimited JSON-RPC 2.0, protocol version 2024-11-05.
  */
 
 interface McpServeSpec {
@@ -295,6 +475,46 @@ interface McpServeSpec {
 /** Build a `Verifier` that boots a generated MCP server over stdio and checks it exposes tools. */
 declare function mcpServeVerifier(spec: McpServeSpec): Verifier;
 
+/**
+ * The senior scientific-method optimizer doctrine — the ONE substantial prompt
+ * core shared by every builder/author surface (tool build, MCP build, codebase
+ * improvement, strategy authoring) and by the driver that steers build workers
+ * (`driverLoopGenerator`).
+ *
+ * Seeded from the proven senior prompts rather than invented: GEPA's
+ * `REFLECTION_SYSTEM` (localize → diagnose → minimal generalizable fix →
+ * preserve what works), the /evolve loop (one hypothesis with a mechanism and a
+ * falsifiable prediction; attack the largest measured gap first), /pursue (one
+ * coherent change set, no partial scaffolding), and the self-improving-loop /
+ * supervisor doctrine (a keep is decided by a real check, never by the author;
+ * observe → rate → decide). Generalized from "mutate a prompt string" to
+ * "build a code surface a held-out measurement will grade".
+ */
+/**
+ * The shared method block every build/author prompt embeds. Domain framing
+ * (what a tool/MCP/codebase-edit deliverable looks like) wraps around it; this
+ * is the process itself.
+ */
+declare const optimizerMethod: string;
+/**
+ * The driver's stance for `driverLoopGenerator` — the build-domain instance of
+ * the supervisor doctrine (observe → rate → decide; refine / re-scope /
+ * decompose; the check decides delivery, never the driver's prose).
+ */
+declare const buildDriverSystem: string;
+/**
+ * The driver's ADOPT-not-build doctrine, appended to `buildDriverSystem` when
+ * a `research` tool is wired into the loop (`DriverLoopGeneratorOptions.
+ * research`). Kept separate so a driver WITHOUT the tool is never told to
+ * call a tool it does not have.
+ */
+declare const researchDriverNote: string;
+/**
+ * The senior authoring process for `authorStrategy` — the same method, shaped
+ * to the strategy contract (author-blind, conserved budget, one module out).
+ */
+declare const strategyAuthorMethod: string;
+
 type ProfileDiffProposerContext<TFindings = unknown> = ProposeContext<TFindings> & {
     profile: AgentProfile;
 };
@@ -398,6 +618,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): 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): 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, policy: StructuralRolloutPolicy): AgentProfile;
+/** 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;
+
 /**
  *
  * Chat-model resolution + catalog validation — the shared primitive every
@@ -823,4 +1131,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 { AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, AgentTaskRunResult, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, InMemoryRuntimeSessionStore, type McpServeSpec, type ModelInfo, PlannerError, type ProfileDiffProposerContext, type ProfileDiffProposerOptions, type RawTraceDistillerOptions, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RunToolLoopOptions, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, RuntimeTelemetryOptions, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, Verifier, applyRunRecordDefaults, cleanModelId, createOpenAICompatibleBackend, decideKnowledgeReadiness, deriveExecutionId, getModels, handleChatTurn, mcpBuildPrompt, mcpServeVerifier, profileDiffProposer, rawTraceDistiller, readinessServerSentEvent, reflectiveGenerator, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runToolLoop, runtimeStreamServerSentEvent, streamToolLoop, toolBuildPrompt, validateChatModelId };
+export { AgentBackendInput, type AgentBackendKind, AgentExecutionBackend, AgentTaskRunResult, BackendTransportError, type CampaignOtlpOptions, type CampaignTraceResolverOptions, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, type DriverLoopGeneratorOptions, InMemoryRuntimeSessionStore, LIFTED_FINDING_ANALYST_ID, type McpServeSpec, type ModelInfo, PlannerError, type ProfileDiffProposerContext, type ProfileDiffProposerOptions, ROLLOUT_POLICY_BOUNDS, ROLLOUT_POLICY_EXTENSION, type RawTraceDistillerOptions, type ReflectiveGeneratorOptions, type ResolveAgentBackendOptions, type ResolvedChatModel, type RouterEnv, type RunChatTurnInput, type RunToolLoopOptions, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, RuntimeTelemetryOptions, type StreamToolLoopOptions, type StreamToolLoopYield, type ToAnalystFindingsOptions, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, Verifier, applyRolloutPolicyToProfile, applyRunRecordDefaults, buildDriverSystem, campaignCellSpansToOtlp, campaignTraceResolver, cleanModelId, convertCampaignDirToOtlp, createOpenAICompatibleBackend, decideKnowledgeReadiness, deriveExecutionId, driverLoopGenerator, enumerateNeighborPolicies, findingLines, getModels, handleChatTurn, isAnalystFinding, mcpBuildPrompt, mcpServeVerifier, normalizeRolloutPolicy, optimizerMethod, parseRolloutPolicy, profileDiffProposer, rawTraceDistiller, readinessServerSentEvent, reflectiveGenerator, researchDriverNote, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, rolloutPolicyProposer, runAgentTask, runAgentTaskStream, runToolLoop, runtimeStreamServerSentEvent, serializeRolloutPolicy, strategyAuthorMethod, streamToolLoop, structuralRolloutPolicyFromProfile, toAnalystFindings, toolBuildPrompt, validateChatModelId };