@tangle-network/agent-runtime 0.73.0 → 0.74.0

package/dist/{coordination-DU0saWeg.d.ts → coordination-DEVknvQo.d.ts}

@@ -1,11 +1,12 @@
-import { L as LocalHarness, p as ExecutorFactory, E as ExecutorRegistry, o as DeliverableSpec, l as Spend, g as Agent, m as Scope, h as ResultBlobStore, B as Budget } from './worktree-DaxOvw-C.js';
+import { m as ExecutorFactory, E as ExecutorRegistry, l as DeliverableSpec, i as Spend, d as Agent, j as Scope, e as ResultBlobStore, B as Budget } from './worktree-CtuEQ7bZ.js';
 import { AgentProfile } from '@tangle-network/agent-interface';
 import { U as UiLens, a as UiFinding, C as CoderTask } from './substrate-rNj6TDc3.js';
-import { e as LoopTraceEmitter, c as LoopTraceEvent, S as SandboxClient, A as AgentRunSpec, E as ExecCtx } from './types-JufmXF2a.js';
+import { e as LoopTraceEmitter, c as LoopTraceEvent, S as SandboxClient, A as AgentRunSpec, E as ExecCtx } from './types-YimN9PQP.js';
 import { SandboxEvent, SandboxInstance, BackendType } from '@tangle-network/sandbox';
 import { AgentEvalError } from '@tangle-network/agent-eval';
 import { O as OtelExporter } from './otel-export-BKmNwiCb.js';
 import { T as ToolSpec, R as RouterConfig } from './router-client-C7kp_ECN.js';
+import { L as LocalHarness } from './local-harness-BE_h8szs.js';
 
 /**
  * @experimental

package/dist/generator-YkAQrOoD.d.ts

@@ -0,0 +1,382 @@
+import { RunRecord, AnalystFinding } from '@tangle-network/agent-eval';
+import { AgentProfileResourceRef, AgentProfileMcpServer, AgentProfileHookCommand, AgentSubagentProfile, AgentProfile } from '@tangle-network/agent-interface';
+
+/**
+ * `@tangle-network/agent-runtime/lifecycle` — artifact-lifecycle FOUNDATION.
+ *
+ * The §1.5 law says an agent IS its `AgentProfile`, and the profile is the WHOLE
+ * agent: prompt + skills + tools + mcp + hooks + subagents. This module names the
+ * discrete, individually-promotable PIECES of that profile — "artifacts" — and
+ * gives them stable ids so the rest of a self-improvement lifecycle (propose →
+ * measure → promote → ship) has something concrete to hang off.
+ *
+ * This is PHASE 1: just the two primitives the rest hangs off.
+ *   1. `ArtifactRegistry` — a typed catalog of profile artifacts with stable ids.
+ *   2. `measureMarginalLift` — the with-vs-without ablation: how much score/cost a
+ *      single artifact adds on top of a baseline profile.
+ *
+ * The per-surface lifecycles, the `BuildableSurface` author contract, and the
+ * promotion-gate wiring are deferred to later phases.
+ */
+
+/**
+ * The profile levers an artifact can target. One-to-one with the §1.5 profile
+ * surface (`prompt + skills + tools + mcp + hooks + subagents`). Each kind maps to
+ * exactly one field of `AgentProfile`, so an artifact can be applied onto a
+ * baseline profile deterministically (see `applyArtifact`).
+ */
+type ArtifactKind = 'skill' | 'tool' | 'mcp' | 'hook' | 'subagent' | 'prompt';
+/**
+ * The payload for each `ArtifactKind`. The shapes are the SAME types the
+ * `AgentProfile` field carries, so applying an artifact is a structural merge
+ * onto the profile — never a bespoke per-kind transform.
+ *
+ *   - `prompt`   — an instruction line appended to `profile.prompt.instructions`.
+ *   - `skill`    — a `SKILL.md`-style resource ref added to `profile.resources.skills`.
+ *   - `tool`     — a tool grant: `{ enabled }` set under `profile.tools[name]`.
+ *   - `mcp`      — one MCP server added under `profile.mcp[name]`.
+ *   - `hook`     — one or more hook commands added under `profile.hooks[event]`.
+ *   - `subagent` — one subagent profile added under `profile.subagents[name]`.
+ */
+interface ArtifactPayloads {
+    prompt: {
+        instruction: string;
+    };
+    skill: {
+        resource: AgentProfileResourceRef;
+    };
+    tool: {
+        enabled: boolean;
+    };
+    mcp: {
+        server: AgentProfileMcpServer;
+    };
+    hook: {
+        event: string;
+        commands: AgentProfileHookCommand[];
+    };
+    subagent: {
+        profile: AgentSubagentProfile;
+    };
+}
+/**
+ * A discrete, individually-promotable piece of an agent profile.
+ *
+ * `kind` selects the profile lever; `payload` is the kind-specific value; `key`
+ * is the profile-field key the payload lands under (the tool name, the MCP server
+ * name, the subagent name — unused for `prompt`, which appends). `id` is stable:
+ * once registered, it never changes, so a marginal-lift measurement, a promotion
+ * decision, and a ship record all reference the same artifact.
+ */
+interface ProfileArtifact<K extends ArtifactKind = ArtifactKind> {
+    /** Stable id. Assigned by the registry at register time; never reassigned. */
+    id: string;
+    kind: K;
+    /**
+     * The profile-field key this artifact lands under (e.g. the tool name, the MCP
+     * server name, the subagent name, the hook event). Optional for `prompt`
+     * (instructions append, they have no key). Defaults to `id` when applying a
+     * keyed artifact without an explicit key.
+     */
+    key?: string;
+    /** Human-facing label for review surfaces. */
+    name: string;
+    /** Optional one-line description of what this artifact does. */
+    description?: string;
+    payload: ArtifactPayloads[K];
+    /**
+     * Lifecycle status — the full artifact state machine:
+     *
+     *   `candidate` → `active` → `decayed` (re-promotable)
+     *                         ↘ `retired` (terminal)
+     *
+     *   - `candidate` — registered, not yet promoted. The default at register time.
+     *   - `active`    — passed the promotion gate and carries a measured held-back
+     *                   lift; the only status `composeProfile` folds into a profile.
+     *   - `decayed`   — was active, but a later re-measure (`driftWatch`) found its
+     *                   lift fell below the keep-bar. Demoted out of the composed
+     *                   profile; kept as an auditable record and a re-promotion
+     *                   candidate if a future re-measure recovers the lift.
+     *   - `retired`   — permanently removed from the active set (`dedupeArtifacts`
+     *                   retires the weaker half of a non-stacking pair). Terminal.
+     *
+     * The registry never auto-promotes; every transition is an explicit call
+     * (`promote`/`promoteWithLift`/`demote`/`retire`).
+     */
+    status: ArtifactStatus;
+    /** Free-form metadata (provenance, generation id, the measured lift, …). */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * The artifact lifecycle states. `active` is the load-bearing one — it is the
+ * sole status `composeProfile` folds into a deployable profile, and it is gated
+ * by a measured held-back lift (the registry invariant). `decayed` and `retired`
+ * are the two ways an artifact LEAVES the active set: a decayed artifact lost its
+ * lift on re-measure (reversible — `driftWatch`), a retired one was deduped away
+ * (terminal — `dedupeArtifacts`).
+ */
+type ArtifactStatus = 'candidate' | 'active' | 'decayed' | 'retired';
+/** The input to `register` — everything on `ProfileArtifact` except the
+ *  registry-owned `id` and `status`. An explicit `id` may be supplied for
+ *  deterministic/idempotent registration; otherwise the registry assigns one. */
+type ArtifactInput<K extends ArtifactKind = ArtifactKind> = Omit<ProfileArtifact<K>, 'id' | 'status'> & {
+    id?: string;
+    status?: ArtifactStatus;
+};
+
+/**
+ * `measureMarginalLift` — the with-vs-without ablation for one artifact.
+ *
+ * "What does THIS one piece add?" is the question a lifecycle has to answer
+ * before it can promote anything. The answer is an ablation: score the baseline
+ * profile, score the baseline-plus-candidate profile, and report the delta. This
+ * is the marginal contribution of the artifact — the same shape the project's
+ * `OutcomeMeasurement` reports for an apply pass, but isolated to ONE artifact so
+ * a registry can rank candidates by what they individually earn.
+ *
+ * The measurement is selector-agnostic: it takes an `EvalRunner` the caller
+ * supplies (any function that scores a profile and reports cost), runs it twice,
+ * and subtracts. It never judges, never picks a winner, never re-scores on a
+ * holdout — those are the gate's job. It only quantifies the ablation so the gate
+ * has a real number to decide on.
+ */
+
+/**
+ * The result of running an eval over ONE profile: a composite score and the cost
+ * to obtain it. This mirrors the project's score/cost convention (`composite`
+ * from `OutcomeMeasurement`, `costUsd` from `LoopResult`), so a caller can pass a
+ * thin wrapper over `runLoop` / `runBenchmark` / `runAgentEval` directly.
+ */
+interface EvalResult {
+    /** Composite score in `[0, 1]` (higher is better) for the profile under test. */
+    composite: number;
+    /** USD cost to produce this result. */
+    costUsd: number;
+    /**
+     * Per-task records the run produced, when the runner emits them. The marginal
+     * lift only needs `composite`, but the held-out promotion gate (`HeldOutGate`)
+     * pairs candidate vs baseline per-task holdout records by (experimentId, seed)
+     * — so a runner feeding `heldOutPromotionGate` MUST populate this with rows
+     * carrying both `search` and `holdout` split scores. Omit it for evals scored
+     * to a single composite (then use `thresholdPromotionGate`).
+     */
+    runs?: RunRecord[];
+    /** Optional opaque passthrough (per-task cells, the raw report, …). */
+    details?: unknown;
+}
+/**
+ * Scores a profile. The caller wires this to whatever eval they run — a
+ * `runLoop` rollout, a `runBenchmark` campaign, a `runAgentEval` cohort — and
+ * returns the composite + cost. `signal` is forwarded for cancellation.
+ */
+type EvalRunner = (profile: AgentProfile, signal?: AbortSignal) => Promise<EvalResult>;
+interface MeasureMarginalLiftOptions {
+    /** The profile the artifact is measured ON TOP OF (the "without" arm). */
+    baseline: AgentProfile;
+    /** The single artifact whose marginal contribution we want. */
+    candidate: ProfileArtifact;
+    /** The eval that scores a profile. Run once per arm (twice total). */
+    evalRunner: EvalRunner;
+    /**
+     * A pre-computed baseline result, to skip the "without" run when the caller
+     * already scored the baseline (e.g. measuring several candidates against the
+     * same baseline). When set, the baseline arm is NOT re-run.
+     */
+    baselineResult?: EvalResult;
+    /** Forwarded to both `evalRunner` invocations for cancellation. */
+    signal?: AbortSignal;
+}
+/**
+ * The marginal lift of one artifact: the with/without ablation.
+ *
+ * `scoreDelta = with.composite − without.composite`. A positive `scoreDelta` is
+ * the evidence a gate needs to promote; a negative one is the signal to drop the
+ * artifact. `costDelta` is the extra USD the artifact costs (often positive — a
+ * new tool/MCP adds calls) and lets the gate weigh lift against spend.
+ */
+interface MarginalLift {
+    /** The artifact id this measurement is for (stable, from the registry). */
+    artifactId: string;
+    /** Eval of `applyArtifact(baseline, candidate)`. */
+    withArtifact: EvalResult;
+    /** Eval of `baseline` alone. */
+    withoutArtifact: EvalResult;
+    /** `withArtifact.composite − withoutArtifact.composite`. */
+    scoreDelta: number;
+    /** `withArtifact.costUsd − withoutArtifact.costUsd`. */
+    costDelta: number;
+}
+/**
+ * Run the with/without ablation for `candidate` over `baseline` and return its
+ * marginal score/cost contribution.
+ *
+ * The "without" arm scores the baseline profile unchanged; the "with" arm scores
+ * `applyArtifact(baseline, candidate)`. Both use the same `evalRunner`, so the
+ * delta isolates the artifact's effect (eval method held constant). The baseline
+ * arm is skipped when `baselineResult` is supplied.
+ *
+ * @example
+ *   const lift = await measureMarginalLift({
+ *     baseline,
+ *     candidate: registry.get(id)!,
+ *     evalRunner: (profile) => scoreProfileOnCohort(profile),
+ *   })
+ *   if (lift.scoreDelta > 0) registry.promote(lift.artifactId)
+ */
+declare function measureMarginalLift(opts: MeasureMarginalLiftOptions): Promise<MarginalLift>;
+
+/**
+ * `PromotionGate` — the held-back exam that decides whether a measured candidate
+ * artifact is promoted into the registry.
+ *
+ * The lifecycle measures each candidate's marginal lift (`measureMarginalLift`),
+ * but a positive ablation delta on the practice problems is NOT enough to ship —
+ * that is how you overfit. The gate is the SECOND, stricter test: it decides
+ * promotion from a held-back split (fresh problems the candidate never tuned on)
+ * with a significance bar, so a promoted artifact earned its place rather than
+ * memorized the practice set.
+ *
+ * The interface is small and pluggable on purpose: production wires
+ * `heldOutPromotionGate`, which delegates to agent-eval's paper-grade
+ * `HeldOutGate` (paired-bootstrap CI on the held-out delta + an overfit-gap
+ * check). A deterministic test can inject a stub gate. The orchestrator never
+ * imports `HeldOutGate` directly — it only knows this interface — so the gate
+ * policy is a configuration choice, not a hardcode.
+ */
+
+/** The verdict a gate returns for one candidate. */
+interface PromotionVerdict {
+    /** Whether to promote the candidate into the registry as `active`. */
+    promote: boolean;
+    /** Human-readable reason (surfaced in provenance + reports). */
+    reason: string;
+    /** Machine-readable rejection code, or `null` on promote. Mirrors the
+     *  `HeldOutGate` rejection taxonomy when that gate is the backend. */
+    rejectionCode: string | null;
+}
+/**
+ * Decides whether ONE measured candidate is promoted. The lifecycle calls this
+ * once per candidate, after `measureMarginalLift` has produced the ablation.
+ *
+ * `lift` carries the with/without ablation (the marginal contribution); the gate
+ * MAY use it directly (the simple "positive lift on the held-back split" policy)
+ * OR ignore the scalar and decide from the paired per-task records the eval
+ * produced (`lift.withArtifact.runs` / `lift.withoutArtifact.runs`) when a
+ * significance gate like `HeldOutGate` is the backend.
+ */
+interface PromotionGate {
+    /** Stable label for the gate policy (provenance). */
+    kind: string;
+    decide(lift: MarginalLift): PromotionVerdict;
+}
+/**
+ * The simplest honest gate: promote iff the candidate's marginal lift on the
+ * held-back split clears `minDelta` (default `> 0`). It reads only the scalar
+ * `scoreDelta`, so it works with any `EvalRunner` (no per-task records needed).
+ *
+ * Use this when the eval is already scored ON the held-back split and you want a
+ * threshold, not a significance test — e.g. a deterministic fixture domain, or a
+ * cheap first pass before a paired-bootstrap gate. For paper-grade promotion on
+ * noisy live evals, prefer `heldOutPromotionGate`.
+ */
+declare function thresholdPromotionGate(minDelta?: number): PromotionGate;
+interface HeldOutPromotionGateOptions {
+    /** Stable label of the baseline candidate the held-out records pair against. */
+    baselineKey: string;
+    /** Minimum paired (candidate, baseline) holdout observations. Default 3. */
+    minProductiveRuns?: number;
+    /** Lower-bound on the bootstrap-CI of the median paired holdout delta. Default 0. */
+    pairedDeltaThreshold?: number;
+    /** Max allowed worsening of the (search − holdout) overfit gap. Default 0.15. */
+    overfitGapThreshold?: number;
+    /** Deterministic bootstrap seed (reproducible CIs). Default unseeded. */
+    seed?: number;
+    /** Hard ceiling on the candidate's median per-task USD cost. Default none. */
+    costPerTaskCeiling?: number;
+}
+/**
+ * The paper-grade promotion gate: delegate to agent-eval's `HeldOutGate`, which
+ * pairs the candidate and baseline per-task holdout records by (experimentId,
+ * seed), runs a paired-bootstrap CI on the median delta, and checks the
+ * overfit gap. Promotes only when the held-out generalization is real, not luck.
+ *
+ * REQUIRES the eval to surface per-task records: `lift.withArtifact.runs` (the
+ * candidate arm) and `lift.withoutArtifact.runs` (the baseline arm), each
+ * carrying matched seeds with both `search` and `holdout` split scores. When the
+ * records are absent, this gate FAILS LOUD — a held-out significance claim with
+ * no per-task data behind it would be a fabricated number, which the
+ * no-silent-fallback doctrine forbids. Use `thresholdPromotionGate` for evals
+ * that only produce a scalar composite.
+ */
+declare function heldOutPromotionGate(opts: HeldOutPromotionGateOptions): PromotionGate;
+
+/**
+ * `CandidateGenerator` — the ONE per-surface seam of the artifact lifecycle.
+ *
+ * Everything else in the lifecycle (measure → gate → store → compose) is
+ * surface-agnostic: it operates on `ProfileArtifact`s regardless of whether they
+ * are skills, tools, prompts, or MCP servers. The ONLY thing that varies by
+ * surface is HOW a fresh candidate piece is produced from the agent's history —
+ * a skill is DISTILLED from traces then refined; a tool grant is proposed from a
+ * "the agent lacked an action" finding; a prompt line is drafted from a recurring
+ * mistake. That per-surface logic is isolated here, behind one interface, so the
+ * orchestrator never grows a `switch (surface)`.
+ *
+ * A generator is pure-ish: given the lifecycle context (the baseline profile, the
+ * captured traces/findings, the registry of what already exists), it returns zero
+ * or more `ArtifactInput`s — candidate pieces that have NOT been measured yet.
+ * The orchestrator owns registration, measurement, gating, and storage; the
+ * generator owns only "what new pieces could this surface contribute".
+ *
+ * This is the interface the per-surface stages (skills, tools, prompt, mcp)
+ * implement. The skill generator (`skillGenerator`) is the reference
+ * implementation and the literal answer to "an empty profile has no skills":
+ * its `distill` step CREATES a skill from traces (the step `skillOpt` cannot do),
+ * then `refine` optimizes it.
+ */
+
+/**
+ * The read-only context a generator sees when proposing candidates. It is the
+ * agent's HISTORY (what to learn from) plus the agent's CURRENT shape (what
+ * already exists, so the generator does not re-propose a duplicate).
+ */
+interface GenerateContext {
+    /** The baseline profile candidates are proposed on top of. A generator reads
+     *  it to avoid re-proposing something the profile already has. */
+    baseline: AgentProfile;
+    /** The domain/agent id the lifecycle is running for — namespaces provenance
+     *  and lets a generator scope its proposals (e.g. distill from this domain's
+     *  traces only). */
+    domain: string;
+    /** Trace-analyst findings to ground proposals in observed behavior. The
+     *  firewall holds: these are OBSERVED signals, never judge verdicts. */
+    findings: ReadonlyArray<AnalystFinding>;
+    /** Raw captured trace text/records to distill from, opaque to the
+     *  orchestrator. A skill generator's `distill` reads this; a tool generator
+     *  may ignore it and read `findings` instead. */
+    traces?: unknown;
+    /** Cooperative cancellation, forwarded from `runLifecycle`. */
+    signal?: AbortSignal;
+}
+/**
+ * Produces fresh, UNMEASURED candidate artifacts for ONE profile surface.
+ *
+ * `kind` is the `ArtifactKind` this generator targets (so the orchestrator can
+ * report and group by surface). `generate` returns candidate inputs the
+ * orchestrator will register, measure (`measureMarginalLift`), gate
+ * (`HeldOutGate`), and — on a pass — promote into the registry. Returning `[]`
+ * is valid: the surface had nothing to contribute this round.
+ */
+interface CandidateGenerator<K extends ArtifactKind = ArtifactKind> {
+    /** The profile surface this generator targets. */
+    kind: K;
+    /**
+     * Propose candidate artifacts from the lifecycle context. MUST NOT measure,
+     * gate, or register — that is the orchestrator's job. MUST NOT mutate
+     * `ctx.baseline`. Returns unmeasured `ArtifactInput`s (no lift score yet); the
+     * orchestrator stamps provenance + the measured lift before promotion.
+     */
+    generate(ctx: GenerateContext): Promise<ArtifactInput<K>[]>;
+}
+
+export { type ArtifactKind as A, type CandidateGenerator as C, type EvalRunner as E, type GenerateContext as G, type HeldOutPromotionGateOptions as H, type MarginalLift as M, type PromotionGate as P, type ProfileArtifact as a, type ArtifactStatus as b, type ArtifactInput as c, type EvalResult as d, type PromotionVerdict as e, type ArtifactPayloads as f, type MeasureMarginalLiftOptions as g, heldOutPromotionGate as h, measureMarginalLift as m, thresholdPromotionGate as t };

package/dist/index.d.ts

@@ -1,20 +1,23 @@
 import { AgentProfile, AgentEvalError, AnalystFinding, KnowledgeReadinessReport, RunRecord, ControlEvalResult, KnowledgeRequirement } from '@tangle-network/agent-eval';
 export { AgentEvalError, AgentEvalErrorCode, ConfigError, ControlBudget, ControlDecision, ControlEvalResult, ControlRunResult, ControlStep, DataAcquisitionPlan, JudgeError, KnowledgeReadinessReport, KnowledgeRequirement, NotFoundError, RunRecord, ValidationError } from '@tangle-network/agent-eval';
-import { f as AgentBackendInput, g as AgentExecutionBackend, O as OpenAIChatTool, h as OpenAIChatToolChoice, i as AgentBackendContext, R as RuntimeStreamEvent, K as KnowledgeReadinessDecision, j as RunAgentTaskOptions, k as AgentTaskRunResult, l as RunAgentTaskStreamOptions, m as AgentRuntimeEvent, n as AgentTaskStatus, o as RuntimeSessionStore, p as RuntimeSession, b as RuntimeHooks } from './types-JufmXF2a.js';
-export { q as AgentAdapter, r as AgentKnowledgeProvider, s as AgentRuntimeEventSink, t as AgentTaskContext, u as AgentTaskSpec, B as BackendErrorDetail, v as RuntimeDecisionEvidenceRef, w as RuntimeDecisionKind, x as RuntimeDecisionPoint, y as RuntimeHookContext, z as RuntimeHookErrorContext, C as RuntimeHookEvent, D as RuntimeHookPhase, F as RuntimeHookTarget, G as RuntimeRunHandle, H as RuntimeRunPersistenceAdapter, J as RuntimeRunRow, M as composeRuntimeHooks, N as defineRuntimeHooks, P as notifyRuntimeDecisionPoint, Q as notifyRuntimeHookEvent, T as startRuntimeRun } from './types-JufmXF2a.js';
+import { f as AgentBackendInput, g as AgentExecutionBackend, O as OpenAIChatTool, h as OpenAIChatToolChoice, i as AgentBackendContext, a as RuntimeStreamEvent, K as KnowledgeReadinessDecision, j as RunAgentTaskOptions, k as AgentTaskRunResult, l as RunAgentTaskStreamOptions, m as AgentRuntimeEvent, n as AgentTaskStatus, o as RuntimeSessionStore, p as RuntimeSession, R as RuntimeHooks } from './types-YimN9PQP.js';
+export { q as AgentAdapter, r as AgentKnowledgeProvider, s as AgentRuntimeEventSink, t as AgentTaskContext, u as AgentTaskSpec, B as BackendErrorDetail, v as RuntimeDecisionEvidenceRef, w as RuntimeDecisionKind, x as RuntimeDecisionPoint, y as RuntimeHookContext, z as RuntimeHookErrorContext, C as RuntimeHookEvent, D as RuntimeHookPhase, F as RuntimeHookTarget, G as RuntimeRunHandle, H as RuntimeRunPersistenceAdapter, J as RuntimeRunRow, M as composeRuntimeHooks, N as defineRuntimeHooks, P as notifyRuntimeDecisionPoint, Q as notifyRuntimeHookEvent, T as startRuntimeRun } from './types-YimN9PQP.js';
 import { AgentProfile as AgentProfile$1 } from '@tangle-network/agent-interface';
-import { Scenario, ProfileDispatchFn, LabeledScenarioStore, WorktreeAdapter, SurfaceProposer } from '@tangle-network/agent-eval/campaign';
-import { L as LocalHarness, r as runLocalHarness } from './worktree-DaxOvw-C.js';
-import { Scenario as Scenario$1, SurfaceProposer as SurfaceProposer$1, JudgeConfig, MutableSurface, DispatchContext, SelfImproveBudget, SelfImproveLlm, SelfImproveResult } from '@tangle-network/agent-eval/contract';
+import { Scenario, ProfileDispatchFn } from '@tangle-network/agent-eval/campaign';
+import { C as CandidateGenerator } from './mcp-serve-verifier-CT1KLTG_.js';
+export { A as AgenticGeneratorOptions, I as ImprovementDriverOptions, M as McpServeSpec, V as Verifier, a as VerifyResult, b as agenticGenerator, c as commandVerifier, i as improvementDriver, m as mcpServeVerifier } from './mcp-serve-verifier-CT1KLTG_.js';
+import { Scenario as Scenario$1, SurfaceProposer, JudgeConfig, MutableSurface, DispatchContext, SelfImproveBudget, SelfImproveLlm, SelfImproveResult } from '@tangle-network/agent-eval/contract';
 import { S as SurfaceImprovementEdit } from './improvement-adapter-CioiEE2z.js';
 import { I as ImprovementAdapter } from './types-BC3bZpH0.js';
-export { D as DELEGATED_LOOP_MODES, a as DelegatedLoopMode, b as DelegatedLoopRegistry, c as DelegatedLoopResult, d as DelegatedLoopRunner, L as LoopRunnerCliArgs, e as LoopRunnerCliResult, R as ResearchLoopResult, f as ResearchLoopRunnerOptions, g as RunDelegatedLoopOptions, V as VetoedFact, W as WorktreeLoopRunnerOptions, h as auditLoopRunner, i as isDelegatedLoopMode, p as parseLoopRunnerArgv, r as researchLoopRunner, j as runDelegatedLoop, k as runLoopRunnerCli, s as selfImproveLoopRunner, w as worktreeLoopRunner } from './loop-runner-bin-eD3m0rHW.js';
-export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-CBurv8Cu.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-BPthX22l.js';
+export { m as mcpToolsForRuntimeMcp, a as mcpToolsForRuntimeMcpSubset } from './openai-tools-D-VCAEmw.js';
 export { E as EvalRunEvent, a as EvalRunGeneration, b as EvalRunsExportConfig, c as EvalRunsExportResult, I as INTELLIGENCE_WIRE_VERSION, L as LoopSpanNode, d as OtelAttribute, e as OtelExportConfig, O as OtelExporter, f as OtelSpan, g as buildLoopOtelSpans, h as buildLoopSpanNodes, i as createOtelExporter, j as exportEvalRuns, l as loopEventToOtelSpan } from './otel-export-BKmNwiCb.js';
 import '@tangle-network/sandbox';
+import './local-harness-BE_h8szs.js';
 import 'node:child_process';
 import './kb-gate-CuzMYGYM.js';
-import './worktree-fanout-DIffZohV.js';
+import './worktree-CtuEQ7bZ.js';
+import './worktree-fanout-Cdez8GR7.js';
 
 /**
  * @stable
@@ -1156,133 +1159,6 @@ declare class PlannerError extends AgentEvalError {
     });
 }
 
-/**
- * @experimental
- *
- * `improvementDriver` — the ONE reflective/agentic improvement proposer for
- * agent-eval's improvement loop. It implements `SurfaceProposer` and owns
- * the candidate lifecycle (worktree create → generate → finalize/discard,
- * × populationSize); it delegates the only thing that genuinely varies — HOW
- * a candidate change is produced — to a pluggable `CandidateGenerator`.
- *
- * There is no separate "analyst driver" vs "autoresearch driver": those are
- * the SAME driver at two settings of a dial.
- *   - cheap reflective path  → `reflectiveGenerator` (shots=1, no sandbox;
- *                              applies pre-drafted patches)
- *   - full agentic path      → `agenticGenerator` (shots=N, multi-shot
- *                              verify-in-session loop; an agent reads code +
- *                              report, edits, and re-tries on verifier failure)
- * Both emit changes into a worktree the driver finalizes into a
- * `CodeSurface{ worktreeRef }` the loop measures on the holdout. See
- * agent-eval's `docs/design/self-improvement-engine.md`.
- */
-
-/** The byte-producing seam — the ONE thing that differs between the cheap
- *  reflective path and the full agentic path. A generator makes (uncommitted)
- *  changes inside `worktreePath`; the driver commits them via the worktree
- *  adapter's `finalize`. */
-interface CandidateGenerator {
-    kind: string;
-    generate(args: {
-        /** The candidate worktree — a fresh checkout of baseRef. Write changes here. */
-        worktreePath: string;
-        /** Phase-2 research report (analyst findings + diff), opaque. */
-        report: unknown;
-        /** Findings resolved from the report or the loop context. */
-        findings: AnalystFinding[];
-        /** Handle to all captured data, to ground the change. */
-        dataset?: LabeledScenarioStore;
-        /** DEPTH: max iterations the generator may take (agentic uses this; the
-         *  reflective generator ignores it). */
-        maxShots: number;
-        signal: AbortSignal;
-    }): Promise<{
-        applied: boolean;
-        summary: string;
-    }>;
-}
-interface ImprovementDriverOptions {
-    worktree: WorktreeAdapter;
-    generator: CandidateGenerator;
-    /** Base ref candidate worktrees fork from. Default `main`. */
-    baseRef?: string;
-}
-declare function improvementDriver(opts: ImprovementDriverOptions): SurfaceProposer<AnalystFinding>;
-
-/**
- * @experimental
- *
- * `agenticGenerator` — the full-agentic `CandidateGenerator`: the
- * `shots=N, sandbox=on` setting of the one `improvementDriver`. It runs a real
- * coding harness (claude / codex / opencode) inside the candidate worktree the
- * driver already created, letting the agent read the codebase + the research
- * report and make the change in place. The driver then commits the worktree
- * into a `CodeSurface`.
- *
- * Mechanism: identical to the proven Phase-2.8 in-process executor — spawn the
- * harness as a subprocess with `cwd` = the worktree, on the same filesystem,
- * so edits land in place (no sandbox-mount round-trip). `runLocalHarness` is
- * the verified primitive. The OUTER sandbox is the improvement loop's own
- * execution context; the generator does not nest a second sandbox per
- * candidate (which would reintroduce a host↔sandbox worktree-transport
- * problem that does not need solving here).
- *
- * `maxShots` is the DEPTH dial — a multi-shot verify-in-session loop, NOT the
- * kernel `runLoop`. Each shot runs one full harness session in the (persistent)
- * worktree; between shots the loop refines based on what the last shot produced:
- *   - empty tree   → "you changed nothing, make the edits" → retry
- *   - dirty + `verify` fails → feed the verifier's failure into the next shot
- *       (the worktree persists, so the harness RESUMES atop its own failing
- *       edits with the error in hand — no `--resume` session plumbing needed,
- *       and harness-agnostic across claude/codex/opencode)
- *   - dirty + `verify` ok (or no verifier configured) → return the candidate
- * A candidate that never verifies within `maxShots` is discarded (`applied:
- * false`), never shipped — if you configured a verifier, a non-passing tree is
- * not a candidate. With no verifier the legacy behavior holds: first dirty shot
- * is the candidate.
- */
-
-/** Outcome of verifying a candidate worktree. `feedback` (compiler errors,
- *  failing test output) is fed into the next shot when `ok` is false. */
-interface VerifyResult {
-    ok: boolean;
-    feedback?: string;
-}
-/** 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;
-interface AgenticGeneratorOptions {
-    /** Local coding harness to run in the worktree. Default `claude`. */
-    harness?: LocalHarness;
-    /** Per-shot wall-clock timeout (ms). Default = `runLocalHarness` default (5m). */
-    timeoutMs?: number;
-    /** Build the harness task prompt from the report + findings. Override for
-     *  domain phrasing; the default turns findings into a concrete coder task. */
-    buildPrompt?: (args: {
-        report: unknown;
-        findings: AnalystFinding[];
-    }) => string;
-    /** Verify the worktree after each dirtying shot. When set, a candidate that
-     *  fails verification is NOT returned — the failure feeds the next shot
-     *  (verify-in-session), up to `maxShots`; a candidate that never verifies is
-     *  discarded (`applied:false`), never shipped. Omitted ⇒ legacy behavior:
-     *  the first dirty shot is the candidate. See `commandVerifier`. */
-    verify?: Verifier;
-    /** Test seam — inject the harness runner (defaults to `runLocalHarness`). */
-    runHarness?: typeof runLocalHarness;
-    /** Test seam — inject the worktree-dirty check (defaults to `git status`). */
-    isDirty?: (worktreePath: string) => boolean;
-}
-declare function agenticGenerator(opts?: AgenticGeneratorOptions): CandidateGenerator;
-/** 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
- *  FAILED candidate (a change that hangs the build is a bad change); a missing
- *  binary or spawn fault throws (a setup bug, not a failed candidate — no
- *  silent fallback). */
-declare function commandVerifier(command: string, args?: string[], timeoutMs?: number): Verifier;
-
 /**
  * Build-prompt starting points for the two buildable artifact types. There is
  * NO `toolGenerator`/`mcpGenerator` wrapper — the factory is `agenticGenerator`
@@ -1343,7 +1219,7 @@ interface ImproveOptions<TScenario extends Scenario$1, TArtifact> {
     /** The `SurfaceProposer` that mutates the surface. When unset, the facade
      *  picks the default for `surface` (`gepaProposer` for prompt, `skillOptProposer`
      *  for skills); surfaces with no default REQUIRE this (fail-loud otherwise). */
-    generator?: SurfaceProposer$1;
+    generator?: SurfaceProposer;
     /** Gate mode. `'holdout'` (default) runs the held-out promotion gate;
      *  `'none'` is a baseline-only run (`budget.generations = 0`). */
     gate?: 'holdout' | 'none';
@@ -1392,36 +1268,6 @@ interface ImproveResult<TScenario extends Scenario$1, TArtifact> {
  */
 declare function improve<TScenario extends Scenario$1, TArtifact>(profile: AgentProfile$1, findings: unknown[], opts: ImproveOptions<TScenario, TArtifact>): Promise<ImproveResult<TScenario, TArtifact>>;
 
-/**
- * `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;
-}
-declare function mcpServeVerifier(spec: McpServeSpec): Verifier;
-
 /**
  * @experimental
  *
@@ -1885,4 +1731,4 @@ interface StreamToolLoopOptions<Raw> {
  *  `capped` if it stops for any non-completed reason with calls still pending. */
 declare function streamToolLoop<Raw>(opts: StreamToolLoopOptions<Raw>): AsyncGenerator<StreamToolLoopYield<Raw>, void, unknown>;
 
-export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AgenticGeneratorOptions, type AuthSource, type BackendCallPolicy, BackendTransportError, type CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, type EvalPersonaOptions, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, type ImproveOptions, type ImproveResult, type ImproveSurface, type ImprovementDriverOptions, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type McpServeSpec, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, type ReflectiveGeneratorOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, type Verifier, type VerifyResult, agenticGenerator, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, commandVerifier, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, evalPersona, getModels, handleChatTurn, improve, improvementDriver, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, mcpServeVerifier, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, toolBuildPrompt, turnId, validateChatModelId };
+export { AgentBackendContext, AgentBackendInput, AgentExecutionBackend, AgentRuntimeEvent, AgentTaskRunResult, AgentTaskStatus, type AuthSource, type BackendCallPolicy, BackendTransportError, CandidateGenerator, type ChatStreamEvent, type ChatTurnHooks, type ChatTurnIdentity, type ChatTurnProducer, type ChatTurnResult, type CircuitBreakerConfig, CircuitBreakerState, CircuitOpenError, type Conversation, type ConversationDriveState, type ConversationJournal, type ConversationJournalEntry, type ConversationParticipant, type ConversationPolicy, type ConversationResult, type ConversationStreamEvent, type ConversationTurn, type D1DatabaseLike, type D1StmtLike, DEFAULT_MAX_DEPTH, DEFAULT_ROUTER_BASE_URL, DeadlineExceededError, type EvalPersonaOptions, FORWARD_HEADERS, FileConversationJournal, type ForwardHeaderName, type HaltContext, type HaltPredicate, type HaltReason, type HaltSignal, type ImproveOptions, type ImproveResult, type ImproveSurface, InMemoryConversationJournal, InMemoryRuntimeSessionStore, type ModelInfo, OpenAIChatTool, OpenAIChatToolChoice, type PersonaConversationResult, type PersonaDriver, PlannerError, type PropagatedHeaders, type ReflectiveGeneratorOptions, type ResolvedChatModel, type RetryBackoff, type RetryableErrorPredicate, type RouterEnv, type RunChatTurnInput, type RunConversationOptions, type RunPersonaConfig, type RunPersonaConversationOptions, type RunToolLoopOptions, type RuntimeEventCollector, RuntimeHooks, RuntimeRunStateError, RuntimeSessionStore, RuntimeStreamEvent, type RuntimeStreamEventCollector, type RuntimeTelemetryOptions, type SanitizedKnowledgeReadinessReport, type SqlAdapter, SqlConversationJournal, type StreamToolLoopOptions, type StreamToolLoopYield, type ToolCallOutcome, type ToolLoopAssistantToolCall, type ToolLoopCall, type ToolLoopEvent, type ToolLoopMessage, type ToolLoopResult, type ToolLoopStopReason, type TurnOrder, applyRunRecordDefaults, buildForwardHeaders, cleanModelId, computeBackoff, createConversationBackend, createIterableBackend, createOpenAICompatibleBackend, createRuntimeEventCollector, createRuntimeStreamEventCollector, createSandboxPromptBackend, d1ToSqlAdapter, decideKnowledgeReadiness, defaultIsRetryable, defineConversation, deriveExecutionId, evalPersona, getModels, handleChatTurn, improve, isDepthExceeded, makePerAttemptSignal, mcpBuildPrompt, readDepth, readinessServerSentEvent, reflectiveGenerator, resolveChatModel, resolveRouterBaseUrl, runAgentTask, runAgentTaskStream, runConversation, runConversationStream, runPersonaConversation, runPersonaDispatch, runToolLoop, runtimeStreamServerSentEvent, sanitizeAgentRuntimeEvent, sanitizeKnowledgeReadinessReport, sanitizeRuntimeStreamEvent, sleep, slugifySpeaker, streamToolLoop, toolBuildPrompt, turnId, validateChatModelId };