@tangle-network/agent-eval 0.20.10 → 0.20.12

package/dist/index.d.ts

@@ -1,7 +1,22 @@
 import { TCloud } from '@tangle-network/tcloud';
-import { R as RunRecord, a as RunSplitTag } from './index-1PZOtZFr.js';
-export { B as BENCHMARK_SPLIT_SEED, b as BenchmarkAdapter, c as BenchmarkDatasetItem, d as BenchmarkEvaluation, e as RunJudgeMetadata, f as RunOutcome, g as RunRecordValidationError, h as RunTokenUsage, i as benchmarkDeterministicSplit, j as benchmarks, k as isRunRecord, p as parseRunRecordSafe, r as roundTripRunRecord, v as validateRunRecord } from './index-1PZOtZFr.js';
-import { AxAIService, AxFunction } from '@ax-llm/ax';
+import { ReleaseConfidenceThresholds, ReleaseConfidenceScorecard } from './reporting.js';
+export { BootstrapOptions, BootstrapResult, GainDistributionBin, GainDistributionFigureSpec, GainDistributionOptions, JudgeReplayGateArgs, PairedBootstrapOptions, PairedBootstrapResult, ParetoFigureSpec, ParetoPoint, ReleaseConfidenceAxis, ReleaseConfidenceAxisName, ReleaseConfidenceInput, ReleaseConfidenceIssue, ReleaseConfidenceMetrics, ReleaseConfidenceStatus, ReleaseTraceEvidence, RenderReleaseReportOptions, SummaryTable, SummaryTableOptions, SummaryTableRow, Verdict, assertReleaseConfidence, bhAdjust, bootstrapCi, evaluateReleaseConfidence, gainHistogram, judgeReplayGate, pairedBootstrap, pairedWilcoxon, paretoChart, releaseTraceEvidenceFromMultiShotTrials, renderReleaseReport, summaryTable } from './reporting.js';
+import { F as FeedbackLabel, a as FeedbackTrajectoryStore, b as FeedbackTrajectory, C as ControlSeverity, c as ControlEvalResult } from './feedback-trajectory-BGQ_ANCN.js';
+export { d as ControlActionFailureMode, e as ControlActionOutcome, f as ControlBudget, g as ControlContext, h as ControlDecision, i as ControlRunResult, j as ControlRuntimeConfig, k as ControlRuntimeError, l as ControlStep, m as ControlStopPolicies, n as FeedbackArtifactType, o as FeedbackAttempt, p as FeedbackLabelKind, q as FeedbackLabelSource, r as FeedbackOptimizerRow, s as FeedbackOutcome, t as FeedbackReplayAdapter, u as FeedbackReplayResult, v as FeedbackSeverity, w as FeedbackSplitPolicy, x as FeedbackTask, y as FeedbackTrajectoryFilter, z as FileSystemFeedbackTrajectoryStore, I as InMemoryFeedbackTrajectoryStore, P as PreferenceMemoryEntry, A as ProposedSideEffect, S as StopDecision, B as allCriticalPassed, D as assignFeedbackSplit, E as controlRunToFeedbackTrajectory, G as createFeedbackTrajectory, H as feedbackTrajectoriesToDatasetScenarios, J as feedbackTrajectoriesToOptimizerRows, K as feedbackTrajectoryToDatasetScenario, L as feedbackTrajectoryToOptimizerRow, M as objectiveEval, N as parseFeedbackTrajectoriesJsonl, O as renderPreferenceMemoryMarkdown, Q as replayFeedbackTrajectories, R as replayFeedbackTrajectory, T as runAgentControlLoop, U as serializeFeedbackTrajectoriesJsonl, V as stopOnNoProgress, W as stopOnRepeatedAction, X as subjectiveEval, Y as summarizePreferenceMemory, Z as withAssignedFeedbackSplit } from './feedback-trajectory-BGQ_ANCN.js';
+export { A as ActionExecutionPolicy, a as ActionPolicyDecision, C as ControlRunToRunRecordOptions, L as LlmJsonCall, b as LlmReviewerConfig, P as ProposeFn, c as ProposeInput, d as ProposeOutput, e as ProposeReviewConfig, f as ProposeReviewControlAction, g as ProposeReviewControlConfig, h as ProposeReviewControlResult, i as ProposeReviewControlState, j as ProposeReviewReport, k as ProposeReviewShot, R as Review, l as ReviewFn, m as ReviewInput, n as ReviewMemoryEntry, o as ReviewMemoryStore, p as RunEvidenceMetadata, V as Verification, q as VerifyFn, r as controlFailureClassFromVerification, s as controlRunToRunRecord, t as createLlmReviewer, u as evaluateActionPolicy, v as inMemoryReviewStore, w as jsonlReviewStore, x as runProposeReview, y as runProposeReviewAsControlLoop, z as scoreFromEvals } from './control-C8NKbF3w.js';
+import { T as TraceEmitter, R as Run$1, S as Span, b as TraceEvent, A as Artifact$1, B as BudgetLedgerEntry, a as TraceStore, F as FailureClass, c as BudgetSpec, d as ToolSpan, e as RunFilter, L as LlmSpan, J as JudgeSpan } from './emitter-BYO2nSDA.js';
+export { E as EventFilter, f as EventKind, g as FAILURE_CLASSES, h as FileSystemTraceStore, i as FileSystemTraceStoreOptions, G as GenericSpan, I as InMemoryTraceStore, M as Message, j as RetrievalSpan, k as RunLayer, l as RunStatus, m as SandboxSpan, n as SpanBase, o as SpanFilter, p as SpanHandle, q as SpanKind, r as SpanStatus, s as TRACE_SCHEMA_VERSION, t as TraceEmitterOptions, u as isJudgeSpan, v as isLlmSpan, w as isRetrievalSpan, x as isSandboxSpan, y as isToolSpan, z as llmSpanFromProvider } from './emitter-BYO2nSDA.js';
+import { A as ActionableSideInfo, O as Objective, P as ParetoResult, T as TrialCache, a as TrialResult, E as EvolvableVariant, M as MutateAdapter, V as VariantAggregate } from './multi-shot-optimization-Bvtz294B.js';
+export { b as AsiSeverity, D as DEFAULT_MUTATION_PRIMITIVES, c as Direction, G as GateDecision, d as GateEvidence, e as GenerationReport, H as HeldOutGate, f as HeldOutGateConfig, g as HeldOutGateRejectionCode, I as InMemoryTrialCache, h as MultiShotGateConfig, i as MultiShotGateResult, j as MultiShotMutateAdapter, k as MultiShotOptimizationConfig, l as MultiShotOptimizationResult, m as MultiShotRun, n as MultiShotRunInput, o as MultiShotRunner, p as MultiShotScore, q as MultiShotScorer, r as MultiShotSplit, s as MultiShotTrace, t as MultiShotTrialResult, u as MultiShotVariant, v as PromptEvolutionConfig, w as PromptEvolutionEvent, x as PromptEvolutionResult, R as ReflectionContext, y as ReflectionProposal, S as ScenarioAggregate, z as ScoreAdapter, B as TrialTrace, C as buildReflectionPrompt, F as crowdingDistance, J as defaultMultiShotObjectives, K as dominates, L as paretoFrontier, N as paretoFrontierWithCrowding, Q as parseReflectionResponse, U as runMultiShotOptimization, W as runPromptEvolution, X as scalarScore, Y as trialTraceFromMultiShotTrial } from './multi-shot-optimization-Bvtz294B.js';
+import { llmSpans } from './traces.js';
+export { AnalyzeTracesInput, AnalyzeTracesOptions, AnalyzeTracesResult, AnalyzeTracesTurnSnapshot, DEFAULT_REDACTION_RULES, DEFAULT_TRACE_ANALYST_BUDGETS, DatasetOverview, OTEL_AGENT_EVAL_SCOPE, OtlpExport, OtlpFileTraceStore, OtlpFileTraceStoreOptions, OtlpResourceSpans, OtlpSpan, QueryTracesPage, REDACTION_VERSION, RedactionReport, RedactionRule, SearchSpanResult, SearchTraceResult, SpanMatchRecord, SpanNotFoundError, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_SUBAGENT_DESCRIPTION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TraceAnalysisStore, TraceAnalystByteBudgets, TraceAnalystFilters, TraceAnalystSpan, TraceAnalystSpanKind, TraceAnalystSpanStatus, TraceAnalystTraceSummary, TraceFileMissingError, TraceInsightContext, TraceInsightFinding, TraceInsightPanelRole, TraceInsightPromptInput, TraceInsightQualityGate, TraceInsightQuestion, TraceInsightReadiness, TraceInsightSuite, TraceInsightTask, TraceNotFoundError, ViewSpansResult, ViewTraceOversized, ViewTraceResult, aggregateLlm, analyzeTraces, argHash, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, defaultTraceInsightPanel, describeTraceInsightScope, domainEvidencePattern, exportRunAsOtlp, groupBy, inferDomainKeywords, judgeSpans, planTraceInsightQuestions, redactString, redactValue, runFailureClass, runsForScenario, scoreTraceInsightReadiness, tokenizeDomainWords, toolSpans, traceAnalystFunctionGroup } from './traces.js';
+import { a as DatasetScenario, b as Dataset, c as DatasetManifest } from './dataset-B9qvlm_o.js';
+export { d as DatasetDifficulty, e as DatasetProvenance, D as DatasetSplit, H as HoldoutLockedError, S as SliceOptions, h as hashScenarios } from './dataset-B9qvlm_o.js';
+import { a as RunRecord } from './run-record-CX_jcAyr.js';
+export { b as RunJudgeMetadata, c as RunOutcome, d as RunRecordValidationError, R as RunSplitTag, e as RunTokenUsage, i as isRunRecord, p as parseRunRecordSafe, r as roundTripRunRecord, v as validateRunRecord } from './run-record-CX_jcAyr.js';
+export { CallbackResearcher, CallbackResearcherOptions, ExperimentPlan, ExperimentResult, FailureMode, NoopResearcher, Researcher, SteeringChange } from './optimization.js';
+export { B as BENCHMARK_SPLIT_SEED, a as BenchmarkAdapter, b as BenchmarkDatasetItem, c as BenchmarkEvaluation, d as benchmarkDeterministicSplit, i as benchmarks } from './index-c5saLbKD.js';
+import '@ax-llm/ax';
 
 interface Scenario {
     id: string;
@@ -323,1525 +338,6 @@ declare class ProductClient {
  */
 declare function runE2EWorkflow(client: ProductClient, name: string, workflow: (client: ProductClient) => Promise<CheckResult[]>): Promise<TestResult>;
 
-/**
- * Dataset — versioned, sliceable, content-hashed scenario collection.
- *
- * Scenarios stop being ephemeral arrays and become first-class
- * artifacts. Every Dataset carries:
- *   - content hash (sha256 over canonicalized scenario array)
- *   - provenance (contributor, createdAt, sourceUrl)
- *   - split labels (train | dev | test | holdout)
- *   - difficulty tiers (easy | medium | hard | extreme)
- *   - tags (free-form, per-scenario)
- *
- * `Dataset.slice({ difficulty, split, holdout, seed })` returns a
- * deterministic, reproducible subset. Holdout slices are locked: you
- * can read them but `mutate` throws, which prevents "oh I'll just
- * tweak that one scenario" contamination drift.
- */
-type DatasetSplit = 'train' | 'dev' | 'test' | 'holdout';
-type DatasetDifficulty = 'easy' | 'medium' | 'hard' | 'extreme';
-interface DatasetScenario {
-    id: string;
-    /** Arbitrary payload; the framework doesn't interpret it. */
-    payload: unknown;
-    split?: DatasetSplit;
-    difficulty?: DatasetDifficulty;
-    /** Canary token that MUST NOT round-trip through a correct agent output. */
-    canary?: string;
-    /**
-     * Behavioral-canary forbidden pattern. A string OR a serialized regex
-     * (`/.../flags`) that the agent under test MUST NOT emit. Used by
-     * {@link import('./canary').checkBehavioralCanary | checkBehavioralCanary},
-     * which inverts the contamination-style semantic: presence in the
-     * agent output is a LEAK / failure, not a positive signal.
-     *
-     * Falls back to {@link canary} when omitted.
-     */
-    forbiddenPattern?: string;
-    tags?: Record<string, string>;
-}
-interface DatasetProvenance {
-    contributor?: string;
-    createdAt: string;
-    sourceUrl?: string;
-    license?: string;
-    description?: string;
-    /** Monotonic human-readable version (e.g. "2026.04.20"). */
-    version: string;
-}
-interface DatasetManifest {
-    name: string;
-    provenance: DatasetProvenance;
-    /** sha256 hex over canonicalized scenarios. */
-    contentHash: string;
-    scenarioCount: number;
-    splitCounts: Record<DatasetSplit, number>;
-}
-interface SliceOptions {
-    split?: DatasetSplit;
-    difficulty?: DatasetDifficulty;
-    /** Number of scenarios (random sample, seeded). Omit to take all that match. */
-    limit?: number;
-    seed?: number;
-    /** Predicate narrowing. Applied after split/difficulty filters. */
-    filter?: (scenario: DatasetScenario) => boolean;
-    /** If true, include scenarios marked as holdout. Default false. */
-    includeHoldout?: boolean;
-}
-/** Locked holdouts — throws on mutate. Callers that need a mutable dataset fork it. */
-declare class HoldoutLockedError extends Error {
-    constructor(datasetName: string);
-}
-declare class Dataset {
-    readonly name: string;
-    readonly provenance: DatasetProvenance;
-    private scenarios;
-    private locked;
-    constructor(init: {
-        name: string;
-        provenance: DatasetProvenance;
-        scenarios: DatasetScenario[];
-        locked?: boolean;
-    });
-    /** All scenarios. Readonly — callers must go through `slice` or `clone`. */
-    all(): readonly DatasetScenario[];
-    get size(): number;
-    /**
-     * Deterministic sliced subset. Seed is REQUIRED when `limit` is set so
-     * the same arguments always produce the same slice across machines.
-     */
-    slice(options?: SliceOptions): DatasetScenario[];
-    /**
-     * Assemble the manifest (name + provenance + content hash + counts).
-     * Content hash is deterministic over canonicalized scenarios.
-     */
-    manifest(): Promise<DatasetManifest>;
-    /** Fresh unlocked copy — for post-release forks when mutation is needed. */
-    clone(overrides?: Partial<{
-        name: string;
-        version: string;
-    }>): Dataset;
-    lock(): void;
-    add(scenario: DatasetScenario): void;
-    remove(scenarioId: string): void;
-    /**
-     * Stable JSON-Lines serialization — deterministic byte-for-byte.
-     * Write to disk for contamination-verifiable archives.
-     */
-    toJsonl(): string;
-    static fromJsonl(jsonl: string, manifest: Omit<DatasetManifest, 'contentHash' | 'scenarioCount' | 'splitCounts'>): Dataset;
-}
-declare function hashScenarios(scenarios: DatasetScenario[]): Promise<string>;
-
-/**
- * HeldOutGate — first-class held-out paired-delta promotion gate.
- *
- * Encodes the "honesty override" pattern that lived inline in
- * `~/webb/redteam/scripts/agent-eval-autoresearch.ts:138–171`.
- * The optimizer's best-guess is one thing; what we should actually
- * ship is another. The gate is the line between them.
- *
- * A candidate is promoted iff ALL three pass:
- *
- *   1. **Productive runs**: the candidate has at least
- *      `minProductiveRuns` paired observations on items where BOTH
- *      candidate and baseline produced a real (non-silent) score.
- *   2. **Paired delta**: the lower bound of the bootstrap CI on the
- *      median per-item delta (candidate − baseline) on the HOLDOUT
- *      split is strictly greater than `pairedDeltaThreshold`.
- *   3. **Overfit gap**: the candidate's gap between search-split
- *      score and holdout-split score is no worse (more positive)
- *      than the baseline's gap by more than `overfitGapThreshold`.
- *      "Better on search, worse on holdout" is the canonical
- *      overfit pattern; this catches it.
- *
- * The decision carries a machine-readable `rejectionCode` plus an
- * `evidence` block with every number the gate looked at, so the
- * downstream researcher / paper / dashboard can re-derive the
- * verdict without re-running.
- *
- * See also:
- *   - `src/paired-stats.ts` for `pairedBootstrap` + `pairedWilcoxon`
- *   - `src/run-record.ts` for the input row schema
- *   - `src/reference-replay.ts` for the older, reference-replay-
- *     specific promotion path (still useful for replay-style evals).
- */
-
-type HeldOutGateRejectionCode = 'few_runs' | 'negative_delta' | 'overfit_gap';
-interface HeldOutGateConfig {
-    /** Minimum number of paired (candidate, baseline) holdout observations
-     *  required before the gate will even consider promoting. Default 3. */
-    minProductiveRuns?: number;
-    /** The bootstrap-CI lower bound on the median paired holdout delta
-     *  must exceed this to promote. Default 0. */
-    pairedDeltaThreshold?: number;
-    /** Maximum allowed worsening of (search − holdout) gap relative to
-     *  baseline. Default 0.15 (i.e. candidate may overfit by up to 15
-     *  absolute score points more than baseline before rejection). */
-    overfitGapThreshold?: number;
-    /** Stable label of the baseline candidate. Required — paper-grade
-     *  evaluation never compares two unlabelled candidates. */
-    baselineKey: string;
-    /** Confidence level for the bootstrap CI. Default 0.95. */
-    confidence?: number;
-    /** Bootstrap resamples. Default 2000. */
-    bootstrapResamples?: number;
-    /** Optional deterministic seed for the bootstrap. Default undefined
-     *  (Math.random). */
-    seed?: number;
-}
-interface GateEvidence {
-    /** Number of paired (candidate, baseline) holdout observations used. */
-    productiveRuns: number;
-    /** Median of (candidate − baseline) paired holdout deltas. */
-    medianPairedDelta: number;
-    /** Bootstrap CI on the median paired holdout delta. */
-    pairedCI: {
-        low: number;
-        high: number;
-    };
-    /** Wilcoxon signed-rank p-value on the paired holdout deltas. */
-    pairedPValue: number;
-    /** Mean candidate score on the search split (NaN if none). */
-    searchScore: number;
-    /** Mean candidate score on the holdout split (NaN if none). */
-    holdoutScore: number;
-    /** Candidate (search − holdout) gap. */
-    overfitGap: number;
-    /** Baseline (search − holdout) gap. */
-    baselineOverfitGap: number;
-}
-interface GateDecision {
-    /** Final promote/no-promote verdict. */
-    promote: boolean;
-    /** The candidate that was evaluated. */
-    candidateId: string;
-    /** The baseline it was compared against. */
-    baselineId: string;
-    /** Every number the gate looked at, for audit + paper export. */
-    evidence: GateEvidence;
-    /** Human-readable reason. */
-    reason: string;
-    /** Machine-readable rejection code, or null on promote. */
-    rejectionCode: HeldOutGateRejectionCode | null;
-}
-/**
- * Held-out paired-delta promotion gate. Construct once with config,
- * call `evaluate(candidateRuns, baselineRuns)` per (candidate,
- * baseline) pair. Stateless across calls.
- */
-declare class HeldOutGate {
-    private readonly minProductiveRuns;
-    private readonly pairedDeltaThreshold;
-    private readonly overfitGapThreshold;
-    private readonly baselineKey;
-    private readonly confidence;
-    private readonly resamples;
-    private readonly seed?;
-    constructor(config: HeldOutGateConfig);
-    /** Decide whether `candidate` should replace `baseline`. Pairing
-     *  is by (experimentId, seed) — identical experiment + seed pairs
-     *  the candidate run with the matching baseline run. Pairs without
-     *  a holdout score on both sides are dropped. */
-    evaluate(candidate: RunRecord[], baseline: RunRecord[]): GateDecision;
-}
-
-/**
- * Pareto frontier — multi-objective optimization over candidate runs.
- *
- * Lifted from ADC pareto.ts and blueprint-agent frontier.ts. When you're
- * trading off (cost, latency, quality) or (passRate, tokenBudget,
- * ttfb), you rarely have a single "winner" — you have a set of
- * non-dominated candidates. This module exposes:
- *
- *   - `paretoFrontier`: filter a set of candidates to the non-dominated ones
- *   - `dominates`: does A dominate B across all objectives?
- *
- * Each objective is declared with a direction: 'maximize' (higher=better)
- * or 'minimize' (lower=better). Candidates are any object; pass an
- * `objective(candidate)` accessor.
- */
-type Direction = 'maximize' | 'minimize';
-interface Objective<T> {
-    /** Stable label used in reports. */
-    name: string;
-    direction: Direction;
-    value: (candidate: T) => number;
-}
-interface ParetoResult<T> {
-    frontier: T[];
-    dominated: T[];
-    /** Index map: frontier[i] dominates each of dominatedBy[i]. */
-    dominanceMap: Array<{
-        dominator: T;
-        dominated: T[];
-    }>;
-}
-/** Does candidate A weakly dominate B — strictly better on at least one objective and no worse on any? */
-declare function dominates<T>(a: T, b: T, objectives: Objective<T>[]): boolean;
-/**
- * Compute the non-dominated frontier. Candidates with NaN/Infinity on any
- * objective are excluded (can't rank them). A candidate enters the frontier
- * iff no other candidate dominates it.
- */
-declare function paretoFrontier<T>(candidates: T[], objectives: Objective<T>[]): ParetoResult<T>;
-/**
- * Weighted-sum scalarisation. Use as a tie-break / single-winner selector
- * when callers don't want to consume a frontier. Each objective contributes
- * its normalised value (0..1 via min-max across the candidate pool) times
- * its weight; missing weights default to 1/N.
- *
- * Direction is honoured automatically — `minimize` axes have their values
- * inverted before scaling so "higher scalar = better" always holds.
- */
-declare function scalarScore<T>(candidates: T[], objectives: Objective<T>[], options?: {
-    weights?: Partial<Record<string, number>>;
-}): Array<{
-    candidate: T;
-    score: number;
-}>;
-/**
- * NSGA-II crowding distance — secondary sort for ties on the frontier.
- *
- * When the Pareto front collapses to a single point (or many candidates tie
- * on dominance), naive selection picks arbitrarily and the population
- * degenerates over generations. NSGA-II preserves diversity by preferring
- * candidates with more empty space around them on the frontier.
- *
- * Returns an array of `{ candidate, distance }` in the SAME order as the
- * input. Higher distance = more isolated = should be preferred when
- * preserving diversity.
- */
-declare function crowdingDistance<T>(candidates: T[], objectives: Objective<T>[]): Array<{
-    candidate: T;
-    distance: number;
-}>;
-/**
- * Pareto frontier with tie-break by crowding distance — the canonical
- * NSGA-II selection step. Returns the frontier sorted by descending crowding
- * distance so callers can `.slice(0, k)` to pick K diverse winners.
- */
-declare function paretoFrontierWithCrowding<T>(candidates: T[], objectives: Objective<T>[]): Array<{
-    candidate: T;
-    distance: number;
-}>;
-
-/**
- * PromptEvolutionLoop — population-based reflective-mutation evolution.
- *
- * Above the existing `AxGepaSteeringOptimizer` (which RANKS variants),
- * this loop GENERATES variants. Each generation:
- *   1. Score the population across (variant × scenario × rep).
- *   2. Pick survivors from the Pareto frontier (with crowding-distance tie-break).
- *   3. Ask the mutator for replacements until population size is restored.
- *   4. Repeat for N generations OR until convergence.
- *
- * Domain-agnostic. Consumers supply:
- *   - A seed population of `EvolvableVariant`s.
- *   - A `ScoreAdapter` that runs (variant, scenario, rep) → `TrialResult`.
- *   - A `MutateAdapter` that produces children given trace evidence.
- *   - Pareto `Objective<TrialAggregate>[]` defining the multi-objective vector.
- *
- * The loop owns: population management, parallel scheduling (concurrency-
- * limited), Pareto selection with crowding distance, generation reporting.
- *
- * It does NOT own: rendering trials to a model, executing prompts, choosing
- * mutation primitives, persisting to disk. Those are the consumer's call.
- */
-
-interface EvolvableVariant<P = unknown> {
-    /** Stable id for the variant — surfaces in reports and trial results. */
-    id: string;
-    /** Variant payload — interpretation is the consumer's responsibility. */
-    payload: P;
-    /** Generation index (0 = seed, then 1, 2, ...). */
-    generation: number;
-    /** Parent variant id when produced via mutation; absent for seeds. */
-    parentId?: string;
-    /** Human label for reports. */
-    label: string;
-    /** What the mutator was trying to fix. */
-    rationale?: string;
-}
-interface TrialResult {
-    variantId: string;
-    scenarioId: string;
-    rep: number;
-    ok: boolean;
-    /** Primary scalar score the consumer cares about (e.g., recall, accuracy). */
-    score: number;
-    /** Token cost (or any cost-like dimension). */
-    cost?: number;
-    /** Wall time in ms. */
-    durationMs?: number;
-    /** Free-form metric bag for objective accessors. */
-    metrics?: Record<string, number>;
-    error?: string;
-}
-/** Aggregated trial summary for one (variant, scenario) pair across reps. */
-interface ScenarioAggregate {
-    variantId: string;
-    scenarioId: string;
-    meanScore: number;
-    meanCost: number;
-    meanDurationMs: number;
-    okRate: number;
-    trials: number;
-    /** Mean of every numeric metric across reps. */
-    metrics: Record<string, number>;
-}
-/** Aggregated trial summary for one variant across all scenarios. */
-interface VariantAggregate {
-    variantId: string;
-    meanScore: number;
-    meanCost: number;
-    meanDurationMs: number;
-    okRate: number;
-    scenarios: ScenarioAggregate[];
-    /** Mean of every numeric metric, averaged across scenarios. */
-    metrics: Record<string, number>;
-}
-interface ScoreAdapter<P = unknown> {
-    score(args: {
-        variant: EvolvableVariant<P>;
-        scenarioId: string;
-        rep: number;
-    }): Promise<TrialResult>;
-}
-interface MutateAdapter<P = unknown> {
-    mutate(args: {
-        parent: EvolvableVariant<P>;
-        parentAggregate: VariantAggregate;
-        topTrials: TrialResult[];
-        bottomTrials: TrialResult[];
-        childCount: number;
-        generation: number;
-    }): Promise<EvolvableVariant<P>[]>;
-}
-interface PromptEvolutionConfig<P = unknown> {
-    runId: string;
-    /** What component is being mutated — surfaces in reports + reflection prompts. */
-    target: string;
-    seedVariants: EvolvableVariant<P>[];
-    scenarioIds: string[];
-    reps: number;
-    generations: number;
-    populationSize: number;
-    /** Maximum concurrent score() calls. */
-    scoreConcurrency: number;
-    scoreAdapter: ScoreAdapter<P>;
-    mutateAdapter: MutateAdapter<P>;
-    /** Pareto objectives over `VariantAggregate`. Ordered by importance. */
-    objectives: Objective<VariantAggregate>[];
-    /** Optional weights for the scalar tie-break selector (by objective name). */
-    scalarWeights?: Record<string, number>;
-    /** Stop early if a generation produces no Pareto improvement. Default true. */
-    earlyStopOnNoImprovement?: boolean;
-    onProgress?: (event: PromptEvolutionEvent) => void;
-    /**
-     * Optional cache key for memoising scored (variantId, scenarioId, rep)
-     * tuples. When provided AND a cache instance is passed, repeated trials
-     * skip re-scoring. Cache keys are stable across runs.
-     */
-    cache?: TrialCache;
-}
-interface TrialCache {
-    get(key: string): TrialResult | undefined;
-    set(key: string, value: TrialResult): void;
-}
-declare class InMemoryTrialCache implements TrialCache {
-    private store;
-    get(key: string): TrialResult | undefined;
-    set(key: string, value: TrialResult): void;
-    size(): number;
-    clear(): void;
-}
-type PromptEvolutionEvent = {
-    type: 'generation-start';
-    generation: number;
-    populationSize: number;
-} | {
-    type: 'trial-complete';
-    generation: number;
-    variantId: string;
-    scenarioId: string;
-    rep: number;
-    ok: boolean;
-    score: number;
-    cached: boolean;
-} | {
-    type: 'generation-complete';
-    report: GenerationReport<unknown>;
-} | {
-    type: 'converged';
-    generation: number;
-    reason: string;
-};
-interface GenerationReport<P = unknown> {
-    runId: string;
-    target: string;
-    generation: number;
-    variants: EvolvableVariant<P>[];
-    aggregates: VariantAggregate[];
-    /** Frontier candidates, sorted by descending crowding distance. */
-    paretoFrontIds: string[];
-    /** Scalar-best variant id — used for the single "winner" if callers want one. */
-    winnerId: string;
-    /** Trials that fed this generation (kept for downstream reporting). */
-    trials: TrialResult[];
-}
-interface PromptEvolutionResult<P = unknown> {
-    runId: string;
-    target: string;
-    generations: GenerationReport<P>[];
-    /** Best variant by scalar score in the final generation. */
-    bestVariant: EvolvableVariant<P>;
-    /** Best aggregate (matches bestVariant). */
-    bestAggregate: VariantAggregate;
-}
-declare function runPromptEvolution<P>(config: PromptEvolutionConfig<P>): Promise<PromptEvolutionResult<P>>;
-
-/**
- * Reflective mutation — primitives for trace-conditioned prompt rewriting.
- *
- * Used by `prompt-evolution.ts` (and any consumer running iterative
- * improvement). Given a parent prompt + concrete trace evidence (top trials,
- * bottom trials, missed expectations), produce an LLM-ready prompt that
- * proposes targeted mutations — not blind rephrasings.
- *
- * Why this lives outside `prompt-evolution.ts`: any consumer that wants to
- * run reflective rewriting WITHOUT the population/Pareto machinery can
- * import these primitives directly.
- *
- * Quality bar (vs. naive "mutate this prompt"):
- *   - Show parent ↔ children diff, not just one variant
- *   - Quote specific missed goldens with their match phrases
- *   - Surface the model's actual emitted output side-by-side with what was expected
- *   - Quote concrete mutation primitives so the model has a vocabulary
- */
-interface TrialTrace {
-    /** Stable id for the trial — surfaces in the prompt for grounding. */
-    id: string;
-    /** Score the trial received on its primary metric. */
-    score: number;
-    /** Candidate inputs the agent was given (e.g., the fixture or scenario). */
-    inputName?: string;
-    /**
-     * Goldens / expectations this trial was tested against, with whether each
-     * was matched. The reflection prompt quotes the missed ones specifically.
-     */
-    expectations?: Array<{
-        id: string;
-        phrase: string;
-        matched: boolean;
-    }>;
-    /** Free-form text — what the agent actually emitted (e.g., findings, plan). */
-    emitted?: string;
-    /** Optional structured metrics (recall, precision, cost, latency). */
-    metrics?: Record<string, number>;
-}
-interface ReflectionContext {
-    /** What is being mutated — appears in the system prompt for orientation. */
-    target: string;
-    /** Current variant's payload — JSON-serialised for the prompt. */
-    parentPayload: unknown;
-    /** Best-performing trials this generation. */
-    topTrials: TrialTrace[];
-    /** Worst-performing trials this generation — the missed-golden source. */
-    bottomTrials: TrialTrace[];
-    /** How many children the mutator should propose. */
-    childCount: number;
-    /** Optional: domain-specific mutation primitives the model can pick from. */
-    mutationPrimitives?: string[];
-}
-declare const DEFAULT_MUTATION_PRIMITIVES: string[];
-/**
- * Build the LLM-ready reflection prompt. Output is plain text — pass it as
- * the user message. The system message should be small and stable (e.g.
- * "Output ONLY a JSON object matching the schema below.").
- */
-declare function buildReflectionPrompt(ctx: ReflectionContext): string;
-interface ReflectionProposal {
-    label: string;
-    rationale: string;
-    payload: unknown;
-}
-declare function parseReflectionResponse(raw: string, maxProposals?: number): ReflectionProposal[];
-
-/**
- * Multi-shot optimization adapter.
- *
- * This is the canonical bridge between variable-length agent trajectories
- * and `runPromptEvolution`. Apps provide four things:
- *
- *   - variants: prompt/config/tool-policy candidates
- *   - runner: executes one full task trajectory for a variant
- *   - scorer: turns that trajectory into score + actionable side information
- *   - mutator: proposes new variants from top/bottom scored trials
- *
- * The adapter owns the boring but easy-to-get-wrong glue: stable seeds,
- * score/cost objectives, error-to-trial conversion, ASI metric projection,
- * and optional paired holdout gating via `HeldOutGate`.
- */
-
-type MultiShotSplit = 'search' | 'dev' | 'holdout';
-type AsiSeverity = 'info' | 'warning' | 'error' | 'critical';
-type MultiShotVariant<P = unknown> = EvolvableVariant<P>;
-interface ActionableSideInfo {
-    /** Stable expectation/check id when available. */
-    expectationId?: string;
-    /** Human-readable diagnosis of what happened. */
-    message: string;
-    severity?: AsiSeverity;
-    /** Concrete trace excerpt, file path, tool call, screenshot id, etc. */
-    evidence?: string;
-    /** Prompt/tool/context surface likely responsible. */
-    responsibleSurface?: string;
-    /** Suggested fix in natural language. */
-    suggestion?: string;
-    /** Whether this expectation was satisfied. Defaults to false for ASI rows. */
-    matched?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface MultiShotTrace {
-    scenarioId: string;
-    /** Full turn/tool trace. Shape is intentionally app-owned. */
-    turns?: unknown[];
-    toolCalls?: unknown[];
-    artifacts?: unknown[];
-    /** Compact final output or summary used by reflection prompts. */
-    transcript?: string;
-    output?: unknown;
-    metadata?: Record<string, unknown>;
-}
-interface MultiShotRun {
-    trace: MultiShotTrace;
-    costUsd?: number;
-    durationMs?: number;
-    tokenUsage?: {
-        input?: number;
-        output?: number;
-        cached?: number;
-    };
-    metadata?: Record<string, unknown>;
-}
-interface MultiShotRunInput<P = unknown> {
-    variant: EvolvableVariant<P>;
-    scenarioId: string;
-    rep: number;
-    split: MultiShotSplit;
-    /** Stable paired seed for baseline/candidate comparisons. */
-    seed: number;
-}
-interface MultiShotRunner<P = unknown> {
-    run(input: MultiShotRunInput<P>): Promise<MultiShotRun> | MultiShotRun;
-}
-interface MultiShotScore {
-    /** Primary score in [0,1]. The adapter clamps for safety. */
-    score: number;
-    /** Pass/fail for top/bottom trial selection. Defaults to true. */
-    ok?: boolean;
-    costUsd?: number;
-    durationMs?: number;
-    metrics?: Record<string, number>;
-    asi?: ActionableSideInfo[];
-    /** Optional rich output shown to reflection mutators. */
-    emitted?: string;
-    metadata?: Record<string, unknown>;
-}
-interface MultiShotScorer<P = unknown> {
-    score(input: MultiShotRunInput<P> & {
-        run: MultiShotRun;
-    }): Promise<MultiShotScore> | MultiShotScore;
-}
-interface MultiShotTrialResult extends TrialResult {
-    split: MultiShotSplit;
-    seed: number;
-    trace?: MultiShotTrace;
-    asi?: ActionableSideInfo[];
-    emitted?: string;
-    metadata?: Record<string, unknown>;
-}
-interface MultiShotMutateAdapter<P = unknown> {
-    mutate(args: {
-        parent: EvolvableVariant<P>;
-        parentAggregate: VariantAggregate;
-        topTrials: MultiShotTrialResult[];
-        bottomTrials: MultiShotTrialResult[];
-        childCount: number;
-        generation: number;
-    }): Promise<EvolvableVariant<P>[]>;
-}
-interface MultiShotGateConfig<P = unknown> {
-    /** Search rows are optional, but enable HeldOutGate's overfit-gap check. */
-    searchScenarioIds?: string[];
-    holdoutScenarioIds: string[];
-    reps?: number;
-    gate: HeldOutGateConfig;
-    /** Convert scored trajectory runs into paper-grade RunRecords. */
-    toRunRecord(input: {
-        variant: EvolvableVariant<P>;
-        scenarioId: string;
-        rep: number;
-        split: RunSplitTag;
-        seed: number;
-        trial: MultiShotTrialResult;
-    }): RunRecord;
-}
-interface MultiShotOptimizationConfig<P = unknown> {
-    runId: string;
-    target: string;
-    seedVariants: EvolvableVariant<P>[];
-    searchScenarioIds: string[];
-    reps: number;
-    generations: number;
-    populationSize: number;
-    scoreConcurrency?: number;
-    runner: MultiShotRunner<P>;
-    scorer: MultiShotScorer<P>;
-    mutateAdapter: MultiShotMutateAdapter<P>;
-    objectives?: Objective<VariantAggregate>[];
-    scalarWeights?: Record<string, number>;
-    cache?: TrialCache;
-    earlyStopOnNoImprovement?: boolean;
-    seedBase?: number;
-    onProgress?: (event: PromptEvolutionEvent) => void;
-    gate?: MultiShotGateConfig<P>;
-}
-interface MultiShotGateResult {
-    decision: GateDecision;
-    candidateRuns: RunRecord[];
-    baselineRuns: RunRecord[];
-}
-interface MultiShotOptimizationResult<P = unknown> {
-    evolution: PromptEvolutionResult<P>;
-    /** Best candidate on the optimizer-visible search split. */
-    searchBestVariant: EvolvableVariant<P>;
-    searchBestAggregate: VariantAggregate;
-    /** Variant callers should actually ship after optional holdout gating. */
-    promotedVariant: EvolvableVariant<P>;
-    promotedAggregate: VariantAggregate;
-    /** Null when no gate was configured or the search-best candidate was the baseline. */
-    gate: MultiShotGateResult | null;
-}
-declare function runMultiShotOptimization<P>(config: MultiShotOptimizationConfig<P>): Promise<MultiShotOptimizationResult<P>>;
-declare function defaultMultiShotObjectives(): Objective<VariantAggregate>[];
-declare function trialTraceFromMultiShotTrial(trial: MultiShotTrialResult): TrialTrace;
-
-/**
- * Release confidence gate.
- *
- * This is the production-facing composition layer over the lower-level
- * primitives:
- *   - Dataset manifests prove corpus/version coverage.
- *   - RunRecord rows prove reproducible search/holdout outcomes.
- *   - Multi-shot trace evidence carries turn counts and ASI diagnostics.
- *   - HeldOutGate decisions remain the paired promotion authority.
- *
- * The gate is intentionally pure and conservative. Missing declared evidence
- * fails closed instead of being treated as a neutral zero.
- */
-
-type ReleaseConfidenceStatus = 'pass' | 'warn' | 'fail';
-type ReleaseConfidenceAxisName = 'corpus' | 'quality' | 'generalization' | 'diagnostics' | 'efficiency';
-interface ReleaseTraceEvidence {
-    scenarioId: string;
-    candidateId?: string;
-    split?: RunSplitTag;
-    score?: number;
-    ok?: boolean;
-    turnCount?: number;
-    costUsd?: number;
-    durationMs?: number;
-    failureMode?: string;
-    asi?: ActionableSideInfo[];
-    metadata?: Record<string, unknown>;
-}
-interface ReleaseConfidenceThresholds {
-    /** Require a Dataset manifest or explicit scenarios. Default true. */
-    requireCorpus?: boolean;
-    minScenarioCount?: number;
-    minSearchRuns?: number;
-    minHoldoutRuns?: number;
-    /** Require at least one holdout scenario/run. Default true. */
-    requireHoldout?: boolean;
-    minPassRate?: number;
-    minMeanScore?: number;
-    /** Search mean may exceed holdout mean by at most this much. */
-    maxOverfitGap?: number;
-    maxMeanCostUsd?: number;
-    maxP95WallMs?: number;
-    /** Low-score/failed rows must carry ASI. Default true. */
-    requireAsiForFailures?: boolean;
-    /** Score below this is considered a failure for ASI coverage. Default 0.5. */
-    failureScoreThreshold?: number;
-}
-interface ReleaseConfidenceInput {
-    target: string;
-    candidateId?: string;
-    baselineId?: string;
-    dataset?: DatasetManifest;
-    scenarios?: readonly DatasetScenario[];
-    runs?: readonly RunRecord[];
-    traces?: readonly ReleaseTraceEvidence[];
-    gateDecision?: GateDecision | null;
-    thresholds?: ReleaseConfidenceThresholds;
-}
-interface ReleaseConfidenceAxis {
-    name: ReleaseConfidenceAxisName;
-    status: ReleaseConfidenceStatus;
-    score: number;
-    detail: string;
-}
-interface ReleaseConfidenceIssue {
-    axis: ReleaseConfidenceAxisName;
-    severity: 'critical' | 'warning';
-    code: string;
-    detail: string;
-}
-interface ReleaseConfidenceMetrics {
-    scenarioCount: number;
-    searchRuns: number;
-    holdoutRuns: number;
-    passRate: number;
-    meanScore: number;
-    searchMeanScore: number;
-    holdoutMeanScore: number;
-    overfitGap: number;
-    meanCostUsd: number;
-    p95WallMs: number;
-    failedRows: number;
-    failuresWithAsi: number;
-    singleShotTraces: number;
-    multiShotTraces: number;
-    splitCounts: Record<DatasetSplit, number>;
-    domainCounts: Record<string, number>;
-    failureModeCounts: Record<string, number>;
-    responsibleSurfaceCounts: Record<string, number>;
-}
-interface ReleaseConfidenceScorecard {
-    target: string;
-    candidateId: string | null;
-    baselineId: string | null;
-    status: ReleaseConfidenceStatus;
-    promote: boolean;
-    axes: ReleaseConfidenceAxis[];
-    issues: ReleaseConfidenceIssue[];
-    metrics: ReleaseConfidenceMetrics;
-    dataset: DatasetManifest | null;
-    gateDecision: GateDecision | null;
-    summary: string;
-}
-declare function releaseTraceEvidenceFromMultiShotTrials(trials: readonly MultiShotTrialResult[]): ReleaseTraceEvidence[];
-declare function evaluateReleaseConfidence(input: ReleaseConfidenceInput): ReleaseConfidenceScorecard;
-declare function assertReleaseConfidence(input: ReleaseConfidenceInput): ReleaseConfidenceScorecard;
-
-/**
- * TraceSchema v1 — the canonical data model for agent-eval.
- *
- * Every score, every failure class, every pipeline in the framework is
- * a view over this data. Shape it once, live with it.
- *
- * Wire-compatible with OpenTelemetry span semantics (see trace/otel.ts)
- * but extended with agent-specific span kinds (llm, tool, retrieval,
- * judge, sandbox) and first-class BudgetLedger / Artifact / JudgeVerdict
- * entities that OTEL leaves as free-form attributes.
- */
-declare const TRACE_SCHEMA_VERSION = "1.0.0";
-type RunStatus = 'running' | 'completed' | 'failed' | 'aborted';
-interface BudgetSpec {
-    tokens?: number;
-    wallMs?: number;
-    calls?: number;
-    usd?: number;
-}
-interface RunOutcome {
-    score?: number;
-    pass?: boolean;
-    failureClass?: FailureClass;
-    notes?: string;
-}
-/**
- * Layer — optional classification in a nested build workflow.
- * `builder`: the meta-agent editing a project (e.g. agent-builder Forge chat).
- * `app-build`: sandbox harness that compiled + tested the generated scaffold.
- * `app-runtime`: a run of the generated agent against a domain scenario.
- * `meta`: any meta-eval (judge replay, correlation analysis).
- */
-type RunLayer = 'builder' | 'app-build' | 'app-runtime' | 'meta' | 'custom';
-interface Run$1 {
-    runId: string;
-    scenarioId: string;
-    variantId?: string;
-    datasetVersion?: string;
-    /** Git SHA of agent code at run time. */
-    codeSha?: string;
-    /** Hash of the prompt template + any system prompt. */
-    promptSha?: string;
-    /** Model id + date + system-prompt hash, concatenated. */
-    modelFingerprint?: string;
-    seed?: number;
-    /** Arbitrary environment markers (shell, docker version, tz). */
-    envFingerprint?: Record<string, string>;
-    /** Version of the redaction rules applied to this run. */
-    redactionVersion?: string;
-    /** Parent run in a nested build workflow. A builder run's children are
-     *  app-build runs; those children are app-runtime runs. */
-    parentRunId?: string;
-    /** Stable project identifier — groups runs across chats + sessions. */
-    projectId?: string;
-    /** Chat/conversation identifier within a project. */
-    chatId?: string;
-    /** Layer classification — hint for aggregation; not enforced. */
-    layer?: RunLayer;
-    startedAt: number;
-    endedAt?: number;
-    status: RunStatus;
-    outcome?: RunOutcome;
-    budget?: BudgetSpec;
-    /** Free-form labels for downstream grouping. */
-    tags?: Record<string, string>;
-}
-type SpanKind = 'agent' | 'llm' | 'tool' | 'retrieval' | 'judge' | 'sandbox' | 'custom';
-type SpanStatus = 'ok' | 'error';
-interface SpanBase {
-    spanId: string;
-    parentSpanId?: string;
-    runId: string;
-    kind: SpanKind;
-    name: string;
-    startedAt: number;
-    endedAt?: number;
-    status?: SpanStatus;
-    error?: string;
-    /** Anything not covered by typed fields. Kept deliberately free-form. */
-    attributes?: Record<string, unknown>;
-}
-interface Message {
-    role: 'system' | 'user' | 'assistant' | 'tool';
-    content: string;
-    tokens?: number;
-    /** Multi-modal content descriptors; blobs themselves live in Artifacts. */
-    images?: Array<{
-        artifactId?: string;
-        url?: string;
-        mime?: string;
-    }>;
-}
-interface LlmSpan extends SpanBase {
-    kind: 'llm';
-    model: string;
-    messages: Message[];
-    output?: string;
-    inputTokens?: number;
-    outputTokens?: number;
-    cachedTokens?: number;
-    reasoningTokens?: number;
-    costUsd?: number;
-    finishReason?: string;
-}
-interface ToolSpan extends SpanBase {
-    kind: 'tool';
-    toolName: string;
-    args: unknown;
-    result?: unknown;
-    latencyMs?: number;
-}
-interface RetrievalSpan extends SpanBase {
-    kind: 'retrieval';
-    query: string;
-    hits: Array<{
-        docId: string;
-        score: number;
-        content?: string;
-    }>;
-}
-interface JudgeSpan extends SpanBase {
-    kind: 'judge';
-    judgeId: string;
-    /** Span this judgment applies to. */
-    targetSpanId: string;
-    dimension: string;
-    /** Numeric score (free-range; interpretation up to the judge). */
-    score: number;
-    rationale?: string;
-    evidence?: string;
-}
-interface SandboxSpan extends SpanBase {
-    kind: 'sandbox';
-    image?: string;
-    command?: string;
-    exitCode?: number;
-    testsTotal?: number;
-    testsPassed?: number;
-    stdoutHash?: string;
-    stderrHash?: string;
-    /** Duration in ms; the harness fills this explicitly (endedAt - startedAt may miss setup). */
-    wallMs?: number;
-}
-interface GenericSpan extends SpanBase {
-    kind: 'agent' | 'custom';
-}
-type Span = LlmSpan | ToolSpan | RetrievalSpan | JudgeSpan | SandboxSpan | GenericSpan;
-type EventKind = 'log' | 'error' | 'budget_decrement' | 'budget_breach' | 'state_mutation' | 'policy_violation' | 'redaction_applied' | 'custom';
-interface TraceEvent {
-    eventId: string;
-    runId: string;
-    spanId?: string;
-    kind: EventKind;
-    timestamp: number;
-    payload: Record<string, unknown>;
-}
-interface BudgetLedgerEntry {
-    runId: string;
-    dimension: keyof BudgetSpec;
-    limit: number;
-    consumed: number;
-    remaining: number;
-    timestamp: number;
-    breached: boolean;
-    /** Span that triggered this entry, if any. */
-    spanId?: string;
-}
-interface Artifact$1 {
-    artifactId: string;
-    runId: string;
-    spanId?: string;
-    contentType: string;
-    sizeBytes: number;
-    /** sha256 in hex. */
-    hash: string;
-    /** External storage URL (R2, S3, filesystem path). */
-    storageUrl?: string;
-    /** Inline content for small blobs — keep under ~64KB. */
-    inlineContent?: string;
-}
-type FailureClass = 'success' | 'reasoning_error' | 'tool_selection_error' | 'tool_argument_error' | 'tool_recovery_failure' | 'hallucination' | 'instruction_following' | 'safety_refusal_miss' | 'policy_violation' | 'budget_exceeded' | 'format_drift' | 'permission_escalation' | 'pii_leak' | 'cost_overrun' | 'timeout' | 'sandbox_failure' | 'missing_user_data' | 'missing_domain_data' | 'missing_codebase_context' | 'missing_runtime_context' | 'missing_credentials' | 'stale_external_data' | 'bad_retrieval' | 'insufficient_evidence' | 'contradictory_evidence' | 'ambiguous_user_intent' | 'knowledge_readiness_blocked' | 'unknown';
-declare const FAILURE_CLASSES: readonly FailureClass[];
-declare function isLlmSpan(s: Span): s is LlmSpan;
-declare function isToolSpan(s: Span): s is ToolSpan;
-declare function isRetrievalSpan(s: Span): s is RetrievalSpan;
-declare function isJudgeSpan(s: Span): s is JudgeSpan;
-declare function isSandboxSpan(s: Span): s is SandboxSpan;
-
-interface RunFilter {
-    scenarioId?: string;
-    variantId?: string;
-    status?: RunStatus;
-    since?: number;
-    until?: number;
-    tag?: {
-        key: string;
-        value: string;
-    };
-    parentRunId?: string;
-    projectId?: string;
-    chatId?: string;
-    layer?: RunLayer;
-}
-interface SpanFilter {
-    runId?: string;
-    parentSpanId?: string;
-    kind?: SpanKind;
-    name?: string;
-    toolName?: string;
-    judgeId?: string;
-    since?: number;
-    until?: number;
-}
-interface EventFilter {
-    runId?: string;
-    spanId?: string;
-    kind?: EventKind;
-    since?: number;
-    until?: number;
-}
-interface TraceStore {
-    appendRun(run: Run$1): Promise<void>;
-    updateRun(runId: string, patch: Partial<Run$1>): Promise<void>;
-    appendSpan(span: Span): Promise<void>;
-    updateSpan(spanId: string, patch: Partial<Span>): Promise<void>;
-    appendEvent(event: TraceEvent): Promise<void>;
-    appendArtifact(artifact: Artifact$1): Promise<void>;
-    appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void>;
-    getRun(runId: string): Promise<Run$1 | undefined>;
-    listRuns(filter?: RunFilter): Promise<Run$1[]>;
-    spans(filter?: SpanFilter): Promise<Span[]>;
-    events(filter?: EventFilter): Promise<TraceEvent[]>;
-    budget(runId: string): Promise<BudgetLedgerEntry[]>;
-    artifacts(runId: string): Promise<Artifact$1[]>;
-}
-declare class InMemoryTraceStore implements TraceStore {
-    private runs;
-    private allSpans;
-    private allEvents;
-    private allArtifacts;
-    private allBudget;
-    appendRun(run: Run$1): Promise<void>;
-    updateRun(runId: string, patch: Partial<Run$1>): Promise<void>;
-    appendSpan(span: Span): Promise<void>;
-    updateSpan(spanId: string, patch: Partial<Span>): Promise<void>;
-    appendEvent(event: TraceEvent): Promise<void>;
-    appendArtifact(artifact: Artifact$1): Promise<void>;
-    appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void>;
-    getRun(runId: string): Promise<Run$1 | undefined>;
-    listRuns(filter?: RunFilter): Promise<Run$1[]>;
-    spans(filter?: SpanFilter): Promise<Span[]>;
-    events(filter?: EventFilter): Promise<TraceEvent[]>;
-    budget(runId: string): Promise<BudgetLedgerEntry[]>;
-    artifacts(runId: string): Promise<Artifact$1[]>;
-}
-interface FileSystemTraceStoreOptions {
-    dir: string;
-    /** Roll over NDJSON files when they exceed this size in bytes. Default 32 MB. */
-    maxBytes?: number;
-}
-declare class FileSystemTraceStore implements TraceStore {
-    private dir;
-    private maxBytes;
-    /** Lazy in-memory index for queries — populated on first read. */
-    private index?;
-    private loaded;
-    constructor(options: FileSystemTraceStoreOptions);
-    private ensureDir;
-    private append;
-    private insertInto;
-    private load;
-    appendRun(run: Run$1): Promise<void>;
-    updateRun(runId: string, patch: Partial<Run$1>): Promise<void>;
-    appendSpan(span: Span): Promise<void>;
-    updateSpan(spanId: string, patch: Partial<Span>): Promise<void>;
-    appendEvent(event: TraceEvent): Promise<void>;
-    appendArtifact(artifact: Artifact$1): Promise<void>;
-    appendBudgetEntry(entry: BudgetLedgerEntry): Promise<void>;
-    getRun(runId: string): Promise<Run$1 | undefined>;
-    listRuns(filter?: RunFilter): Promise<Run$1[]>;
-    spans(filter?: SpanFilter): Promise<Span[]>;
-    events(filter?: EventFilter): Promise<TraceEvent[]>;
-    budget(runId: string): Promise<BudgetLedgerEntry[]>;
-    artifacts(runId: string): Promise<Artifact$1[]>;
-}
-
-/**
- * TraceEmitter — hierarchical span builder that auto-parents using an
- * internal stack. One emitter per Run; emitters do NOT share state.
- *
- * Convenience methods (`llm`, `tool`, `retrieval`, `judge`, `sandbox`)
- * return a `SpanHandle` with `.end()` / `.fail()` so callers don't
- * have to thread spanIds manually. For async workflows that can't use
- * the stack (e.g. fan-out parallel calls), pass `parentSpanId`
- * explicitly.
- */
-
-interface SpanHandle<S extends Span = Span> {
-    span: S;
-    end(patch?: Partial<S>): Promise<void>;
-    fail(error: string | Error, patch?: Partial<S>): Promise<void>;
-}
-interface TraceEmitterOptions {
-    runId?: string;
-    /** Inject a clock for deterministic tests. */
-    now?: () => number;
-    /** Inject an id generator for deterministic tests. */
-    id?: () => string;
-}
-declare class TraceEmitter {
-    private store;
-    private stack;
-    private _runId;
-    private now;
-    private id;
-    constructor(store: TraceStore, options?: TraceEmitterOptions);
-    get runId(): string;
-    startRun(run: Omit<Run$1, 'runId' | 'startedAt' | 'status'>): Promise<Run$1>;
-    endRun(outcome?: RunOutcome): Promise<void>;
-    abortRun(reason: string): Promise<void>;
-    span<S extends Span = Span>(init: {
-        kind: SpanKind;
-        name: string;
-        parentSpanId?: string;
-        attributes?: Record<string, unknown>;
-    } & Partial<Omit<S, 'spanId' | 'runId' | 'startedAt' | 'kind' | 'name'>>): Promise<SpanHandle<S>>;
-    private handle;
-    private pop;
-    llm(init: Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<LlmSpan>>;
-    tool(init: Omit<ToolSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<ToolSpan>>;
-    retrieval(init: Omit<RetrievalSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<RetrievalSpan>>;
-    recordJudge(verdict: Omit<JudgeSpan, 'spanId' | 'runId' | 'kind' | 'startedAt' | 'endedAt'>): Promise<JudgeSpan>;
-    sandbox(init: Omit<SandboxSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>): Promise<SpanHandle<SandboxSpan>>;
-    emit(event: {
-        kind: EventKind;
-        spanId?: string;
-        payload?: Record<string, unknown>;
-    }): Promise<TraceEvent>;
-    recordBudget(entry: Omit<BudgetLedgerEntry, 'runId' | 'timestamp'> & {
-        timestamp?: number;
-    }): Promise<BudgetLedgerEntry>;
-    recordArtifact(artifact: Omit<Artifact$1, 'artifactId' | 'runId'>): Promise<Artifact$1>;
-    /**
-     * Runs `fn` inside a span; auto-ends on success, auto-fails on throw.
-     * Returns the fn's return value. Use this for the 95% case.
-     */
-    within<T>(init: Parameters<TraceEmitter['span']>[0], fn: (handle: SpanHandle) => Promise<T>): Promise<T>;
-}
-/** Helper to build an LLM span handle args object from a provider-shaped response. */
-declare function llmSpanFromProvider(args: {
-    name?: string;
-    model: string;
-    messages: Message[];
-    output: string;
-    usage?: {
-        inputTokens?: number;
-        outputTokens?: number;
-        cachedTokens?: number;
-        reasoningTokens?: number;
-    };
-    costUsd?: number;
-    finishReason?: string;
-}): Omit<LlmSpan, 'spanId' | 'runId' | 'kind' | 'startedAt'>;
-
-/**
- * Policy-based agent control runtime.
- *
- * This is the minimal reusable loop behind driver-agent patterns:
- *
- *   observe state -> validate -> decide next action -> act -> observe -> ...
- *
- * It deliberately does not model named "topologies". Direct execution,
- * critic/revise, driver intervention, specialist calls, and human escalation
- * are all just actions chosen by the control policy.
- */
-
-type ControlSeverity = 'info' | 'warning' | 'error' | 'critical';
-type ControlActionFailureMode = 'continue' | 'stop';
-interface ControlEvalResult {
-    /** Stable validator or judge id. */
-    id: string;
-    /** Whether this check passed. */
-    passed: boolean;
-    /** Optional normalized score. 1 = best, 0 = worst. */
-    score?: number;
-    /** Objective validators should usually be "error" or "critical" when failed. */
-    severity?: ControlSeverity;
-    /** Human-readable result. */
-    detail?: string;
-    /** Small evidence string or pointer. Avoid large payloads. */
-    evidence?: string;
-    /** True when the result came from deterministic state, not LLM judgment. */
-    objective?: boolean;
-    /** Structured details for downstream control policies and reports. */
-    metadata?: Record<string, unknown>;
-}
-interface ControlBudget {
-    maxSteps: number;
-    maxWallMs?: number;
-    maxCostUsd?: number;
-}
-interface ControlStopPolicies<TState, TAction> {
-    /**
-     * Stop after N consecutive steps with no state fingerprint change and
-     * less than `minScoreDelta` score movement. Disabled when omitted.
-     */
-    maxNoProgressSteps?: number;
-    /**
-     * Stop after the same action fingerprint is selected N consecutive
-     * times. Disabled when omitted.
-     */
-    maxRepeatedActions?: number;
-    /** Minimum score movement that counts as progress. Default 0.001. */
-    minScoreDelta?: number;
-    /** Override the default JSON/string fingerprint for state comparisons. */
-    stateFingerprint?: (state: TState) => string;
-    /** Override the default JSON/string fingerprint for repeated-action checks. */
-    actionFingerprint?: (action: TAction) => string;
-}
-interface ControlContext<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
-    intent: string;
-    state: TState;
-    evals: TEval[];
-    history: ControlStep<TState, TAction, TActionResult, TEval>[];
-    budget: ControlBudget;
-    stepIndex: number;
-    wallMs: number;
-    spentCostUsd: number;
-    remainingCostUsd?: number;
-    abortSignal: AbortSignal;
-    emitter?: TraceEmitter;
-}
-type ControlDecision<TAction> = {
-    type: 'continue';
-    action: TAction;
-    reason?: string;
-} | {
-    type: 'stop';
-    reason: string;
-    pass?: boolean;
-    score?: number;
-};
-interface StopDecision {
-    stop: boolean;
-    pass: boolean;
-    reason: string;
-    score?: number;
-    failureClass?: FailureClass;
-}
-interface ControlActionOutcome<TActionResult> {
-    ok: boolean;
-    result?: TActionResult;
-    error?: string;
-    costUsd?: number;
-    durationMs: number;
-}
-interface ControlRuntimeError {
-    phase: 'observe' | 'validate' | 'decide' | 'act' | 'stop-policy' | 'on-step' | 'trace';
-    stepIndex: number;
-    message: string;
-}
-interface ControlStep<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
-    index: number;
-    decision: ControlDecision<TAction>;
-    beforeState: TState;
-    afterState: TState;
-    evalsBefore: TEval[];
-    evalsAfter: TEval[];
-    actionOutcome?: ControlActionOutcome<TActionResult>;
-    startedAt: string;
-    endedAt: string;
-}
-interface ControlRunResult<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
-    intent: string;
-    pass: boolean;
-    completed: boolean;
-    reason: string;
-    score?: number;
-    steps: ControlStep<TState, TAction, TActionResult, TEval>[];
-    finalState: TState | undefined;
-    finalEvals: TEval[];
-    wallMs: number;
-    spentCostUsd: number;
-    runId: string | null;
-    failureClass?: FailureClass;
-    runtimeErrors: ControlRuntimeError[];
-    stoppedBy: 'policy' | 'stop-policy' | 'budget' | 'abort' | 'runtime-error';
-}
-interface ControlRuntimeConfig<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult> {
-    intent: string;
-    budget?: Partial<ControlBudget>;
-    signal?: AbortSignal;
-    /** Defaults to `continue`: action failures are recorded, then the policy gets another chance. */
-    actionFailure?: ControlActionFailureMode;
-    /**
-     * Extract cost from an action result. Used for `maxCostUsd` budget
-     * enforcement and trace budget ledger emission.
-     */
-    getActionCostUsd?: (ctx: {
-        action: TAction;
-        result: TActionResult;
-        state: TState;
-        evals: TEval[];
-        history: ControlStep<TState, TAction, TActionResult, TEval>[];
-    }) => number | undefined;
-    /** Read typed task/product state. Prefer structured state over transcript-only context. */
-    observe: (ctx: {
-        history: ControlStep<TState, TAction, TActionResult, TEval>[];
-        abortSignal: AbortSignal;
-    }) => Promise<TState> | TState;
-    /** Objective validators first, subjective judges only where objective state is insufficient. */
-    validate: (ctx: {
-        intent: string;
-        state: TState;
-        history: ControlStep<TState, TAction, TActionResult, TEval>[];
-        abortSignal: AbortSignal;
-    }) => Promise<TEval[]> | TEval[];
-    /** Choose the next control action. Can call a worker, ask user, run critic, inspect state, or stop. */
-    decide: (ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<ControlDecision<TAction>> | ControlDecision<TAction>;
-    /** Execute the action selected by the policy. */
-    act: (action: TAction, ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<TActionResult> | TActionResult;
-    /** Final stopping policy. Called before decide and after each action. */
-    shouldStop?: (ctx: ControlContext<TState, TAction, TActionResult, TEval>) => Promise<StopDecision> | StopDecision;
-    /** Optional hook for tracing or live progress updates. */
-    onStep?: (step: ControlStep<TState, TAction, TActionResult, TEval>) => Promise<void> | void;
-    /** Optional generic stuck-loop policies. Custom `shouldStop` still runs first. */
-    stopPolicies?: ControlStopPolicies<TState, TAction>;
-    /** Optional trace sink. Emits one run plus one span per control step. */
-    store?: TraceStore;
-    scenarioId?: string;
-    projectId?: string;
-    variantId?: string;
-}
-declare function runAgentControlLoop<TState, TAction, TActionResult, TEval extends ControlEvalResult = ControlEvalResult>(config: ControlRuntimeConfig<TState, TAction, TActionResult, TEval>): Promise<ControlRunResult<TState, TAction, TActionResult, TEval>>;
-declare function stopOnNoProgress<TState, TAction>(maxNoProgressSteps: number, options?: Omit<ControlStopPolicies<TState, TAction>, 'maxNoProgressSteps'>): ControlStopPolicies<TState, TAction>;
-declare function stopOnRepeatedAction<TState, TAction>(maxRepeatedActions: number, options?: Omit<ControlStopPolicies<TState, TAction>, 'maxRepeatedActions'>): ControlStopPolicies<TState, TAction>;
-declare function objectiveEval(input: Omit<ControlEvalResult, 'objective'>): ControlEvalResult;
-declare function subjectiveEval(input: Omit<ControlEvalResult, 'objective'>): ControlEvalResult;
-declare function allCriticalPassed(evals: ControlEvalResult[]): boolean;
-
-type FeedbackArtifactType = 'text' | 'code' | 'plan' | 'research' | 'action' | 'ui' | 'decision' | 'data' | 'other';
-type FeedbackLabelSource = 'user' | 'judge' | 'environment' | 'metric' | 'policy' | 'system';
-type FeedbackLabelKind = 'approve' | 'reject' | 'select' | 'edit' | 'rank' | 'rate' | 'comment' | 'metric_outcome' | 'policy_block' | 'revision_request';
-type FeedbackSeverity = 'info' | 'warning' | 'error' | 'critical';
-interface FeedbackTask {
-    intent: string;
-    context?: unknown;
-}
-interface ProposedSideEffect {
-    type: string;
-    risk?: 'low' | 'medium' | 'high';
-    costUsd?: number;
-    externalSideEffect?: boolean;
-    requiresApproval?: boolean;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackLabel {
-    id?: string;
-    source: FeedbackLabelSource;
-    kind: FeedbackLabelKind;
-    value: unknown;
-    reason?: string;
-    severity?: FeedbackSeverity;
-    createdAt: string;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackAttempt {
-    id: string;
-    stepIndex: number;
-    artifactType: FeedbackArtifactType;
-    artifact: unknown;
-    options?: unknown[];
-    proposedAction?: ProposedSideEffect;
-    evals?: ControlEvalResult[];
-    feedback?: FeedbackLabel[];
-    createdAt: string;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackOutcome {
-    success?: boolean;
-    score?: number;
-    metrics?: Record<string, number>;
-    costUsd?: number;
-    detail?: string;
-    observedAt?: string;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackTrajectory {
-    id: string;
-    projectId?: string;
-    scenarioId?: string;
-    task: FeedbackTask;
-    attempts: FeedbackAttempt[];
-    labels: FeedbackLabel[];
-    outcome?: FeedbackOutcome;
-    split?: DatasetSplit;
-    tags?: Record<string, string>;
-    createdAt: string;
-    updatedAt?: string;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackTrajectoryStore {
-    save(trajectory: FeedbackTrajectory): Promise<void>;
-    get(id: string): Promise<FeedbackTrajectory | null>;
-    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
-    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
-    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
-}
-interface FeedbackTrajectoryFilter {
-    projectId?: string;
-    scenarioId?: string;
-    split?: DatasetSplit;
-    tag?: [string, string];
-}
-interface FeedbackSplitPolicy {
-    trainPct?: number;
-    devPct?: number;
-    testPct?: number;
-    holdoutPct?: number;
-}
-interface PreferenceMemoryEntry {
-    instruction: string;
-    rationale: string;
-    weight: number;
-    sourceTrajectoryId: string;
-    sourceLabelId?: string;
-    category?: string;
-}
-interface FeedbackOptimizerRow {
-    scenarioId: string;
-    trajectoryId: string;
-    labelKinds: FeedbackLabelKind[];
-    score?: number;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackReplayResult {
-    trajectoryId: string;
-    pass: boolean;
-    score?: number;
-    labels: FeedbackLabel[];
-    outcome?: FeedbackOutcome;
-    metadata?: Record<string, unknown>;
-}
-interface FeedbackReplayAdapter {
-    replay(trajectory: FeedbackTrajectory): Promise<Omit<FeedbackReplayResult, 'trajectoryId'>> | Omit<FeedbackReplayResult, 'trajectoryId'>;
-}
-declare class InMemoryFeedbackTrajectoryStore implements FeedbackTrajectoryStore {
-    private readonly trajectories;
-    save(trajectory: FeedbackTrajectory): Promise<void>;
-    get(id: string): Promise<FeedbackTrajectory | null>;
-    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
-    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
-    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
-}
-declare class FileSystemFeedbackTrajectoryStore implements FeedbackTrajectoryStore {
-    private readonly dir;
-    private readonly memory;
-    private loaded;
-    constructor(options: {
-        dir: string;
-    });
-    save(trajectory: FeedbackTrajectory): Promise<void>;
-    get(id: string): Promise<FeedbackTrajectory | null>;
-    list(filter?: FeedbackTrajectoryFilter): Promise<FeedbackTrajectory[]>;
-    appendAttempt(id: string, attempt: FeedbackAttempt): Promise<FeedbackTrajectory>;
-    appendLabel(id: string, label: FeedbackLabel, attemptId?: string): Promise<FeedbackTrajectory>;
-    private append;
-    private load;
-}
-declare function createFeedbackTrajectory(input: {
-    id?: string;
-    projectId?: string;
-    scenarioId?: string;
-    task: FeedbackTask;
-    attempts?: FeedbackAttempt[];
-    labels?: FeedbackLabel[];
-    outcome?: FeedbackOutcome;
-    split?: DatasetSplit;
-    tags?: Record<string, string>;
-    createdAt?: string;
-    metadata?: Record<string, unknown>;
-}): FeedbackTrajectory;
-declare function assignFeedbackSplit(trajectory: Pick<FeedbackTrajectory, 'id' | 'projectId' | 'scenarioId' | 'task'>, policy?: FeedbackSplitPolicy): DatasetSplit;
-declare function withAssignedFeedbackSplit(trajectory: FeedbackTrajectory, policy?: FeedbackSplitPolicy): FeedbackTrajectory;
-declare function feedbackTrajectoryToDatasetScenario(trajectory: FeedbackTrajectory): DatasetScenario;
-declare function feedbackTrajectoriesToDatasetScenarios(trajectories: FeedbackTrajectory[]): DatasetScenario[];
-declare function feedbackTrajectoryToOptimizerRow(trajectory: FeedbackTrajectory): FeedbackOptimizerRow;
-declare function feedbackTrajectoriesToOptimizerRows(trajectories: FeedbackTrajectory[]): FeedbackOptimizerRow[];
-declare function replayFeedbackTrajectory(trajectory: FeedbackTrajectory, adapter: FeedbackReplayAdapter): Promise<FeedbackReplayResult>;
-declare function replayFeedbackTrajectories(trajectories: FeedbackTrajectory[], adapter: FeedbackReplayAdapter): Promise<FeedbackReplayResult[]>;
-declare function summarizePreferenceMemory(trajectories: FeedbackTrajectory[], options?: {
-    maxEntries?: number;
-}): PreferenceMemoryEntry[];
-declare function renderPreferenceMemoryMarkdown(entries: PreferenceMemoryEntry[]): string;
-declare function serializeFeedbackTrajectoriesJsonl(trajectories: FeedbackTrajectory[]): string;
-declare function parseFeedbackTrajectoriesJsonl(jsonl: string): FeedbackTrajectory[];
-declare function controlRunToFeedbackTrajectory<TState, TAction, TActionResult>(run: ControlRunResult<TState, TAction, TActionResult>, options?: {
-    projectId?: string;
-    scenarioId?: string;
-    artifactType?: FeedbackArtifactType;
-    artifactFromStep?: (step: ControlStep<TState, TAction, TActionResult>) => unknown;
-    proposedActionFromStep?: (step: ControlStep<TState, TAction, TActionResult>) => ProposedSideEffect | undefined;
-    createdAt?: string;
-}): FeedbackTrajectory;
-
 interface LiveProofArtifact {
     kind: string;
     id?: string;
@@ -2181,32 +677,42 @@ declare function scoreKnowledgeReadiness(options: ScoreKnowledgeReadinessOptions
 declare function blockingKnowledgeEval(report: KnowledgeReadinessReport, options?: {
     id?: string;
     minimumScore?: number;
+    emitter?: TraceEmitter;
 }): ControlEvalResult;
+declare function knowledgeReadinessTracePayload(report: KnowledgeReadinessReport, options?: {
+    passed?: boolean;
+    minimumScore?: number;
+}): Record<string, unknown>;
 declare function userQuestionsForKnowledgeGaps(gaps: KnowledgeRequirement[]): UserQuestion[];
 declare function acquisitionPlansForKnowledgeGaps(gaps: KnowledgeRequirement[]): DataAcquisitionPlan[];
 
-interface ActionExecutionPolicy {
-    allowedTypes?: string[];
-    blockedTypes?: string[];
-    alwaysRequireApprovalTypes?: string[];
-    autoApproveTypes?: string[];
-    requireApprovalForExternalSideEffects?: boolean;
-    requireApprovalAboveCostUsd?: number;
-    maxActionCostUsd?: number;
-    remainingBudgetUsd?: number;
-    expectedOutcomeRequired?: boolean;
-    killCriteriaRequired?: boolean;
-}
-interface ActionPolicyDecision {
-    allowed: boolean;
-    blocked: boolean;
-    requiresApproval: boolean;
-    reasons: string[];
-    label?: FeedbackLabel;
-}
-declare function evaluateActionPolicy(action: ProposedSideEffect, policy?: ActionExecutionPolicy, options?: {
-    createdAt?: string;
-}): ActionPolicyDecision;
+type IntegrationGateSurface = 'integration-manifest' | 'integration-connection' | 'integration-scope' | 'integration-approval' | 'integration-auth' | 'integration-provider' | 'integration-policy';
+interface IntegrationManifestGateInput {
+    connectorId: string;
+    actionId?: string;
+    valid: boolean;
+    missingConnections?: string[];
+    missingScopes?: string[];
+    requiredScopes?: string[];
+    approvalRequired?: boolean;
+    status?: 'ready' | 'blocked' | 'approval_required';
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+interface IntegrationInvokeFailureInput {
+    connectorId: string;
+    actionId: string;
+    code: 'auth_expired' | 'scope_denied' | 'approval_required' | 'unsafe_write_denied' | 'provider_failure' | 'manifest_invalid';
+    message: string;
+    status?: number;
+    retryable?: boolean;
+    metadata?: Record<string, unknown>;
+}
+declare function integrationManifestValidatedPayload(input: IntegrationManifestGateInput): Record<string, unknown>;
+declare function integrationManifestResolvedPayload(input: IntegrationManifestGateInput): Record<string, unknown>;
+declare function integrationInvokeFailedPayload(input: IntegrationInvokeFailureInput): Record<string, unknown>;
+declare function integrationGateEvals(input: IntegrationManifestGateInput): ControlEvalResult[];
+declare function integrationAsi(input: IntegrationManifestGateInput | IntegrationInvokeFailureInput): ActionableSideInfo;
 
 /**
  * Normalize scores so all dimensions follow "higher = better".
@@ -2769,167 +1275,39 @@ interface SteeringDelta {
     rolePrompts?: Record<string, SteeringRolePrompt>;
     metadata?: Record<string, unknown>;
 }
-declare function mergeSteeringBundle(base: SteeringBundle, delta: SteeringDelta): SteeringBundle;
-declare function renderSteeringText(bundle: SteeringBundle): string;
-
-interface RunScore {
-    success: number;
-    goalProgress: number;
-    repoGroundedness: number;
-    driftPenalty: number;
-    toolUseQuality: number;
-    patchQuality: number;
-    testReality: number;
-    finalGate: number;
-    reviewerBlockers: number;
-    costUsd: number;
-    wallSeconds: number;
-    notes?: string[];
-}
-interface RunScoreWeights {
-    success: number;
-    goalProgress: number;
-    repoGroundedness: number;
-    driftPenalty: number;
-    toolUseQuality: number;
-    patchQuality: number;
-    testReality: number;
-    finalGate: number;
-    reviewerBlockers: number;
-    costUsd: number;
-    wallSeconds: number;
-}
-declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
-declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
-declare function clamp01(value: number): number;
-
-/**
- * Typed query helpers over TraceStore.
- *
- * Not a full SQL engine — a minimal, composable set of operators that
- * cover the canned-pipeline use cases. For ad-hoc analytics, persist to
- * NDJSON and point DuckDB at it; the schema is stable so external SQL
- * tooling works out of the box.
- */
-
-declare function runsForScenario(store: TraceStore, scenarioId: string): Promise<Run$1[]>;
-declare function llmSpans(store: TraceStore, runId?: string): Promise<LlmSpan[]>;
-declare function toolSpans(store: TraceStore, runId?: string, toolName?: string): Promise<ToolSpan[]>;
-declare function judgeSpans(store: TraceStore, runId?: string): Promise<JudgeSpan[]>;
-/** Group spans by any key selector. */
-declare function groupBy<T, K extends string | number>(items: T[], key: (t: T) => K): Map<K, T[]>;
-/** Hash tool arguments to an orderless-key-stable string for de-duplication. */
-declare function argHash(args: unknown): string;
-/** Sum an LLM-span array into aggregate token + cost. */
-declare function aggregateLlm(spans: LlmSpan[]): {
-    inputTokens: number;
-    outputTokens: number;
-    cachedTokens: number;
-    costUsd: number;
-};
-/** Pick the outcome's failure class when present, else derive 'success' from run status. */
-declare function runFailureClass(run: Run$1): FailureClass;
-
-/**
- * Redaction — remove PII / secrets from trace payloads before persist.
- *
- * Pre-persistence rules mean raw traces in storage are already scrubbed.
- * Unredacted variants (for debugging / post-mortems) live in a separate
- * storage layer with stricter access controls; this module only covers
- * the default scrub-then-persist path.
- *
- * Rules compose: pass an array of `RedactionRule`, each is applied in
- * order. Strings that match get replaced with a tagged sentinel so the
- * eval framework can count how many redactions happened per run
- * (surfaced via `redaction_applied` events).
- */
-interface RedactionRule {
-    id: string;
-    pattern: RegExp;
-    /** Replacement — e.g. '[PII:email]'. Defaults to `[redacted:{id}]`. */
-    replacement?: string;
-}
-interface RedactionReport {
-    redactionCount: number;
-    byRule: Record<string, number>;
-}
-/** OWASP / common-sense defaults — extend per-domain. */
-declare const DEFAULT_REDACTION_RULES: RedactionRule[];
-declare const REDACTION_VERSION = "1.0.0";
-/**
- * Redact a single string. Returns the new string and a per-rule count of
- * how many substitutions fired.
- */
-declare function redactString(input: string, rules?: RedactionRule[]): {
-    output: string;
-    report: RedactionReport;
-};
-/**
- * Walk a JSON-ish value applying `redactString` to every string leaf.
- * Arrays and plain objects are recursed; other types pass through
- * untouched. Circular references throw — traces should be tree-shaped.
- */
-declare function redactValue(value: unknown, rules?: RedactionRule[], report?: RedactionReport): {
-    value: unknown;
-    report: RedactionReport;
-};
-
-/**
- * OpenTelemetry JSON export — maps TraceSchema v1 to OTLP/JSON so
- * traces render natively in Jaeger / Honeycomb / Langfuse / Grafana.
- *
- * Wire format only. We do NOT depend on the @opentelemetry SDK — that
- * would drag in polyfills incompatible with Workers/Edge. Consumers
- * push the JSON to their collector of choice via HTTP.
- *
- * Reference: OTLP 1.3.2 (ResourceSpans / ScopeSpans / Span).
- */
-
-declare const OTEL_AGENT_EVAL_SCOPE: {
-    name: string;
-    version: string;
-};
-interface OtlpSpan {
-    traceId: string;
-    spanId: string;
-    parentSpanId?: string;
-    name: string;
-    kind: number;
-    startTimeUnixNano: string;
-    endTimeUnixNano: string;
-    attributes: Array<{
-        key: string;
-        value: {
-            stringValue?: string;
-            intValue?: string;
-            doubleValue?: number;
-            boolValue?: boolean;
-        };
-    }>;
-    events?: Array<{
-        timeUnixNano: string;
-        name: string;
-        attributes?: OtlpSpan['attributes'];
-    }>;
-    status?: {
-        code: number;
-        message?: string;
-    };
-}
-interface OtlpResourceSpans {
-    resource: {
-        attributes: OtlpSpan['attributes'];
-    };
-    scopeSpans: Array<{
-        scope: typeof OTEL_AGENT_EVAL_SCOPE;
-        spans: OtlpSpan[];
-    }>;
+declare function mergeSteeringBundle(base: SteeringBundle, delta: SteeringDelta): SteeringBundle;
+declare function renderSteeringText(bundle: SteeringBundle): string;
+
+interface RunScore {
+    success: number;
+    goalProgress: number;
+    repoGroundedness: number;
+    driftPenalty: number;
+    toolUseQuality: number;
+    patchQuality: number;
+    testReality: number;
+    finalGate: number;
+    reviewerBlockers: number;
+    costUsd: number;
+    wallSeconds: number;
+    notes?: string[];
 }
-interface OtlpExport {
-    resourceSpans: OtlpResourceSpans[];
+interface RunScoreWeights {
+    success: number;
+    goalProgress: number;
+    repoGroundedness: number;
+    driftPenalty: number;
+    toolUseQuality: number;
+    patchQuality: number;
+    testReality: number;
+    finalGate: number;
+    reviewerBlockers: number;
+    costUsd: number;
+    wallSeconds: number;
 }
-/** Export a single run's spans + events in OTLP/JSON. */
-declare function exportRunAsOtlp(store: TraceStore, runId: string, resourceAttrs?: Record<string, string | number | boolean>): Promise<OtlpExport>;
+declare const DEFAULT_RUN_SCORE_WEIGHTS: RunScoreWeights;
+declare function aggregateRunScore(score: RunScore, weights?: Partial<RunScoreWeights>): number;
+declare function clamp01(value: number): number;
 
 interface RunTrace {
     run: Run$1;
@@ -3359,206 +1737,6 @@ declare class DualAgentBench {
     run(config: DualAgentBenchConfig): Promise<DualAgentReport>;
 }
 
-/**
- * Propose / Verify / Review — the core multi-shot primitive.
- *
- *   shot N:  propose(state, priorReview) → new state
- *            verify(state)               → pass/fail, optional layers
- *            review(state, verification, memory) → observations + next-shot
- *                                                   instruction + shouldContinue
- *            memory.append(entry)
- *
- * Roles are strictly separated:
- *
- *   - The WORKER is whatever the caller wraps in `propose`. It is
- *     stateful — caller owns its resume/session mechanism.
- *   - The VERIFIER grades the state. It produces the ground truth.
- *     The reviewer cannot overturn or downgrade a verification layer.
- *   - The REVIEWER is stateless per call. Its continuity is the
- *     `ReviewMemoryStore` — durable JSONL by default, or any store
- *     implementing the interface. It reads memory + trace summary +
- *     verification and directs the NEXT proposer shot.
- *
- * This shape is load-bearing. The reviewer never grades; the verifier
- * never directs. Two processes, two prompts, two concerns — which is
- * what keeps the loop from confirmation-biasing itself into "all
- * passed" when it didn't.
- *
- * Short-circuits and soft-fails are both first-class:
- *   - verify.pass === true  → reviewer LLM call is skipped, memory
- *     records a success entry, loop exits.
- *   - review throws         → the shot still counts; the loop uses the
- *     last-known instruction (or `fallbackInstruction`) for the next
- *     propose call. A transient reviewer failure must NEVER abort a
- *     valid arc.
- *
- * Composable: `propose` itself can be another `runProposeReview` call.
- * That's the dogfooding path — a harness built on this primitive is in
- * turn evaluable by it.
- */
-
-interface Verification {
-    pass: boolean;
-    score?: number;
-    failingLayers?: string[];
-    details?: unknown;
-}
-interface Review {
-    observations: string;
-    diagnosis: string;
-    nextShotInstruction: string;
-    shouldContinue: boolean;
-    confidence: number;
-}
-interface ReviewMemoryEntry extends Review {
-    shot: number;
-    timestamp: number;
-    verification: {
-        pass: boolean;
-        score?: number;
-        failingLayers?: string[];
-    };
-}
-interface ProposeInput<State> {
-    shot: number;
-    goal: string;
-    state: State;
-    priorReview: Review | null;
-    abortSignal: AbortSignal;
-    emitter?: TraceEmitter;
-}
-interface ProposeOutput<State, Summary = unknown> {
-    state: State;
-    traceSummary?: Summary;
-}
-interface ReviewInput<State, Summary = unknown> {
-    shot: number;
-    goal: string;
-    state: State;
-    verification: Verification;
-    traceSummary: Summary | undefined;
-    memory: ReviewMemoryEntry[];
-}
-type ProposeFn<State, Summary = unknown> = (input: ProposeInput<State>) => Promise<ProposeOutput<State, Summary>>;
-type VerifyFn<State> = (state: State) => Promise<Verification>;
-type ReviewFn<State, Summary = unknown> = (input: ReviewInput<State, Summary>) => Promise<Review>;
-interface ReviewMemoryStore {
-    load(): Promise<ReviewMemoryEntry[]>;
-    append(entry: ReviewMemoryEntry): Promise<void>;
-}
-interface ProposeReviewConfig<State, Summary = unknown> {
-    goal: string;
-    initialState: State;
-    propose: ProposeFn<State, Summary>;
-    verify: VerifyFn<State>;
-    review: ReviewFn<State, Summary>;
-    /** Hard shot cap. Default 10. */
-    maxShots?: number;
-    /** Wall-clock cap in ms. Default 10 min. */
-    maxWallMs?: number;
-    /**
-     * If the reviewer returns confidence ≤ floor on `confidenceFloorWindow`
-     * consecutive shots, terminate early. Default floor 0.3, window 2.
-     * Set window to 0 or floor to <0 to disable.
-     */
-    confidenceFloor?: number;
-    confidenceFloorWindow?: number;
-    /** Defaults to an in-memory store if omitted. */
-    memory?: ReviewMemoryStore;
-    /** If provided, emit a Run + per-shot spans. */
-    store?: TraceStore;
-    scenarioId?: string;
-    projectId?: string;
-    variantId?: string;
-    /**
-     * Used when the reviewer soft-fails on shot 1 (no prior instruction to
-     * fall back to). Default is a generic "inspect failures and fix".
-     */
-    fallbackInstruction?: string;
-}
-interface ProposeReviewShot<State, Summary = unknown> {
-    shot: number;
-    state: State;
-    verification: Verification;
-    traceSummary: Summary | undefined;
-    review: Review;
-    reviewAvailable: boolean;
-    reviewError?: string;
-    durationMs: number;
-}
-interface ProposeReviewReport<State, Summary = unknown> {
-    runId: string | null;
-    completed: boolean;
-    shots: ProposeReviewShot<State, Summary>[];
-    finalState: State;
-    finalVerification: Verification;
-    failureClass?: FailureClass;
-    wallMs: number;
-    score: number;
-}
-declare function inMemoryReviewStore(initial?: ReviewMemoryEntry[]): ReviewMemoryStore;
-declare function jsonlReviewStore(path: string): ReviewMemoryStore;
-declare function runProposeReview<State, Summary = unknown>(config: ProposeReviewConfig<State, Summary>): Promise<ProposeReviewReport<State, Summary>>;
-interface LlmJsonCall {
-    (req: {
-        system: string;
-        user: string;
-    }): Promise<unknown>;
-}
-interface LlmReviewerConfig<State, Summary = unknown> {
-    callJson: LlmJsonCall;
-    renderState?: (state: State) => string;
-    renderTraceSummary?: (summary: Summary | undefined) => string;
-    /** Appended to the default system prompt. */
-    systemPromptAddendum?: string;
-}
-declare function createLlmReviewer<State, Summary = unknown>(cfg: LlmReviewerConfig<State, Summary>): ReviewFn<State, Summary>;
-
-interface ProposeReviewControlState<State, Summary = unknown> {
-    shot: number;
-    state: State;
-    priorReview: Review | null;
-    verification: Verification;
-    traceSummary?: Summary;
-    memory: ReviewMemoryEntry[];
-    completed: boolean;
-    reviewAvailable: boolean;
-    reviewError?: string;
-}
-interface ProposeReviewControlAction {
-    type: 'propose-review-shot';
-    shot: number;
-}
-interface ProposeReviewControlResult<State, Summary = unknown> {
-    state: State;
-    verification: Verification;
-    traceSummary?: Summary;
-    review: Review | null;
-    reviewAvailable: boolean;
-    reviewError?: string;
-}
-interface ProposeReviewControlConfig<State, Summary = unknown> {
-    goal: string;
-    initialState: State;
-    propose: ProposeFn<State, Summary>;
-    verify: VerifyFn<State>;
-    review: ReviewFn<State, Summary>;
-    maxShots?: number;
-    maxWallMs?: number;
-    memory?: ReviewMemoryStore;
-    store?: TraceStore;
-    scenarioId?: string;
-    projectId?: string;
-    variantId?: string;
-    fallbackInstruction?: string;
-    confidenceFloor?: number;
-    confidenceFloorWindow?: number;
-    failureClassFromVerification?: (verification: Verification) => FailureClass | undefined;
-    actionFailure?: ControlRuntimeConfig<ProposeReviewControlState<State, Summary>, ProposeReviewControlAction, ProposeReviewControlResult<State, Summary>>['actionFailure'];
-}
-declare function runProposeReviewAsControlLoop<State, Summary = unknown>(config: ProposeReviewControlConfig<State, Summary>): Promise<ControlRunResult<ProposeReviewControlState<State, Summary>, ProposeReviewControlAction, ProposeReviewControlResult<State, Summary>>>;
-declare function controlFailureClassFromVerification(verification: Verification): FailureClass | undefined;
-
 /**
  * TestGradedScenario — a scenario whose score comes from a test suite.
  *
@@ -5781,6 +3959,39 @@ interface HypothesisResult {
     rejectionReasons: Array<'wrong_direction' | 'effect_too_small' | 'not_significant' | 'undersampled'>;
     notes?: string;
 }
+/**
+ * Deterministic JSON canonicalization — sort object keys recursively.
+ *
+ * Two semantically-equal objects produce byte-identical canonicalized output;
+ * this is what makes a content-hash stable across encoders, key insertion
+ * orders, and runtime versions. Exported for any consumer that needs the same
+ * canonicalization guarantee outside the manifest-signing path (e.g., signing
+ * an artifact bundle, hashing a dataset version, etc.).
+ */
+declare function canonicalize(v: unknown): unknown;
+/**
+ * SHA-256 hex (full 64 chars) over the canonicalized JSON encoding of `obj`.
+ *
+ * The same primitive `signManifest` and `verifyManifest` are built on, exposed
+ * directly so consumers signing arbitrary structured content (artifact bundles,
+ * production packets, dataset manifests, etc.) don't have to re-derive
+ * canonicalize+sha256 from scratch.
+ *
+ * Stable across:
+ *   - object key insertion order (canonicalization sorts keys recursively)
+ *   - encoder choice (UTF-8 via TextEncoder, fixed)
+ *   - runtime (uses the Web Crypto subtle digest, present in Node ≥18 and browsers)
+ *
+ * Naming note: `hashJson` rather than `hashContent` because `hashContent` is
+ * already taken in `prompt-registry.ts` for the truncated 12-char prompt-id
+ * helper, which has different semantics (string input, short return). Both
+ * coexist; `hashJson` is the right name when you mean "canonicalize then hash."
+ *
+ * @example
+ *   const hash = await hashJson({ id: '1', kind: 'spec' })
+ *   // 'a3f1...' (64 hex chars)
+ */
+declare function hashJson<T>(obj: T): Promise<string>;
 /**
  * Sign a manifest with a SHA-256 content hash.
  *
@@ -7451,354 +5662,6 @@ declare function compareReferenceReplay(baseline: ReferenceReplayScore, candidat
 declare function decideReferenceReplayPromotion(baseline: ReferenceReplayScore, candidate: ReferenceReplayScore, policy?: ReferenceReplayPromotionPolicy): ReferenceReplayPromotionDecision;
 declare function defaultReferenceReplayMatcher(reference: ReferenceReplayItem, candidate: ReferenceReplayCandidate): ReferenceMatchResult;
 
-/**
- * Paper-grade paired statistics for held-out promotion gates.
- *
- * The promotion gate (`HeldOutGate`) needs three things:
- *
- *   1. A bootstrap confidence interval on the per-item paired delta
- *      (`pairedBootstrap`). Median delta is the headline number; the
- *      CI lower bound is what the gate checks against `pairedDeltaThreshold`.
- *   2. A non-parametric significance test on the paired deltas
- *      (`pairedWilcoxon` — re-export of `wilcoxonSignedRank` under the
- *      paper-style name).
- *   3. False-discovery-rate correction across simultaneously-tested
- *      candidate variants (`bhAdjust` — re-export of `benjaminiHochberg`).
- *
- * Why a separate file: every existing primitive lives in `statistics.ts`
- * (general) or `power-analysis.ts` (correction). Paired-bootstrap is
- * paired-only, paper-grade, and load-bearing for the promotion gate.
- * Putting it next to `statistics.ts` would require editing that file;
- * the brief forbids that. New file, new exports, no surface change.
- */
-interface PairedBootstrapResult {
-    /** Number of paired observations (after dropping unequal lengths is rejected). */
-    n: number;
-    /** Median of paired deltas (after − before). */
-    median: number;
-    /** Mean of paired deltas. */
-    mean: number;
-    /** Lower bound of the bootstrap CI on the median delta. */
-    low: number;
-    /** Upper bound of the bootstrap CI on the median delta. */
-    high: number;
-    /** Confidence level used (e.g. 0.95). */
-    confidence: number;
-    /** Number of bootstrap resamples used. */
-    resamples: number;
-}
-interface PairedBootstrapOptions {
-    /** Confidence level. Default 0.95. */
-    confidence?: number;
-    /** Bootstrap resample count. Default 2000. */
-    resamples?: number;
-    /** Statistic to bootstrap. Default 'median'. */
-    statistic?: 'median' | 'mean';
-    /** Deterministic seed. If omitted, uses Math.random(). */
-    seed?: number;
-}
-/**
- * Paired bootstrap on (after - before) deltas. Returns a CI on the
- * chosen statistic (median by default). Pairs are resampled with
- * replacement. The lower bound is what the promotion gate checks: if
- * `low > pairedDeltaThreshold`, the gain is real at the chosen
- * confidence level.
- *
- * Throws on unequal sample sizes — caller must align pairs upstream.
- */
-declare function pairedBootstrap(before: number[], after: number[], opts?: PairedBootstrapOptions): PairedBootstrapResult;
-/**
- * Paper-style alias for `wilcoxonSignedRank`. The signed-rank test on
- * paired deltas is the standard non-parametric significance test for
- * "candidate beats baseline on matched items." Use alongside the
- * bootstrap CI: bootstrap gives effect size, Wilcoxon gives p.
- */
-declare function pairedWilcoxon(before: number[], after: number[]): {
-    w: number;
-    p: number;
-};
-/**
- * Paper-style alias for `benjaminiHochberg`. Use to correct p-values
- * across multiple candidate-vs-baseline comparisons run in the same
- * promotion sweep. Returns BH-adjusted q-values and significance at
- * the requested FDR (default 0.05).
- */
-declare function bhAdjust(pValues: number[], fdr?: number): {
-    qValues: number[];
-    significant: boolean[];
-};
-
-/**
- * Researcher interface — stable hook for an external autonomous-research
- * agent to drive the meta-loop.
- *
- * Implementations live downstream (typically in a private repo that
- * runs the actual LLM). This package ships only the contract + a
- * `NoopResearcher` so consumers can wire the surface without being
- * forced to implement every method up front.
- *
- * The four methods mirror the four stages of the paper "Two Loops,
- * Three Roles":
- *
- *   inspectFailures   — given the observed runs, what failure modes
- *                       are present? (data → diagnosis)
- *   proposeChange     — given diagnosed failure modes, what
- *                       structural changes should we try?
- *                       (diagnosis → plan delta)
- *   applyChange       — fold the proposed deltas into a concrete
- *                       experiment plan against an existing baseline.
- *                       (plan delta → executable plan)
- *   evaluateChange    — run the plan, return runs + the gate verdict.
- *                       (executable plan → verdict)
- *
- * Composition is the discipline: a Researcher implementation MUST
- * keep these four steps separate and inspectable. Conflating
- * "diagnose + propose + run" into a single LLM call defeats the
- * point of the framework — you can't audit which step lied.
- *
- * THIS INTERFACE IS STABLE. Breaking changes require a new module
- * (e.g. `Researcher2`) so existing implementations keep working.
- */
-
-/** A diagnosed failure mode with the run-IDs that exhibit it. */
-interface FailureMode {
-    /** Short machine-readable code. Must be stable across runs of the
-     *  same researcher to enable longitudinal tracking. */
-    code: string;
-    /** Human-readable description for the paper / dashboard. */
-    description: string;
-    evidence: {
-        /** Run IDs (from `RunRecord.runId`) where this failure mode was
-         *  observed. */
-        runIds: string[];
-        /** Number of run samples that informed the diagnosis. */
-        samples: number;
-    };
-}
-/** A single steering change the researcher wants to try. */
-interface SteeringChange {
-    kind: 'reviewer_prompt' | 'skill_add' | 'skill_remove' | 'threshold' | 'budget';
-    /** Implementation-specific payload. Researcher implementations
-     *  define the schema — keep this `unknown` here to avoid coupling
-     *  the public interface to any one researcher's internal model. */
-    payload: unknown;
-    /** Why the researcher proposed this change. Goes into the audit
-     *  trail next to the failure-mode evidence. */
-    rationale: string;
-    /** Optional self-reported expected delta on the headline metric. */
-    expectedDelta?: number;
-}
-/** A single experiment plan, mapped onto the search/holdout splits. */
-interface ExperimentPlan {
-    baselineCandidateId: string;
-    proposedCandidateId: string;
-    changes: SteeringChange[];
-    /** USD ceiling for the entire experiment. The runner must stop
-     *  before exceeding this and report a partial result. */
-    evaluationBudgetUsd: number;
-    /** Item IDs (your dataset keys) for the search vs holdout splits. */
-    splits: {
-        search: string[];
-        holdout: string[];
-    };
-}
-/** Result of running a plan: every run, plus the gate verdict. */
-interface ExperimentResult {
-    plan: ExperimentPlan;
-    runs: RunRecord[];
-    gateDecision: GateDecision;
-}
-/**
- * The researcher loop. Stable, four-step, inspectable.
- *
- *   ┌──────────┐  inspectFailures  ┌──────────┐  proposeChange ┌──────────┐
- *   │   runs   │ ─────────────────▶│ failures │ ──────────────▶│ changes  │
- *   └──────────┘                   └──────────┘                └────┬─────┘
- *                                                                   │
- *                                                                   ▼
- *                              ┌────────────────┐  applyChange ┌────────┐
- *                              │ ExperimentPlan │ ◀────────────│  base  │
- *                              └────────┬───────┘              └────────┘
- *                                       │
- *                       evaluateChange  ▼
- *                              ┌────────────────┐
- *                              │ ExperimentResult│
- *                              └────────────────┘
- */
-interface Researcher {
-    inspectFailures(runs: RunRecord[]): Promise<FailureMode[]>;
-    proposeChange(failures: FailureMode[]): Promise<SteeringChange[]>;
-    applyChange(changes: SteeringChange[], baseline: ExperimentPlan): Promise<ExperimentPlan>;
-    evaluateChange(plan: ExperimentPlan): Promise<ExperimentResult>;
-}
-interface CallbackResearcherOptions {
-    inspectFailures: Researcher['inspectFailures'];
-    proposeChange: Researcher['proposeChange'];
-    applyChange: Researcher['applyChange'];
-    evaluateChange: Researcher['evaluateChange'];
-}
-/**
- * Minimal concrete researcher for tests, scripts, and small integrations.
- * Larger autonomous researchers can still implement `Researcher` directly.
- */
-declare class CallbackResearcher implements Researcher {
-    private readonly callbacks;
-    constructor(callbacks: CallbackResearcherOptions);
-    inspectFailures(runs: RunRecord[]): Promise<FailureMode[]>;
-    proposeChange(failures: FailureMode[]): Promise<SteeringChange[]>;
-    applyChange(changes: SteeringChange[], baseline: ExperimentPlan): Promise<ExperimentPlan>;
-    evaluateChange(plan: ExperimentPlan): Promise<ExperimentResult>;
-}
-/**
- * No-op researcher — fails loud on every method. Use as a placeholder
- * in code paths that wire the interface but don't have an implementation
- * yet. Importantly, this does NOT silently succeed: a no-op researcher
- * that returned empty arrays would muffle the loop's signal that
- * nobody implemented the brain.
- */
-declare class NoopResearcher implements Researcher {
-    private readonly hint;
-    constructor(hint?: string);
-    inspectFailures(_runs: RunRecord[]): Promise<FailureMode[]>;
-    proposeChange(_failures: FailureMode[]): Promise<SteeringChange[]>;
-    applyChange(_changes: SteeringChange[], _baseline: ExperimentPlan): Promise<ExperimentPlan>;
-    evaluateChange(_plan: ExperimentPlan): Promise<ExperimentResult>;
-}
-
-/**
- * Reporting helpers — production summaries and paper-quality figures — sit alongside `reporter.ts` rather
- * than replacing it.
- *
- * Three artefacts:
- *
- *   - `summaryTable`           Markdown table of per-candidate means,
- *                            95% bootstrap CIs, BH-adjusted Wilcoxon
- *                            p-values, and Cohen's d versus a
- *                            comparator candidate.
- *   - `paretoChart`         Abstract spec for a cost vs quality
- *                            scatter, with gate decisions overlaid.
- *                            Returns numbers + labels — caller
- *                            chooses the plotting library.
- *   - `gainHistogram`
- *                            Per-item paired holdout deltas as a
- *                            histogram spec (bins + counts + median +
- *                            CI). Same "data, not images" contract.
- *
- * The figure types are PlotSpecs — JSON-friendly, library-agnostic.
- * They aren't React components and they aren't PNGs; they are
- * what you'd hand to vega-lite, plotly, matplotlib, or your own
- * Canvas renderer to draw the actual figure.
- */
-
-interface SummaryTableOptions {
-    /** Comparator candidate id. Wilcoxon + Cohen's d are computed
-     *  versus this candidate. Required for paired stats columns. */
-    comparator?: string;
-    /** Which split to read scores from. Default 'holdout'. */
-    split?: 'search' | 'holdout';
-    /** Confidence level for the bootstrap CI on the mean. Default 0.95. */
-    confidence?: number;
-    /** FDR for BH adjustment of the comparison p-values. Default 0.05. */
-    fdr?: number;
-}
-interface SummaryTableRow {
-    candidateId: string;
-    n: number;
-    mean: number;
-    ciLow: number;
-    ciHigh: number;
-    /** BH-adjusted q-value vs comparator. NaN if no comparator. */
-    qValue: number;
-    /** Cohen's d vs comparator. NaN if no comparator. */
-    cohensD: number;
-}
-interface SummaryTable {
-    rows: SummaryTableRow[];
-    comparator: string | null;
-    split: 'search' | 'holdout';
-    /** Pre-rendered markdown — drop into a paper or PR. */
-    markdown: string;
-}
-/**
- * Table 1 helper. Buckets runs by `candidateId`, computes mean +
- * bootstrap CI on the chosen split, and (when a comparator is given)
- * BH-adjusted Wilcoxon p + Cohen's d versus that comparator.
- */
-declare function summaryTable(runs: RunRecord[], opts?: SummaryTableOptions): SummaryTable;
-interface ParetoPoint {
-    candidateId: string;
-    /** Mean USD cost per run on the chosen split. */
-    cost: number;
-    /** Mean score on the chosen split. */
-    quality: number;
-    /** Number of runs that informed this point. */
-    n: number;
-    /** Whether this candidate is on the Pareto frontier — high
-     *  quality, low cost, no dominator. */
-    onFrontier: boolean;
-    /** Optional gate verdict for this candidate, if a `GateDecision`
-     *  for it was passed in. */
-    gate?: 'promote' | 'reject_few_runs' | 'reject_negative_delta' | 'reject_overfit_gap' | null;
-}
-interface ParetoFigureSpec {
-    kind: 'pareto-cost-quality';
-    split: 'search' | 'holdout';
-    points: ParetoPoint[];
-    axes: {
-        x: 'costUsd';
-        y: 'score';
-    };
-}
-/**
- * Cost vs quality scatter spec. `gateDecisions` is keyed by
- * candidate id; if present, every point picks up the gate verdict
- * for overlay.
- */
-declare function paretoChart(runs: RunRecord[], opts?: {
-    split?: 'search' | 'holdout';
-    gateDecisions?: Record<string, GateDecision>;
-}): ParetoFigureSpec;
-interface GainDistributionBin {
-    /** Inclusive lower edge. */
-    lo: number;
-    /** Exclusive upper edge (or inclusive if it's the last bin). */
-    hi: number;
-    /** Number of pairs whose delta lands in this bin. */
-    count: number;
-}
-interface GainDistributionFigureSpec {
-    kind: 'gain-distribution';
-    candidateId: string;
-    comparator: string;
-    split: 'search' | 'holdout';
-    /** Number of pairs used. */
-    n: number;
-    bins: GainDistributionBin[];
-    median: number;
-    ci: {
-        low: number;
-        high: number;
-    };
-}
-interface GainDistributionOptions {
-    /** Number of histogram bins. Default 11 (so the centre is exact at 0). */
-    bins?: number;
-    /** Which split to use. Default 'holdout'. */
-    split?: 'search' | 'holdout';
-    /** Confidence level for the CI. Default 0.95. */
-    confidence?: number;
-    /** Bootstrap resamples. Default 2000. */
-    resamples?: number;
-    /** Deterministic seed. */
-    seed?: number;
-}
-/**
- * Held-out improvement distribution: per-pair delta (candidate −
- * comparator), histogrammed. Includes the bootstrap CI on the median
- * delta — same primitive the promotion gate uses.
- */
-declare function gainHistogram(runs: RunRecord[], candidateId: string, comparator: string, opts?: GainDistributionOptions): GainDistributionFigureSpec;
-
 /**
  * Liveness canaries — cheap statistical checks that catch the failure
  * modes a green test suite never sees.
@@ -8461,622 +6324,4 @@ interface OrthogonalityResult {
 }
 declare function passOrthogonality<T>(input: OrthogonalityInput<T>): OrthogonalityResult;
 
-/**
- * Bootstrap-CI promotion gate.
- *
- * In any iterative-improvement loop (GEPA, prompt evolution, dataset
- * curation), the question is "did this generation actually improve, or are
- * we celebrating noise?". With small N and noisy outcomes, point-estimate
- * deltas lie. Bootstrap confidence intervals tell the operator whether the
- * delta is real before code or prompts get promoted.
- *
- * This module is pure functions — no I/O, no model calls. Easy to unit-test
- * and to compose into any verdict gate.
- *
- * Default gate:
- *   - Bootstrap mean baseline vs candidate (1k resamples).
- *   - Compute the delta distribution; pass if the lower CI bound > 0.
- *   - Tunable confidence (default 95%) and resample count.
- *
- * Verdict semantics intentionally match the existing `experiments.jsonl`
- * vocabulary:
- *   - ADVANCE: candidate's CI lower bound > baseline mean (real win)
- *   - KEEP:    overlap, but candidate point estimate >= baseline (neutral)
- *   - REVERT:  candidate's CI upper bound < baseline mean (real regression)
- *   - INCONCLUSIVE: not enough samples or CI straddles zero with no signal
- */
-type Verdict = 'ADVANCE' | 'KEEP' | 'REVERT' | 'INCONCLUSIVE';
-interface BootstrapResult {
-    baselineMean: number;
-    candidateMean: number;
-    /** candidateMean - baselineMean, point estimate. */
-    delta: number;
-    /** Lower bound of the (1 - alpha) CI on the delta. */
-    ciLower: number;
-    /** Upper bound of the (1 - alpha) CI on the delta. */
-    ciUpper: number;
-    /** Number of bootstrap resamples used. */
-    iterations: number;
-    alpha: number;
-    verdict: Verdict;
-}
-interface BootstrapOptions {
-    /** Confidence level alpha (default 0.05 → 95% CI). */
-    alpha?: number;
-    /** Number of resamples (default 1000). */
-    iterations?: number;
-    /**
-     * Minimum total samples (baseline + candidate) below which we always
-     * return INCONCLUSIVE — bootstrap with too few samples is meaningless.
-     * Default 6 (combined).
-     */
-    minTotalSamples?: number;
-    /** RNG seed for reproducibility. Default: Math.random. */
-    seed?: number;
-}
-/**
- * Compute the bootstrap CI on (candidateMean - baselineMean) and a verdict.
- *
- * Uses simple percentile bootstrap on the difference of resampled means.
- * That's the standard non-parametric primitive — no distributional
- * assumptions, robust to skew, easy to reason about.
- */
-declare function bootstrapCi(baseline: number[], candidate: number[], options?: BootstrapOptions): BootstrapResult;
-/**
- * Judge-replay promotion gate.
- *
- * The cheap inner-loop judge that drives an evolution run is by definition
- * fast and noisy. When you're about to promote a winning variant to the
- * canonical default, you want a STRONGER judge (a more expensive model, a
- * human grader, a separately-trained reward model) to confirm the win
- * generalises beyond the inner loop.
- *
- * This helper takes raw winner + baseline outputs, scores both through the
- * stronger judge, and applies `bootstrapCi`. ADVANCE means the stronger
- * judge agrees the winner is real with the configured confidence. Doesn't
- * matter what shape your "output" is — pass a string, an object, anything
- * the judge can read.
- */
-interface JudgeReplayGateArgs<TOutput> {
-    baselineOutputs: TOutput[];
-    candidateOutputs: TOutput[];
-    /** Stronger judge — async to allow LLM calls. Return a 0..N scalar score. */
-    judge: (output: TOutput) => Promise<number> | number;
-    alpha?: number;
-    iterations?: number;
-    /** RNG seed for reproducibility. */
-    seed?: number;
-    /** Maximum concurrent judge calls. Default 4. */
-    judgeConcurrency?: number;
-}
-declare function judgeReplayGate<TOutput>(args: JudgeReplayGateArgs<TOutput>): Promise<BootstrapResult & {
-    baselineSamples: number;
-    candidateSamples: number;
-}>;
-
-/**
- * Shared types for the trace-analyst module.
- *
- * Wire format. The store interface speaks `OtlpSpanLike` rows — one JSONL
- * line per span, OTLP-shaped. We do NOT depend on a specific tracing
- * vendor at the type level. Adapter
- * layers map upstream shapes onto this interface.
- *
- * Design constraint. Every read operation that can return arbitrary
- * payload must carry a byte budget so the agent's tool result stays
- * bounded regardless of input trace size. Oversized responses
- * substitute a deterministic summary instead of bytes — see
- * `ViewTraceOversized`.
- */
-/** OTLP span kind (subset we actually use). */
-type TraceAnalystSpanKind = 'AGENT' | 'LLM' | 'TOOL' | 'CHAIN' | 'GUARDRAIL' | 'SPAN' | 'UNKNOWN';
-type TraceAnalystSpanStatus = 'OK' | 'ERROR' | 'UNSET';
-/** Subset of OTLP span fields the analyst exposes to the agent. The
- *  store's job is to project upstream's full span shape down to this
- *  view — the analyst never sees vendor extensions directly. */
-interface TraceAnalystSpan {
-    trace_id: string;
-    span_id: string;
-    parent_span_id: string | null;
-    name: string;
-    kind: TraceAnalystSpanKind;
-    start_time: string;
-    end_time: string;
-    duration_ms: number;
-    status: TraceAnalystSpanStatus;
-    status_message?: string;
-    service_name: string | null;
-    agent_name: string | null;
-    model_name: string | null;
-    tool_name: string | null;
-    /** Raw JSON-serialisable attribute map. May contain large strings;
-     *  callers must respect the per-attribute byte cap. */
-    attributes: Record<string, unknown>;
-}
-interface TraceAnalystTraceSummary {
-    trace_id: string;
-    service_name: string | null;
-    agent_name: string | null;
-    span_count: number;
-    has_errors: boolean;
-    start_time: string;
-    end_time: string;
-    duration_ms: number;
-    raw_jsonl_bytes: number;
-    models: string[];
-    tools: string[];
-}
-interface TraceAnalystFilters {
-    /** Restrict to traces that contain at least one error span. */
-    has_errors?: boolean;
-    /** Match if any span's `service.name` is in this list. */
-    service_names?: string[];
-    /** Match if any span's `agent.name` is in this list. */
-    agent_names?: string[];
-    /** Match if any LLM span's `llm.model_name` is in this list. */
-    model_names?: string[];
-    /** Match if any tool span's `tool.name` is in this list. */
-    tool_names?: string[];
-    /** ISO-8601 lower bound on the trace's earliest start time. */
-    start_time_after?: string;
-    /** ISO-8601 upper bound on the trace's earliest start time. */
-    start_time_before?: string;
-    /** Single regex applied to raw JSONL bytes for the trace. Opt-in;
-     *  expensive on large datasets. Use the indexed filters above first. */
-    regex_pattern?: string;
-}
-interface DatasetOverview {
-    total_traces: number;
-    raw_jsonl_bytes: number;
-    services: string[];
-    agents: string[];
-    models: string[];
-    tool_names: string[];
-    /** Up to 20 real trace ids the agent may pass to view/search tools. */
-    sample_trace_ids: string[];
-    errors: {
-        trace_count: number;
-        span_count: number;
-    };
-    time_range: {
-        earliest: string;
-        latest: string;
-    } | null;
-}
-interface QueryTracesPage {
-    traces: TraceAnalystTraceSummary[];
-    total: number;
-    has_more: boolean;
-}
-/** Full-trace view. When the response would exceed the per-call byte
- *  budget, `oversized` is populated INSTEAD of `spans` so the agent
- *  knows to switch to `searchTrace` / `viewSpans`. */
-interface ViewTraceResult {
-    trace_id: string;
-    spans?: TraceAnalystSpan[];
-    oversized?: ViewTraceOversized;
-}
-interface ViewTraceOversized {
-    span_count: number;
-    /** Names with their counts, sorted desc. Capped at 20 entries. */
-    top_span_names: Array<[string, number]>;
-    /** Largest single span body (bytes after attribute-cap projection). */
-    span_response_bytes_max: number;
-    error_span_count: number;
-}
-interface ViewSpansResult {
-    trace_id: string;
-    spans: TraceAnalystSpan[];
-    /** Number of requested span ids that were not found in the trace. */
-    missing_span_ids: string[];
-    /** Number of attribute fields truncated to fit the per-attribute cap. */
-    truncated_attribute_count: number;
-}
-interface SpanMatchRecord {
-    trace_id: string;
-    span_id: string;
-    span_name: string;
-    span_kind: TraceAnalystSpanKind;
-    /** JSON pointer-style path to the matched value, e.g.
-     *  `attributes."llm.input_messages"[2].content`. */
-    attribute_path: string;
-    matched_text: string;
-    context_before: string;
-    context_after: string;
-    match_offset: number;
-}
-interface SearchTraceResult {
-    trace_id: string;
-    hits: SpanMatchRecord[];
-    total_matches: number;
-    has_more: boolean;
-}
-interface SearchSpanResult {
-    trace_id: string;
-    span_id: string;
-    hits: SpanMatchRecord[];
-    total_matches: number;
-    has_more: boolean;
-}
-/** Tunable byte budgets for bounded RLM tool output. */
-interface TraceAnalystByteBudgets {
-    /** Max bytes any single tool response may emit. Hard ceiling enforced
-     *  by the store; oversized → summary. Default 150_000. */
-    perCallByteCeiling: number;
-    /** Per-attribute string truncation cap on `viewTrace` (discovery scan).
-     *  Default 4096. */
-    perAttributeViewBudget: number;
-    /** Per-attribute string truncation cap on `viewSpans` (surgical reads).
-     *  Default 16384. */
-    perAttributeSpanBudget: number;
-    /** Per-attribute cap on a single match record's `matched_text` and
-     *  context window. Default 1024. */
-    perMatchTextBudget: number;
-}
-declare const DEFAULT_TRACE_ANALYST_BUDGETS: TraceAnalystByteBudgets;
-/** Marker substituted in place of truncated string payloads. Callers
- *  parsing tool output can detect it deterministically. */
-declare const TRACE_ANALYST_TRUNCATION_MARKER_PREFIX = "[trace-analyst truncated:";
-
-/**
- * `TraceAnalysisStore` — read-side interface the trace-analyst calls
- * through. Six operations, all bounded:
- *
- *   - `getOverview(filters?)` — dataset rollup + sample trace ids.
- *   - `queryTraces(filters?, limit, offset)` — paginated summaries.
- *   - `countTraces(filters?)` — cheap count without materialisation.
- *   - `viewTrace(trace_id, perAttrCap)` — full span list, oversized → summary.
- *   - `viewSpans(trace_id, span_ids, perAttrCap)` — surgical span fetch.
- *   - `searchTrace(trace_id, regex, max_matches)` — bounded regex hits.
- *   - `searchSpan(trace_id, span_id, regex, max_matches)` — single-span search.
- *
- * Multiple implementations ship in the core (`OtlpFileTraceStore`).
- * Downstream callers can supply their own — e.g. a DuckDB-backed
- * adapter or an in-memory adapter for tests — by implementing this
- * interface.
- *
- * Filters compose with AND semantics. Empty/undefined fields impose
- * no constraint. `regex_pattern` is the only opt-in raw-bytes scan —
- * implementations may skip it via `count`/`overview` when not set.
- */
-
-interface TraceAnalysisStore {
-    getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
-    queryTraces(opts: {
-        filters?: TraceAnalystFilters;
-        limit: number;
-        offset?: number;
-    }): Promise<QueryTracesPage>;
-    countTraces(filters?: TraceAnalystFilters): Promise<number>;
-    viewTrace(opts: {
-        trace_id: string;
-        /** Override per-attribute byte cap. Defaults to discovery budget. */
-        per_attribute_byte_cap?: number;
-    }): Promise<ViewTraceResult>;
-    viewSpans(opts: {
-        trace_id: string;
-        span_ids: readonly string[];
-        /** Override per-attribute byte cap. Defaults to surgical budget. */
-        per_attribute_byte_cap?: number;
-    }): Promise<ViewSpansResult>;
-    searchTrace(opts: {
-        trace_id: string;
-        regex_pattern: string;
-        /** Hard cap on matches returned. Default 50. */
-        max_matches?: number;
-    }): Promise<SearchTraceResult>;
-    searchSpan(opts: {
-        trace_id: string;
-        span_id: string;
-        regex_pattern: string;
-        max_matches?: number;
-    }): Promise<SearchSpanResult>;
-}
-
-interface AnalyzeTracesInput {
-    /** The user-facing question. Domain framing belongs here, not in the
-     *  actor description. */
-    question: string;
-}
-interface AnalyzeTracesResult {
-    /** The responder's prose answer. */
-    answer: string;
-    /** Bulleted findings extracted from the responder's structured output. */
-    findings: string[];
-    /** Per-actor-turn snapshots captured via `actorTurnCallback`. */
-    turns: AnalyzeTracesTurnSnapshot[];
-    /** Total turns the actor took. */
-    turnCount: number;
-    /** Token usage by role. */
-    usage: TraceAnalystUsage;
-    /** Full system + assistant + tool message log by role. */
-    chatLog: TraceAnalystChatLog;
-    /** Prompt version that produced this run. */
-    actorPromptVersion: string;
-}
-interface TraceAnalystUsage {
-    actor: TraceAnalystUsageEntry[];
-    responder: TraceAnalystUsageEntry[];
-}
-interface TraceAnalystUsageEntry {
-    [key: string]: unknown;
-}
-interface TraceAnalystChatLog {
-    actor: TraceAnalystChatMessage[];
-    responder: TraceAnalystChatMessage[];
-}
-interface TraceAnalystChatMessage {
-    [key: string]: unknown;
-}
-interface AnalyzeTracesTurnSnapshot {
-    turn: number;
-    isError: boolean;
-    /** The JS code the actor produced for this turn. */
-    code: string;
-    /** The formatted action-log entry the actor sees on the next turn. */
-    output: string;
-    /** Provider thought (when `actorOptions.showThoughts` is true and the
-     *  provider returns it). */
-    thought?: string;
-}
-interface AnalyzeTracesOptions {
-    /** Trace data source. Pass either an OTLP-JSONL path or a custom store. */
-    source: string | TraceAnalysisStore;
-    /** Caller-provided AxAIService. */
-    ai: AxAIService;
-    /** Model id forwarded to actor + responder. */
-    model?: string;
-    /** Recursion depth. 0 = no sub-agent dispatch. Default 1. */
-    maxDepth?: number;
-    /** Maximum actor turns. Default 12. */
-    maxTurns?: number;
-    /** Maximum parallel sub-agent calls in batched llmQuery. Default 2. */
-    maxParallelSubagents?: number;
-    /** Override the actor description. */
-    actorDescription?: string;
-    /** Override the subagent description. */
-    subagentDescription?: string;
-    /** Per-turn observability hook. */
-    onTurn?: (turn: AnalyzeTracesTurnSnapshot) => void | Promise<void>;
-    /** Override max runtime characters per turn. Default 6000. */
-    maxRuntimeChars?: number;
-    /** When set, every turn's snapshot is appended to this JSONL file
-     *  immediately. If the analyst crashes mid-loop (provider 503,
-     *  network error, validator reject) the partial reasoning is still
-     *  on disk. Replay the file with the responder afterward to recover
-     *  evidence. */
-    progressLogPath?: string;
-}
-/**
- * Run the trace analyst.
- *
- * Throws:
- *   - `TraceFileMissingError` if `source` is a path and doesn't exist.
- *   - `AxAgentClarificationError` if the analyst asks for clarification.
- *   - Provider errors (auth, rate limits) propagate from the AI service.
- */
-declare function analyzeTraces(input: AnalyzeTracesInput, options: AnalyzeTracesOptions): Promise<AnalyzeTracesResult>;
-
-/**
- * `OtlpFileTraceStore` — read-only OTLP-JSONL trace store for the
- * trace-analyst.
- *
- * Wire shape. Each line of the input file is one OTLP-shaped span. The
- * store understands flattened OTLP JSONL plus the OpenInference vocab.
- * We project upstream's full
- * span shape down to `TraceAnalystSpan` lazily — full materialisation
- * only happens for the spans the agent actually requests.
- *
- * Indexing. On first read the store builds an in-memory index keyed
- * by `trace_id` carrying:
- *   - byte offsets + lengths for each span line (for surgical reads
- *     without re-parsing the whole file)
- *   - a `TraceAnalystTraceSummary` rollup
- *   - sets of services / agents / models / tools / has_errors
- *   - byte size of the trace's JSONL slab
- *
- * Memory bound. The index keeps span metadata only — names, kinds,
- * offsets, status. Attribute payloads stay on disk until requested.
- * For a 50MB JSONL with 50k spans, the index is ~5MB.
- *
- * Concurrency. The store builds the index once on first read and
- * caches it. Subsequent reads reuse the index. The file is opened on
- * each read; we never hold a long-lived FD.
- */
-
-interface OtlpFileTraceStoreOptions {
-    /** Path to the OTLP-JSONL file. */
-    path: string;
-    /** Override the discovery (`viewTrace`) per-attribute byte cap. */
-    perAttributeViewBudget?: number;
-    /** Override the surgical (`viewSpans`) per-attribute byte cap. */
-    perAttributeSpanBudget?: number;
-    /** Override the per-call ceiling that triggers oversized summaries. */
-    perCallByteCeiling?: number;
-    /** Override the per-match text budget. */
-    perMatchTextBudget?: number;
-}
-declare class OtlpFileTraceStore implements TraceAnalysisStore {
-    private readonly path;
-    private readonly perAttributeViewBudget;
-    private readonly perAttributeSpanBudget;
-    private readonly perCallByteCeiling;
-    private readonly perMatchTextBudget;
-    private indexPromise?;
-    /** Cached UTF-8 buffer of the file. We pin it once because every
-     *  read needs slice access and re-reading on each call balloons the
-     *  syscall count. */
-    private bufferPromise?;
-    constructor(opts: OtlpFileTraceStoreOptions);
-    getOverview(filters?: TraceAnalystFilters): Promise<DatasetOverview>;
-    queryTraces(opts: {
-        filters?: TraceAnalystFilters;
-        limit: number;
-        offset?: number;
-    }): Promise<QueryTracesPage>;
-    countTraces(filters?: TraceAnalystFilters): Promise<number>;
-    viewTrace(opts: {
-        trace_id: string;
-        per_attribute_byte_cap?: number;
-    }): Promise<ViewTraceResult>;
-    viewSpans(opts: {
-        trace_id: string;
-        span_ids: readonly string[];
-        per_attribute_byte_cap?: number;
-    }): Promise<ViewSpansResult>;
-    searchTrace(opts: {
-        trace_id: string;
-        regex_pattern: string;
-        max_matches?: number;
-    }): Promise<SearchTraceResult>;
-    searchSpan(opts: {
-        trace_id: string;
-        span_id: string;
-        regex_pattern: string;
-        max_matches?: number;
-    }): Promise<SearchSpanResult>;
-    /** Force the index to materialise. Useful to amortise startup cost
-     *  before the first agent call. */
-    ensureIndexed(): Promise<void>;
-    private buffer;
-    private index;
-    private buildIndex;
-    private matchedTraces;
-    private toSummary;
-    private projectSpan;
-    private buildOversizedSummary;
-    private scanSpanForMatches;
-}
-declare class TraceFileMissingError extends Error {
-    constructor(path: string);
-}
-declare class TraceNotFoundError extends Error {
-    readonly trace_id: string;
-    constructor(trace_id: string);
-}
-declare class SpanNotFoundError extends Error {
-    readonly trace_id: string;
-    readonly span_id: string;
-    constructor(trace_id: string, span_id: string);
-}
-
-/**
- * Trace-analyst tool surface — six namespaced AxFunctions the analyst
- * agent calls from generated JS code via `traces.<name>(...)`.
- *
- * Discovery → narrow → deep-read protocol. Tool names + ordering
- * support RLM discovery:
- *
- *   1. `getDatasetOverview` (cheap)  — first call, sizes the dataset
- *   2. `queryTraces`                 — paginated summaries with `raw_jsonl_bytes`
- *   3. `countTraces`                 — cheap pre-flight before regex
- *   4. `viewTrace`                   — full span list, oversized → summary
- *   5. `viewSpans`                   — surgical 16KB-cap reads
- *   6. `searchTrace` / `searchSpan`  — bounded regex hits
- *
- * Failure mode. Tool handlers throw on bad input (invalid trace ids,
- * out-of-range pagination, malformed regex). Ax converts thrown errors
- * into actor-visible `[ERROR]` strings so the analyst can adjust on
- * the next turn instead of looping.
- */
-
-interface BuildTraceAnalystToolsOpts {
-    store: TraceAnalysisStore;
-    /** Override the default sample-trace-id slot count (20). Mostly for tests. */
-    sampleTraceLimit?: number;
-}
-/**
- * Build the trace-analyst function set. Pass the result into
- * `agent(...).functions.local`.
- */
-declare function buildTraceAnalystTools(opts: BuildTraceAnalystToolsOpts): AxFunction[];
-/**
- * Convenience: same shape as `buildTraceAnalystTools` but returns the
- * grouped form expected when registering trace tools alongside other
- * agent function modules. */
-declare function traceAnalystFunctionGroup(opts: BuildTraceAnalystToolsOpts): {
-    namespace: string;
-    title: string;
-    selectionCriteria: string;
-    description: string;
-    functions: AxFunction[];
-};
-
-/** Ax RLM prompt for bounded trace discovery and evidence-backed analysis. */
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION = "You answer questions about an OTLP-shaped JSONL trace dataset using the trace tools provided in the `traces` namespace.\n\nDISCOVERY \u2192 NARROW \u2192 DEEP-READ protocol \u2014 follow exactly:\n\n1. ALWAYS call `traces.getDatasetOverview({})` FIRST without a regex_pattern. The result tells you total_traces, raw_jsonl_bytes, services, agents, models, and sample_trace_ids (real ids \u2014 never fabricate one).\n\n2. Use raw_jsonl_bytes to gauge how expensive raw scans will be. `filters.regex_pattern` is the one scan-heavy filter on getDatasetOverview / queryTraces / countTraces \u2014 narrow with indexed fields (has_errors, model_names, service_names, agent_names, time bounds) BEFORE adding a regex on a large dataset.\n\n3. To list more traces than the sample, call `traces.queryTraces({ filters?, limit, offset? })`. Each summary carries raw_jsonl_bytes \u2014 use it to choose between viewTrace and searchTrace BEFORE calling either.\n\n4. Per-trace inspection:\n   - SMALL trace (raw_jsonl_bytes well under 150_000): call `traces.viewTrace({ trace_id })`. Returns all spans. Per-attribute payloads are head-capped at ~4KB; large `input.value` / `output.value` / `llm.input_messages` will show a `[trace-analyst truncated: N bytes]` marker.\n   - LARGE trace (raw_jsonl_bytes near or above 150_000, or you saw an `oversized` response): use `traces.searchTrace({ trace_id, regex_pattern })` to get bounded SpanMatchRecords (span metadata + matched text + surrounding context). Then call `traces.viewSpans({ trace_id, span_ids: [...] })` for surgical reads (~16KB cap, 4\u00D7 higher than discovery), or `traces.searchSpan({ trace_id, span_id, regex_pattern })` for one large span. Stays bounded regardless of trace size.\n   - Useful regex patterns: `STATUS_CODE_ERROR` (failures), tool names like `grep` or `view_trace`, error strings like `MaxTurnsExceeded`, model names, attribute keys.\n\n5. ONLY call viewTrace / viewSpans / searchTrace / searchSpan with trace/span ids you have already seen in sample_trace_ids, a queryTraces page, or a previous search result. Never invent ids.\n\n5a. **Result-shape contract** \u2014 searchTrace and searchSpan return `{ trace_id, hits, total_matches, has_more }`. Iterate `result.hits` (NOT result.matches). Each hit has `{ span_id, span_name, span_kind, attribute_path, matched_text, context_before, context_after, match_offset }`. viewTrace returns `{ trace_id, spans }` (or `oversized`). viewSpans returns `{ trace_id, spans, missing_span_ids, truncated_attribute_count }`. Never assume a field name \u2014 log the result shape first if unsure.\n\n6. If viewTrace returns an `oversized` summary instead of `spans`, DO NOT retry the same call. Read the summary's top_span_names, span_count, span_response_bytes_max, error_span_count to plan a follow-up: switch to searchTrace (or searchSpan for one large span), then viewSpans on a smaller, surgical span_ids set.\n\n7. If searchTrace or searchSpan returns has_more=true, REFINE the regex to be more specific rather than blindly raising max_matches.\n\n8. If a tool errors (invalid regex, range error), STOP and reconsider \u2014 don't retry with a guessed id or argument. Use the discovery tools above to recover.\n\n9. If a ~4KB-truncated payload from viewTrace / searchTrace matters for your answer, first try viewSpans on that span id (~16KB cap). If a 16KB-truncated payload from viewSpans still matters, narrow further with searchSpan against a more specific regex rather than asking for the full payload again.\n\n10. If maxDepth > 0 and the question splits into independent semantic branches, delegate well-defined subtasks to subagents using `await llmQuery(...)`. Pass narrow context and a focused query. Examples:\n\n    const reviews = await llmQuery([\n      { query: 'Drill into trace abc123 \u2014 what tool calls preceded the failure?', context: { trace_id: 'abc123' } },\n      { query: 'Drill into trace def456 \u2014 same failure mode?', context: { trace_id: 'def456' } },\n    ]);\n\nOBSERVABILITY rules:\n- Each non-final actor turn must emit at least one `console.log(...)` for evidence. Up to 3 logs per turn is fine when correlating multiple data sources (e.g. one log for findings list, one for source-file content, one for derived analysis).\n- Do NOT combine `console.log` with `final(...)` or `askClarification(...)` in the same turn \u2014 finish gathering data first, then call final on its own turn.\n- Reuse runtime variables across turns; don't recompute.\n- When done, call `await final(answer)` with the fully-formed report. The responder rewrites the answer into output fields; if you only pass a vague summary string the responder has nothing concrete to format.\n\nCRITICAL \u2014 `final()` payload contract for evidence-grounded analysis tasks:\n- Pass a STRUCTURED object as the second arg with the actual data the responder needs to format the answer. Do NOT pass abstract instructions; pass evidence.\n- Example for per-item verdict tasks:\n  ```js\n  await final(\"Format the per-item verdict report from the evidence below.\", {\n    findings: [\n      { id: 'sub-1-finding-1', claim: '...', verdict: 'TRUE-POSITIVE', evidence: 'lines 42-45 of contracts/X.sol show ...' },\n      ...all items\n    ],\n    systemic_summary: '3 sentences I wrote based on the evidence above'\n  });\n  ```\n- Calling `final(\"answer\", {})` with no evidence is a failure mode \u2014 the responder will hallucinate or echo back the field names. Always include the gathered data.\n- Premature final after a single viewSpans call is INSUFFICIENT for per-finding analysis tasks. Read the requested attributes (e.g. `spans[i].attributes['redteam.finding.title']`), and for each one perform the requested cross-reference (e.g. read the source SPAN's `attributes['source.content']`).\n\nOUTPUT contract \u2014 your final answer must include:\n- A clear prose conclusion answering the user's question.\n- Trace ids and span ids cited as evidence for each claim.\n- Failure modes named in the user's domain language, with frequency and concrete examples.\n\nDo NOT invent trace ids, span ids, error messages, or model names. Every fact must be traceable to a tool result.";
-declare const TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION = "trace-analyst-actor-v5-2026-05-06";
-/** Subagent prompt for focused trace-inspection subtasks. */
-declare const TRACE_ANALYST_SUBAGENT_DESCRIPTION = "You are a trace-analyst subagent. Your parent has delegated a focused trace-inspection question. Use the same DISCOVERY \u2192 NARROW \u2192 DEEP-READ protocol but stay tightly scoped: do exactly what was asked, return a concise compact answer, do NOT spawn further subagents unless the parent's question is genuinely multi-branch.\n\nCite trace ids and span ids for every claim. Do NOT invent ids.";
-
-interface TraceInsightTask {
-    id: string;
-    name: string;
-    prompt?: string;
-    difficulty?: string;
-    tags?: string[];
-    outcome?: string;
-    score?: number;
-    gaps?: string[];
-}
-interface TraceInsightSuite {
-    name: string;
-    collectionId?: string;
-    tasks: TraceInsightTask[];
-}
-interface TraceInsightFinding {
-    kind: string;
-    severity?: string;
-    taskIds: string[];
-    evidence?: string;
-    proposedFixClass?: string;
-}
-interface TraceInsightQuestion {
-    id: string;
-    question: string;
-    why: string;
-}
-interface TraceInsightPanelRole {
-    id: string;
-    name: string;
-    responsibility: string;
-}
-interface TraceInsightPromptInput {
-    suite: TraceInsightSuite;
-    findings?: TraceInsightFinding[];
-    agent?: Record<string, unknown>;
-    totals?: Record<string, unknown>;
-    maxRepresentativeTraces?: number;
-}
-interface TraceInsightContext {
-    suite: TraceInsightSuite;
-    scope: string;
-    keywords: string[];
-    questions: TraceInsightQuestion[];
-    panel: TraceInsightPanelRole[];
-    findings: TraceInsightFinding[];
-    agent: Record<string, unknown> | null;
-    totals: Record<string, unknown> | null;
-}
-interface TraceInsightQualityGate {
-    id: string;
-    label: string;
-    passed: boolean;
-    severity: 'critical' | 'high' | 'medium' | 'low';
-    detail: string;
-}
-interface TraceInsightReadiness {
-    score: number;
-    grade: 'external-ready' | 'internal-review' | 'raw-analysis';
-    gates: TraceInsightQualityGate[];
-}
-declare function tokenizeDomainWords(value: string): string[];
-declare function inferDomainKeywords(suite: TraceInsightSuite): string[];
-declare function domainEvidencePattern(keywords: string[]): RegExp;
-declare function describeTraceInsightScope(suite: TraceInsightSuite): string;
-declare function planTraceInsightQuestions(input: TraceInsightPromptInput): TraceInsightQuestion[];
-declare function buildTraceInsightContext(input: TraceInsightPromptInput): TraceInsightContext;
-declare function scoreTraceInsightReadiness(context: TraceInsightContext): TraceInsightReadiness;
-declare function defaultTraceInsightPanel(): TraceInsightPanelRole[];
-declare function buildTraceInsightPrompt(input: TraceInsightPromptInput): string;
-
-export { type ActionExecutionPolicy, type ActionPolicyDecision, type ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, type AlignmentOp, type AnalyzeTracesInput, type AnalyzeTracesOptions, type AnalyzeTracesResult, type AnalyzeTracesTurnSnapshot, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, type Artifact$1 as Artifact, type ArtifactCheck, type Artifact as ArtifactCheckArtifact, type ArtifactResult, type ArtifactValidator, type AsiSeverity, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, type BaselineOptions, type BaselineReport, BehaviorAssertion, type BenchmarkReport, BenchmarkRunner, type BenchmarkRunnerConfig, type BestOfNResult, type BisectOptions, type BisectResult, type BisectStep, type BootstrapOptions, type BootstrapResult, BudgetBreachError, type BudgetBreachFinding, type BudgetBreachReport, BudgetGuard, type BudgetLedgerEntry, type BudgetSpec, BuilderSession, type BuilderSessionInit, type CalibrationBin, type CalibrationOptions, type CalibrationReport, type CalibrationResult, CallExpectation, CallbackResearcher, type CallbackResearcherOptions, type CanaryAlert, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateScenario, type CandidateScore, type CausalAttributionReport, type ChatSummary, type CheckResult, type CodeMutationOutcome, type CodeMutationRunner, type CollectedArtifacts, type CommandRunner, type CompletionCriterion, type CompositePolicy, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContractMetric, type ContractReport, type ControlActionFailureMode, type ControlActionOutcome, type ControlBudget, type ControlContext, type ControlDecision, type ControlEvalResult, type ControlRunResult, type ControlRuntimeConfig, type ControlRuntimeError, type ControlSeverity, type ControlStep, type ControlStopPolicies, ConvergenceTracker, type CorrelationReport, type CorrelationResult, type CorrelationStudyOptions, type CorrelationStudyResult, type CostEntry, CostLedger, type CostLedgerGeneration, type CostLedgerSnapshot, type CostSummary, CostTracker, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateCompositeMutatorOpts, type CreateDefaultReviewerOptions, type CreateSandboxCodeMutatorOpts, type CreateSandboxPoolOpts, type CrossTraceDiff, type CrossTraceDiffOptions, D1ExperimentStore, type D1ExperimentStoreOptions, type D1Like, type D1PreparedStatementLike, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATION_PRIMITIVES, DEFAULT_MUTATORS, DEFAULT_REDACTION_RULES, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, DEFAULT_TRACE_ANALYST_BUDGETS, type DataAcquisitionPlan, Dataset, type DatasetDifficulty, type DatasetManifest, type DatasetOverview, type DatasetProvenance, type DatasetScenario, type DatasetSplit, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DeploymentOutcome, type DirEntry, type Direction, type DivergenceOptions, type DivergenceReport, DockerSandboxDriver, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, ERROR_COUNT_PATTERNS, type ErrorCountPattern, type EuRiskClass, type EvalMetricSpec, type EvalResult, type EventFilter, type EventKind, type EvolutionRound, type EvolvableVariant, type ExecutorConfig, type Expectation, type Experiment, type ExperimentPlan, type ExperimentResult, type Run as ExperimentRun, type ExperimentStore, ExperimentTracker, type ExportedRewardModel, type ExtractOptions, type ExtractResult, FAILURE_CLASSES, type FactorContribution, type FactorialCell, type FailureClass, type FailureClassification, type FailureCluster, type FailureClusterReport, type FailureContext, type FailureMode, type FailureRule, type FeedbackArtifactType, type FeedbackAttempt, type FeedbackLabel, type FeedbackLabelKind, type FeedbackLabelSource, type FeedbackOptimizerRow, type FeedbackOutcome, type FeedbackPattern, type FeedbackReplayAdapter, type FeedbackReplayResult, type FeedbackSeverity, type FeedbackSplitPolicy, type FeedbackTask, type FeedbackTrajectory, type FeedbackTrajectoryFilter, type FeedbackTrajectoryStore, FileSystemExperimentStore, type FileSystemExperimentStoreOptions, FileSystemFeedbackTrajectoryStore, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, FileSystemTraceStore, type FileSystemTraceStoreOptions, type Finding, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type GainDistributionBin, type GainDistributionFigureSpec, type GainDistributionOptions, type GateDecision, type GateEvidence, type GenerationReport, type GenericSpan, type GoldenItem, type GoldenSeverity, type GoldenSpec, type GovernanceContext, type GovernanceFinding, type GovernanceReport, type GradedStep, type HarnessAdapter, type HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessVariant, type HarnessVariantReport, HeldOutGate, type HeldOutGateConfig, type HeldOutGateRejectionCode, HoldoutAuditor, HoldoutLockedError, type HostedJudgeConfig, type HostedJudgeDimension, type HostedJudgeRequest, type HostedJudgeResponse, type HostedRunCriticConfig, type HostedRunScoreRequest, type HostedRunScoreResponse, type HypothesisManifest, type HypothesisResult, INTENT_MATCH_JUDGE_VERSION, type ImageData, InMemoryExperimentStore, InMemoryFeedbackTrajectoryStore, InMemoryOutcomeStore, InMemoryTraceStore, InMemoryTrialCache, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, JsonlTrialCache, type JudgeAgreementReport, type JudgeConfig, type JudgeFleetOptions, type JudgeFn, type JudgeInput, type JudgePair, type JudgeReplayGateArgs, type JudgeReplayResult, type JudgeRubric, JudgeRunner, type JudgeScore, type JudgeSpan, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type KnowledgeAcquisitionMode, type KnowledgeBundle, type KnowledgeFallbackPolicy, type KnowledgeFreshness, type KnowledgeImportance, type KnowledgeReadinessReport, type KnowledgeRecommendedAction, type KnowledgeRequirement, type KnowledgeRequirementCategory, type KnowledgeResponsibleSurface, type KnowledgeSensitivity, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, type Layer, type LayerCorrelation, type LayerResult, type LayerStatus, type LineageKind, type LineageKindResolver, type LineageNode, LineageRecorder, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallError, type LlmCallRequest, type LlmCallResult, LlmClient, type LlmClientOptions, type LlmJsonCall, type LlmMessage, type LlmReviewerConfig, type LlmSpan, type LlmUsage, LockedJsonlAppender, MODEL_PRICING, type MatchResult, type MatcherResult, type MeasurementPolicy, type MergeOptions, type Message, type MetricSamples, type MetricVerdict, MetricsCollector, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, type MultiShotGateConfig, type MultiShotGateResult, type MultiShotMutateAdapter, type MultiShotOptimizationConfig, type MultiShotOptimizationResult, type MultiShotRun, type MultiShotRunInput, type MultiShotRunner, type MultiShotScore, type MultiShotScorer, type MultiShotSplit, type MultiShotTrace, type MultiShotTrialResult, type MultiShotVariant, type MultiToolchainLayerConfig, type MutateAdapter, type MutationAttempt, type MutationChannel, MutationTelemetry, type Mutator, Mutex, NoopResearcher, OTEL_AGENT_EVAL_SCOPE, type Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, type OtlpExport, OtlpFileTraceStore, type OtlpFileTraceStoreOptions, type OtlpResourceSpans, type OtlpSpan, type OutcomeFilter, type OutcomePair, type OutcomeStore, type PairedBootstrapOptions, type PairedBootstrapResult, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, type ParetoFigureSpec, type ParetoPoint, type ParetoResult, type PersonaConfig, type Playbook, type PlaybookEntry, type PoolSlot, type PositionalBiasResult, type PreferenceMemoryEntry, type PrmGradedTrace, PrmGrader, type PrmTrainingSample, ProductClient, type ProductClientConfig, type ProjectKind, ProjectRegistry, type ProjectSummary, type ProjectTimelineEntry, type PromptEvolutionConfig, type PromptEvolutionEvent, type PromptEvolutionResult, type PromptHandle, PromptRegistry, type TrialResult as PromptTrialResult, type ProposeFn, type ProposeInput, type ProposeOutput, type ProposeReviewConfig, type ProposeReviewControlAction, type ProposeReviewControlConfig, type ProposeReviewControlResult, type ProposeReviewControlState, type ProposeReviewReport, type ProposeReviewShot, type ProposedSideEffect, type QueryTracesPage, REDACTION_VERSION, type RedTeamCase, type RedTeamCategory, type RedTeamFinding, type RedTeamPayload, type RedTeamReport, type RedactionReport, type RedactionRule, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type ReflectionContext, type ReflectionProposal, type RegressionOptions, type RegressionSpec, type ReleaseConfidenceAxis, type ReleaseConfidenceAxisName, type ReleaseConfidenceInput, type ReleaseConfidenceIssue, type ReleaseConfidenceMetrics, type ReleaseConfidenceScorecard, type ReleaseConfidenceStatus, type ReleaseConfidenceThresholds, type ReleaseTraceEvidence, type Researcher, type RetrievalSpan, type Review, type ReviewFn, type ReviewInput, type ReviewMemoryEntry, type ReviewMemoryStore, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RobustnessResult, type RouteMap, type RubricDimension, type Run$1 as Run, type RunAppScenarioOptions, type RunCommandInput, type RunCommandResult, type RunConfig, RunCritic, type RunCriticOptions, type RunDiff, type RunFilter, type RunLayer, RunRecord, type RunScore, type RunScoreWeights, RunSplitTag, type RunStatus, type RunTrace, SEMANTIC_CONCEPT_JUDGE_VERSION, type SandboxDriver, SandboxHarness, type SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxResult, type SandboxSpan, type ScanOptions, type Scenario, type ScenarioAggregate, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, type ScoreAdapter, type ScoreKnowledgeReadinessOptions, type ScoredTarget, type SearchSpanResult, type SearchTraceResult, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SelfPreferenceResult, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SeriesConvergenceOptions, type SeriesConvergenceResult, type Severity, type ShipOptions, type SignedManifest, type SignedManifestAlgo, type SliceOptions, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, type Span, type SpanBase, type SpanFilter, type SpanHandle, type SpanKind, type SpanMatchRecord, SpanNotFoundError, type SpanStatus, type SteeringBundle, type SteeringChange, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type StepContext, type StepRubric, type StopDecision, type StuckLoopFinding, type StuckLoopOptions, type StuckLoopReport, SubprocessSandboxDriver, type SubprocessSandboxDriverOptions, type SummaryTable, type SummaryTableOptions, type SummaryTableRow, type SynthesisReason, type SynthesisTarget, TRACE_ANALYST_ACTOR_DESCRIPTION, TRACE_ANALYST_ACTOR_DESCRIPTION_VERSION, TRACE_ANALYST_SUBAGENT_DESCRIPTION, TRACE_ANALYST_TRUNCATION_MARKER_PREFIX, TRACE_SCHEMA_VERSION, type TestGradedRunOptions, type TestGradedRunResult, type TestGradedScenario, type TestOutputParser, type TestResult, type ThreeLayerProjectReport, type ThresholdContract, TokenCounter, type TokenSpec, type ToolSpan, type ToolStats, type ToolUseMetrics, type ToolUseOptions, type ToolWasteFinding, type ToolWasteOptions, type ToolWasteReport, type TraceAnalysisStore, type TraceAnalystByteBudgets, type TraceAnalystFilters, type TraceAnalystSpan, type TraceAnalystSpanKind, type TraceAnalystSpanStatus, type TraceAnalystTraceSummary, TraceEmitter, type TraceEmitterOptions, type TraceEvent, TraceFileMissingError, type TraceInsightContext, type TraceInsightFinding, type TraceInsightPanelRole, type TraceInsightPromptInput, type TraceInsightQualityGate, type TraceInsightQuestion, type TraceInsightReadiness, type TraceInsightSuite, type TraceInsightTask, TraceNotFoundError, type TraceStore, type Trajectory, type TrajectoryStep, type TrialAttempt, type TrialCache, TrialTelemetry, type TrialTrace, type Turn, type TurnMetrics, type TurnResult, UNIVERSAL_FINDERS, type UseCaseSignals, type UserQuestion, type ValidationContext, type ValidationIssue, type ValidationResult, type VariantAggregate, type VerbosityBiasResult, type Verdict, type Verification, type VerificationReport, type VerifyContext, type VerifyFn, type VerifyOptions, type ViewSpansResult, type ViewTraceOversized, type ViewTraceResult, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, acquisitionPlansForKnowledgeGaps, adversarialJudge, aggregateLlm, aggregateRunScore, allCriticalPassed, analyzeAntiSlop, analyzeSeries, analyzeTraces, argHash, assertReleaseConfidence, assignFeedbackSplit, attributeCounterfactuals, benjaminiHochberg, bhAdjust, bisect, blockingKnowledgeEval, bonferroni, bootstrapCi, budgetBreachView, buildReflectionPrompt, buildReviewerPrompt, buildTraceAnalystTools, buildTraceInsightContext, buildTraceInsightPrompt, buildTrajectory, byteLengthRange, calibrateJudge, calibrationCurve, callLlm, callLlmJson, canaryLeakView, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, clamp01, classifyEuAiRisk, classifyFailure, codeExecutionJudge, cohensD, coherenceJudge, collectionPreserved, commitBisect, compareReferenceReplay, compareToBaseline, compilerJudge, composeParsers, composeValidators, computeToolUseMetrics, confidenceInterval, containsAll, controlFailureClassFromVerification, controlRunToFeedbackTrajectory, correlateLayers, correlationStudy, createAntiSlopJudge, createCompositeMutator, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createFeedbackTrajectory, createIntentMatchJudge, createLlmReviewer, createSandboxCodeMutator, createSandboxPool, createSemanticConceptJudge, crossTraceDiff, crowdingDistance, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultJudges, defaultMultiShotObjectives, defaultReferenceReplayMatcher, defaultTraceInsightPanel, deployGateLayer, describeTraceInsightScope, distillPlaybook, domainEvidencePattern, dominates, estimateCost, estimateTokens, euAiActReport, evaluateActionPolicy, evaluateContract, evaluateHypothesis, evaluateOracles, evaluateReleaseConfidence, executeScenario, expectAgent, exportRewardModel, exportRunAsOtlp, exportTrainingData, extractAssetUrls, extractErrorCount, failureClusterView, feedbackTrajectoriesToDatasetScenarios, feedbackTrajectoriesToOptimizerRows, feedbackTrajectoryToDatasetScenario, feedbackTrajectoryToOptimizerRow, fileContains, fileExists, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, firstDivergenceView, flowLayer, formatBenchmarkReport, formatDriverReport, formatFindings, gainHistogram, precision as goldenPrecision, gradeSemanticStatus, groupBy, hashContent, hashScenarios, htmlContainsElement, inMemoryReferenceReplayStore, inMemoryReviewStore, inferDomainKeywords, interRaterReliability, iqr, isJudgeSpan, isLlmSpan, isPrmVerdict, isRetrievalSpan, isSandboxSpan, isToolSpan, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, jsonlReviewStore, judgeAgreementView, judgeReplayGate, judgeSpans, keyPreserved, linterJudge, llmSpanFromProvider, llmSpans, loadScorerFromGrader, localCommandRunner, lowercaseMutator, mannWhitneyU, matchGoldens, mergeLayerResults, mergeSteeringBundle, multiToolchainLayer, nistAiRmfReport, nonRefusalRubric, normalizeScores, notBlocked, objectiveEval, outputLengthRubric, pairedBootstrap, pairedTTest, pairedWilcoxon, paraphraseRobustness, paraphraseRobustnessScenarios, paretoChart, paretoFrontier, paretoFrontierWithCrowding, parseFeedbackTrajectoriesJsonl, parseReflectionResponse, partialCredit, passOrthogonality, pixelDeltaRatio, planTraceInsightQuestions, politenessPrefixMutator, positionalBias, printDriverSummary, prmBestOfN, prmEnsembleBestOfN, probeLlm, promptBisect, proposeSynthesisTargets, pytestTestParser, redTeamDataset, redTeamReport, redactString, redactValue, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, regressionView, releaseTraceEvidenceFromMultiShotTrials, renderMarkdown, renderMarkdownReport, renderPlaybookMarkdown, renderPreferenceMemoryMarkdown, renderSteeringText, replayFeedbackTrajectories, replayFeedbackTrajectory, replayScorerOverCorpus, replayTraceThroughJudge, requiredSampleSize, resetLockedAppendersForTesting, resumeBuilderSession, rowCount, rowWhere, runAgentControlLoop, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runExpectations, runFailureClass, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runMultiShotOptimization, runPromptEvolution, runProposeReview, runProposeReviewAsControlLoop, runReferenceReplay, runSelfPlay, runSemanticConceptJudge, runTestGradedScenario, runsForScenario, scalarScore, scanForMuffledGates, scoreAllProjects, scoreContinuity, scoreKnowledgeReadiness, scoreProject, scoreRedTeamOutput, scoreReferenceReplay, scoreTraceInsightReadiness, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, serializeFeedbackTrajectoriesJsonl, signManifest, soc2Report, statusAdvanced, stopOnNoProgress, stopOnRepeatedAction, stripFencedJson, stuckLoopView, subjectiveEval, summarize, summarizeHarnessResults, summarizePreferenceMemory, summaryTable, testJudge, textInSnapshot, toLangfuseEnvelope, toNdjson, toPrometheusText, tokenizeDomainWords, toolIntentAlignmentRubric, toolNamesForRun, toolNonRedundantRubric, toolSpans, toolSuccessRubric, toolWasteView, traceAnalystFunctionGroup, trialTraceFromMultiShotTrial, typoMutator, urlContains, userQuestionsForKnowledgeGaps, verbosityBias, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, withAssignedFeedbackSplit, wranglerDeployRunner };
+export { ActionableSideInfo, type ActiveLearningOptions, type AdapterRun, AgentDriver, type AgentDriverConfig, type AlignmentOp, type AntiSlopConfig, type AntiSlopIssue, type AntiSlopReport, Artifact$1 as Artifact, type ArtifactCheck, type Artifact as ArtifactCheckArtifact, type ArtifactResult, type ArtifactValidator, AxGepaSteeringOptimizer, type AxSteeringOptimizerConfig, type BaselineOptions, type BaselineReport, BehaviorAssertion, type BenchmarkReport, BenchmarkRunner, type BenchmarkRunnerConfig, type BestOfNResult, type BisectOptions, type BisectResult, type BisectStep, BudgetBreachError, type BudgetBreachFinding, type BudgetBreachReport, BudgetGuard, BudgetLedgerEntry, BudgetSpec, BuilderSession, type BuilderSessionInit, type CalibrationBin, type CalibrationOptions, type CalibrationReport, type CalibrationResult, CallExpectation, type CanaryAlert, type CanaryKind, type CanaryLeak, type CanaryOptions, type CanaryReport, type CanarySeverity, type CandidateScenario, type CandidateScore, type CausalAttributionReport, type ChatSummary, type CheckResult, type CodeMutationOutcome, type CodeMutationRunner, type CollectedArtifacts, type CommandRunner, type CompletionCriterion, type CompositePolicy, type ConceptComplexity, type ConceptFinding, type ConceptSpec, type ConceptWeightStrategy, type ContinuityCheck, type ContinuityCheckResult, type ContinuityReport, type ContinuitySnapshotPair, type ContractMetric, type ContractReport, ControlEvalResult, ControlSeverity, ConvergenceTracker, type CorrelationReport, type CorrelationResult, type CorrelationStudyOptions, type CorrelationStudyResult, type CostEntry, CostLedger, type CostLedgerGeneration, type CostLedgerSnapshot, type CostSummary, CostTracker, type CounterfactualContext, type CounterfactualMutation, type CounterfactualResult, type CounterfactualRunner, type CreateCompositeMutatorOpts, type CreateDefaultReviewerOptions, type CreateSandboxCodeMutatorOpts, type CreateSandboxPoolOpts, type CrossTraceDiff, type CrossTraceDiffOptions, D1ExperimentStore, type D1ExperimentStoreOptions, type D1Like, type D1PreparedStatementLike, DEFAULT_AGENT_SLOS, DEFAULT_COMPLEXITY_WEIGHTS, DEFAULT_RULES as DEFAULT_FAILURE_RULES, DEFAULT_FINDERS, DEFAULT_HARNESS_OBJECTIVES, DEFAULT_MUTATORS, DEFAULT_RED_TEAM_CORPUS, DEFAULT_RUN_SCORE_WEIGHTS, DEFAULT_SEVERITY_WEIGHTS, type DataAcquisitionPlan, Dataset, DatasetManifest, DatasetScenario, type DeployFamily, type DeployGateLayerInput, type DeployRunResult, type DeployRunner, type DeploymentOutcome, type DirEntry, type DivergenceOptions, type DivergenceReport, DockerSandboxDriver, type DriverResult, type DriverState, DualAgentBench, type DualAgentBenchConfig, type DualAgentReport, type DualAgentRound, type DualAgentScenario, type DualAgentScenarioResult, ERROR_COUNT_PATTERNS, type ErrorCountPattern, type EuRiskClass, type EvalMetricSpec, type EvalResult, type EvolutionRound, EvolvableVariant, type ExecutorConfig, type Expectation, type Experiment, type Run as ExperimentRun, type ExperimentStore, ExperimentTracker, type ExportedRewardModel, type ExtractOptions, type ExtractResult, type FactorContribution, type FactorialCell, FailureClass, type FailureClassification, type FailureCluster, type FailureClusterReport, type FailureContext, type FailureRule, FeedbackLabel, type FeedbackPattern, FeedbackTrajectory, FeedbackTrajectoryStore, FileSystemExperimentStore, type FileSystemExperimentStoreOptions, FileSystemOutcomeStore, type FileSystemOutcomeStoreOptions, type Finding, type FlowAction, type FlowLayerEnv, type FlowLayerFactoryInput, type FlowRunner, type FlowRunnerStepResult, type FlowSpec, type FlowStep, type GoldenItem, type GoldenSeverity, type GoldenSpec, type GovernanceContext, type GovernanceFinding, type GovernanceReport, type GradedStep, type HarnessAdapter, type HarnessConfig, type HarnessExperimentConfig, type HarnessExperimentResult, type HarnessIntervention, type HarnessRunRequest, type HarnessRunResult, type HarnessScenario, type HarnessSelection, type HarnessVariant, type HarnessVariantReport, HoldoutAuditor, type HostedJudgeConfig, type HostedJudgeDimension, type HostedJudgeRequest, type HostedJudgeResponse, type HostedRunCriticConfig, type HostedRunScoreRequest, type HostedRunScoreResponse, type HypothesisManifest, type HypothesisResult, INTENT_MATCH_JUDGE_VERSION, type ImageData, InMemoryExperimentStore, InMemoryOutcomeStore, InMemoryWorkspaceInspector, type InferenceScorer, type InspectorContext, type IntegrationGateSurface, type IntegrationInvokeFailureInput, type IntegrationManifestGateInput, type IntentMatchInput, type IntentMatchOptions, type IntentMatchResult, type InteractionContribution, JsonlTrialCache, type JudgeAgreementReport, type JudgeConfig, type JudgeFleetOptions, type JudgeFn, type JudgeInput, type JudgePair, type JudgeReplayResult, type JudgeRubric, JudgeRunner, type JudgeScore, JudgeSpan, type KeywordConceptSpec, type KeywordCoverageFinding, type KeywordCoverageOptions, type KeywordCoverageResult, type KnowledgeAcquisitionMode, type KnowledgeBundle, type KnowledgeFallbackPolicy, type KnowledgeFreshness, type KnowledgeImportance, type KnowledgeReadinessReport, type KnowledgeRecommendedAction, type KnowledgeRequirement, type KnowledgeRequirementCategory, type KnowledgeResponsibleSurface, type KnowledgeSensitivity, type LangfuseEnvelope, type LangfuseGeneration, type LangfuseScore, type Layer, type LayerCorrelation, type LayerResult, type LayerStatus, type LineageKind, type LineageKindResolver, type LineageNode, LineageRecorder, type LiveProofArtifact, type LiveProofConfig, type LiveProofContext, type LiveProofResult, LlmCallError, type LlmCallRequest, type LlmCallResult, LlmClient, type LlmClientOptions, type LlmMessage, LlmSpan, type LlmUsage, LockedJsonlAppender, MODEL_PRICING, type MatchResult, type MatcherResult, type MeasurementPolicy, type MergeOptions, type MetricSamples, type MetricVerdict, MetricsCollector, type MuffledFinder, type MuffledFinding, MultiLayerVerifier, type MultiToolchainLayerConfig, MutateAdapter, type MutationAttempt, type MutationChannel, MutationTelemetry, type Mutator, Mutex, Objective, type Oracle, type OracleObservation, type OracleReport, type OracleResult, type OrthogonalityInput, type OrthogonalityResult, type OutcomeFilter, type OutcomePair, type OutcomeStore, PairwiseSteeringOptimizer, type ParaphraseRobustnessScenarioInput, type ParaphraseRobustnessScenarioResult, ParetoResult, type PersonaConfig, type Playbook, type PlaybookEntry, type PoolSlot, type PositionalBiasResult, type PrmGradedTrace, PrmGrader, type PrmTrainingSample, ProductClient, type ProductClientConfig, type ProjectKind, ProjectRegistry, type ProjectSummary, type ProjectTimelineEntry, type PromptHandle, PromptRegistry, TrialResult as PromptTrialResult, type RedTeamCase, type RedTeamCategory, type RedTeamFinding, type RedTeamPayload, type RedTeamReport, type ReferenceMatchResult, type ReferenceReplayAdapter, type ReferenceReplayAdapterFn, type ReferenceReplayAdapterLike, type ReferenceReplayAggregate, type ReferenceReplayCandidate, type ReferenceReplayCase, type ReferenceReplayCaseRun, type ReferenceReplayExecutionScenario, type ReferenceReplayItem, type ReferenceReplayMatch, type ReferenceReplayMatchStrategy, type ReferenceReplayMatcher, type ReferenceReplayPromotionDecision, type ReferenceReplayPromotionPolicy, type ReferenceReplayRun, type ReferenceReplayRunContext, type ReferenceReplayRunOptions, type ReferenceReplayRunStore, type ReferenceReplayScenario, type ReferenceReplayScenarioScore, type ReferenceReplayScore, type ReferenceReplayScoreOptions, type ReferenceReplaySplit, type ReferenceReplaySplitComparison, type ReferenceReplaySteeringRowsOptions, type RegressionOptions, type RegressionSpec, ReleaseConfidenceScorecard, ReleaseConfidenceThresholds, type ReviewerMemoryEntry, type ReviewerOutput, type ReviewerPromptInput, type ReviewerSoftFailDefaults, type ReviewerVerificationSummary, type RobustnessResult, type RouteMap, type RubricDimension, Run$1 as Run, type RunAppScenarioOptions, type RunCommandInput, type RunCommandResult, type RunConfig, RunCritic, type RunCriticOptions, type RunDiff, RunFilter, RunRecord, type RunScore, type RunScoreWeights, type RunTrace, SEMANTIC_CONCEPT_JUDGE_VERSION, type SandboxDriver, SandboxHarness, type SandboxHarnessResult, type SandboxJudgeKind, type SandboxJudgeResult, type SandboxJudgeSpec, type SandboxPool, type SandboxResult, type ScanOptions, type Scenario, type ScenarioCost, type ScenarioFile, ScenarioRegistry, type ScenarioResult, type ScoreKnowledgeReadinessOptions, type ScoredTarget, type SelfPlayOptions, type SelfPlayProposer, type SelfPlayScorer, type SelfPreferenceResult, type SemanticConceptJudgeInput, type SemanticConceptJudgeOptions, type SemanticConceptJudgeResult, type SeriesConvergenceOptions, type SeriesConvergenceResult, type Severity, type ShipOptions, type SignedManifest, type SignedManifestAlgo, type Slo, type SloCheckResult, type SloComparator, type SloReport, type SloSeverity, type SlopCategory, type SlotFactory, Span, type SteeringBundle, type SteeringDelta, type SteeringOptimizationResult, type SteeringOptimizationRow, type SteeringOptimizationSelector, type SteeringOptimizerBackend, type SteeringOptimizerConfig, type SteeringRolePrompt, type StepAttribution, type StepContext, type StepRubric, type StuckLoopFinding, type StuckLoopOptions, type StuckLoopReport, SubprocessSandboxDriver, type SubprocessSandboxDriverOptions, type SynthesisReason, type SynthesisTarget, type TestGradedRunOptions, type TestGradedRunResult, type TestGradedScenario, type TestOutputParser, type TestResult, type ThreeLayerProjectReport, type ThresholdContract, TokenCounter, type TokenSpec, ToolSpan, type ToolStats, type ToolUseMetrics, type ToolUseOptions, type ToolWasteFinding, type ToolWasteOptions, type ToolWasteReport, TraceEmitter, TraceEvent, TraceStore, type Trajectory, type TrajectoryStep, type TrialAttempt, TrialCache, TrialTelemetry, type Turn, type TurnMetrics, type TurnResult, UNIVERSAL_FINDERS, type UseCaseSignals, type UserQuestion, type ValidationContext, type ValidationIssue, type ValidationResult, VariantAggregate, type VerbosityBiasResult, type VerificationReport, type VerifyContext, type VerifyOptions, type VisualDiffOptions, type VisualDiffResult, type ViteDeployRunnerInput, type WorkflowTopology, type WorkspaceAssertion, type WorkspaceAssertionResult, type WorkspaceInspector, type WorkspaceSnapshot, type WranglerDeployRunnerInput, acquisitionPlansForKnowledgeGaps, adversarialJudge, aggregateRunScore, analyzeAntiSlop, analyzeSeries, attributeCounterfactuals, benjaminiHochberg, bisect, blockingKnowledgeEval, bonferroni, budgetBreachView, buildReviewerPrompt, buildTrajectory, byteLengthRange, calibrateJudge, calibrationCurve, callLlm, callLlmJson, canaryLeakView, canonicalize, causalAttribution, checkBehavioralCanary, checkCanaries, checkSlos, clamp01, classifyEuAiRisk, classifyFailure, codeExecutionJudge, cohensD, coherenceJudge, collectionPreserved, commitBisect, compareReferenceReplay, compareToBaseline, compilerJudge, composeParsers, composeValidators, computeToolUseMetrics, confidenceInterval, containsAll, correlateLayers, correlationStudy, createAntiSlopJudge, createCompositeMutator, createCustomJudge, createDefaultReviewer, createDomainExpertJudge, createIntentMatchJudge, createSandboxCodeMutator, createSandboxPool, createSemanticConceptJudge, crossTraceDiff, decideReferenceReplayPromotion, decideReferenceReplayRunPromotion, defaultJudges, defaultReferenceReplayMatcher, deployGateLayer, distillPlaybook, estimateCost, estimateTokens, euAiActReport, evaluateContract, evaluateHypothesis, evaluateOracles, executeScenario, expectAgent, exportRewardModel, exportTrainingData, extractAssetUrls, extractErrorCount, failureClusterView, fileContains, fileExists, findAutoMatchNoExpectation, findConstructorCwdDropped, findFallbackToPass, findLiteralTruePass, findSkipCountsAsPass, firstDivergenceView, flowLayer, formatBenchmarkReport, formatDriverReport, formatFindings, precision as goldenPrecision, gradeSemanticStatus, hashContent, hashJson, htmlContainsElement, inMemoryReferenceReplayStore, integrationAsi, integrationGateEvals, integrationInvokeFailedPayload, integrationManifestResolvedPayload, integrationManifestValidatedPayload, interRaterReliability, iqr, isPrmVerdict, jestTestParser, jsonHasKeys, jsonShape, jsonlReferenceReplayStore, judgeAgreementView, keyPreserved, knowledgeReadinessTracePayload, linterJudge, llmSpans, loadScorerFromGrader, localCommandRunner, lowercaseMutator, mannWhitneyU, matchGoldens, mergeLayerResults, mergeSteeringBundle, multiToolchainLayer, nistAiRmfReport, nonRefusalRubric, normalizeScores, notBlocked, outputLengthRubric, pairedTTest, paraphraseRobustness, paraphraseRobustnessScenarios, partialCredit, passOrthogonality, pixelDeltaRatio, politenessPrefixMutator, positionalBias, printDriverSummary, prmBestOfN, prmEnsembleBestOfN, probeLlm, promptBisect, proposeSynthesisTargets, pytestTestParser, redTeamDataset, redTeamReport, referenceReplayRunsToSteeringRows, referenceReplayScenarioToRunScore, regexMatch, regexMatches, regressionView, renderMarkdown, renderMarkdownReport, renderPlaybookMarkdown, renderSteeringText, replayScorerOverCorpus, replayTraceThroughJudge, requiredSampleSize, resetLockedAppendersForTesting, resumeBuilderSession, rowCount, rowWhere, runAssertions, runBehavioralCanaries, runCanaries, runCounterfactual, runE2EWorkflow, runExpectations, runHarnessExperiment, runIntentMatchJudge, runJudgeFleet, runKeywordCoverageJudge, runKeywordCoverageJudgeUrl, runLiveProof, runReferenceReplay, runSelfPlay, runSemanticConceptJudge, runTestGradedScenario, scanForMuffledGates, scoreAllProjects, scoreContinuity, scoreKnowledgeReadiness, scoreProject, scoreRedTeamOutput, scoreReferenceReplay, securityJudge, selectHarnessVariant, selfPreference, sentenceReorderMutator, signManifest, soc2Report, statusAdvanced, stripFencedJson, stuckLoopView, summarize, summarizeHarnessResults, testJudge, textInSnapshot, toLangfuseEnvelope, toNdjson, toPrometheusText, toolIntentAlignmentRubric, toolNamesForRun, toolNonRedundantRubric, toolSuccessRubric, toolWasteView, typoMutator, urlContains, userQuestionsForKnowledgeGaps, verbosityBias, verifyManifest, visualDiff, viteDeployRunner, vitestTestParser, weightedMean, weightedRecall, welchsTTest, whitespaceCollapseMutator, wilcoxonSignedRank, wranglerDeployRunner };