@tangle-network/agent-eval 0.72.0 → 0.72.4

package/dist/{provenance-C69gLUXH.d.ts → provenance-B-TFszPW.d.ts}

@@ -1,8 +1,10 @@
-import { o as Mutator, I as ImprovementDriver, S as Scenario, G as Gate, f as CampaignResult, M as MutableSurface, k as GateResult, j as GateDecision } from './types-CnmZ2bkP.js';
+import { o as Mutator, I as ImprovementDriver, S as Scenario, G as Gate, k as GateResult, i as GateContext, f as CampaignResult, M as MutableSurface, j as GateDecision } from './types-Bba0vl1V.js';
 import { R as RedTeamCase } from './red-team-DW9Ca_tj.js';
 import { R as RunRecord } from './run-record-BgTFzO2r.js';
-import { a as RunCampaignOptions, C as CampaignStorage } from './run-improvement-loop-Bzamo6GB.js';
-import { H as HostedClient, T as TraceSpanEvent } from './index-BGBrVS24.js';
+import { D as Direction } from './pareto-E-pembql.js';
+import { a as PairedBootstrapResult } from './statistics-B7yCbi9i.js';
+import { a as RunCampaignOptions, C as CampaignStorage } from './run-improvement-loop-BqYH2vCR.js';
+import { HostedClient, TraceSpanEvent } from './hosted/index.js';
 
 /**
  * @experimental
@@ -113,6 +115,131 @@ interface HeldOutGateOptions<TScenario extends Scenario = Scenario> {
 }
 declare function heldOutGate<TArtifact, TScenario extends Scenario>(options: HeldOutGateOptions<TScenario>): Gate<TArtifact, TScenario>;
 
+/**
+ * @experimental
+ *
+ * Promotion policy over the evidence VECTOR — the substrate's answer to "never
+ * collapse the multi-objective promotion decision into one scalar." A
+ * `defaultProductionGate` is one opinionated composition; this module factors
+ * the decision into two reusable pieces so MANY policies can compete over the
+ * SAME evidence (the quant-desk pattern: one evidence bus, plural strategies):
+ *
+ *   buildEvidenceVector(ctx, objectives, opts) -> EvidenceVector   // the bus
+ *   PromotionPolicy = (ev: EvidenceVector) => GateResult           // a strategy
+ *   paretoPolicy(ev)                                               // the default strategy
+ *   paretoSignificanceGate(options): Gate                          // bus + policy as a Gate
+ *
+ * The Pareto policy is SYMMETRIC multi-objective: every objective is BOTH a
+ * potential gain source AND a safety floor (unlike `defaultProductionGate`,
+ * where only `composite` can win and `criticalDimensions` are pure floors). A
+ * candidate ships iff it weakly DOMINATES the baseline at the confidence level —
+ * no objective credibly worse (CI floor breach) AND at least one objective
+ * credibly better (CI gain). Insufficient evidence on ANY axis -> need_more_work
+ * (NOT folded into hold: "gather more reps" and "reject" are different actions).
+ *
+ * Cost/latency are NOT CI axes here — `GateContext` carries only an aggregate
+ * per-side cost, no per-cell observation vector to bootstrap. Treat them as hard
+ * constraints (compose with a budget gate via `composeGate`), not faked CIs.
+ */
+
+/** Where an objective's per-cell scalar comes from. `composite` reads the
+ *  judge's composite; `dimension` reads a named per-dimension score. */
+type ObjectiveSource = {
+    kind: 'composite';
+} | {
+    kind: 'dimension';
+    dimension: string;
+};
+interface PromotionObjective {
+    /** Stable label used in reports + `contributingGates`. */
+    name: string;
+    source: ObjectiveSource;
+    /** 'maximize' (quality dims) or 'minimize' (error/risk/length dims). Orients
+     *  the paired delta so a positive bootstrap always means "candidate better". */
+    direction: Direction;
+    /** The good-direction paired-delta CI lower bound must EXCEED this to count
+     *  as a significant gain on this axis. Interpreted in the judge's native
+     *  scale. Default 0 (⇒ "confidently better"). */
+    gainThreshold?: number;
+    /** A floor breach (regression) is declared when the good-direction CI lower
+     *  bound is below −floorTolerance. When omitted it auto-scales off observed
+     *  magnitudes (0.05 on [0,1], 5 on 0-100), matching `dimensionRegressions`. */
+    floorTolerance?: number;
+}
+/** Per-axis verdict from the good-direction paired bootstrap. */
+type AxisVerdict = 'improved' | 'regressed' | 'flat' | 'few_runs';
+interface AxisEvidence {
+    name: string;
+    source: ObjectiveSource;
+    direction: Direction;
+    /** Paired bootstrap on the GOOD-DIRECTION delta (oriented by `direction`):
+     *  a positive value means the candidate is better on this axis. */
+    bootstrap: PairedBootstrapResult;
+    /** Paired observations contributing to this axis. */
+    n: number;
+    gainThreshold: number;
+    floorTolerance: number;
+    verdict: AxisVerdict;
+}
+interface EvidenceVector {
+    /** One entry per objective — NOTHING averaged across axes. */
+    axes: AxisEvidence[];
+    /** Smallest paired n across axes that produced observations — the binding
+     *  evidence-sufficiency constraint. 0 when no axis produced observations. */
+    minN: number;
+    /** Aggregate per-side cost from the gate context (a constraint input, not a
+     *  CI axis — see the module header). */
+    cost: {
+        candidate: number;
+        baseline: number;
+    };
+}
+/** A promotion strategy: a pure function from the evidence vector to a verdict.
+ *  Many policies can run over the same `EvidenceVector` and disagree — that's
+ *  the point (competing strategies, shared evidence). */
+type PromotionPolicy = (ev: EvidenceVector) => GateResult;
+interface BuildEvidenceVectorOptions {
+    /** Minimum paired observations before an axis can claim significance; below
+     *  it the axis is `few_runs`. Default 3. */
+    minProductiveRuns?: number;
+    /** Confidence level for every axis bootstrap. Default 0.95. */
+    confidence?: number;
+    /** Bootstrap resamples. Default 2000. */
+    resamples?: number;
+    /** Fixed bootstrap seed for a deterministic, reproducible verdict. Default 1337. */
+    seed?: number;
+}
+/**
+ * The Evidence Bus. For each objective, pair candidate vs baseline by full
+ * cellId and bootstrap a CI on the good-direction paired delta. Reuses the
+ * exact `pairHoldout` + `pairedBootstrap` machinery the held-out gate uses, so
+ * a single source of truth governs pairing granularity + scale handling.
+ */
+declare function buildEvidenceVector<TArtifact, TScenario extends Scenario>(ctx: GateContext<TArtifact, TScenario>, objectives: PromotionObjective[], opts?: BuildEvidenceVectorOptions): EvidenceVector;
+/**
+ * The default strategy: symmetric multi-objective Pareto significance. Ship iff
+ * the candidate weakly dominates the baseline at the confidence level — no axis
+ * credibly worse AND ≥1 axis credibly better. Floor breach on any axis → hold
+ * (anti-Goodhart, dominates everything). Insufficient evidence on any axis →
+ * need_more_work. Statistically equivalent → hold (never ship noise).
+ */
+declare const paretoPolicy: PromotionPolicy;
+interface ParetoSignificanceGateOptions extends BuildEvidenceVectorOptions {
+    /** The objective vector. Every axis is both a gain source and a safety floor. */
+    objectives: PromotionObjective[];
+    /** Strategy applied to the evidence vector. Default `paretoPolicy`. Override
+     *  to run a stricter/looser strategy over the SAME bus (competing policies). */
+    policy?: PromotionPolicy;
+    /** Override the gate name in reports. */
+    name?: string;
+}
+/**
+ * Wrap the bus + a policy as a `Gate`. Plugs into the existing
+ * `runImprovementLoop({ gate })` slot and composes via `composeGate`; default
+ * loop behavior is unchanged because consumers opt in by passing this gate.
+ */
+declare function paretoSignificanceGate<TArtifact = unknown, TScenario extends Scenario = Scenario>(options: ParetoSignificanceGateOptions): Gate<TArtifact, TScenario>;
+
 /**
  * @experimental
  *
@@ -311,4 +438,4 @@ interface EmitLoopProvenanceArgs<TArtifact, TScenario extends Scenario> extends
  */
 declare function emitLoopProvenance<TArtifact, TScenario extends Scenario>(args: EmitLoopProvenanceArgs<TArtifact, TScenario>): Promise<EmitLoopProvenanceResult>;
 
-export { type BuildLoopProvenanceArgs as B, type DefaultProductionGateOptions as D, type EvolutionaryDriverOptions as E, type HeldOutGateOptions as H, type LoopProvenanceRecord as L, type RunEvalOptions as R, type EmitLoopProvenanceArgs as a, type EmitLoopProvenanceResult as b, composeGate as c, defaultProductionGate as d, evolutionaryDriver as e, type LoopProvenanceBackend as f, type LoopProvenanceCandidate as g, heldOutGate as h, buildLoopProvenanceRecord as i, emitLoopProvenance as j, provenanceSpansPath as k, loopProvenanceSpans as l, provenanceRecordPath as p, runEval as r, surfaceContentHash as s };
+export { type AxisEvidence as A, type BuildEvidenceVectorOptions as B, type DefaultProductionGateOptions as D, type EvidenceVector as E, type HeldOutGateOptions as H, type LoopProvenanceRecord as L, type ObjectiveSource as O, type ParetoSignificanceGateOptions as P, type RunEvalOptions as R, type AxisVerdict as a, type EvolutionaryDriverOptions as b, type PromotionObjective as c, type PromotionPolicy as d, buildEvidenceVector as e, composeGate as f, defaultProductionGate as g, evolutionaryDriver as h, heldOutGate as i, paretoSignificanceGate as j, type BuildLoopProvenanceArgs as k, type EmitLoopProvenanceArgs as l, type EmitLoopProvenanceResult as m, type LoopProvenanceBackend as n, type LoopProvenanceCandidate as o, paretoPolicy as p, buildLoopProvenanceRecord as q, runEval as r, emitLoopProvenance as s, loopProvenanceSpans as t, provenanceRecordPath as u, provenanceSpansPath as v, surfaceContentHash as w };

package/dist/redact-B40YG2M_.d.ts

@@ -0,0 +1,45 @@
+/**
+ * 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;
+};
+
+export { DEFAULT_REDACTION_RULES as D, type RedactionRule as R, type RedactionReport as a, REDACTION_VERSION as b, redactValue as c, redactString as r };

package/dist/registry-DuVYiTvw.d.ts

@@ -0,0 +1,128 @@
+import { A as Analyst, a as AnalystContext, b as AnalystRunSummary, c as AnalystFinding, d as AnalystRunResult, C as ChatClient, e as AnalystRunInputs, f as AnalystRunEvent } from './types-CRD68aH7.js';
+
+/**
+ * AnalystRegistry — orchestrate N analysts against one run.
+ *
+ * Owns three responsibilities and only three:
+ *   1. Registration — ids must be unique; bad registrations fail loudly
+ *      at register-time, not run-time.
+ *   2. Routing — each analyst declares its `inputKind`; the registry
+ *      picks the matching field from AnalystRunInputs and skips the
+ *      analyst with a logged reason if it's missing.
+ *   3. Isolation — one analyst's exception MUST NOT stop other analysts.
+ *      Failed analysts produce zero findings + a 'failed' summary row.
+ *
+ * Cross-cutting concerns (telemetry, error → finding conversion, cost
+ * ingestion, storage rotation) live in `AnalystHooks`. Budget shaping
+ * (equal split vs weighted vs custom) lives in `BudgetPolicy`. Both
+ * have sensible defaults; consumers override only what they need.
+ */
+
+interface AnalystHooks {
+    /** Before analyze() — last chance to mutate ctx (e.g. inject tags, override budget). */
+    onBeforeAnalyze?(args: {
+        analyst: Analyst;
+        ctx: AnalystContext;
+        runId: string;
+    }): void | Promise<void>;
+    /** After every analyst (ok | failed | skipped). Use for telemetry, ingestion, rotation. */
+    onAfterAnalyze?(args: {
+        analyst: Analyst;
+        summary: AnalystRunSummary;
+        findings: AnalystFinding[];
+        runId: string;
+    }): void | Promise<void>;
+    /**
+     * On analyst exception. Hook MAY return findings to convert the
+     * error into structured findings; the summary still reports 'failed'.
+     * Return void to keep the default empty-findings behavior.
+     */
+    onError?(args: {
+        analyst: Analyst;
+        error: Error;
+        runId: string;
+    }): AnalystFinding[] | undefined | Promise<AnalystFinding[] | undefined>;
+    /** Once after registry.run() completes. Use for final aggregation, persistence. */
+    onComplete?(args: {
+        result: AnalystRunResult;
+    }): void | Promise<void>;
+}
+interface BudgetPolicy {
+    /** Overall USD cap across the registry.run(). */
+    totalUsd?: number;
+    /** Per-analyst weight for the default allocator. Missing ids get weight 1. */
+    weights?: Record<string, number>;
+    /**
+     * Custom allocator — receives the analyst, remaining/total budget, and
+     * the count of analysts that will run. Returns the per-analyst budget
+     * (or undefined to leave it uncapped). Overrides weights when set.
+     */
+    allocate?: (args: {
+        analyst: Analyst;
+        totalUsd: number | undefined;
+        remainingUsd: number | undefined;
+        runningCount: number;
+    }) => number | undefined;
+}
+interface AnalystRegistryOptions {
+    /** Shared chat client passed to every LLM analyst via AnalystContext. */
+    chat?: ChatClient;
+    /** Logger callback. Defaults to a no-op. */
+    log?: (msg: string, fields?: Record<string, unknown>) => void;
+    /** Hooks invoked around analyze() — observability + customization seam. */
+    hooks?: AnalystHooks;
+    /** Default budget when run() doesn't override. */
+    defaultBudget?: BudgetPolicy;
+}
+interface RegistryRunOpts {
+    /** Restrict to a subset of registered analysts by id. */
+    only?: string[];
+    /** Skip these analysts even if registered. Useful for cheap iteration. */
+    skip?: string[];
+    /** Budget policy — totalUsd + optional weights/allocator. Falls back to options.defaultBudget. */
+    budget?: BudgetPolicy;
+    /** Wall-clock cap. Analysts SHOULD honor `ctx.deadlineMs`. */
+    timeoutMs?: number;
+    /** Abort signal — forwarded into every analyst's context. */
+    signal?: AbortSignal;
+    /** Tags echoed into AnalystContext.tags — useful for tracking environment/version in findings. */
+    tags?: Record<string, string>;
+    /**
+     * Prior-run findings made available as retrieval context to every
+     * analyst via `ctx.priorFindings`. The registry forwards the slice
+     * whose `analyst_id` matches each registered analyst so a kind sees
+     * only its own history. Pass `{ '*': findings }` to broadcast to
+     * every analyst (useful for cross-kind chaining where the improvement
+     * analyst consumes upstream failure findings).
+     */
+    priorFindings?: ReadonlyArray<AnalystFinding> | Record<string, ReadonlyArray<AnalystFinding>>;
+}
+declare class AnalystRegistry {
+    private readonly analysts;
+    private readonly options;
+    constructor(options?: AnalystRegistryOptions);
+    register(analyst: Analyst): void;
+    list(): ReadonlyArray<{
+        id: string;
+        description: string;
+        version: string;
+        cost: Analyst['cost'];
+    }>;
+    run(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): Promise<AnalystRunResult>;
+    /**
+     * Streaming counterpart to `run()`. Emits `AnalystRunEvent` values
+     * in real time — `run-started`, then per-analyst `skipped` /
+     * `started` / `completed`, then a terminal `run-completed` whose
+     * payload is the full `AnalystRunResult`. UIs use this to render
+     * progress; persistence consumers use `run()` and read the result.
+     *
+     * Hooks (`onBeforeAnalyze` / `onAfterAnalyze` / `onError` /
+     * `onComplete`) fire as before — streaming is additive, not a hook
+     * replacement.
+     */
+    runStream(runId: string, inputs: AnalystRunInputs, runOpts?: RegistryRunOpts): AsyncGenerator<AnalystRunEvent, void, void>;
+    private selectAnalysts;
+    private routeInput;
+}
+
+export { type AnalystHooks as A, type BudgetPolicy as B, type RegistryRunOpts as R, AnalystRegistry as a, type AnalystRegistryOptions as b };

package/dist/{researcher-WJvIpX3L.d.ts → researcher-C_KJyIGg.d.ts}

@@ -7,146 +7,6 @@ import { R as RawProviderSink } from './raw-provider-sink-C46HDghv.js';
 import { F as FailureClass } from './schema-m0gsnbt3.js';
 import { T as TraceStore } from './store-CKUAgsJz.js';
 
-/**
- * Multi-layer verifier — ordered pipeline of verification layers.
- *
- * Different contract from {@link JudgeRunner} (which runs parallel
- * specs against a sandbox). MultiLayerVerifier is a DAG of layers
- * (install → typecheck → build → lint → serve → semantic → …) with
- * dependency-based skip, per-layer findings, soft-fail semantics, and
- * an aggregated `blendedScore` across all passed layers.
- *
- * Use when you want:
- *   - ordered stages where a failing upstream stage skips downstream ones
- *   - each stage produces rich `findings` (severity + message + evidence)
- *   - a single composite score across stages with per-stage weights
- *   - soft-fail stages whose failure doesn't abort the pipeline
- *
- * Use {@link JudgeRunner} when you want:
- *   - N independent judges running in parallel against the same artifact
- *   - no inter-judge dependencies
- *   - boolean `passed` per judge + overall
- *
- * Both primitives compose — JudgeRunner can be invoked as a single
- * layer inside a MultiLayerVerifier if that suits the caller.
- */
-type LayerStatus = 'pass' | 'fail' | 'skipped' | 'error' | 'timeout';
-type Severity = 'critical' | 'major' | 'minor' | 'info';
-interface Finding {
-    severity: Severity;
-    message: string;
-    evidence?: string;
-    /** Optional layer name the finding belongs to (set by the verifier if omitted). */
-    layer?: string;
-    /**
-     * Free-form structured payload — used by `multiToolchainLayer` to attach
-     * `{ adapter: 'pnpm' }`, by judges to attach evidence pointers, etc.
-     * Renderers MAY interrogate; agent-eval primitives never assume shape.
-     */
-    detail?: Record<string, unknown>;
-}
-interface LayerResult {
-    layer: string;
-    status: LayerStatus;
-    /** 0..1 score, optional — layers that don't produce a numeric score omit. */
-    score?: number;
-    durationMs: number;
-    findings: Finding[];
-    /** Short human-readable summary (one line). */
-    reason?: string;
-    /**
-     * Numeric layer-level diagnostics: error counts, warning counts,
-     * cyclomatic complexity, total adapter wall-time, etc. Keyed by
-     * diagnostic name; null = "diagnostic not applicable / not measured."
-     * Renderers that know the keys can display them; ones that don't,
-     * ignore. Free-form on purpose — consumers type the value shape in
-     * their own namespace.
-     */
-    diagnostics?: Record<string, number | null>;
-    /** Any rich per-layer detail — rendered as-is by consumers that know the layer. */
-    detail?: Record<string, unknown>;
-}
-interface VerifyContext<Env = unknown> {
-    /** Per-run opaque context the caller provides. Layers destructure what they need. */
-    env: Env;
-    /** Previously-computed results from layers that already ran. */
-    prior: Record<string, LayerResult>;
-    /** Signal — if aborted, layers MUST bail within reasonable wall. */
-    signal: AbortSignal;
-}
-interface Layer<Env = unknown> {
-    name: string;
-    /** Stages that must have `status: 'pass'` before this layer runs. */
-    dependsOn?: string[];
-    /**
-     * Weight in the composite `blendedScore`. Default 1.0. Layers with weight 0
-     * contribute findings but not score.
-     */
-    weight?: number;
-    /**
-     * If true, a `fail` status contributes to `blendedScore` (as 0) instead of
-     * being dropped — use for layers whose failure is a real signal. Default:
-     * fail drops from numerator + denominator, matching VB's existing semantics.
-     */
-    failContributesToScore?: boolean;
-    /** Optional per-layer wall-cap in ms. Honored by the verifier (AbortSignal). */
-    capMs?: number;
-    run: (ctx: VerifyContext<Env>) => Promise<LayerResult> | LayerResult;
-}
-interface VerifyOptions<Env = unknown> {
-    env: Env;
-    /**
-     * Overall wall cap. Default: sum of layer capMs, or Infinity if any layer
-     * omits a cap. The verifier short-circuits remaining layers on overall cap.
-     */
-    overallCapMs?: number;
-    /** Called with each layer result as it completes. */
-    onLayer?: (result: LayerResult) => void;
-}
-interface VerificationReport {
-    layers: LayerResult[];
-    passCount: number;
-    failCount: number;
-    skippedCount: number;
-    errorCount: number;
-    /** True iff at least one scored layer ran AND every scored layer passed. */
-    allPass: boolean;
-    /**
-     * Weighted mean of `score` across contributing layers. 0 when no layers
-     * contributed. See {@link Layer.failContributesToScore} for fail semantics.
-     */
-    blendedScore: number;
-    durationMs: number;
-    startedAt: string;
-    finishedAt: string;
-}
-/**
- * Grade a semantic-concept-style judge result into a single layer status.
- *
- * Pass when overall score >= threshold AND no critical-severity concept gap.
- * Fail otherwise. Use inside a `Layer.run` when wrapping a concept judge.
- *
- * Generalized from VerticalBench H3 fix: `failingConcepts.length === 0` was
- * too strict — a single concept at 6/10 failed the entire layer despite
- * overall score being >= 0.7. Now we trust the judge's own `severity` field:
- * `critical` findings veto; `major`/`minor` reduce the score but don't veto.
- */
-declare function gradeSemanticStatus(input: {
-    score: number;
-    findings: Array<{
-        severity: Severity;
-        present?: boolean;
-        score?: number;
-    }>;
-    available: boolean;
-    threshold?: number;
-}): LayerStatus;
-declare class MultiLayerVerifier<Env = unknown> {
-    private readonly layers;
-    constructor(layers: Layer<Env>[]);
-    run(opts: VerifyOptions<Env>): Promise<VerificationReport>;
-}
-
 /**
  * EvalCampaign — opinionated matrix runner that wires the four
  * capture-integrity directives by construction.
@@ -524,4 +384,4 @@ declare class NoopResearcher implements Researcher {
     evaluateChange(_plan: ExperimentPlan): Promise<ExperimentResult>;
 }
 
-export { CallbackResearcher as C, type ExperimentPlan as E, type FailureMode as F, type Layer as L, MultiLayerVerifier as M, NoopResearcher as N, type Researcher as R, type SteeringChange as S, type VerificationReport as V, type ExperimentResult as a, type EvalCampaignResult as b, type EvalCampaignOptions as c, type Severity as d, type VerifyOptions as e, type LayerResult as f, type VerifyContext as g, type CallbackResearcherOptions as h, type CampaignFactoryParams as i, type CampaignIntegrityPolicy as j, type CampaignRunContext as k, type CampaignRunOutcome as l, type CampaignRunner as m, type CampaignScenario as n, type CampaignVariant as o, type FailedRun as p, type Finding as q, runEvalCampaign as r, type LayerStatus as s, gradeSemanticStatus as t };
+export { CallbackResearcher as C, type ExperimentPlan as E, type FailureMode as F, NoopResearcher as N, type Researcher as R, type SteeringChange as S, type ExperimentResult as a, type EvalCampaignResult as b, type EvalCampaignOptions as c, type CallbackResearcherOptions as d, type CampaignFactoryParams as e, type CampaignIntegrityPolicy as f, type CampaignRunContext as g, type CampaignRunOutcome as h, type CampaignRunner as i, type CampaignScenario as j, type CampaignVariant as k, type FailedRun as l, runEvalCampaign as r };

package/dist/rl.d.ts

@@ -1,12 +1,13 @@
 import { R as RunRecord, b as RunSplitTag } from './run-record-BgTFzO2r.js';
-import { f as CampaignResult } from './types-CnmZ2bkP.js';
-import { V as VerificationReport, R as Researcher, F as FailureMode, S as SteeringChange, E as ExperimentPlan, a as ExperimentResult, b as EvalCampaignResult, c as EvalCampaignOptions } from './researcher-WJvIpX3L.js';
-export { r as runEvalCampaign } from './researcher-WJvIpX3L.js';
+import { f as CampaignResult } from './types-Bba0vl1V.js';
+import { a as VerificationReport } from './multi-layer-verifier-DlWCXuxL.js';
 import { S as Span } from './schema-m0gsnbt3.js';
 import { T as TraceStore } from './store-CKUAgsJz.js';
 import { O as OutcomeStore } from './outcome-store-D6KWmYvj.js';
 export { D as DeploymentOutcome, F as FileSystemOutcomeStore, b as FileSystemOutcomeStoreOptions, I as InMemoryOutcomeStore } from './outcome-store-D6KWmYvj.js';
 import { b as RubricPredictiveValidityReport } from './rubric-predictive-validity-D_4BSXGV.js';
+import { R as Researcher, F as FailureMode, S as SteeringChange, E as ExperimentPlan, a as ExperimentResult, b as EvalCampaignResult, c as EvalCampaignOptions } from './researcher-C_KJyIGg.js';
+export { r as runEvalCampaign } from './researcher-C_KJyIGg.js';
 import { I as InterimReleaseConfidence } from './sequential-5iSVfzl2.js';
 import './errors-Dwqw-T_m.js';
 import './llm-client-DbjLfz-K.js';

package/dist/rl.js

@@ -10,8 +10,8 @@ import {
 } from "./chunk-3RF76KTD.js";
 import {
   runEvalCampaign
-} from "./chunk-AIWHLG7J.js";
-import "./chunk-F3SRAAZO.js";
+} from "./chunk-GJJNJVIR.js";
+import "./chunk-IHDHUN2X.js";
 import {
   rubricPredictiveValidity
 } from "./chunk-YRZ4M5GS.js";
@@ -24,10 +24,10 @@ import {
   wilcoxonSignedRank
 } from "./chunk-ITBRCT73.js";
 import "./chunk-SBCB6VZY.js";
+import "./chunk-PC4UYEBM.js";
+import "./chunk-F3SRAAZO.js";
 import "./chunk-TVVP3ZZQ.js";
 import "./chunk-VSMTAMNK.js";
-import "./chunk-IHDHUN2X.js";
-import "./chunk-PC4UYEBM.js";
 import {
   ValidationError
 } from "./chunk-3BFEG2F6.js";

package/dist/run-critic-BAIjX99r.d.ts

@@ -0,0 +1,56 @@
+import { R as Run, S as Span, a as TraceEvent, A as Artifact, B as BudgetLedgerEntry } from './schema-m0gsnbt3.js';
+import { T as TraceStore } from './store-CKUAgsJz.js';
+
+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;
+
+interface RunTrace {
+    run: Run;
+    spans: Span[];
+    events: TraceEvent[];
+    artifacts: Artifact[];
+    budget: BudgetLedgerEntry[];
+}
+interface RunCriticOptions {
+    weights?: Partial<RunScoreWeights>;
+    driftPatterns?: RegExp[];
+}
+declare class RunCritic {
+    private readonly weights?;
+    private readonly driftPatterns;
+    constructor(options?: RunCriticOptions);
+    score(store: TraceStore, runId: string): Promise<RunScore>;
+    scoreTrace(trace: RunTrace): RunScore;
+    rank(score: RunScore): number;
+    private isDrift;
+}
+
+export { DEFAULT_RUN_SCORE_WEIGHTS as D, type RunScore as R, type RunTrace as a, type RunScoreWeights as b, RunCritic as c, type RunCriticOptions as d, aggregateRunScore as e, clamp01 as f };

package/dist/{run-improvement-loop-Bzamo6GB.d.ts → run-improvement-loop-BqYH2vCR.d.ts}

@@ -1,5 +1,5 @@
 import { L as LlmClientOptions } from './llm-client-DbjLfz-K.js';
-import { I as ImprovementDriver, S as Scenario, f as CampaignResult, k as GateResult, D as DispatchFn, a as JudgeConfig, L as LabeledScenarioStore, g as CampaignTraceWriter, m as GenerationRecord, M as MutableSurface, P as ParetoParent, G as Gate } from './types-CnmZ2bkP.js';
+import { I as ImprovementDriver, S as Scenario, f as CampaignResult, k as GateResult, D as DispatchFn, a as JudgeConfig, L as LabeledScenarioStore, g as CampaignTraceWriter, m as GenerationRecord, M as MutableSurface, P as ParetoParent, G as Gate } from './types-Bba0vl1V.js';
 
 /**
  * @experimental
@@ -308,6 +308,30 @@ interface RunOptimizationOptions<TScenario extends Scenario, TArtifact> extends
     /** Phase-2 research report forwarded to `propose()` (analyst findings +
      *  diff). Opaque here; the driver types it. */
     report?: unknown;
+    /** Structured findings forwarded to `propose()` as `ctx.findings`. A
+     *  findings producer (trace-analyst registry, HALO) emits these from the
+     *  generation's traces; findings-grounded drivers (`improvementDriver`,
+     *  `memoryCurationDriver`, `traceAnalystDriver`) consume them. Opaque here;
+     *  the driver types its `TFindings`. Empty when no producer is wired. */
+    findings?: unknown[];
+    /** Per-generation findings producer — the EYES→HANDS loop closure. After each
+     *  generation's candidates are scored, this is called with that generation's
+     *  results; whatever it returns REPLACES `ctx.findings` for the NEXT
+     *  generation's `propose()`, so the diagnosis is refreshed each round instead
+     *  of being a static one-shot. Generic by design: the substrate does not
+     *  import an analyst — the consumer plugs its trace-analyst registry / HALO
+     *  here (reading the per-candidate `runDir` traces). When absent, findings
+     *  stay the static `opts.findings`. */
+    analyzeGeneration?: (input: {
+        generation: number;
+        runDir: string;
+        candidates: Array<{
+            surfaceHash: string;
+            campaign: CampaignResult<TArtifact, TScenario>;
+            composite: number;
+        }>;
+        history: GenerationRecord[];
+    }) => Promise<unknown[]>;
 }
 interface RunOptimizationResult<TArtifact, TScenario extends Scenario> {
     generations: Array<{