@tangle-network/agent-runtime 0.94.13 → 0.96.1

package/dist/{completion-gate-D1gX1-hg.d.ts → completion-gate-C80jiRfN.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-1d5QGK3t.js';
+import { c as Executor } from './types-CmnA2iL3.js';
 
 /**
  *

package/dist/conversation.d.ts

@@ -1,4 +1,4 @@
-import { c as AgentExecutionBackend } from './types-BwoZWq-i.js';
+import { c as AgentExecutionBackend, k as RuntimeSessionStore } from './types-BwoZWq-i.js';
 import { AgentProfile, MaximumCharge } from '@tangle-network/agent-eval';
 import { Scenario, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
 
@@ -370,6 +370,8 @@ interface ConversationTurn {
      * `${runId}.t${index}.${speakerSlug}`.
      */
     turnId: string;
+    /** Backend session used for this turn. Present on turns recorded by session-aware runners. */
+    sessionId?: string;
     text: string;
     /**
      * Aggregated backend usage for this turn alone. Populated from any
@@ -424,6 +426,13 @@ interface RunConversationOptions {
      * driver process crash mid-run loses zero acknowledged turns.
      */
     journal?: ConversationJournal;
+    /**
+     * Stores each participant's backend session. The runner keeps an in-memory
+     * store for one invocation when omitted. Reuse a durable store with the same
+     * `runId` and journal after a process restart. Backends implementing `resume`
+     * continue their provider session; other backends receive the full transcript.
+     */
+    sessionStore?: RuntimeSessionStore;
     /**
      * Headers to forward verbatim to every participant backend call (gateway
      * propagation: `X-Tangle-Forwarded-Authorization`, run/turn correlation,
@@ -656,6 +665,8 @@ declare class SqlConversationJournal implements ConversationJournal {
  * forward events as they arrive. Both share one driving loop.
  *
  * Distributed-systems primitives layered on top of the loop:
+ *   - **Participant sessions**: one backend session per participant is resumed
+ *     between turns; stateless backends receive one reconstructed transcript.
  *   - **Idempotent turn ids** — `turnId(runId, index, speaker)` stays stable
  *     across retries so caching gateways can dedupe.
  *   - **Durable journal** — optional `ConversationJournal` persists every

package/dist/conversation.js

@@ -23,10 +23,9 @@ import {
   sleep,
   slugifySpeaker,
   turnId
-} from "./chunk-VYA2YEKA.js";
-import "./chunk-AEG3NGJ2.js";
+} from "./chunk-2KGAN2HM.js";
+import "./chunk-Q2JSAVQ3.js";
 import "./chunk-YEJR7IXO.js";
-import "./chunk-DGUM43GV.js";
 export {
   CircuitBreakerState,
   CircuitOpenError,

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

@@ -1,12 +1,12 @@
-import { E as ExecutorFactory, e as ExecutorRegistry, i as Spend, A as Agent, S as Scope, a as ResultBlobStore, B as Budget } from './types-1d5QGK3t.js';
+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 { 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, a as LoopTraceEvent, A as AgentRunSpec } from './types-ByAYqlVb.js';
+import { S as SandboxClient, E as ExecCtx, r as LoopTraceEmitter, b as LoopTraceEvent, A as AgentRunSpec } from './types-B3vAW0Oq.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 { R as RuntimeStreamEvent } from './types-BwoZWq-i.js';
-import { G as GitRunner, a as WorktreeCheckRunner, D as DeliverableSpec } from './completion-gate-D1gX1-hg.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 { ProviderExecutorOptions, AgentEnvironmentProviderRegistry } from './environment-provider.js';
 import { AgentEnvironmentProvider } from '@tangle-network/agent-interface/environment-provider';
@@ -1012,9 +1012,9 @@ interface DelegateUiAuditResult {
     estimatedDurationMs?: number;
 }
 /**
- * Loose shape of a research output over the wire — the substrate cannot
- * import the `ResearchOutput` type from agent-knowledge without inducing
- * a dependency cycle, so the MCP layer treats it structurally.
+ * Provider-neutral research output carried over the MCP boundary. The MCP
+ * layer accepts this structural shape instead of coupling its wire contract to
+ * one research implementation.
  *
  * @experimental
  */
@@ -1908,11 +1908,10 @@ declare function settleDetachedCoderTurn(turn: DetachedTurn, options: SettleDeta
  *
  * Feedback persistence surface for the MCP layer.
  *
- * The substrate cannot import `@tangle-network/agent-knowledge` (it would
- * induce a dependency cycle), so the store is an abstract interface. The
- * default implementation is in-memory; consumers wire their own adapter
- * (a real KbStore-backed sink, an HTTP relay to gtm-agent's knowledge
- * service, etc.) via `createMcpServer({ feedbackStore })`.
+ * Feedback storage is product policy, so the MCP layer depends on this narrow
+ * interface instead of choosing a knowledge store. The default implementation
+ * is in-memory; consumers wire their own durable adapter via
+ * `createMcpServer({ feedbackStore })`.
  *
  * Feedback events are append-only: every rating is a new event with a
  * fresh id, even when the same delegation is rated multiple times. The

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-1d5QGK3t.js';
-import { S as SandboxClient } from './types-ByAYqlVb.js';
+import { R as Runtime, E as ExecutorFactory } from './types-CmnA2iL3.js';
+import { S as SandboxClient } from './types-B3vAW0Oq.js';
 import '@tangle-network/agent-eval';
 import './types-BwoZWq-i.js';
 

package/dist/environment-provider.js

@@ -4,9 +4,8 @@ import {
   providerAsSandboxClient,
   resolveAgentEnvironmentProvider,
   sandboxClientAsProvider
-} from "./chunk-VSWBYWFK.js";
+} from "./chunk-M6MD6JBS.js";
 import "./chunk-3MDZX7YU.js";
-import "./chunk-DGUM43GV.js";
 export {
   createAgentEnvironmentProviderRegistry,
   providerAsExecutor,

package/dist/{agentic-generator-DDMM45kZ.d.ts → improve-g75IE2Cx.d.ts}

@@ -1,7 +1,8 @@
-import { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
+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 { LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
+import { AnalystFinding, CostLedgerHandle, MaximumCharge } from '@tangle-network/agent-eval';
 
 /**
  *
@@ -129,7 +130,6 @@ interface VerifyResult {
  *  throw). */
 type Verifier = (worktreePath: string) => Promise<VerifyResult> | VerifyResult;
 interface AgenticGeneratorShotReceipt {
-    readonly schemaVersion: 1;
     readonly generation: number | null;
     readonly candidateIndex: number | null;
     /** One-based shot number within this candidate. */
@@ -255,4 +255,152 @@ declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGene
  *  silent fallback). */
 declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
 
-export { AGENTIC_PROFILE_RESOURCE_ROOT as A, type CandidateGenerator as C, type ImprovementDriverOptions as I, type ManagedImprovementDriver as M, type Verifier as V, type AgenticGeneratorOptions as a, type AgenticGeneratorShotDisposition as b, type AgenticGeneratorShotExecution as c, type AgenticGeneratorShotReceipt as d, type VerifyResult as e, agenticGenerator as f, commandVerifier as g, improvementDriver as i };
+/**
+ *
+ * `improve` — the ONE public, surface-pluggable RSI verb.
+ *
+ * A thin facade over agent-eval's `selfImprove` (the held-out-gated closed
+ * loop). It removes the two things a caller otherwise has to know to drive the
+ * loop by hand: WHICH `MutableSurface` of the profile is being optimized, and
+ * WHICH `SurfaceProposer` mutates that surface. You name a `surface`; the
+ * facade picks the matching default proposer, extracts the baseline surface from
+ * the profile, and runs `selfImprove`. It returns a frozen candidate and never
+ * changes the input profile or caller-owned state.
+ *
+ *   - `surface: 'prompt'` → `gepaProposer` mutates `profile.prompt.systemPrompt`.
+ *   - `surface: 'skills'` → `skillOptProposer` mutates one named inline skill.
+ *   - `surface: 'memory'` → `memoryCurationProposer` curates the profile's
+ *     additional instructions as bounded durable lessons.
+ *   - `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
+ *     proposer exists (a code/config proposer needs caller-supplied wiring — a
+ *     worktree repo root, a candidate generator, a serializer). The facade
+ *     requires an explicit `opts.generator` for these and throws a `ConfigError`
+ *     otherwise. This is a designed boundary, not a missing default: there is
+ *     no safe value the facade could invent for those surfaces. Code instead
+ *     requires `opts.code.repoRoot` and accepts only the runtime-owned
+ *     `opts.code.generator` path so every isolated checkout can be released.
+ *
+ * Everything else (`scenarios`, `judge`, `agent`, `budget`, `llm`) passes
+ * straight through to `selfImprove`.
+ *
+ * @experimental
+ */
+
+/** 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';
+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. */
+    surface?: ImproveSurface;
+    /** The `SurfaceProposer` that mutates a profile surface. When unset, the facade
+     *  picks the default for prompt, skills, and memory; surfaces
+     *  with no default REQUIRE this (fail-loud otherwise). Forbidden for code;
+     *  use `code.generator` so the runtime owns candidate cleanup. */
+    generator?: SurfaceProposer$1;
+    /** Gate mode. `'holdout'` (default) runs the held-out promotion gate;
+     *  `'none'` is a baseline-only run (`budget.generations = 0`). */
+    gate?: 'holdout' | 'none';
+    /** Restrict the run to this subset of models. When set, the reflection model
+     *  (`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[];
+    /** 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 ~1500-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: name `surface: 'code'`, point at a repo, and the
+     *  facade assembles the whole candidate pipeline — an isolated incumbent plus 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. Required for every code run because a real
+     *  repository and base ref are necessary to measure the incumbent. */
+    code?: ImproveCodeOptions;
+    /** Select the exact inline skill document to optimize. */
+    skills?: ImproveSkillsOptions;
+    /** Custom held-back-exam decision. The string `gate` above controls whether
+     *  the exam runs; this callback controls how its evidence decides promotion. */
+    promotionGate?: SelfImproveOptions<TScenario, TArtifact>['gate'];
+};
+interface ImproveSkillsOptions {
+    /** `name` of one inline entry in `profile.resources.skills`. */
+    resourceName: string;
+}
+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;
+    /** Git-compatible adapter override, primarily for tests. Candidate advancement
+     *  still requires normal Git worktree and commit semantics. */
+    worktree?: WorktreeAdapter;
+    /** 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 ImprovementCandidate {
+    /** Surface searched by this run. */
+    surface: ImproveSurface;
+    /** Exact winning value returned by agent-eval. */
+    value: MutableSurface;
+    /** Detached profile candidate when the surface maps directly to AgentProfile. */
+    profile?: AgentProfile;
+}
+interface ImproveResult<TScenario extends Scenario, TArtifact> {
+    /** Frozen candidate only. Live state is changed through an approved activation. */
+    candidate: ImprovementCandidate;
+    /** Held-out decision for this search result. */
+    decision: SelfImproveResult<TScenario, TArtifact>['gateDecision'];
+    /** Held-out lift (`winner − baseline` composite). */
+    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. */
+    raw: SelfImproveResult<TScenario, TArtifact>;
+    /** Release resources owned by this result. Idempotent; currently disposes
+     *  the returned code worktree and is a no-op for profile-only surfaces. */
+    dispose(): Promise<void>;
+}
+/**
+ * Run the held-out-gated self-improvement loop on ONE profile surface.
+ *
+ * @example Optimize the system prompt, default holdout gate:
+ *
+ *   const out = await improve(profile, findings, {
+ *     surface: 'prompt',
+ *     scenarios,
+ *     judge,
+ *     agent: (surface, scenario, ctx) => runAgent(surface, scenario, ctx.signal),
+ *   })
+ *   if (out.decision === 'ship') console.log(out.candidate)
+ */
+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 };

package/dist/{improvement-adapter-BieWeK5J.d.ts → improvement-adapter-HAZz-7vK.d.ts}

@@ -1,5 +1,5 @@
 import { FindingSubject, AnalystFinding } from '@tangle-network/agent-eval';
-import { I as ImprovementAdapter } from './types-BC3bZpH0.js';
+import { I as ImprovementProposalSource } from './types-CmYCMbFT.js';
 
 /**
  * `AgentSurfaces` — declarative map of the mutable file/directory paths
@@ -116,23 +116,15 @@ declare function validateSurfaces(surfaces: AgentSurfaces, repoRoot: string): Re
 declare function renderSurfaceIssues(issues: ReadonlyArray<SurfaceValidationIssue>, repoRoot: string): string;
 
 /**
- * Substrate-default `ImprovementAdapter` — surfaces-driven, LLM-drafted
- * patches, optional auto-apply or PR-open.
+ * Surface improvement proposer — resolves analyst findings into LLM-drafted
+ * candidate patches without changing the caller's repository.
  *
- * This is the one ImprovementAdapter every vertical agent uses. The
- * substrate parses each finding's `subject` via
+ * The proposer parses each finding's `subject` via
  * `parseFindingSubject` (agent-eval), resolves it to a real file path
  * via the agent's `AgentSurfaces`, reads the current content, and asks
  * an LLM to draft a unified-diff patch given the finding + current
  * content + per-kind editing-discipline rules.
  *
- * Auto-apply gates on the source-finding's confidence and the
- * autoApply.improvement policy. Two modes:
- *   `write` — apply the patch in-place via `git apply -p0`. Operator
- *     reviews via `git diff`.
- *   `open-pr` — write to a branch, commit, push, open a PR via `gh`.
- *     Operator reviews via the PR UI.
- *
  * Fail-loud rules:
  *   - Findings whose subject doesn't parse → counted in `errors`.
  *   - Findings whose subject targets an undeclared surface → counted in
@@ -169,7 +161,7 @@ interface SurfaceImprovementEdit {
     /** Carry-forward severity for prioritization. */
     severity: AnalystFinding['severity'];
 }
-interface CreateSurfaceImprovementAdapterOpts {
+interface CreateSurfaceImprovementProposerOptions {
     surfaces: AgentSurfaces;
     repoRoot: string;
     /**
@@ -181,21 +173,6 @@ interface CreateSurfaceImprovementAdapterOpts {
      * substantive prompt rewrites, etc.) via this callback.
      */
     draftPatch: (input: DraftPatchInput) => Promise<DraftPatchOutput>;
-    /**
-     * Apply mode:
-     *   `write` — `git apply` in-place; operator reviews via `git diff`
-     *   `open-pr` — branch + commit + push + `gh pr create`
-     *   `none` — never apply; collect proposals for the report only
-     *
-     * The `apply` method honours this even when the loop calls it; the
-     * effective behaviour is also gated on the per-finding confidence
-     * threshold via `runAnalystLoop`'s `autoApply` policy.
-     */
-    mode?: 'write' | 'open-pr' | 'none';
-    /** When `mode === 'open-pr'`, the base branch new PRs target. Default: `main`. */
-    baseBranch?: string;
-    /** Required for `mode === 'open-pr'` — the GH owner/repo (`tangle-network/tax-agent`). */
-    ghRepo?: string;
     /**
      * When the resolved target doesn't exist, allow the substrate to
      * CREATE the file (for `knowledge.wiki`, `new-tool` subjects). Default
@@ -220,7 +197,7 @@ interface DraftPatchOutput {
     /** Multi-line rationale for the PR body. */
     rationale: string;
 }
-/** The substrate-default `ImprovementAdapter`: resolve each finding's subject to a real surface path, LLM-draft a unified-diff patch, then auto-apply or open a PR. */
-declare function createSurfaceImprovementAdapter(opts: CreateSurfaceImprovementAdapterOpts): ImprovementAdapter<SurfaceImprovementEdit>;
+/** Resolve each finding to a real surface and draft a detached patch candidate. */
+declare function createSurfaceImprovementProposer(opts: CreateSurfaceImprovementProposerOptions): ImprovementProposalSource<SurfaceImprovementEdit>;
 
-export { type AgentSurfaces as A, type CreateSurfaceImprovementAdapterOpts as C, type DraftPatchInput as D, type ResolvedSurface as R, type SurfaceImprovementEdit as S, type DraftPatchOutput as a, type SurfaceValidationIssue as b, createSurfaceImprovementAdapter as c, resolveSubjectPath as d, renderSurfaceIssues as r, validateSurfaces as v };
+export { type AgentSurfaces as A, type CreateSurfaceImprovementProposerOptions as C, type DraftPatchInput as D, type ResolvedSurface as R, type SurfaceImprovementEdit as S, type DraftPatchOutput as a, type SurfaceValidationIssue as b, createSurfaceImprovementProposer as c, resolveSubjectPath as d, renderSurfaceIssues as r, validateSurfaces as v };

package/dist/index.d.ts

@@ -2,38 +2,39 @@ import { AgentEvalError, AnalystFinding, KnowledgeReadinessReport, RunRecord, Co
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
 import { c as createOpenAICompatibleBackend } from './backends-BO4Jqoe2.js';
 export { a as createIterableBackend, b as createSandboxPromptBackend } from './backends-BO4Jqoe2.js';
-export { AgentCandidateCodeSource, AgentCandidateCodeSurfaceSource, AgentCandidateModelGrantActivateInput, AgentCandidateModelGrantClient, AgentCandidateModelGrantReservation, AgentCandidateModelGrantReserveInput, AgentCandidateModelGrantSettleInput, AgentCandidateProfileSource, AgentCandidateWorkspaceArchiveLimits, BuildAgentCandidateBundleInput, CaptureAgentCandidateWorkspaceOptions, CapturedAgentCandidateWorkspace, CreateAgentCandidateWorkspacePortOptions, CreateProtectedAgentCandidateModelPortOptions, DisposePreparedAgentCandidateOptions, FileAgentCandidateExecutionClaimStore, FileAgentCandidateExecutionClaimStoreOptions, RecoverExpiredAgentCandidateOptions, applyExactAgentProfileDiff, buildAgentCandidateBundle, candidateExecutionClaim, captureAgentCandidateWorkspace, captureAgentCandidateWorkspaceFiles, createAgentCandidateWorkspacePort, createProtectedAgentCandidateModelPort, disposePreparedAgentCandidateExecution, parseExactAgentProfile, parseExactAgentProfileDiff, persistCandidateOutputArtifact, recoverExpiredAgentCandidateExecution, verifyAgentCandidateBundle } from './candidate-execution/index.js';
-export { d as AgentCandidateArtifactPort, e as AgentCandidateBenchmarkGraderIdentity, f as AgentCandidateBenchmarkGraderPort, A as AgentCandidateBundleInput, g as AgentCandidateContainerPort, h as AgentCandidateExecutionAttemptRecord, i as AgentCandidateExecutionAttemptRef, j as AgentCandidateExecutionClaim, k as AgentCandidateExecutionClaimResult, l as AgentCandidateExecutionClaimStore, m as AgentCandidateExecutionCleanupHandles, n as AgentCandidateExecutionFailureClass, o as AgentCandidateExecutionFinishResult, p as AgentCandidateExecutionLease, q as AgentCandidateExecutionPhase, r as AgentCandidateExecutionPhaseResult, b as AgentCandidateExecutionPorts, s as AgentCandidateExecutionRecoveryEvidence, t as AgentCandidateExecutionStageResult, u as AgentCandidateExecutionTerminalRecord, v as AgentCandidateExecutionTerminalResult, w as AgentCandidateExecutionUsage, x as AgentCandidateExecutorFinalCapture, y as AgentCandidateExecutorMemoryCapture, z as AgentCandidateExecutorPort, B as AgentCandidateExecutorProfileFile, C as AgentCandidateExecutorRequest, D as AgentCandidateExecutorStopRequest, F as AgentCandidateExecutorTaskOutcomeCapture, G as AgentCandidateExecutorWorkspaceFile, H as AgentCandidateExecutorWorkspaceInput, I as AgentCandidateMemoryPort, J as AgentCandidateMemoryResetResult, K as AgentCandidateModelLimits, L as AgentCandidateModelPort, M as AgentCandidateOutputArtifactPort, N as AgentCandidateOutputPurpose, O as AgentCandidateProtectedModelActivation, Q as AgentCandidateProtectedModelCall, R as AgentCandidateProtectedModelReservation, S as AgentCandidateProtectedModelSettlement, T as AgentCandidateProtectedRunCapture, U as AgentCandidateRepositoryPort, V as AgentCandidateRetryRejection, c as AgentCandidateRunFinalization, a as AgentCandidateTaskExecution, W as AgentCandidateVerificationPorts, X as AgentCandidateWorkspacePort, Y as CANDIDATE_TRACE_ENV, Z as CANDIDATE_TRACE_TAGS, _ as CanonicalCandidateDocument, E as ExecutePreparedAgentCandidateOptions, $ as InMemoryAgentCandidateExecutionClaimStore, P as PrepareAgentCandidateExecutionOptions, a0 as PreparedAgentCandidateExecution, a1 as PreparedAgentCandidateInstruction, a2 as PreparedAgentCandidateKnowledge, a3 as PreparedAgentCandidateLaunch, a4 as PreparedAgentCandidateTrace, a5 as ResolvedAgentCandidateContainer, a6 as VerifiedAgentCandidate, a7 as VerifiedAgentCandidateTaskOutcome, a8 as executePreparedAgentCandidate, a9 as prepareAgentCandidateExecution, aa as sealAgentCandidateBundle } from './prepare-CtdtsFNG.js';
+export { AGENT_CANDIDATE_EXECUTION_SUPPORT, AgentCandidateBundleInput, AgentCandidateCodeSource, AgentCandidateCodeSurfaceSource, AgentCandidateModelGrantActivateInput, AgentCandidateModelGrantClient, AgentCandidateModelGrantReservation, AgentCandidateModelGrantReserveInput, AgentCandidateModelGrantSettleInput, AgentCandidateProfileSource, AgentCandidateWorkspaceArchiveLimits, BuildAgentCandidateBundleInput, CANDIDATE_KNOWLEDGE_RETRIEVAL_CONFIG_ENV, CANDIDATE_KNOWLEDGE_ROOT_ENV, CaptureAgentCandidateWorkspaceOptions, CapturedAgentCandidateWorkspace, CreateAgentCandidateWorkspacePortOptions, CreateProtectedAgentCandidateModelPortOptions, DisposePreparedAgentCandidateOptions, FileAgentCandidateExecutionClaimStore, FileAgentCandidateExecutionClaimStoreOptions, RecoverExpiredAgentCandidateOptions, buildAgentCandidateBundle, candidateExecutionClaim, candidateKnowledgeExecutionPaths, captureAgentCandidateWorkspace, captureAgentCandidateWorkspaceFiles, createAgentCandidateWorkspacePort, createProtectedAgentCandidateModelPort, disposePreparedAgentCandidateExecution, persistCandidateOutputArtifact, recoverExpiredAgentCandidateExecution, sealAgentCandidateBundle, verifyAgentCandidateBundle } from './candidate-execution/index.js';
+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 { C as CandidateGenerator } from './agentic-generator-DDMM45kZ.js';
-export { A as AGENTIC_PROFILE_RESOURCE_ROOT, a as AgenticGeneratorOptions, b as AgenticGeneratorShotDisposition, c as AgenticGeneratorShotExecution, d as AgenticGeneratorShotReceipt, I as ImprovementDriverOptions, M as ManagedImprovementDriver, V as Verifier, e as VerifyResult, f as agenticGenerator, g as commandVerifier, i as improvementDriver } from './agentic-generator-DDMM45kZ.js';
-export { c as ImproveCodeOptions, d as ImproveMemoryOptions, a as ImproveOptions, b as ImproveResult, e as ImproveSkillsOptions, I as ImproveSurface, f as applyImprovementWinnerToProfile, i as improve } from './improve-BN3HyXIO.js';
-export { M as McpServeSpec, m as mcpServeVerifier } from './mcp-serve-verifier-DQQDbuyz.js';
+import { V as Verifier, C as CandidateGenerator } from './improve-g75IE2Cx.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-g75IE2Cx.js';
 import { ProposeContext, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
-import { AgentProfileDiff, AgentProfile } from '@tangle-network/agent-interface';
+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-BieWeK5J.js';
-import { I as ImprovementAdapter } from './types-BC3bZpH0.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-BRQSQdHa.js';
+import { S as SurfaceImprovementEdit } from './improvement-adapter-HAZz-7vK.js';
+import { I as ImprovementProposalSource } from './types-CmYCMbFT.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 { 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-Dr_axlAf.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';
 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-ByAYqlVb.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-ByAYqlVb.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 './local-harness-ZqCx51u7.js';
 import 'node:child_process';
 import '@tangle-network/agent-knowledge';
-import './supervise-DmYOug5f.js';
-import './types-1d5QGK3t.js';
+import './activation-B0ZD7nfX.js';
+import './supervise-BLPI50-w.js';
+import './types-CmnA2iL3.js';
 import '@tangle-network/sandbox';
-import './completion-gate-D1gX1-hg.js';
+import './completion-gate-C80jiRfN.js';
 import '@tangle-network/agent-profile-materialize';
 import './kb-gate-CwHO0vz6.js';
-import './worktree-fanout-CPprU-qI.js';
+import './worktree-fanout-DCA3G4bO.js';
 import './substrate-DO2GHNg2.js';
 import './environment-provider.js';
 import '@tangle-network/agent-interface/environment-provider';
@@ -263,16 +264,42 @@ 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;
 
-interface AgentProfileDiffProposal {
-    diff: AgentProfileDiff;
-    label?: string;
-    rationale?: string;
+/**
+ * `mcpServeVerifier` — the intrinsic verifier for a built MCP server: the
+ * boot-and-probe checker named in docs/artifact-lifecycle-frontier.md. A
+ * generated MCP server is only a candidate if it actually *serves* — so this
+ * boots it over stdio (the default local MCP transport) and runs the real
+ * handshake: `initialize` → `notifications/initialized` → `tools/list`, and
+ * asserts the server answers with at least `minTools` tools.
+ *
+ * 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 {
+    /** Command that starts the built MCP server in the worktree (stdio transport). */
+    command: string;
+    args?: string[];
+    /** Extra env for the server process (merged over `process.env`). */
+    env?: Record<string, string>;
+    /** Handshake timeout (ms). Default 30s. */
+    timeoutMs?: number;
+    /** Minimum tools the server must expose to pass. Default 1. */
+    minTools?: number;
 }
+/** Build a `Verifier` that boots a generated MCP server over stdio and checks it exposes tools. */
+declare function mcpServeVerifier(spec: McpServeSpec): Verifier;
+
 type ProfileDiffProposerContext<TFindings = unknown> = ProposeContext<TFindings> & {
     profile: AgentProfile;
 };
 interface ProfileDiffProposerOptions<TFindings = unknown> {
-    proposeDiffs(context: ProfileDiffProposerContext<TFindings>): Promise<readonly AgentProfileDiffProposal[]> | readonly AgentProfileDiffProposal[];
+    proposeDiffs(context: ProfileDiffProposerContext<TFindings>): Promise<readonly AgentProfileDiff[]> | readonly AgentProfileDiff[];
 }
 /**
  * Turn exact AgentProfileDiffs from any source into full profile candidates for
@@ -286,7 +313,7 @@ declare function profileDiffProposer<TFindings = unknown>(options: ProfileDiffPr
  * `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
+ * generation's failing cells into ~1500-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
@@ -294,7 +321,7 @@ declare function profileDiffProposer<TFindings = unknown>(options: ProfileDiffPr
  * 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).
+ * (up to the harness's full context, ~millions of tokens, vs a ~1500-char digest).
  *
  * It emits `AnalystFinding[]` so it drops into the SAME `opts.analyzeGeneration`
  * slot the default distiller uses, and renders through the same
@@ -353,7 +380,7 @@ declare function rawTraceDistiller<TScenario extends Scenario = Scenario, TArtif
 /**
  *
  * `reflectiveGenerator` — the cheap, no-sandbox `CandidateGenerator`. It drafts
- * surface edits via the existing improvement adapter (`proposeFromFindings`,
+ * surface edits via the existing improvement proposer (`proposeFromFindings`,
  * one LLM patch per finding) and applies them as ONE coherent improvement into
  * the candidate worktree. `maxShots` is ignored — reflection is single-shot by
  * construction (the patches are already drafted).
@@ -366,7 +393,7 @@ declare function rawTraceDistiller<TScenario extends Scenario = Scenario, TArtif
  */
 
 interface ReflectiveGeneratorOptions {
-    improvementAdapter: ImprovementAdapter<SurfaceImprovementEdit>;
+    improvementProposalSource: ImprovementProposalSource<SurfaceImprovementEdit>;
 }
 /** 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;
@@ -796,4 +823,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, type AgentProfileDiffProposal, AgentTaskRunResult, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, DEFAULT_ROUTER_BASE_URL, InMemoryRuntimeSessionStore, 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, applyRunRecordDefaults, cleanModelId, createOpenAICompatibleBackend, decideKnowledgeReadiness, deriveExecutionId, getModels, handleChatTurn, mcpBuildPrompt, profileDiffProposer, rawTraceDistiller, readinessServerSentEvent, reflectiveGenerator, resolveAgentBackend, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runToolLoop, runtimeStreamServerSentEvent, streamToolLoop, toolBuildPrompt, validateChatModelId };
+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 };